diff --git a/gen/Manifest.toml b/gen/Manifest.toml
index ec9f4a23..6f9a541b 100644
--- a/gen/Manifest.toml
+++ b/gen/Manifest.toml
@@ -27,27 +27,27 @@ version = "3.3.6"
 
 [[deps.Clang]]
 deps = ["CEnum", "Clang_jll", "Downloads", "Pkg", "TOML"]
-git-tree-sha1 = "ac81f3ea7c53b20d64ad1609a0298d9731fbdcf8"
+git-tree-sha1 = "d78c2973d7a752be377fe173bc9ff2dc2d9c3ed6"
 uuid = "40e3b903-d033-50b4-a0cc-940c62c95e31"
-version = "0.17.3"
+version = "0.17.6"
 
 [[deps.Clang_jll]]
-deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "TOML", "Zlib_jll", "libLLVM_jll"]
-git-tree-sha1 = "b88c99c9093f9db49a40d0715ea0e3ae5bbd91f7"
+deps = ["Artifacts", "JLLWrappers", "Libdl", "TOML", "Zlib_jll", "libLLVM_jll"]
+git-tree-sha1 = "4c6c08b9707a548bfb429640c6aec39d0d31a376"
 uuid = "0ee61d77-7f21-5576-8119-9fcc46b10100"
-version = "14.0.6+2"
+version = "15.0.7+5"
 
 [[deps.CommonMark]]
-deps = ["Crayons", "JSON", "SnoopPrecompile", "URIs"]
-git-tree-sha1 = "e2f4627b0d3f2c1876360e0b242a7c23923b469d"
+deps = ["Crayons", "JSON", "PrecompileTools", "URIs"]
+git-tree-sha1 = "532c4185d3c9037c0237546d817858b23cf9e071"
 uuid = "a80b9123-70ca-4bc0-993e-6e3bcb318db6"
-version = "0.8.10"
+version = "0.8.12"
 
 [[deps.Compat]]
 deps = ["UUIDs"]
-git-tree-sha1 = "7a60c856b9fa189eb34f5f8a6f6b5529b7942957"
+git-tree-sha1 = "4e88377ae7ebeaf29a047aa1ee40826e0b708a5d"
 uuid = "34da2185-b29b-5c13-b0c7-acf172513d20"
-version = "4.6.1"
+version = "4.7.0"
 
     [deps.Compat.extensions]
     CompatLinearAlgebraExt = "LinearAlgebra"
@@ -63,9 +63,9 @@ version = "4.1.1"
 
 [[deps.DataStructures]]
 deps = ["Compat", "InteractiveUtils", "OrderedCollections"]
-git-tree-sha1 = "d1fff3a548102f48987a52a2e0d114fa97d730f0"
+git-tree-sha1 = "cf25ccb972fec4e4817764d01c82386ae94f77b4"
 uuid = "864edb3b-99cc-5e75-8d2d-829cb0a9cfe8"
-version = "0.18.13"
+version = "0.18.14"
 
 [[deps.Dates]]
 deps = ["Printf"]
@@ -96,20 +96,20 @@ version = "1.4.1"
 
 [[deps.JSON]]
 deps = ["Dates", "Mmap", "Parsers", "Unicode"]
-git-tree-sha1 = "3c837543ddb02250ef42f4738347454f95079d4e"
+git-tree-sha1 = "31e996f0a15c7b280ba9f76636b3ff9e2ae58c9a"
 uuid = "682c06a0-de6a-54ab-a142-c8b1cf79cde6"
-version = "0.21.3"
+version = "0.21.4"
 
 [[deps.JuliaFormatter]]
-deps = ["CSTParser", "CommonMark", "DataStructures", "Glob", "Pkg", "SnoopPrecompile", "Tokenize"]
-git-tree-sha1 = "0f6545dd63fec03d0cfe0c1d28f851e2d804e942"
+deps = ["CSTParser", "CommonMark", "DataStructures", "Glob", "Pkg", "PrecompileTools", "Tokenize"]
+git-tree-sha1 = "60567b51bd9e1e19ae2fd8a54dcd6bc5994727f0"
 uuid = "98e50ef6-434e-11e9-1051-2b60c6c9e899"
-version = "1.0.25"
+version = "1.0.34"
 
 [[deps.LibCURL]]
 deps = ["LibCURL_jll", "MozillaCACerts_jll"]
 uuid = "b27032c2-a3e7-50c8-80cd-2d36dbcbfd21"
-version = "0.6.3"
+version = "0.6.4"
 
 [[deps.LibCURL_jll]]
 deps = ["Artifacts", "LibSSH2_jll", "Libdl", "MbedTLS_jll", "Zlib_jll", "nghttp2_jll"]
@@ -157,21 +157,27 @@ uuid = "bac558e1-5e72-5ebc-8fee-abe8a469f55d"
 version = "1.6.0"
 
 [[deps.Parsers]]
-deps = ["Dates", "SnoopPrecompile"]
-git-tree-sha1 = "478ac6c952fddd4399e71d4779797c538d0ff2bf"
+deps = ["Dates", "PrecompileTools", "UUIDs"]
+git-tree-sha1 = "4b2e829ee66d4218e0cef22c0a64ee37cf258c29"
 uuid = "69de0a69-1ddd-5017-9359-2bf0b02dc9f0"
-version = "2.5.8"
+version = "2.7.1"
 
 [[deps.Pkg]]
 deps = ["Artifacts", "Dates", "Downloads", "FileWatching", "LibGit2", "Libdl", "Logging", "Markdown", "Printf", "REPL", "Random", "SHA", "Serialization", "TOML", "Tar", "UUIDs", "p7zip_jll"]
 uuid = "44cfe95a-1eb2-52ea-b672-e2afdf69b78f"
 version = "1.10.0"
 
+[[deps.PrecompileTools]]
+deps = ["Preferences"]
+git-tree-sha1 = "9673d39decc5feece56ef3940e5dafba15ba0f81"
+uuid = "aea7be01-6a6a-4083-8856-8a6e6704d82a"
+version = "1.1.2"
+
 [[deps.Preferences]]
 deps = ["TOML"]
-git-tree-sha1 = "47e5f437cc0e7ef2ce8406ce1e7e24d44915f88d"
+git-tree-sha1 = "7eb1686b4f04b82f96ed7a4ea5890a4f0c7a09f1"
 uuid = "21216c6a-2e73-6563-6e65-726566657250"
-version = "1.3.0"
+version = "1.4.0"
 
 [[deps.Printf]]
 deps = ["Unicode"]
@@ -182,7 +188,7 @@ deps = ["InteractiveUtils", "Markdown", "Sockets", "Unicode"]
 uuid = "3fa0cd96-eef1-5676-8a61-b3b8758bbffb"
 
 [[deps.Random]]
-deps = ["SHA", "Serialization"]
+deps = ["SHA"]
 uuid = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
 
 [[deps.SHA]]
@@ -192,19 +198,13 @@ version = "0.7.0"
 [[deps.Serialization]]
 uuid = "9e88b42a-f829-5b0c-bbe9-9e923198166b"
 
-[[deps.SnoopPrecompile]]
-deps = ["Preferences"]
-git-tree-sha1 = "e760a70afdcd461cf01a575947738d359234665c"
-uuid = "66db9d55-30c0-4569-8b51-7e840670fc0c"
-version = "1.0.3"
-
 [[deps.Sockets]]
 uuid = "6462fe0b-24de-5631-8697-dd941f90decc"
 
 [[deps.SuiteSparse_jll]]
 deps = ["Artifacts", "Libdl", "Pkg", "libblastrampoline_jll"]
 uuid = "bea87d4a-7f5b-5778-9afe-8cc45184846c"
-version = "7.0.1+3"
+version = "7.2.0+0"
 
 [[deps.TOML]]
 deps = ["Dates"]
@@ -241,12 +241,12 @@ version = "1.2.13+0"
 [[deps.libLLVM_jll]]
 deps = ["Artifacts", "Libdl"]
 uuid = "8f36deef-c2a5-5394-99ed-8e07531fb29a"
-version = "14.0.6+2"
+version = "15.0.7+5"
 
 [[deps.libblastrampoline_jll]]
 deps = ["Artifacts", "Libdl"]
 uuid = "8e850b90-86db-534c-a0d3-1478176c7d93"
-version = "5.4.0+0"
+version = "5.8.0+0"
 
 [[deps.nghttp2_jll]]
 deps = ["Artifacts", "Libdl"]
diff --git a/gen/generator.toml b/gen/generator.toml
index 0998d5e7..11a116e9 100644
--- a/gen/generator.toml
+++ b/gen/generator.toml
@@ -1,5 +1,5 @@
 [general]
-library_names = {"SuiteSparse_config.h" = "libsuitesparseconfig", "SuiteSparseQR_C.h" = "libspqr", "umfpack.h" = "libumfpack", "cholmod.h" = "libcholmod"}
+library_names = {"SuiteSparse_config.h" = "libsuitesparseconfig", "SuiteSparseQR_C.h" = "libspqr", "umfpack.h" = "libumfpack", "cholmod.h" = "libcholmod", "amd.h" = "libamd"}
 
 use_julia_native_enum_type = true
 use_deterministic_symbol = true
diff --git a/src/solvers/cholmod.jl b/src/solvers/cholmod.jl
index d95bec95..66a11734 100644
--- a/src/solvers/cholmod.jl
+++ b/src/solvers/cholmod.jl
@@ -18,7 +18,7 @@ using LinearAlgebra
 using LinearAlgebra: RealHermSymComplexHerm, AdjOrTrans
 import LinearAlgebra: (\), AdjointFactorization,
                  cholesky, cholesky!, det, diag, ishermitian, isposdef,
-                 issuccess, issymmetric, ldlt, ldlt!, logdet
+                 issuccess, issymmetric, ldlt, ldlt!, logdet, lowrankdowndate!
 
 using SparseArrays
 using SparseArrays: getcolptr, AbstractSparseVecOrMat
@@ -35,7 +35,7 @@ import SparseArrays: AbstractSparseMatrix, SparseMatrixCSC, indtype, sparse, spz
 import ..increment, ..increment!
 
 using ..LibSuiteSparse
-import ..LibSuiteSparse: SuiteSparse_long, TRUE, FALSE
+import ..LibSuiteSparse: TRUE, FALSE, CHOLMOD_INT, CHOLMOD_INTLONG, CHOLMOD_LONG
 
 # # itype defines the types of integer used:
 # CHOLMOD_INT,      # all integer arrays are int
@@ -84,42 +84,26 @@ xtyp(::Type{ComplexF32}) = CHOLMOD_COMPLEX
 xtyp(::Type{ComplexF64}) = CHOLMOD_COMPLEX
 
 # check the size of SuiteSparse_long
-if sizeof(SuiteSparse_long) == 4
+if sizeof(Int) == 4
     const IndexTypes = (:Int32,)
     const ITypes = Union{Int32}
 else
     const IndexTypes = (:Int32, :Int64)
     const ITypes = Union{Int32, Int64}
 end
-ityp(::Type{SuiteSparse_long}) = CHOLMOD_LONG
+# end
+ityp(::Type{Int32}) = CHOLMOD_INT
+ityp(::Type{Int64}) = CHOLMOD_LONG
+
+jlitype(t) = t == CHOLMOD_INT ? Int32 : 
+    (t == CHOLMOD_LONG ? Int64 : throw(CHOLMODException("Unsupported itype $t")))
+
+cholname(name::Symbol, type) = type === :Int64 ? Symbol(:cholmod_l_, name) : 
+    type === :Int32 ? Symbol(:cholmod_, name) : throw(ArgumentError("Unsupported type: $type"))
 
 const VTypes = Union{ComplexF64, Float64}
 const VRealTypes = Union{Float64}
 
-# overload field access methods
-function Base.getproperty(x::cholmod_sparse, f::Symbol)
-    f === :p && return Ptr{SuiteSparse_long}(getfield(x, f))
-    f === :i && return Ptr{SuiteSparse_long}(getfield(x, f))
-    f === :nz && return Ptr{SuiteSparse_long}(getfield(x, f))
-    return getfield(x, f)
-end
-
-function Base.getproperty(x::cholmod_factor, f::Symbol)
-    f === :Perm && return Ptr{SuiteSparse_long}(getfield(x, f))
-    f === :ColCount && return Ptr{SuiteSparse_long}(getfield(x, f))
-    f === :IPerm && return Ptr{SuiteSparse_long}(getfield(x, f))
-    f === :p && return Ptr{SuiteSparse_long}(getfield(x, f))
-    f === :i && return Ptr{SuiteSparse_long}(getfield(x, f))
-    f === :nz && return Ptr{SuiteSparse_long}(getfield(x, f))
-    f === :next && return Ptr{SuiteSparse_long}(getfield(x, f))
-    f === :prev && return Ptr{SuiteSparse_long}(getfield(x, f))
-    f === :super && return Ptr{SuiteSparse_long}(getfield(x, f))
-    f === :pi && return Ptr{SuiteSparse_long}(getfield(x, f))
-    f === :px && return Ptr{SuiteSparse_long}(getfield(x, f))
-    f === :s && return Ptr{SuiteSparse_long}(getfield(x, f))
-    return getfield(x, f)
-end
-
 # exception
 struct CHOLMODException <: Exception
     msg::String
@@ -134,38 +118,61 @@ const CHOLMOD_MIN_VERSION = v"2.1.1"
 
 # Set a `common` field, execute some code and then safely reset the field to
 # its initial value
+# Will set the field for both long and int common structs.
+# This seems like the most obvious behavior, changing common parameters
+# would be expected to change all cholmod calls within this block,
+# and Int32 & Int64 probably shouldn't be mixed much anyway.
 macro cholmod_param(kwarg, code)
     @assert kwarg.head == :(=)
     param = kwarg.args[1]
     value = kwarg.args[2]
 
     common_param = # Read `common.param`
-        Expr(:., :(task_local_storage(:cholmod_common)[]), QuoteNode(param))
-
+        Expr(:., :(getcommon(Int32)[]), QuoteNode(param))
+    common_param_l = # Read `common.param`
+        Expr(:., :(getcommon(Int64)[]), QuoteNode(param))
     return quote
         default_value = $common_param
+        default_value_l = $common_param_l
         try
             $common_param = $(esc(value))
+            $common_param_l = $(esc(value))
             $(esc(code))
         finally
             $common_param = default_value
+            $common_param_l = default_value_l
         end
     end
 end
 
-function newcommon(; print = 0)
+function newcommon_l(; print = 0) # no printing from CHOLMOD by default
     common = finalizer(cholmod_l_finish, Ref(cholmod_common()))
     result = cholmod_l_start(common)
     @assert result == TRUE "failed to run `cholmod_l_start`!"
-    common[].print = 0  # no printing from CHOLMOD by default
+    common[].print = print
     common[].error_handler = @cfunction(error_handler, Cvoid, (Cint, Cstring, Cint, Cstring))
     return common
 end
 
-function getcommon()
+function newcommon(; print = 0) # no printing from CHOLMOD by default
+    common = finalizer(cholmod_finish, Ref(cholmod_common()))
+    result = cholmod_start(common)
+    @assert result == TRUE "failed to run `cholmod_l_start`!"
+    common[].print = print
+    common[].error_handler = @cfunction(error_handler, Cvoid, (Cint, Cstring, Cint, Cstring))
+    return common
+end
+
+function getcommon(::Type{Int32})
     return get!(newcommon, task_local_storage(), :cholmod_common)::Ref{cholmod_common}
 end
 
+function getcommon(::Type{Int64})
+    return get!(newcommon_l, task_local_storage(), :cholmod_common_l)::Ref{cholmod_common}
+end
+
+getcommon() = getcommon(Int)
+
 const BUILD_VERSION = VersionNumber(CHOLMOD_MAIN_VERSION, CHOLMOD_SUB_VERSION, CHOLMOD_SUBSUB_VERSION)
 
 function __init__()
@@ -212,25 +219,6 @@ function __init__()
                 """
         end
 
-        intsize = sizeof(SuiteSparse_long)
-        if intsize != 4length(IndexTypes)
-            @error """
-                 CHOLMOD integer size incompatibility
-
-                 Julia was compiled with a version of CHOLMOD that
-                 supported $(32length(IndexTypes)) bit integers. It is
-                 currently linked with version that supports $(8intsize)
-                 integers. This might cause Julia to terminate when
-                 working with sparse matrix factorizations, e.g. solving
-                 systems of equations with \\.
-
-                 This problem can be fixed by modifying the Julia build
-                 configuration or by downloading the OS X or generic
-                 Linux binary from www.julialang.org, which include
-                 the correct versions of all dependencies.
-                 """
-        end
-
         # Register gc tracked allocator if CHOLMOD is new enough
         if current_version >= v"4.0.3"
             ccall((:SuiteSparse_config_malloc_func_set, :libsuitesparseconfig),
@@ -284,22 +272,22 @@ mutable struct Dense{Tv<:VTypes} <: DenseMatrix{Tv}
     end
 end
 
-mutable struct Sparse{Tv<:VTypes} <: AbstractSparseMatrix{Tv,SuiteSparse_long}
+mutable struct Sparse{Tv<:VTypes, Ti<:ITypes} <: AbstractSparseMatrix{Tv,Ti}
     ptr::Ptr{cholmod_sparse}
-    function Sparse{Tv}(ptr::Ptr{cholmod_sparse}) where Tv<:VTypes
+    function Sparse{Tv, Ti}(ptr::Ptr{cholmod_sparse}) where {Tv<:VTypes, Ti<:ITypes}
         if ptr == C_NULL
             throw(ArgumentError("sparse matrix construction failed for " *
                 "unknown reasons. Please submit a bug report."))
         end
         s = unsafe_load(ptr)
-        if s.itype != ityp(SuiteSparse_long)
-            free!(ptr)
-            throw(CHOLMODException("itype=$(s.itype) not supported"))
+        if s.itype != ityp(Ti)
+            free!(ptr, Ti)
+            throw(CHOLMODException("Ti=$Ti does not match s.itype=$(s.itype)"))
         elseif s.xtype != xtyp(Tv)
-            free!(ptr)
+            free!(ptr, Ti)
             throw(CHOLMODException("xtype=$(s.xtype) not supported"))
         elseif s.dtype != dtyp(Tv)
-            free!(ptr)
+            free!(ptr, Ti)
             throw(CHOLMODException("dtype=$(s.dtype) not supported"))
         end
         A = new(ptr)
@@ -308,6 +296,15 @@ mutable struct Sparse{Tv<:VTypes} <: AbstractSparseMatrix{Tv,SuiteSparse_long}
     end
 end
 
+function Sparse{Tv}(ptr::Ptr{cholmod_sparse}) where Tv
+    if ptr == C_NULL
+        throw(ArgumentError("sparse matrix construction failed for " *
+            "unknown reasons. Please submit a bug report."))
+    end
+    s = unsafe_load(ptr)
+    return Sparse{Tv, jlitype(s.itype)}(ptr)
+end
+
 # Useful when reading in files, but not type stable
 function Sparse(p::Ptr{cholmod_sparse})
     if p == C_NULL
@@ -315,26 +312,29 @@ function Sparse(p::Ptr{cholmod_sparse})
                             "unknown reasons. Please submit a bug report."))
     end
     s = unsafe_load(p)
-    Tv = s.xtype == CHOLMOD_REAL ? Float64 : ComplexF64
-    Sparse{Tv}(p)
+    if s.dtype == CHOLMOD_SINGLE
+        free!(p, jlitype(s.itype))
+        throw(CHOLMODException("dtype=$(s.dtype) not supported"))
+    end
+    Sparse{s.xtype == CHOLMOD_REAL ? Float64 : ComplexF64}(p)
 end
 
-mutable struct Factor{Tv<:VTypes} <: Factorization{Tv}
+mutable struct Factor{Tv<:VTypes, Ti<:ITypes} <: Factorization{Tv}
     ptr::Ptr{cholmod_factor}
-    function Factor{Tv}(ptr::Ptr{cholmod_factor}, register_finalizer = true) where Tv
+    function Factor{Tv, Ti}(ptr::Ptr{cholmod_factor}, register_finalizer = true) where {Tv, Ti}
         if ptr == C_NULL
             throw(ArgumentError("factorization construction failed for " *
                 "unknown reasons. Please submit a bug report."))
         end
         s = unsafe_load(ptr)
-        if s.itype != ityp(SuiteSparse_long)
-            free!(ptr)
-            throw(CHOLMODException("itype=$(s.itype) not supported"))
+        if s.itype != ityp(Ti)
+            free!(ptr, Ti)
+            throw(CHOLMODException("Ti=$Ti does not match s.itype=$(s.itype)"))
         elseif s.xtype != xtyp(Tv) && s.xtype != CHOLMOD_PATTERN
-            free!(ptr)
+            free!(ptr, Ti)
             throw(CHOLMODException("xtype=$(s.xtype) not supported"))
         elseif s.dtype != dtyp(Tv)
-            free!(ptr)
+            free!(ptr, Ti)
             throw(CHOLMODException("dtype=$(s.dtype) not supported"))
         end
         F = new(ptr)
@@ -345,6 +345,15 @@ mutable struct Factor{Tv<:VTypes} <: Factorization{Tv}
     end
 end
 
+function Factor{Tv}(ptr::Ptr{cholmod_factor}) where Tv
+    if ptr == C_NULL
+        throw(ArgumentError("factorization construction failed for " *
+                "unknown reasons. Please submit a bug report."))
+    end
+    s = unsafe_load(ptr)
+    return Factor{Tv, jlitype(s.itype)}(ptr)
+end
+
 const SuiteSparseStruct = Union{cholmod_dense, cholmod_sparse, cholmod_factor}
 
 # All pointer loads should be checked to make sure that SuiteSparse is not called with
@@ -364,10 +373,10 @@ Base.pointer(x::Sparse{Tv}) where {Tv} = Base.unsafe_convert(Ptr{cholmod_sparse}
 Base.pointer(x::Factor{Tv}) where {Tv} = Base.unsafe_convert(Ptr{cholmod_factor}, x)
 
 # FactorComponent, for encoding particular factors from a factorization
-mutable struct FactorComponent{Tv,S} <: AbstractMatrix{Tv}
-    F::Factor{Tv}
+mutable struct FactorComponent{Tv, S, Ti} <: AbstractMatrix{Tv}
+    F::Factor{Tv, Ti}
 
-    function FactorComponent{Tv,S}(F::Factor{Tv}) where {Tv,S}
+    function FactorComponent{Tv, S, Ti}(F::Factor{Tv, Ti}) where {Tv, S, Ti}
         s = unsafe_load(pointer(F))
         if s.is_ll != 0
             if !(S === :L || S === :U || S === :PtL || S === :UP)
@@ -382,8 +391,11 @@ mutable struct FactorComponent{Tv,S} <: AbstractMatrix{Tv}
         new(F)
     end
 end
-function FactorComponent(F::Factor{Tv}, sym::Symbol) where Tv
-    FactorComponent{Tv,sym}(F)
+function FactorComponent{Tv, S}(F::Factor{Tv, Ti}) where {Tv, S, Ti}
+    return FactorComponent{Tv, S, Ti}(F)
+end
+function FactorComponent(F::Factor{Tv, Ti}, sym::Symbol) where {Tv, Ti}
+    FactorComponent{Tv, sym, Ti}(F)
 end
 
 Factor(FC::FactorComponent) = FC.F
@@ -393,261 +405,370 @@ Factor(FC::FactorComponent) = FC.F
 #################
 
 # Dense wrappers
-function allocate_dense(m::Integer, n::Integer, d::Integer, ::Type{Tv}) where {Tv<:VTypes}
-    Dense{Tv}(cholmod_l_allocate_dense(m, n, d, xtyp(Tv), getcommon()))
-end
+# The ifelse here may be unecessary.
+# nothing different actually occurs in cholmod_l_allocate vs cholmod_allocate AFAICT.
+# And CHOLMOD has no way of tracking the difference internally (no internal itype field).
+# This leads me to believe they can be mixed with long and int versions of sparse freely.
+# Julia will take care of erroring on conversion from Integer -> size_t due to overflow.
+
+@static if sizeof(Int) == 4
+    function allocate_dense(m::Integer, n::Integer, d::Integer, ::Type{Tv}) where {Tv<:VTypes}
+        Dense{Tv}(cholmod_allocate_dense(m, n, d, xtyp(Tv), getcommon()))
+    end
+    function free!(p::Ptr{cholmod_dense})
+        cholmod_free_dense(Ref(p), getcommon()) == TRUE
+    end
+    function zeros(m::Integer, n::Integer, ::Type{Tv}) where Tv<:VTypes
+        Dense{Tv}(cholmod_zeros(m, n, xtyp(Tv), getcommon()))
+    end
+    function ones(m::Integer, n::Integer, ::Type{Tv}) where Tv<:VTypes
+        Dense{Tv}(cholmod_ones(m, n, xtyp(Tv), getcommon()))
+    end
+    function eye(m::Integer, n::Integer, ::Type{Tv}) where Tv<:VTypes
+        Dense{Tv}(cholmod_eye(m, n, xtyp(Tv), getcommon()))
+    end
+    function copy(A::Dense{Tv}) where Tv<:VTypes
+        Dense{Tv}(cholmod_copy_dense(A, getcommon()))
+    end
+    function check_dense(A::Dense{Tv}) where Tv<:VTypes
+        cholmod_check_dense(pointer(A), getcommon()) != 0
+    end
+    function norm_dense(D::Dense{Tv}, p::Integer) where Tv<:VTypes
+        s = unsafe_load(pointer(D))
+        if p == 2
+            if s.ncol > 1
+                throw(ArgumentError("2 norm only supported when matrix has one column"))
+            end
+        elseif p != 0 && p != 1
+            throw(ArgumentError("second argument must be either 0 (Inf norm), 1, or 2"))
+        end
+        cholmod_norm_dense(D, p, getcommon())
+    end
+else
+    function allocate_dense(m::Integer, n::Integer, d::Integer, ::Type{Tv}) where {Tv<:VTypes}
+        Dense{Tv}(cholmod_l_allocate_dense(m, n, d, xtyp(Tv), getcommon()))
+    end
+    function free!(p::Ptr{cholmod_dense})
+        cholmod_l_free_dense(Ref(p), getcommon()) == TRUE
+    end
+    function zeros(m::Integer, n::Integer, ::Type{Tv}) where Tv<:VTypes
+        Dense{Tv}(cholmod_l_zeros(m, n, xtyp(Tv), getcommon()))
+    end
+    function ones(m::Integer, n::Integer, ::Type{Tv}) where Tv<:VTypes
+        Dense{Tv}(cholmod_l_ones(m, n, xtyp(Tv), getcommon()))
+    end
+    function eye(m::Integer, n::Integer, ::Type{Tv}) where Tv<:VTypes
+        Dense{Tv}(cholmod_l_eye(m, n, xtyp(Tv), getcommon()))
+    end
+    function copy(A::Dense{Tv}) where Tv<:VTypes
+        Dense{Tv}(cholmod_l_copy_dense(A, getcommon()))
+    end
+    function check_dense(A::Dense{Tv}) where Tv<:VTypes
+        cholmod_l_check_dense(pointer(A), getcommon()) != 0
+    end
 
-function free!(p::Ptr{cholmod_dense})
-    cholmod_l_free_dense(Ref(p), getcommon()) == TRUE
+    function norm_dense(D::Dense{Tv}, p::Integer) where Tv<:VTypes
+        s = unsafe_load(pointer(D))
+        if p == 2
+            if s.ncol > 1
+                throw(ArgumentError("2 norm only supported when matrix has one column"))
+            end
+        elseif p != 0 && p != 1
+            throw(ArgumentError("second argument must be either 0 (Inf norm), 1, or 2"))
+        end
+        cholmod_l_norm_dense(D, p, getcommon())
+    end
 end
 
-function zeros(m::Integer, n::Integer, ::Type{Tv}) where Tv<:VTypes
-    Dense{Tv}(cholmod_l_zeros(m, n, xtyp(Tv), getcommon()))
-end
 zeros(m::Integer, n::Integer) = zeros(m, n, Float64)
 
-function ones(m::Integer, n::Integer, ::Type{Tv}) where Tv<:VTypes
-    Dense{Tv}(cholmod_l_ones(m, n, xtyp(Tv), getcommon()))
-end
 ones(m::Integer, n::Integer) = ones(m, n, Float64)
 
-function eye(m::Integer, n::Integer, ::Type{Tv}) where Tv<:VTypes
-    Dense{Tv}(cholmod_l_eye(m, n, xtyp(Tv), getcommon()))
-end
 eye(m::Integer, n::Integer) = eye(m, n, Float64)
 eye(n::Integer) = eye(n, n, Float64)
 
-function copy(A::Dense{Tv}) where Tv<:VTypes
-    Dense{Tv}(cholmod_l_copy_dense(A, getcommon()))
-end
-
-function sort!(S::Sparse{Tv}) where Tv<:VTypes
-    cholmod_l_sort(S, getcommon())
-    return S
-end
-
-function norm_dense(D::Dense{Tv}, p::Integer) where Tv<:VTypes
-    s = unsafe_load(pointer(D))
-    if p == 2
-        if s.ncol > 1
-            throw(ArgumentError("2 norm only supported when matrix has one column"))
-        end
-    elseif p != 0 && p != 1
-        throw(ArgumentError("second argument must be either 0 (Inf norm), 1, or 2"))
-    end
-    cholmod_l_norm_dense(D, p, getcommon())
-end
-
-function check_dense(A::Dense{Tv}) where Tv<:VTypes
-    cholmod_l_check_dense(pointer(A), getcommon()) != 0
-end
-
 # Non-Dense wrappers
-function allocate_sparse(nrow::Integer, ncol::Integer, nzmax::Integer,
-        sorted::Bool, packed::Bool, stype::Integer, ::Type{Tv}) where {Tv<:VTypes}
-    Sparse{Tv}(cholmod_l_allocate_sparse(nrow, ncol, nzmax, sorted, packed, stype,
-                                         xtyp(Tv), getcommon()))
-end
 
-function free!(ptr::Ptr{cholmod_sparse})
-    cholmod_l_free_sparse(Ref(ptr), getcommon()) == TRUE
-end
-
-function free!(ptr::Ptr{cholmod_factor})
-    # Warning! Important that finalizer doesn't modify the global Common struct.
-    cholmod_l_free_factor(Ref(ptr), getcommon()) == TRUE
-end
-
-function aat(A::Sparse{Tv}, fset::Vector{SuiteSparse_long}, mode::Integer) where Tv<:VRealTypes
-    Sparse{Tv}(cholmod_l_aat(A, fset, length(fset), mode, getcommon()))
-end
-
-function sparse_to_dense(A::Sparse{Tv}) where Tv<:VTypes
-    Dense{Tv}(cholmod_l_sparse_to_dense(A, getcommon()))
-end
-function dense_to_sparse(D::Dense{Tv}, ::Type{SuiteSparse_long}) where Tv<:VTypes
-    Sparse{Tv}(cholmod_l_dense_to_sparse(D, true, getcommon()))
-end
-
-function factor_to_sparse!(F::Factor{Tv}) where Tv<:VTypes
-    ss = unsafe_load(pointer(F))
-    ss.xtype == CHOLMOD_PATTERN && throw(CHOLMODException("only numeric factors are supported"))
-    Sparse{Tv}(cholmod_l_factor_to_sparse(F, getcommon()))
-end
-
-function change_factor!(F::Factor{Tv}, to_ll::Bool, to_super::Bool, to_packed::Bool,
-                        to_monotonic::Bool) where Tv<:VTypes
-    cholmod_l_change_factor(xtyp(Tv), to_ll, to_super, to_packed, to_monotonic, F, getcommon()) == TRUE
-end
+for TI ∈ IndexTypes
+@eval begin
+    mutable struct $(cholname(:sparse_struct_typed, TI))
+        nrow::Csize_t
+        ncol::Csize_t
+        nzmax::Csize_t
+        p::Ptr{$TI}
+        i::Ptr{$TI}
+        nz::Ptr{$TI}
+        x::Ptr{Cvoid}
+        z::Ptr{Cvoid}
+        stype::Cint
+        itype::Cint
+        xtype::Cint
+        dtype::Cint
+        sorted::Cint
+        packed::Cint
+        cholmod_sparse_struct() = new()
+    end
+    
+    typedpointer(x::Sparse{<:Any, $TI}) = Ptr{$(cholname(:sparse_struct_typed, TI))}(pointer(x))
+
+    mutable struct $(cholname(:factor_struct_typed, TI))
+        n::Csize_t
+        minor::Csize_t
+        Perm::Ptr{$TI}
+        ColCount::Ptr{$TI}
+        IPerm::Ptr{$TI}
+        nzmax::Csize_t
+        p::Ptr{$TI}
+        i::Ptr{$TI}
+        x::Ptr{Cvoid}
+        z::Ptr{Cvoid}
+        nz::Ptr{$TI}
+        next::Ptr{$TI}
+        prev::Ptr{$TI}
+        nsuper::Csize_t
+        ssize::Csize_t
+        xsize::Csize_t
+        maxcsize::Csize_t
+        maxesize::Csize_t
+        super::Ptr{$TI}
+        pi::Ptr{$TI}
+        px::Ptr{$TI}
+        s::Ptr{$TI}
+        ordering::Cint
+        is_ll::Cint
+        is_super::Cint
+        is_monotonic::Cint
+        itype::Cint
+        xtype::Cint
+        dtype::Cint
+        useGPU::Cint
+        cholmod_factor_struct() = new()
+    end
 
-function check_sparse(A::Sparse{Tv}) where Tv<:VTypes
-    cholmod_l_check_sparse(A, getcommon()) != 0
-end
+    typedpointer(x::Factor{<:Any, $TI}) = Ptr{$(cholname(:factor_struct_typed, TI))}(pointer(x))
 
-function check_factor(F::Factor{Tv}) where Tv<:VTypes
-    cholmod_l_check_factor(F, getcommon()) != 0
-end
+    function sort!(S::Sparse{<:VTypes, $TI})
+        $(cholname(:sort, TI))(S, getcommon($TI))
+        return S
+    end
+    function allocate_sparse(nrow::Integer, ncol::Integer, nzmax::Integer,
+        sorted::Bool, packed::Bool, stype::Integer, ::Type{Tv}, ::Type{$TI}) where {Tv<:VTypes}
+        Sparse{Tv, $TI}($(cholname(:allocate_sparse, TI))(nrow, ncol, nzmax, sorted, 
+            packed, stype, xtyp(Tv), getcommon($TI)))
+    end
+    function free!(ptr::Ptr{cholmod_sparse}, ::Type{$TI})
+        $(cholname(:free_sparse, TI))(Ref(ptr), getcommon($TI)) == TRUE
+    end
+    
+    function free!(ptr::Ptr{cholmod_factor}, ::Type{$TI})
+        # Warning! Important that finalizer doesn't modify the global Common struct.
+        $(cholname(:free_factor, TI))(Ref(ptr), getcommon($TI)) == TRUE
+    end
+    function aat(A::Sparse{Tv}, fset::Vector{$TI}, mode::Integer) where Tv<:VRealTypes
+        Sparse{Tv, $TI}($(cholname(:aat, TI))(A, fset, length(fset), mode, getcommon($TI)))
+    end
 
-nnz(A::Sparse{<:VTypes}) = cholmod_l_nnz(A, getcommon())
+    function sparse_to_dense(A::Sparse{Tv, $TI}) where Tv<:VTypes
+        Dense{Tv}($(cholname(:sparse_to_dense, TI))(A, getcommon($TI)))
+    end
+    function dense_to_sparse(D::Dense{Tv}, ::Type{$TI}) where Tv<:VTypes
+        Sparse{Tv}($(cholname(:dense_to_sparse, TI))(D, true, getcommon($TI)))
+    end
 
-function speye(m::Integer, n::Integer, ::Type{Tv}) where Tv<:VTypes
-    Sparse{Tv}(cholmod_l_speye(m, n, xtyp(Tv), getcommon()))
-end
+    function factor_to_sparse!(F::Factor{Tv, $TI}) where Tv<:VTypes
+        ss = unsafe_load(pointer(F))
+        ss.xtype == CHOLMOD_PATTERN && throw(CHOLMODException("only numeric factors are supported"))
+        Sparse{Tv, $TI}($(cholname(:factor_to_sparse, TI))(F, getcommon($TI)))
+    end
+    function change_factor!(F::Factor{Tv, $TI}, to_ll::Bool, to_super::Bool, to_packed::Bool,
+        to_monotonic::Bool) where Tv<:VTypes
+        $(cholname(:change_factor, TI))(xtyp(Tv), to_ll, to_super, to_packed, to_monotonic, F, getcommon($TI)) == TRUE
+    end
+    function check_sparse(A::Sparse{Tv, $TI}) where Tv<:VTypes
+        $(cholname(:check_sparse, TI))(A, getcommon($TI)) != 0
+    end
+    
+    function check_factor(F::Factor{Tv, $TI}) where Tv<:VTypes
+        $(cholname(:check_factor, TI))(F, getcommon($TI)) != 0
+    end
+    nnz(A::Sparse{<:VTypes, $TI}) = $(cholname(:nnz, TI))(A, getcommon($TI))
 
-function spzeros(m::Integer, n::Integer, nzmax::Integer, ::Type{Tv}) where Tv<:VTypes
-    Sparse{Tv}(cholmod_l_spzeros(m, n, nzmax, xtyp(Tv), getcommon()))
-end
+    function speye(m::Integer, n::Integer, ::Type{Tv}, ::Type{$TI}) where Tv<:VTypes
+        Sparse{Tv, $TI}($(cholname(:speye, TI))(m, n, xtyp(Tv), getcommon($TI)))
+    end
+    
+    function spzeros(m::Integer, n::Integer, nzmax::Integer, ::Type{Tv}, ::Type{$TI}) where Tv<:VTypes
+        Sparse{Tv, $TI}($(cholname(:spzeros, TI))(m, n, nzmax, xtyp(Tv), getcommon($TI)))
+    end
 
-function transpose_(A::Sparse{Tv}, values::Integer) where Tv<:VTypes
-    Sparse{Tv}(cholmod_l_transpose(A, values, getcommon()))
-end
+    function transpose_(A::Sparse{Tv, $TI}, values::Integer) where Tv<:VTypes
+        Sparse{Tv, $TI}($(cholname(:transpose, TI))(A, values, getcommon($TI)))
+    end
 
-function copy(F::Factor{Tv}) where Tv<:VTypes
-    Factor{Tv}(cholmod_l_copy_factor(F, getcommon()))
-end
-function copy(A::Sparse{Tv}) where Tv<:VTypes
-    Sparse{Tv}(cholmod_l_copy_sparse(A, getcommon()))
-end
-function copy(A::Sparse{Tv}, stype::Integer, mode::Integer) where Tv<:VRealTypes
-    Sparse{Tv}(cholmod_l_copy(A, stype, mode, getcommon()))
-end
+    function copy(F::Factor{Tv, $TI}) where Tv<:VTypes
+        Factor{Tv, $TI}($(cholname(:copy_factor, TI))(F, getcommon($TI)))
+    end
+    function copy(A::Sparse{Tv, $TI}) where Tv<:VTypes
+        Sparse{Tv, $TI}($(cholname(:copy_sparse, TI))(A, getcommon($TI)))
+    end
+    function copy(A::Sparse{Tv, $TI}, stype::Integer, mode::Integer) where Tv<:VRealTypes
+        Sparse{Tv, $TI}($(cholname(:copy, TI))(A, stype, mode, getcommon($TI)))
+    end
 
-function print_sparse(A::Sparse{Tv}, name::String) where Tv<:VTypes
-    isascii(name) || error("non-ASCII name: $name")
-    @cholmod_param print = 3 begin
-        cholmod_l_print_sparse(A, name, getcommon())
+    function print_sparse(A::Sparse{Tv, $TI}, name::String) where Tv<:VTypes
+        isascii(name) || error("non-ASCII name: $name")
+        @cholmod_param print = 3 begin
+            $(cholname(:print_sparse, TI))(A, name, getcommon($TI))
+        end
+        nothing
     end
-    nothing
-end
-function print_factor(F::Factor{Tv}, name::String) where Tv<:VTypes
-    @cholmod_param print = 3 begin
-        cholmod_l_print_factor(F, name, getcommon())
+    function print_factor(F::Factor{Tv, $TI}, name::String) where Tv<:VTypes
+        @cholmod_param print = 3 begin
+            $(cholname(:print_factor, TI))(F, name, getcommon($TI))
+        end
+        nothing
     end
-    nothing
-end
 
-function ssmult(A::Sparse{Tv}, B::Sparse{Tv}, stype::Integer,
+    function ssmult(A::Sparse{Tv, $TI}, B::Sparse{Tv, $TI}, stype::Integer,
         values::Bool, sorted::Bool) where Tv<:VRealTypes
-    lA = unsafe_load(pointer(A))
-    lB = unsafe_load(pointer(B))
-    if lA.ncol != lB.nrow
-        throw(DimensionMismatch("inner matrix dimensions do not fit"))
+        lA = unsafe_load(pointer(A))
+        lB = unsafe_load(pointer(B))
+        if lA.ncol != lB.nrow
+            throw(DimensionMismatch("inner matrix dimensions do not fit"))
+        end
+        return Sparse{Tv, $TI}($(cholname(:ssmult, TI))(A, B, stype, values, sorted, getcommon($TI)))
     end
-    Sparse{Tv}(cholmod_l_ssmult(A, B, stype, values, sorted, getcommon()))
-end
 
-function norm_sparse(A::Sparse{Tv}, norm::Integer) where Tv<:VTypes
-    if norm != 0 && norm != 1
-        throw(ArgumentError("norm argument must be either 0 or 1"))
+    function norm_sparse(A::Sparse{Tv, $TI}, norm::Integer) where Tv<:VTypes
+        if norm != 0 && norm != 1
+            throw(ArgumentError("norm argument must be either 0 or 1"))
+        end
+        $(cholname(:norm_sparse, TI))(A, norm, getcommon($TI))
     end
-    cholmod_l_norm_sparse(A, norm, getcommon())
-end
 
-function horzcat(A::Sparse{Tv}, B::Sparse{Tv}, values::Bool) where Tv<:VRealTypes
-    Sparse{Tv}(cholmod_l_horzcat(A, B, values, getcommon()))
-end
+    function horzcat(A::Sparse{Tv, $TI}, B::Sparse{Tv, $TI}, values::Bool) where Tv<:VRealTypes
+        Sparse{Tv, $TI}($(cholname(:horzcat, TI))(A, B, values, getcommon($TI)))
+    end
 
-function scale!(S::Dense{Tv}, scale::Integer, A::Sparse{Tv}) where Tv<:VRealTypes
-    sS = unsafe_load(pointer(S))
-    sA = unsafe_load(pointer(A))
-    if sS.ncol != 1 && sS.nrow != 1
-        throw(DimensionMismatch("first argument must be a vector"))
-    end
-    if scale == CHOLMOD_SCALAR && sS.nrow != 1
-        throw(DimensionMismatch("scaling argument must have length one"))
-    elseif scale == CHOLMOD_ROW && sS.nrow*sS.ncol != sA.nrow
-        throw(DimensionMismatch("scaling vector has length $(sS.nrow*sS.ncol), " *
-            "but matrix has $(sA.nrow) rows."))
-    elseif scale == CHOLMOD_COL && sS.nrow*sS.ncol != sA.ncol
-        throw(DimensionMismatch("scaling vector has length $(sS.nrow*sS.ncol), " *
-            "but matrix has $(sA.ncol) columns"))
-    elseif scale == CHOLMOD_SYM
-        if sA.nrow != sA.ncol
-            throw(DimensionMismatch("matrix must be square"))
-        elseif sS.nrow*sS.ncol != sA.nrow
+    function scale!(S::Dense{Tv}, scale::Integer, A::Sparse{Tv, $TI}) where Tv<:VRealTypes
+        sS = unsafe_load(pointer(S))
+        sA = unsafe_load(pointer(A))
+        if sS.ncol != 1 && sS.nrow != 1
+            throw(DimensionMismatch("first argument must be a vector"))
+        end
+        if scale == CHOLMOD_SCALAR && sS.nrow != 1
+            throw(DimensionMismatch("scaling argument must have length one"))
+        elseif scale == CHOLMOD_ROW && sS.nrow*sS.ncol != sA.nrow
+            throw(DimensionMismatch("scaling vector has length $(sS.nrow*sS.ncol), " *
+                "but matrix has $(sA.nrow) rows."))
+        elseif scale == CHOLMOD_COL && sS.nrow*sS.ncol != sA.ncol
             throw(DimensionMismatch("scaling vector has length $(sS.nrow*sS.ncol), " *
-                "but matrix has $(sA.ncol) columns and rows"))
+                "but matrix has $(sA.ncol) columns"))
+        elseif scale == CHOLMOD_SYM
+            if sA.nrow != sA.ncol
+                throw(DimensionMismatch("matrix must be square"))
+            elseif sS.nrow*sS.ncol != sA.nrow
+                throw(DimensionMismatch("scaling vector has length $(sS.nrow*sS.ncol), " *
+                    "but matrix has $(sA.ncol) columns and rows"))
+            end
         end
+
+        sA = unsafe_load(pointer(A))
+        $(cholname(:scale, TI))(S, scale, A, getcommon($TI))
+        return A
     end
 
-    sA = unsafe_load(pointer(A))
-    cholmod_l_scale(S, scale, A, getcommon())
-    A
-end
+    function sdmult!(A::Sparse{Tv, $TI}, transpose::Bool,
+            α::Number, β::Number, X::Dense{Tv}, Y::Dense{Tv}) where Tv<:VTypes
+        m, n = size(A)
+        nc = transpose ? m : n
+        nr = transpose ? n : m
+        if nc != size(X, 1)
+            throw(DimensionMismatch("incompatible dimensions, $nc and $(size(X,1))"))
+        end
+        $(cholname(:sdmult, TI))(A, transpose, Ref(α), Ref(β), X, Y, getcommon($TI))
+        Y
+    end
 
-function sdmult!(A::Sparse{Tv}, transpose::Bool,
-        α::Number, β::Number, X::Dense{Tv}, Y::Dense{Tv}) where Tv<:VTypes
-    m, n = size(A)
-    nc = transpose ? m : n
-    nr = transpose ? n : m
-    if nc != size(X, 1)
-        throw(DimensionMismatch("incompatible dimensions, $nc and $(size(X,1))"))
+    function vertcat(A::Sparse{Tv, $TI}, B::Sparse{Tv, $TI}, values::Bool) where Tv<:VRealTypes
+        Sparse{Tv, $TI}($(cholname(:vertcat, TI))(A, B, values, getcommon($TI)))
     end
-    cholmod_l_sdmult(A, transpose, Ref(α), Ref(β), X, Y, getcommon())
-    Y
-end
 
-function vertcat(A::Sparse{Tv}, B::Sparse{Tv}, values::Bool) where Tv<:VRealTypes
-    Sparse{Tv}(cholmod_l_vertcat(A, B, values, getcommon()))
-end
+    function symmetry(A::Sparse{Tv, $TI}, option::Integer) where Tv<:VTypes
+        xmatched = Ref{$TI}()
+        pmatched = Ref{$TI}()
+        nzoffdiag = Ref{$TI}()
+        nzdiag = Ref{$TI}()
+        rv = $(cholname(:symmetry, TI))(A, option, xmatched, pmatched,
+                                nzoffdiag, nzdiag, getcommon($TI))
+        rv, xmatched[], pmatched[], nzoffdiag[], nzdiag[]
+    end
 
-function symmetry(A::Sparse{Tv}, option::Integer) where Tv<:VTypes
-    xmatched = Ref{SuiteSparse_long}()
-    pmatched = Ref{SuiteSparse_long}()
-    nzoffdiag = Ref{SuiteSparse_long}()
-    nzdiag = Ref{SuiteSparse_long}()
-    rv = cholmod_l_symmetry(A, option, xmatched, pmatched,
-                            nzoffdiag, nzdiag, getcommon())
-    rv, xmatched[], pmatched[], nzoffdiag[], nzdiag[]
-end
+    # For analyze, analyze_p, and factorize_p!, the Common argument must be
+    # supplied in order to control if the factorization is LLt or LDLt
+    function analyze(A::Sparse{Tv, $TI}) where Tv<:VTypes
+        return Factor{Tv, $TI}($(cholname(:analyze, TI))(A, getcommon($TI)))
+    end
+    function analyze_p(A::Sparse{Tv, $TI}, perm::Vector{$TI}) where Tv<:VTypes
+        length(perm) != size(A,1) && throw(BoundsError())
+        Factor{Tv, $TI}($(cholname(:analyze_p, TI))(A, perm, C_NULL, 0, getcommon($TI)))
+    end
+    function factorize!(A::Sparse{Tv, $TI}, F::Factor{Tv, $TI}) where Tv<:VTypes
+        $(cholname(:factorize, TI))(A, F, getcommon($TI))
+        return F
+    end
+    function factorize_p!(A::Sparse{Tv, $TI}, β::Real, F::Factor{Tv, $TI}) where Tv<:VTypes
+        # note that β is passed as a complex number (double beta[2]),
+        # but the CHOLMOD manual says that only beta[0] (real part) is used
+        $(cholname(:factorize_p, TI))(A, Ref{Cdouble}(β), C_NULL, 0, F, getcommon($TI))
+        return F
+    end
 
-# For analyze, analyze_p, and factorize_p!, the Common argument must be
-# supplied in order to control if the factorization is LLt or LDLt
-function analyze(A::Sparse{Tv}) where Tv<:VTypes
-    Factor{Tv}(cholmod_l_analyze(A, getcommon()))
-end
-function analyze_p(A::Sparse{Tv}, perm::Vector{SuiteSparse_long}) where Tv<:VTypes
-    length(perm) != size(A,1) && throw(BoundsError())
-    Factor{Tv}(cholmod_l_analyze_p(A, perm, C_NULL, 0, getcommon()))
-end
-function factorize!(A::Sparse{Tv}, F::Factor{Tv}) where Tv<:VTypes
-    cholmod_l_factorize(A, F, getcommon())
-    F
-end
-function factorize_p!(A::Sparse{Tv}, β::Real, F::Factor{Tv}) where Tv<:VTypes
-    # note that β is passed as a complex number (double beta[2]),
-    # but the CHOLMOD manual says that only beta[0] (real part) is used
-    cholmod_l_factorize_p(A, Ref{Cdouble}(β), C_NULL, 0, F, getcommon())
-    F
-end
+    function solve(sys::Integer, F::Factor{Tv, $TI}, B::Dense{Tv}) where Tv<:VTypes
+        if size(F,1) != size(B,1)
+            throw(DimensionMismatch("LHS and RHS should have the same number of rows. " *
+                "LHS has $(size(F,1)) rows, but RHS has $(size(B,1)) rows."))
+        end
+        if !issuccess(F)
+            s = unsafe_load(pointer(F))
+            if s.is_ll == 1
+                throw(LinearAlgebra.PosDefException(s.minor))
+            else
+                throw(LinearAlgebra.ZeroPivotException(s.minor))
+            end
+        end
+        Dense{Tv}($(cholname(:solve, TI))(sys, F, B, getcommon($TI)))
+    end
 
-function solve(sys::Integer, F::Factor{Tv}, B::Dense{Tv}) where Tv<:VTypes
-    if size(F,1) != size(B,1)
-        throw(DimensionMismatch("LHS and RHS should have the same number of rows. " *
-            "LHS has $(size(F,1)) rows, but RHS has $(size(B,1)) rows."))
+    function spsolve(sys::Integer, F::Factor{Tv, $TI}, B::Sparse{Tv, $TI}) where Tv<:VTypes
+        if size(F,1) != size(B,1)
+            throw(DimensionMismatch("LHS and RHS should have the same number of rows. " *
+                "LHS has $(size(F,1)) rows, but RHS has $(size(B,1)) rows."))
+        end
+        Sparse{Tv, $TI}($(cholname(:spsolve, TI))(sys, F, B, getcommon($TI)))
     end
-    if !issuccess(F)
-        s = unsafe_load(pointer(F))
-        if s.is_ll == 1
-            throw(LinearAlgebra.PosDefException(s.minor))
-        else
-            throw(LinearAlgebra.ZeroPivotException(s.minor))
+    # Autodetects the types
+    # TODO: does this need another Sparse method to autodetect index type?
+    function read_sparse(file::Libc.FILE, ::Type{$TI})
+        Sparse($(cholname(:read_sparse, TI))(file.ptr, getcommon($TI)))
+    end
+    function lowrankupdowndate!(F::Factor{Tv, $TI}, C::Sparse{Tv, $TI}, update::Cint) where Tv<:VTypes
+        lF = unsafe_load(pointer(F))
+        lC = unsafe_load(pointer(C))
+        if lF.n != lC.nrow
+            throw(DimensionMismatch("matrix dimensions do not fit"))
         end
+        $(cholname(:updown, TI))(update, C, F, getcommon($TI))
+        return F
     end
-    Dense{Tv}(cholmod_l_solve(sys, F, B, getcommon()))
 end
-
-function spsolve(sys::Integer, F::Factor{Tv}, B::Sparse{Tv}) where Tv<:VTypes
-    if size(F,1) != size(B,1)
-        throw(DimensionMismatch("LHS and RHS should have the same number of rows. " *
-            "LHS has $(size(F,1)) rows, but RHS has $(size(B,1)) rows."))
-    end
-    Sparse{Tv}(cholmod_l_spsolve(sys, F, B, getcommon()))
 end
 
-# Autodetects the types
-function read_sparse(file::Libc.FILE, ::Type{SuiteSparse_long})
-    Sparse(cholmod_l_read_sparse(file.ptr, getcommon()))
+function speye(m::Integer, n::Integer, ::Type{Tv}) where Tv<:VTypes
+    speye(m, n, Tv, Int)
+end
+function spzeros(m::Integer, n::Integer, nzmax::Integer, ::Type{Tv}) where Tv<:VTypes
+    spzeros(m, n, nzmax, Tv, Int)
 end
 
 function read_sparse(file::IO, T)
@@ -658,7 +779,7 @@ function read_sparse(file::IO, T)
 end
 
 function get_perm(F::Factor)
-    s = unsafe_load(pointer(F))
+    s = unsafe_load(typedpointer(F))
     p = unsafe_wrap(Array, s.Perm, s.n, own = false)
     p .+ 1
 end
@@ -695,10 +816,10 @@ function Dense(A::Union{StridedVecOrMat, Adjoint{<:Any, <:StridedVecOrMat}, Tran
 end
 Dense(A::Sparse) = sparse_to_dense(A)
 
-# This constructior assumes zero based colptr and rowval
+# This constructor assumes zero based colptr and rowval
 function Sparse(m::Integer, n::Integer,
-        colptr0::Vector{SuiteSparse_long}, rowval0::Vector{SuiteSparse_long},
-        nzval::Vector{Tv}, stype) where Tv<:VTypes
+        colptr0::Vector{Ti}, rowval0::Vector{Ti},
+        nzval::Vector{Tv}, stype) where {Tv<:VTypes, Ti<:ITypes}
     # checks
     ## length of input
     if length(colptr0) <= n
@@ -719,8 +840,8 @@ function Sparse(m::Integer, n::Integer,
         end
     end
 
-    o = allocate_sparse(m, n, colptr0[n + 1], iss, true, stype, Tv)
-    s = unsafe_load(pointer(o))
+    o = allocate_sparse(m, n, colptr0[n + 1], iss, true, stype, Tv, Ti)
+    s = unsafe_load(typedpointer(o))
 
     unsafe_copyto!(s.p, pointer(colptr0), n + 1)
     unsafe_copyto!(s.i, pointer(rowval0), colptr0[n + 1])
@@ -732,9 +853,9 @@ function Sparse(m::Integer, n::Integer,
 end
 
 function Sparse(m::Integer, n::Integer,
-        colptr0::Vector{SuiteSparse_long},
-        rowval0::Vector{SuiteSparse_long},
-        nzval::Vector{<:VTypes})
+        colptr0::Vector{Ti},
+        rowval0::Vector{Ti},
+        nzval::Vector{<:VTypes}) where {Ti<:ITypes}
     o = Sparse(m, n, colptr0, rowval0, nzval, 0)
 
     # sort indices
@@ -747,7 +868,7 @@ function Sparse(m::Integer, n::Integer,
     o
 end
 
-function Sparse{Tv}(A::SparseMatrixCSC, stype::Integer) where Tv<:VTypes
+function Sparse{Tv}(A::SparseMatrixCSC{<:Any, Ti}, stype::Integer) where {Tv<:VTypes, Ti}
     ## Check length of input. This should never fail but see #20024
     if length(getcolptr(A)) <= size(A, 2)
         throw(ArgumentError("length of colptr must be at least size(A,2) + 1 = $(size(A, 2) + 1) but was $(length(getcolptr(A)))"))
@@ -759,8 +880,8 @@ function Sparse{Tv}(A::SparseMatrixCSC, stype::Integer) where Tv<:VTypes
         throw(ArgumentError("length of nzval is $(length(nonzeros(A))) but value of colptr requires length to be at least $(nnz(A))"))
     end
 
-    o = allocate_sparse(size(A, 1), size(A, 2), nnz(A), true, true, stype, Tv)
-    s = unsafe_load(pointer(o))
+    o = allocate_sparse(size(A, 1), size(A, 2), nnz(A), true, true, stype, Tv, Ti)
+    s = unsafe_load(typedpointer(o))
     for i = 1:(size(A, 2) + 1)
         unsafe_store!(s.p, getcolptr(A)[i] - 1, i)
     end
@@ -791,7 +912,7 @@ function Sparse{Tv}(A::SparseMatrixCSC, stype::Integer) where Tv<:VTypes
 end
 
 # handle promotion
-function Sparse(A::SparseMatrixCSC{Tv,SuiteSparse_long}, stype::Integer) where {Tv}
+function Sparse(A::SparseMatrixCSC{Tv, <:ITypes}, stype::Integer) where {Tv}
     T = promote_type(Tv, Float64)
     return Sparse{T}(A, stype)
 end
@@ -812,11 +933,11 @@ Sparse(A::Symmetric{Tv, SparseMatrixCSC{Tv,Ti}}) where {Tv<:Real, Ti} =
 Sparse(A::Hermitian{Tv,SparseMatrixCSC{Tv,Ti}}) where {Tv, Ti} =
     Sparse(A.data, A.uplo == 'L' ? -1 : 1)
 
-Sparse(A::Dense) = dense_to_sparse(A, SuiteSparse_long)
+Sparse(A::Dense) = dense_to_sparse(A, Int)
 Sparse(L::Factor) = factor_to_sparse!(copy(L))
 function Sparse(filename::String)
     open(filename) do f
-        return read_sparse(f, SuiteSparse_long)
+        return read_sparse(f, Int)
     end
 end
 
@@ -873,8 +994,8 @@ function _trim_nz_builder!(m, n, colptr, rowval, nzval)
     return (m, n, colptr, rowval, nzval)
 end
 
-function SparseVector{Tv,SuiteSparse_long}(A::Sparse{Tv}) where Tv
-    s = unsafe_load(pointer(A))
+function SparseVector{Tv, Ti}(A::Sparse{Tv, Ti}) where {Tv, Ti<:ITypes}
+    s = unsafe_load(typedpointer(A))
     if s.stype != 0
         throw(ArgumentError("matrix has stype != 0. Convert to matrix " *
             "with stype == 0 before converting to SparseVector"))
@@ -884,8 +1005,8 @@ function SparseVector{Tv,SuiteSparse_long}(A::Sparse{Tv}) where Tv
     return SparseVector(args[1], args[4], args[5])
 end
 
-function SparseMatrixCSC{Tv,SuiteSparse_long}(A::Sparse{Tv}) where Tv
-    s = unsafe_load(pointer(A))
+function SparseMatrixCSC{Tv,Ti}(A::Sparse{Tv, Ti}) where {Tv, Ti<:ITypes}
+    s = unsafe_load(typedpointer(A))
     if s.stype != 0
         throw(ArgumentError("matrix has stype != 0. Convert to matrix " *
             "with stype == 0 before converting to SparseMatrixCSC"))
@@ -894,44 +1015,45 @@ function SparseMatrixCSC{Tv,SuiteSparse_long}(A::Sparse{Tv}) where Tv
     s.sorted == 0 && _sort_buffers!(args...);
     return SparseMatrixCSC(_trim_nz_builder!(args...)...)
 end
+SparseMatrixCSC(A::Sparse{Tv, Ti}) where {Tv, Ti} = SparseMatrixCSC{Tv, Ti}(A)
 
-function Symmetric{Float64,SparseMatrixCSC{Float64,SuiteSparse_long}}(A::Sparse{Float64})
-    s = unsafe_load(pointer(A))
+function Symmetric{Float64,SparseMatrixCSC{Float64,Ti}}(A::Sparse{Float64, Ti}) where {Ti<:ITypes}
+    s = unsafe_load(typedpointer(A))
     issymmetric(A) || throw(ArgumentError("matrix is not symmetric"))
     args = _extract_args(s, Float64)
     s.sorted == 0 && _sort_buffers!(args...)
     Symmetric(SparseMatrixCSC(_trim_nz_builder!(args...)...), s.stype > 0 ? :U : :L)
 end
-convert(T::Type{Symmetric{Float64,SparseMatrixCSC{Float64,SuiteSparse_long}}}, A::Sparse{Float64}) = T(A)
+convert(T::Type{Symmetric{Float64,SparseMatrixCSC{Float64,Ti}}}, A::Sparse{Float64, Ti}) where {Ti<:ITypes} = T(A)
 
-function Hermitian{Tv,SparseMatrixCSC{Tv,SuiteSparse_long}}(A::Sparse{Tv}) where Tv<:VTypes
-    s = unsafe_load(pointer(A))
+function Hermitian{Tv,SparseMatrixCSC{Tv, Ti}}(A::Sparse{Tv, Ti}) where {Tv<:VTypes, Ti<:ITypes}
+    s = unsafe_load(typedpointer(A))
     ishermitian(A) || throw(ArgumentError("matrix is not Hermitian"))
     args = _extract_args(s, Tv)
     s.sorted == 0 && _sort_buffers!(args...)
     Hermitian(SparseMatrixCSC(_trim_nz_builder!(args...)...), s.stype > 0 ? :U : :L)
 end
-convert(T::Type{Hermitian{Tv,SparseMatrixCSC{Tv,SuiteSparse_long}}}, A::Sparse{Tv}) where {Tv<:VTypes} = T(A)
+convert(T::Type{Hermitian{Tv,SparseMatrixCSC{Tv,Ti}}}, A::Sparse{Tv, Ti}) where {Tv<:VTypes, Ti<:ITypes} = T(A)
 
-function sparsevec(A::Sparse{Tv}) where {Tv}
+function sparsevec(A::Sparse{Tv, Ti}) where {Tv, Ti}
     s = unsafe_load(pointer(A))
     @assert s.stype == 0
-    return SparseVector{Tv,SuiteSparse_long}(A)
+    return SparseVector{Tv, Ti}(A)
 end
 
-function sparse(A::Sparse{Float64}) # Notice! Cannot be type stable because of stype
+function sparse(A::Sparse{Float64, Ti}) where Ti # Notice! Cannot be type stable because of stype
     s = unsafe_load(pointer(A))
     if s.stype == 0
-        return SparseMatrixCSC{Float64,SuiteSparse_long}(A)
+        return SparseMatrixCSC{Float64, Ti}(A)
     end
-    Symmetric{Float64,SparseMatrixCSC{Float64,SuiteSparse_long}}(A)
+    Symmetric{Float64,SparseMatrixCSC{Float64, Ti}}(A)
 end
-function sparse(A::Sparse{ComplexF64}) # Notice! Cannot be type stable because of stype
+function sparse(A::Sparse{ComplexF64, Ti}) where Ti # Notice! Cannot be type stable because of stype
     s = unsafe_load(pointer(A))
     if s.stype == 0
-        return SparseMatrixCSC{ComplexF64,SuiteSparse_long}(A)
+        return SparseMatrixCSC{ComplexF64, Ti}(A)
     end
-    Hermitian{ComplexF64,SparseMatrixCSC{ComplexF64,SuiteSparse_long}}(A)
+    Hermitian{ComplexF64,SparseMatrixCSC{ComplexF64, Ti}}(A)
 end
 function sparse(F::Factor)
     s = unsafe_load(pointer(F))
@@ -977,8 +1099,8 @@ function change_stype!(A::Sparse, i::Integer)
 end
 
 free!(A::Dense)  = free!(pointer(A))
-free!(A::Sparse) = free!(pointer(A))
-free!(F::Factor) = free!(pointer(F))
+free!(A::Sparse{<:Any, Ti}) where Ti = free!(pointer(A), Ti)
+free!(F::Factor{<:Any, Ti}) where Ti = free!(pointer(F), Ti)
 
 nnz(F::Factor) = nnz(Sparse(F))
 
@@ -1051,7 +1173,7 @@ end
 
 IndexStyle(::Sparse) = IndexCartesian()
 function getindex(A::Sparse{T}, i0::Integer, i1::Integer) where T
-    s = unsafe_load(pointer(A))
+    s = unsafe_load(typedpointer(A))
     !(1 <= i0 <= s.nrow && 1 <= i1 <= s.ncol) && throw(BoundsError())
     s.stype < 0 && i0 < i1 && return conj(A[i1,i0])
     s.stype > 0 && i0 > i1 && return conj(A[i1,i0])
@@ -1095,7 +1217,7 @@ end
 (*)(A::Sparse, B::Dense) = sdmult!(A, false, 1., 0., B, zeros(size(A, 1), size(B, 2)))
 (*)(A::Sparse, B::VecOrMat) = (*)(A, Dense(B))
 
-function *(A::Sparse{Tv}, adjB::Adjoint{Tv,Sparse{Tv}}) where Tv<:VRealTypes
+function *(A::Sparse{Tv, Ti}, adjB::Adjoint{Tv,Sparse{Tv, Ti}}) where {Tv<:VRealTypes, Ti}
     B = adjB.parent
     if A !== B
         aa1 = transpose_(B, 2)
@@ -1107,7 +1229,7 @@ function *(A::Sparse{Tv}, adjB::Adjoint{Tv,Sparse{Tv}}) where Tv<:VRealTypes
     ## A->stype == 0 (storage of upper and lower parts). If necessary
     ## the matrix A is first converted to stype == 0
     s = unsafe_load(pointer(A))
-    fset = s.ncol == 0 ? SuiteSparse_long[] : SuiteSparse_long[0:s.ncol-1;]
+    fset = s.ncol == 0 ? Ti[] : Ti[0:s.ncol-1;]
     if s.stype != 0
         aa1 = copy(A, 0, 1)
         return aat(aa1, fset, 1)
@@ -1135,9 +1257,9 @@ end
 ## Factorization methods
 
 ## Compute that symbolic factorization only
-function symbolic(A::Sparse{<:VTypes};
-    perm::Union{Nothing,AbstractVector{SuiteSparse_long}}=nothing,
-    postorder::Bool=isnothing(perm)||isempty(perm), userperm_only::Bool=true)
+function symbolic(A::Sparse{<:VTypes, Ti};
+    perm::Union{Nothing,AbstractVector{<:Integer}}=nothing,
+    postorder::Bool=isnothing(perm)||isempty(perm), userperm_only::Bool=true) where Ti
 
     sA = unsafe_load(pointer(A))
     sA.stype == 0 && throw(ArgumentError("sparse matrix is not symmetric/Hermitian"))
@@ -1148,10 +1270,10 @@ function symbolic(A::Sparse{<:VTypes};
         else # user permutation provided
             if userperm_only # use perm even if it is worse than AMD
                 @cholmod_param nmethods = 1 begin
-                    return analyze_p(A, SuiteSparse_long[p-1 for p in perm])
+                    return analyze_p(A, Ti[p-1 for p in perm])
                 end
             else
-                return analyze_p(A, SuiteSparse_long[p-1 for p in perm])
+                return analyze_p(A, Ti[p-1 for p in perm])
             end
         end
     end
@@ -1186,14 +1308,14 @@ See also [`cholesky`](@ref).
 """
 cholesky!(F::Factor, A::Union{SparseMatrixCSC{T},
           SparseMatrixCSC{Complex{T}},
-          Symmetric{T,SparseMatrixCSC{T,SuiteSparse_long}},
-          Hermitian{Complex{T},SparseMatrixCSC{Complex{T},SuiteSparse_long}},
-          Hermitian{T,SparseMatrixCSC{T,SuiteSparse_long}}};
+          Symmetric{T,<:SparseMatrixCSC{T}},
+          Hermitian{Complex{T},<:SparseMatrixCSC{Complex{T}}},
+          Hermitian{T,<:SparseMatrixCSC{T}}};
           shift = 0.0, check::Bool = true) where {T<:Real} =
     cholesky!(F, Sparse(A); shift = shift, check = check)
 
 function cholesky(A::Sparse; shift::Real=0.0, check::Bool = true,
-    perm::Union{Nothing,AbstractVector{SuiteSparse_long}}=nothing)
+    perm::Union{Nothing,AbstractVector{<:Integer}}=nothing)
 
     # Compute the symbolic factorization
     F = symbolic(A; perm = perm)
@@ -1245,7 +1367,7 @@ julia> A = [2 1 1; 1 2 0; 1 0 2]
  1  0  2
 
 julia> C = cholesky(sparse(A))
-SparseArrays.CHOLMOD.Factor{Float64}
+SparseArrays.CHOLMOD.Factor{Float64, $(Int)}
 type:    LLt
 method:  simplicial
 maxnnz:  5
@@ -1253,7 +1375,7 @@ nnz:     5
 success: true
 
 julia> C.p
-3-element Vector{Int64}:
+3-element Vector{$(Int)}:
  3
  2
  1
@@ -1270,7 +1392,7 @@ julia> L * L' ≈ A[C.p, C.p]
 true
 
 julia> P = sparse(1:3, C.p, ones(3))
-3×3 SparseMatrixCSC{Float64, Int64} with 3 stored entries:
+3×3 SparseMatrixCSC{Float64, $(Int)} with 3 stored entries:
   ⋅    ⋅   1.0
   ⋅   1.0   ⋅
  1.0   ⋅    ⋅
@@ -1279,7 +1401,7 @@ julia> P' * L * L' * P ≈ A
 true
 
 julia> C = cholesky(sparse(A), perm=1:3)
-SparseArrays.CHOLMOD.Factor{Float64}
+SparseArrays.CHOLMOD.Factor{Float64, $(Int)}
 type:    LLt
 method:  simplicial
 maxnnz:  6
@@ -1313,12 +1435,11 @@ true
 [^DavisHager2009]: Davis, Timothy A., & Hager, W. W. (2009). Dynamic Supernodes in Sparse Cholesky Update/Downdate and Triangular Solves. ACM Trans. Math. Softw., 35(4). [doi:10.1145/1462173.1462176](https://doi.org/10.1145/1462173.1462176)
 """
 cholesky(A::Union{SparseMatrixCSC{T}, SparseMatrixCSC{Complex{T}},
-    Symmetric{T,SparseMatrixCSC{T,SuiteSparse_long}},
-    Hermitian{Complex{T},SparseMatrixCSC{Complex{T},SuiteSparse_long}},
-    Hermitian{T,SparseMatrixCSC{T,SuiteSparse_long}}};
+    Symmetric{T, <:SparseMatrixCSC{T}},
+    Hermitian{Complex{T}, <:SparseMatrixCSC{Complex{T}}},
+    Hermitian{T, <:SparseMatrixCSC{T}}};
     kws...) where {T<:Real} = cholesky(Sparse(A); kws...)
 
-
 function ldlt!(F::Factor{Tv}, A::Sparse{Tv};
                shift::Real=0.0, check::Bool = true) where Tv
     # Makes it an LDLt
@@ -1349,14 +1470,14 @@ See also [`ldlt`](@ref).
 """
 ldlt!(F::Factor, A::Union{SparseMatrixCSC{T},
     SparseMatrixCSC{Complex{T}},
-    Symmetric{T,SparseMatrixCSC{T,SuiteSparse_long}},
-    Hermitian{Complex{T},SparseMatrixCSC{Complex{T},SuiteSparse_long}},
-    Hermitian{T,SparseMatrixCSC{T,SuiteSparse_long}}};
+    Symmetric{T, <:SparseMatrixCSC{T}},
+    Hermitian{Complex{T}, <:SparseMatrixCSC{Complex{T}}},
+    Hermitian{T, <:SparseMatrixCSC{T}}};
     shift = 0.0, check::Bool = true) where {T<:Real} =
     ldlt!(F, Sparse(A), shift = shift, check = check)
 
 function ldlt(A::Sparse; shift::Real=0.0, check::Bool = true,
-    perm::Union{Nothing,AbstractVector{SuiteSparse_long}}=nothing)
+    perm::Union{Nothing,AbstractVector{<:Integer}}=nothing)
 
     # Makes it an LDLt
     @cholmod_param final_ll = false begin
@@ -1411,10 +1532,10 @@ it should be a permutation of `1:size(A,1)` giving the ordering to use
     Many other functions from CHOLMOD are wrapped but not exported from the
     `Base.SparseArrays.CHOLMOD` module.
 """
-ldlt(A::Union{SparseMatrixCSC{T},SparseMatrixCSC{Complex{T}},
-    Symmetric{T,SparseMatrixCSC{T,SuiteSparse_long}},
-    Hermitian{Complex{T},SparseMatrixCSC{Complex{T},SuiteSparse_long}},
-    Hermitian{T,SparseMatrixCSC{T,SuiteSparse_long}}};
+ldlt(A::Union{SparseMatrixCSC{T}, SparseMatrixCSC{Complex{T}},
+    Symmetric{T, <:SparseMatrixCSC{T}},
+    Hermitian{Complex{T}, <:SparseMatrixCSC{Complex{T}}},
+    Hermitian{T, <:SparseMatrixCSC{T}}};
     kws...) where {T<:Real} = ldlt(Sparse(A); kws...)
 
 ## Rank updates
@@ -1429,15 +1550,7 @@ factor will be `L*L' == P*A*P' + C'*C`
 
 `update`: `Cint(1)` for `A + CC'`, `Cint(0)` for `A - CC'`
 """
-function lowrankupdowndate!(F::Factor{Tv}, C::Sparse{Tv}, update::Cint) where Tv<:VTypes
-    lF = unsafe_load(pointer(F))
-    lC = unsafe_load(pointer(C))
-    if lF.n != lC.nrow
-        throw(DimensionMismatch("matrix dimensions do not fit"))
-    end
-    cholmod_l_updown(update, C, F, getcommon())
-    F
-end
+lowrankdowndate!
 
 #Helper functions for rank updates
 lowrank_reorder(V::AbstractArray,p) = Sparse(sparse(V[p,:]))
@@ -1597,17 +1710,17 @@ function \(adjL::AdjointFactorization{<:VTypes,<:Factor}, B::StridedMatrix)
     return Matrix(solve(CHOLMOD_A, L, Dense(B)))
 end
 
-const RealHermSymComplexHermF64SSL = Union{
-    Symmetric{Float64,SparseMatrixCSC{Float64,SuiteSparse_long}},
-    Hermitian{Float64,SparseMatrixCSC{Float64,SuiteSparse_long}},
-    Hermitian{ComplexF64,SparseMatrixCSC{ComplexF64,SuiteSparse_long}}}
+const RealHermSymComplexHermF64SSL{Ti} = Union{
+    Symmetric{Float64, SparseMatrixCSC{Float64, Ti}},
+    Hermitian{Float64, SparseMatrixCSC{Float64, Ti}},
+    Hermitian{ComplexF64, SparseMatrixCSC{ComplexF64, Ti}}} where {Ti<:ITypes}
 const StridedVecOrMatInclAdjAndTrans = Union{StridedVecOrMat, Adjoint{<:Any, <:StridedVecOrMat}, Transpose{<:Any, <:StridedVecOrMat}}
-function \(A::RealHermSymComplexHermF64SSL, B::StridedVecOrMatInclAdjAndTrans)
+function \(A::RealHermSymComplexHermF64SSL{Ti}, B::StridedVecOrMatInclAdjAndTrans) where Ti
     F = cholesky(A; check = false)
     if issuccess(F)
         return \(F, B)
     else
-        return \(lu(SparseMatrixCSC{eltype(A), SuiteSparse_long}(A)), B)
+        return \(lu(SparseMatrixCSC{eltype(A), Ti}(A)), B)
     end
 end
 
@@ -1617,14 +1730,14 @@ const AbstractSparseVecOrMatInclAdjAndTrans = Union{AbstractSparseVecOrMat, AdjO
         " consider to convert B to a dense array"))
 
 ## Other convenience methods
-function diag(F::Factor{Tv}) where Tv
-    f = unsafe_load(pointer(F))
-    fsuper = Ptr{SuiteSparse_long}(f.super)
-    fpi = Ptr{SuiteSparse_long}(f.pi)
+function diag(F::Factor{Tv, Ti}) where {Tv, Ti}
+    f = unsafe_load(typedpointer(F))
+    fsuper = f.super
+    fpi = f.pi
     res = Base.zeros(Tv, Int(f.n))
     xv  = Ptr{Tv}(f.x)
     if f.is_super!=0
-        px = Ptr{SuiteSparse_long}(f.px)
+        px = f.px
         pos = 1
         for i in 1:f.nsuper
             base = unsafe_load(px, i) + 1
@@ -1637,8 +1750,8 @@ function diag(F::Factor{Tv}) where Tv
             end
         end
     else
-        c0 = Ptr{SuiteSparse_long}(f.p)
-        r0 = Ptr{SuiteSparse_long}(f.i)
+        c0 = f.p
+        r0 = f.i
         xv = Ptr{Tv}(f.x)
         for j in 1:f.n
             jj = unsafe_load(c0, j) + 1
diff --git a/src/solvers/lib/aarch64-apple-darwin20.jl b/src/solvers/lib/aarch64-apple-darwin20.jl
index fcf756d2..a5aa4e44 100644
--- a/src/solvers/lib/aarch64-apple-darwin20.jl
+++ b/src/solvers/lib/aarch64-apple-darwin20.jl
@@ -1,137 +1,150 @@
 function SuiteSparse_config_printf_func_get()
-    @ccall libcholmod.SuiteSparse_config_printf_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_printf_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_malloc_func_get()
-    @ccall libcholmod.SuiteSparse_config_malloc_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_malloc_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_calloc_func_get()
-    @ccall libcholmod.SuiteSparse_config_calloc_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_calloc_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_realloc_func_get()
-    @ccall libcholmod.SuiteSparse_config_realloc_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_realloc_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_free_func_get()
-    @ccall libcholmod.SuiteSparse_config_free_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_free_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_hypot_func_get()
-    @ccall libcholmod.SuiteSparse_config_hypot_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_hypot_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_divcomplex_func_get()
-    @ccall libcholmod.SuiteSparse_config_divcomplex_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_divcomplex_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_malloc_func_set(malloc_func)
-    @ccall libcholmod.SuiteSparse_config_malloc_func_set(malloc_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_malloc_func_set(malloc_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_calloc_func_set(calloc_func)
-    @ccall libcholmod.SuiteSparse_config_calloc_func_set(calloc_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_calloc_func_set(calloc_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_realloc_func_set(realloc_func)
-    @ccall libcholmod.SuiteSparse_config_realloc_func_set(realloc_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_realloc_func_set(realloc_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_free_func_set(free_func)
-    @ccall libcholmod.SuiteSparse_config_free_func_set(free_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_free_func_set(free_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_printf_func_set(printf_func)
-    @ccall libcholmod.SuiteSparse_config_printf_func_set(printf_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_printf_func_set(printf_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_hypot_func_set(hypot_func)
-    @ccall libcholmod.SuiteSparse_config_hypot_func_set(hypot_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_hypot_func_set(hypot_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_divcomplex_func_set(divcomplex_func)
-    @ccall libcholmod.SuiteSparse_config_divcomplex_func_set(divcomplex_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_divcomplex_func_set(divcomplex_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_malloc(s)
-    @ccall libcholmod.SuiteSparse_config_malloc(s::Csize_t)::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_malloc(s::Csize_t)::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_calloc(n, s)
-    @ccall libcholmod.SuiteSparse_config_calloc(n::Csize_t, s::Csize_t)::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_calloc(n::Csize_t,
+                                                          s::Csize_t)::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_realloc(arg1, s)
-    @ccall libcholmod.SuiteSparse_config_realloc(arg1::Ptr{Cvoid}, s::Csize_t)::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_realloc(arg1::Ptr{Cvoid},
+                                                           s::Csize_t)::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_free(arg1)
-    @ccall libcholmod.SuiteSparse_config_free(arg1::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_free(arg1::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_hypot(x, y)
-    @ccall libcholmod.SuiteSparse_config_hypot(x::Cdouble, y::Cdouble)::Cdouble
+    @ccall libsuitesparseconfig.SuiteSparse_config_hypot(x::Cdouble, y::Cdouble)::Cdouble
 end
 
 function SuiteSparse_config_divcomplex(xr, xi, yr, yi, zr, zi)
-    @ccall libcholmod.SuiteSparse_config_divcomplex(xr::Cdouble, xi::Cdouble, yr::Cdouble, yi::Cdouble, zr::Ptr{Cdouble}, zi::Ptr{Cdouble})::Cint
+    @ccall libsuitesparseconfig.SuiteSparse_config_divcomplex(xr::Cdouble, xi::Cdouble,
+                                                              yr::Cdouble, yi::Cdouble,
+                                                              zr::Ptr{Cdouble},
+                                                              zi::Ptr{Cdouble})::Cint
 end
 
 function SuiteSparse_start()
-    @ccall libcholmod.SuiteSparse_start()::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_start()::Cvoid
 end
 
 function SuiteSparse_finish()
-    @ccall libcholmod.SuiteSparse_finish()::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_finish()::Cvoid
 end
 
 function SuiteSparse_malloc(nitems, size_of_item)
-    @ccall libcholmod.SuiteSparse_malloc(nitems::Csize_t, size_of_item::Csize_t)::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_malloc(nitems::Csize_t,
+                                                   size_of_item::Csize_t)::Ptr{Cvoid}
 end
 
 function SuiteSparse_calloc(nitems, size_of_item)
-    @ccall libcholmod.SuiteSparse_calloc(nitems::Csize_t, size_of_item::Csize_t)::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_calloc(nitems::Csize_t,
+                                                   size_of_item::Csize_t)::Ptr{Cvoid}
 end
 
 function SuiteSparse_realloc(nitems_new, nitems_old, size_of_item, p, ok)
-    @ccall libcholmod.SuiteSparse_realloc(nitems_new::Csize_t, nitems_old::Csize_t, size_of_item::Csize_t, p::Ptr{Cvoid}, ok::Ptr{Cint})::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_realloc(nitems_new::Csize_t,
+                                                    nitems_old::Csize_t,
+                                                    size_of_item::Csize_t, p::Ptr{Cvoid},
+                                                    ok::Ptr{Cint})::Ptr{Cvoid}
 end
 
 function SuiteSparse_free(p)
-    @ccall libcholmod.SuiteSparse_free(p::Ptr{Cvoid})::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_free(p::Ptr{Cvoid})::Ptr{Cvoid}
 end
 
 function SuiteSparse_tic(tic)
-    @ccall libcholmod.SuiteSparse_tic(tic::Ptr{Cdouble})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_tic(tic::Ptr{Cdouble})::Cvoid
 end
 
 function SuiteSparse_toc(tic)
-    @ccall libcholmod.SuiteSparse_toc(tic::Ptr{Cdouble})::Cdouble
+    @ccall libsuitesparseconfig.SuiteSparse_toc(tic::Ptr{Cdouble})::Cdouble
 end
 
 function SuiteSparse_time()
-    @ccall libcholmod.SuiteSparse_time()::Cdouble
+    @ccall libsuitesparseconfig.SuiteSparse_time()::Cdouble
 end
 
 function SuiteSparse_hypot(x, y)
-    @ccall libcholmod.SuiteSparse_hypot(x::Cdouble, y::Cdouble)::Cdouble
+    @ccall libsuitesparseconfig.SuiteSparse_hypot(x::Cdouble, y::Cdouble)::Cdouble
 end
 
 function SuiteSparse_divcomplex(ar, ai, br, bi, cr, ci)
-    @ccall libcholmod.SuiteSparse_divcomplex(ar::Cdouble, ai::Cdouble, br::Cdouble, bi::Cdouble, cr::Ptr{Cdouble}, ci::Ptr{Cdouble})::Cint
+    @ccall libsuitesparseconfig.SuiteSparse_divcomplex(ar::Cdouble, ai::Cdouble,
+                                                       br::Cdouble, bi::Cdouble,
+                                                       cr::Ptr{Cdouble},
+                                                       ci::Ptr{Cdouble})::Cint
 end
 
 function SuiteSparse_version(version)
-    @ccall libcholmod.SuiteSparse_version(version::Ptr{Cint})::Cint
+    @ccall libsuitesparseconfig.SuiteSparse_version(version::Ptr{Cint})::Cint
 end
 
 function SuiteSparse_BLAS_library()
-    @ccall libcholmod.SuiteSparse_BLAS_library()::Ptr{Cchar}
+    @ccall libsuitesparseconfig.SuiteSparse_BLAS_library()::Ptr{Cchar}
 end
 
 function SuiteSparse_BLAS_integer_size()
-    @ccall libcholmod.SuiteSparse_BLAS_integer_size()::Csize_t
+    @ccall libsuitesparseconfig.SuiteSparse_BLAS_integer_size()::Csize_t
 end
 
 struct cholmod_method_struct
@@ -140,16 +153,16 @@ struct cholmod_method_struct
     prune_dense::Cdouble
     prune_dense2::Cdouble
     nd_oksep::Cdouble
-    other_1::NTuple{4, Cdouble}
+    other_1::NTuple{4,Cdouble}
     nd_small::Csize_t
-    other_2::NTuple{4, Csize_t}
+    other_2::NTuple{4,Csize_t}
     aggressive::Cint
     order_for_lu::Cint
     nd_compress::Cint
     nd_camd::Cint
     nd_components::Cint
     ordering::Cint
-    other_3::NTuple{4, Csize_t}
+    other_3::NTuple{4,Csize_t}
 end
 
 mutable struct cholmod_common_struct
@@ -166,8 +179,8 @@ mutable struct cholmod_common_struct
     final_pack::Cint
     final_monotonic::Cint
     final_resymbol::Cint
-    zrelax::NTuple{3, Cdouble}
-    nrelax::NTuple{3, Csize_t}
+    zrelax::NTuple{3,Cdouble}
+    nrelax::NTuple{3,Csize_t}
     prefer_zomplex::Cint
     prefer_upper::Cint
     quick_return_if_not_posdef::Cint
@@ -179,7 +192,7 @@ mutable struct cholmod_common_struct
     nmethods::Cint
     current::Cint
     selected::Cint
-    method::NTuple{10, cholmod_method_struct}
+    method::NTuple{10,cholmod_method_struct}
     postorder::Cint
     default_nesdis::Cint
     metis_memory::Cdouble
@@ -222,7 +235,7 @@ mutable struct cholmod_common_struct
     SPQR_flopcount_bound::Cdouble
     SPQR_tol_used::Cdouble
     SPQR_norm_E_fro::Cdouble
-    SPQR_istat::NTuple{10, Int64}
+    SPQR_istat::NTuple{10,Int64}
     useGPU::Cint
     maxGpuMemBytes::Csize_t
     maxGpuMemFraction::Cdouble
@@ -231,10 +244,10 @@ mutable struct cholmod_common_struct
     gpuFlops::Int64
     gpuNumKernelLaunches::Cint
     cublasHandle::Ptr{Cvoid}
-    gpuStream::NTuple{8, Ptr{Cvoid}}
-    cublasEventPotrf::NTuple{3, Ptr{Cvoid}}
+    gpuStream::NTuple{8,Ptr{Cvoid}}
+    cublasEventPotrf::NTuple{3,Ptr{Cvoid}}
     updateCKernelsComplete::Ptr{Cvoid}
-    updateCBuffersFree::NTuple{8, Ptr{Cvoid}}
+    updateCBuffersFree::NTuple{8,Ptr{Cvoid}}
     dev_mempool::Ptr{Cvoid}
     dev_mempool_size::Csize_t
     host_pinned_mempool::Ptr{Cvoid}
@@ -300,11 +313,14 @@ function cholmod_l_maxrank(arg1, arg2)
 end
 
 function cholmod_allocate_work(nrow, iworksize, xworksize, Common)
-    @ccall libcholmod.cholmod_allocate_work(nrow::Csize_t, iworksize::Csize_t, xworksize::Csize_t, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_allocate_work(nrow::Csize_t, iworksize::Csize_t,
+                                            xworksize::Csize_t,
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_allocate_work(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_allocate_work(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_allocate_work(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t,
+                                              arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_free_work(Common)
@@ -324,11 +340,13 @@ function cholmod_l_clear_flag(arg1)
 end
 
 function cholmod_error(status, file, line, message, Common)
-    @ccall libcholmod.cholmod_error(status::Cint, file::Ptr{Cchar}, line::Cint, message::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_error(status::Cint, file::Ptr{Cchar}, line::Cint,
+                                    message::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_error(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_error(arg1::Cint, arg2::Ptr{Cchar}, arg3::Cint, arg4::Ptr{Cchar}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_error(arg1::Cint, arg2::Ptr{Cchar}, arg3::Cint,
+                                      arg4::Ptr{Cchar}, arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_dbound(dj, Common)
@@ -348,11 +366,14 @@ function cholmod_l_hypot(arg1, arg2)
 end
 
 function cholmod_divcomplex(ar, ai, br, bi, cr, ci)
-    @ccall libcholmod.cholmod_divcomplex(ar::Cdouble, ai::Cdouble, br::Cdouble, bi::Cdouble, cr::Ptr{Cdouble}, ci::Ptr{Cdouble})::Cint
+    @ccall libcholmod.cholmod_divcomplex(ar::Cdouble, ai::Cdouble, br::Cdouble, bi::Cdouble,
+                                         cr::Ptr{Cdouble}, ci::Ptr{Cdouble})::Cint
 end
 
 function cholmod_l_divcomplex(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_divcomplex(arg1::Cdouble, arg2::Cdouble, arg3::Cdouble, arg4::Cdouble, arg5::Ptr{Cdouble}, arg6::Ptr{Cdouble})::Cint
+    @ccall libcholmod.cholmod_l_divcomplex(arg1::Cdouble, arg2::Cdouble, arg3::Cdouble,
+                                           arg4::Cdouble, arg5::Ptr{Cdouble},
+                                           arg6::Ptr{Cdouble})::Cint
 end
 
 mutable struct cholmod_sparse_struct
@@ -384,155 +405,217 @@ end
 const descendantScore = cholmod_descendant_score_t
 
 function cholmod_score_comp(i, j)
-    @ccall libcholmod.cholmod_score_comp(i::Ptr{cholmod_descendant_score_t}, j::Ptr{cholmod_descendant_score_t})::Cint
+    @ccall libcholmod.cholmod_score_comp(i::Ptr{cholmod_descendant_score_t},
+                                         j::Ptr{cholmod_descendant_score_t})::Cint
 end
 
 function cholmod_l_score_comp(i, j)
-    @ccall libcholmod.cholmod_l_score_comp(i::Ptr{cholmod_descendant_score_t}, j::Ptr{cholmod_descendant_score_t})::Cint
+    @ccall libcholmod.cholmod_l_score_comp(i::Ptr{cholmod_descendant_score_t},
+                                           j::Ptr{cholmod_descendant_score_t})::Cint
 end
 
 function cholmod_allocate_sparse(nrow, ncol, nzmax, sorted, packed, stype, xtype, Common)
-    @ccall libcholmod.cholmod_allocate_sparse(nrow::Csize_t, ncol::Csize_t, nzmax::Csize_t, sorted::Cint, packed::Cint, stype::Cint, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_allocate_sparse(nrow::Csize_t, ncol::Csize_t, nzmax::Csize_t,
+                                              sorted::Cint, packed::Cint, stype::Cint,
+                                              xtype::Cint,
+                                              Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_allocate_sparse(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
-    @ccall libcholmod.cholmod_l_allocate_sparse(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t, arg4::Cint, arg5::Cint, arg6::Cint, arg7::Cint, arg8::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_allocate_sparse(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t,
+                                                arg4::Cint, arg5::Cint, arg6::Cint,
+                                                arg7::Cint,
+                                                arg8::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_free_sparse(A, Common)
-    @ccall libcholmod.cholmod_free_sparse(A::Ptr{Ptr{cholmod_sparse}}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_free_sparse(A::Ptr{Ptr{cholmod_sparse}},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_free_sparse(arg1, arg2)
-    @ccall libcholmod.cholmod_l_free_sparse(arg1::Ptr{Ptr{cholmod_sparse}}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_free_sparse(arg1::Ptr{Ptr{cholmod_sparse}},
+                                            arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_reallocate_sparse(nznew, A, Common)
-    @ccall libcholmod.cholmod_reallocate_sparse(nznew::Csize_t, A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_reallocate_sparse(nznew::Csize_t, A::Ptr{cholmod_sparse},
+                                                Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_reallocate_sparse(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_reallocate_sparse(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_reallocate_sparse(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                                  arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_nnz(A, Common)
-    @ccall libcholmod.cholmod_nnz(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_nnz(A::Ptr{cholmod_sparse},
+                                  Common::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_l_nnz(arg1, arg2)
-    @ccall libcholmod.cholmod_l_nnz(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_l_nnz(arg1::Ptr{cholmod_sparse},
+                                    arg2::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_speye(nrow, ncol, xtype, Common)
-    @ccall libcholmod.cholmod_speye(nrow::Csize_t, ncol::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_speye(nrow::Csize_t, ncol::Csize_t, xtype::Cint,
+                                    Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_speye(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_speye(arg1::Csize_t, arg2::Csize_t, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_speye(arg1::Csize_t, arg2::Csize_t, arg3::Cint,
+                                      arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_spzeros(nrow, ncol, nzmax, xtype, Common)
-    @ccall libcholmod.cholmod_spzeros(nrow::Csize_t, ncol::Csize_t, nzmax::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_spzeros(nrow::Csize_t, ncol::Csize_t, nzmax::Csize_t,
+                                      xtype::Cint,
+                                      Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_spzeros(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_spzeros(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t, arg4::Cint, arg5::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_spzeros(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t,
+                                        arg4::Cint,
+                                        arg5::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_transpose(A, values, Common)
-    @ccall libcholmod.cholmod_transpose(A::Ptr{cholmod_sparse}, values::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_transpose(A::Ptr{cholmod_sparse}, values::Cint,
+                                        Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_transpose(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_transpose(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_transpose(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                          arg3::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_transpose_unsym(A, values, Perm, fset, fsize, F, Common)
-    @ccall libcholmod.cholmod_transpose_unsym(A::Ptr{cholmod_sparse}, values::Cint, Perm::Ptr{Int32}, fset::Ptr{Int32}, fsize::Csize_t, F::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_transpose_unsym(A::Ptr{cholmod_sparse}, values::Cint,
+                                              Perm::Ptr{Int32}, fset::Ptr{Int32},
+                                              fsize::Csize_t, F::Ptr{cholmod_sparse},
+                                              Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_transpose_unsym(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_transpose_unsym(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Csize_t, arg6::Ptr{cholmod_sparse}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_transpose_unsym(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                                arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                                arg5::Csize_t, arg6::Ptr{cholmod_sparse},
+                                                arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_transpose_sym(A, values, Perm, F, Common)
-    @ccall libcholmod.cholmod_transpose_sym(A::Ptr{cholmod_sparse}, values::Cint, Perm::Ptr{Int32}, F::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_transpose_sym(A::Ptr{cholmod_sparse}, values::Cint,
+                                            Perm::Ptr{Int32}, F::Ptr{cholmod_sparse},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_transpose_sym(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_transpose_sym(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{Int64}, arg4::Ptr{cholmod_sparse}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_transpose_sym(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                              arg3::Ptr{Int64}, arg4::Ptr{cholmod_sparse},
+                                              arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_ptranspose(A, values, Perm, fset, fsize, Common)
-    @ccall libcholmod.cholmod_ptranspose(A::Ptr{cholmod_sparse}, values::Cint, Perm::Ptr{Int32}, fset::Ptr{Int32}, fsize::Csize_t, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_ptranspose(A::Ptr{cholmod_sparse}, values::Cint,
+                                         Perm::Ptr{Int32}, fset::Ptr{Int32}, fsize::Csize_t,
+                                         Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_ptranspose(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_ptranspose(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Csize_t, arg6::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_ptranspose(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                           arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                           arg5::Csize_t,
+                                           arg6::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_sort(A, Common)
-    @ccall libcholmod.cholmod_sort(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_sort(A::Ptr{cholmod_sparse},
+                                   Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_sort(arg1, arg2)
-    @ccall libcholmod.cholmod_l_sort(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_sort(arg1::Ptr{cholmod_sparse},
+                                     arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_band(A, k1, k2, mode, Common)
-    @ccall libcholmod.cholmod_band(A::Ptr{cholmod_sparse}, k1::Int64, k2::Int64, mode::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_band(A::Ptr{cholmod_sparse}, k1::Int64, k2::Int64, mode::Cint,
+                                   Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_band(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_band(arg1::Ptr{cholmod_sparse}, arg2::Int64, arg3::Int64, arg4::Cint, arg5::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_band(arg1::Ptr{cholmod_sparse}, arg2::Int64, arg3::Int64,
+                                     arg4::Cint,
+                                     arg5::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_band_inplace(k1, k2, mode, A, Common)
-    @ccall libcholmod.cholmod_band_inplace(k1::Int64, k2::Int64, mode::Cint, A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_band_inplace(k1::Int64, k2::Int64, mode::Cint,
+                                           A::Ptr{cholmod_sparse},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_band_inplace(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_band_inplace(arg1::Int64, arg2::Int64, arg3::Cint, arg4::Ptr{cholmod_sparse}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_band_inplace(arg1::Int64, arg2::Int64, arg3::Cint,
+                                             arg4::Ptr{cholmod_sparse},
+                                             arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_aat(A, fset, fsize, mode, Common)
-    @ccall libcholmod.cholmod_aat(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, mode::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_aat(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t,
+                                  mode::Cint,
+                                  Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_aat(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_aat(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Cint, arg5::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_aat(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                    arg3::Csize_t, arg4::Cint,
+                                    arg5::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_copy_sparse(A, Common)
-    @ccall libcholmod.cholmod_copy_sparse(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_copy_sparse(A::Ptr{cholmod_sparse},
+                                          Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_copy_sparse(arg1, arg2)
-    @ccall libcholmod.cholmod_l_copy_sparse(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_copy_sparse(arg1::Ptr{cholmod_sparse},
+                                            arg2::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_copy(A, stype, mode, Common)
-    @ccall libcholmod.cholmod_copy(A::Ptr{cholmod_sparse}, stype::Cint, mode::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_copy(A::Ptr{cholmod_sparse}, stype::Cint, mode::Cint,
+                                   Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_copy(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_copy(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_copy(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Cint,
+                                     arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_add(A, B, alpha, beta, values, sorted, Common)
-    @ccall libcholmod.cholmod_add(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse}, alpha::Ptr{Cdouble}, beta::Ptr{Cdouble}, values::Cint, sorted::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_add(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse},
+                                  alpha::Ptr{Cdouble}, beta::Ptr{Cdouble}, values::Cint,
+                                  sorted::Cint,
+                                  Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_add(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_add(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Ptr{Cdouble}, arg5::Cint, arg6::Cint, arg7::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_add(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse},
+                                    arg3::Ptr{Cdouble}, arg4::Ptr{Cdouble}, arg5::Cint,
+                                    arg6::Cint,
+                                    arg7::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_sparse_xtype(to_xtype, A, Common)
-    @ccall libcholmod.cholmod_sparse_xtype(to_xtype::Cint, A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_sparse_xtype(to_xtype::Cint, A::Ptr{cholmod_sparse},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_sparse_xtype(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_sparse_xtype(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_sparse_xtype(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                             arg3::Ptr{cholmod_common})::Cint
 end
 
 mutable struct cholmod_factor_struct
@@ -572,75 +655,100 @@ end
 const cholmod_factor = cholmod_factor_struct
 
 function cholmod_allocate_factor(n, Common)
-    @ccall libcholmod.cholmod_allocate_factor(n::Csize_t, Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_allocate_factor(n::Csize_t,
+                                              Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_l_allocate_factor(arg1, arg2)
-    @ccall libcholmod.cholmod_l_allocate_factor(arg1::Csize_t, arg2::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_l_allocate_factor(arg1::Csize_t,
+                                                arg2::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_free_factor(L, Common)
-    @ccall libcholmod.cholmod_free_factor(L::Ptr{Ptr{cholmod_factor}}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_free_factor(L::Ptr{Ptr{cholmod_factor}},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_free_factor(arg1, arg2)
-    @ccall libcholmod.cholmod_l_free_factor(arg1::Ptr{Ptr{cholmod_factor}}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_free_factor(arg1::Ptr{Ptr{cholmod_factor}},
+                                            arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_reallocate_factor(nznew, L, Common)
-    @ccall libcholmod.cholmod_reallocate_factor(nznew::Csize_t, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_reallocate_factor(nznew::Csize_t, L::Ptr{cholmod_factor},
+                                                Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_reallocate_factor(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_reallocate_factor(arg1::Csize_t, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_reallocate_factor(arg1::Csize_t, arg2::Ptr{cholmod_factor},
+                                                  arg3::Ptr{cholmod_common})::Cint
 end
 
-function cholmod_change_factor(to_xtype, to_ll, to_super, to_packed, to_monotonic, L, Common)
-    @ccall libcholmod.cholmod_change_factor(to_xtype::Cint, to_ll::Cint, to_super::Cint, to_packed::Cint, to_monotonic::Cint, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+function cholmod_change_factor(to_xtype, to_ll, to_super, to_packed, to_monotonic, L,
+                               Common)
+    @ccall libcholmod.cholmod_change_factor(to_xtype::Cint, to_ll::Cint, to_super::Cint,
+                                            to_packed::Cint, to_monotonic::Cint,
+                                            L::Ptr{cholmod_factor},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_change_factor(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_change_factor(arg1::Cint, arg2::Cint, arg3::Cint, arg4::Cint, arg5::Cint, arg6::Ptr{cholmod_factor}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_change_factor(arg1::Cint, arg2::Cint, arg3::Cint,
+                                              arg4::Cint, arg5::Cint,
+                                              arg6::Ptr{cholmod_factor},
+                                              arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_pack_factor(L, Common)
-    @ccall libcholmod.cholmod_pack_factor(L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_pack_factor(L::Ptr{cholmod_factor},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_pack_factor(arg1, arg2)
-    @ccall libcholmod.cholmod_l_pack_factor(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_pack_factor(arg1::Ptr{cholmod_factor},
+                                            arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_reallocate_column(j, need, L, Common)
-    @ccall libcholmod.cholmod_reallocate_column(j::Csize_t, need::Csize_t, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_reallocate_column(j::Csize_t, need::Csize_t,
+                                                L::Ptr{cholmod_factor},
+                                                Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_reallocate_column(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_reallocate_column(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{cholmod_factor}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_reallocate_column(arg1::Csize_t, arg2::Csize_t,
+                                                  arg3::Ptr{cholmod_factor},
+                                                  arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_factor_to_sparse(L, Common)
-    @ccall libcholmod.cholmod_factor_to_sparse(L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_factor_to_sparse(L::Ptr{cholmod_factor},
+                                               Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_factor_to_sparse(arg1, arg2)
-    @ccall libcholmod.cholmod_l_factor_to_sparse(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_factor_to_sparse(arg1::Ptr{cholmod_factor},
+                                                 arg2::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_copy_factor(L, Common)
-    @ccall libcholmod.cholmod_copy_factor(L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_copy_factor(L::Ptr{cholmod_factor},
+                                          Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_l_copy_factor(arg1, arg2)
-    @ccall libcholmod.cholmod_l_copy_factor(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_l_copy_factor(arg1::Ptr{cholmod_factor},
+                                            arg2::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_factor_xtype(to_xtype, L, Common)
-    @ccall libcholmod.cholmod_factor_xtype(to_xtype::Cint, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_factor_xtype(to_xtype::Cint, L::Ptr{cholmod_factor},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_factor_xtype(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_factor_xtype(arg1::Cint, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_factor_xtype(arg1::Cint, arg2::Ptr{cholmod_factor},
+                                             arg3::Ptr{cholmod_common})::Cint
 end
 
 mutable struct cholmod_dense_struct
@@ -658,91 +766,118 @@ end
 const cholmod_dense = cholmod_dense_struct
 
 function cholmod_allocate_dense(nrow, ncol, d, xtype, Common)
-    @ccall libcholmod.cholmod_allocate_dense(nrow::Csize_t, ncol::Csize_t, d::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_allocate_dense(nrow::Csize_t, ncol::Csize_t, d::Csize_t,
+                                             xtype::Cint,
+                                             Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_allocate_dense(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_allocate_dense(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t, arg4::Cint, arg5::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_allocate_dense(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t,
+                                               arg4::Cint,
+                                               arg5::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_zeros(nrow, ncol, xtype, Common)
-    @ccall libcholmod.cholmod_zeros(nrow::Csize_t, ncol::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_zeros(nrow::Csize_t, ncol::Csize_t, xtype::Cint,
+                                    Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_zeros(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_zeros(arg1::Csize_t, arg2::Csize_t, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_zeros(arg1::Csize_t, arg2::Csize_t, arg3::Cint,
+                                      arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_ones(nrow, ncol, xtype, Common)
-    @ccall libcholmod.cholmod_ones(nrow::Csize_t, ncol::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_ones(nrow::Csize_t, ncol::Csize_t, xtype::Cint,
+                                   Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_ones(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_ones(arg1::Csize_t, arg2::Csize_t, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_ones(arg1::Csize_t, arg2::Csize_t, arg3::Cint,
+                                     arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_eye(nrow, ncol, xtype, Common)
-    @ccall libcholmod.cholmod_eye(nrow::Csize_t, ncol::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_eye(nrow::Csize_t, ncol::Csize_t, xtype::Cint,
+                                  Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_eye(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_eye(arg1::Csize_t, arg2::Csize_t, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_eye(arg1::Csize_t, arg2::Csize_t, arg3::Cint,
+                                    arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_free_dense(X, Common)
-    @ccall libcholmod.cholmod_free_dense(X::Ptr{Ptr{cholmod_dense}}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_free_dense(X::Ptr{Ptr{cholmod_dense}},
+                                         Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_free_dense(arg1, arg2)
-    @ccall libcholmod.cholmod_l_free_dense(arg1::Ptr{Ptr{cholmod_dense}}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_free_dense(arg1::Ptr{Ptr{cholmod_dense}},
+                                           arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_ensure_dense(XHandle, nrow, ncol, d, xtype, Common)
-    @ccall libcholmod.cholmod_ensure_dense(XHandle::Ptr{Ptr{cholmod_dense}}, nrow::Csize_t, ncol::Csize_t, d::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_ensure_dense(XHandle::Ptr{Ptr{cholmod_dense}}, nrow::Csize_t,
+                                           ncol::Csize_t, d::Csize_t, xtype::Cint,
+                                           Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_ensure_dense(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_ensure_dense(arg1::Ptr{Ptr{cholmod_dense}}, arg2::Csize_t, arg3::Csize_t, arg4::Csize_t, arg5::Cint, arg6::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_ensure_dense(arg1::Ptr{Ptr{cholmod_dense}}, arg2::Csize_t,
+                                             arg3::Csize_t, arg4::Csize_t, arg5::Cint,
+                                             arg6::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_sparse_to_dense(A, Common)
-    @ccall libcholmod.cholmod_sparse_to_dense(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_sparse_to_dense(A::Ptr{cholmod_sparse},
+                                              Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_sparse_to_dense(arg1, arg2)
-    @ccall libcholmod.cholmod_l_sparse_to_dense(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_sparse_to_dense(arg1::Ptr{cholmod_sparse},
+                                                arg2::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_dense_to_sparse(X, values, Common)
-    @ccall libcholmod.cholmod_dense_to_sparse(X::Ptr{cholmod_dense}, values::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_dense_to_sparse(X::Ptr{cholmod_dense}, values::Cint,
+                                              Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_dense_to_sparse(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_dense_to_sparse(arg1::Ptr{cholmod_dense}, arg2::Cint, arg3::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_dense_to_sparse(arg1::Ptr{cholmod_dense}, arg2::Cint,
+                                                arg3::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_copy_dense(X, Common)
-    @ccall libcholmod.cholmod_copy_dense(X::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_copy_dense(X::Ptr{cholmod_dense},
+                                         Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_copy_dense(arg1, arg2)
-    @ccall libcholmod.cholmod_l_copy_dense(arg1::Ptr{cholmod_dense}, arg2::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_copy_dense(arg1::Ptr{cholmod_dense},
+                                           arg2::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_copy_dense2(X, Y, Common)
-    @ccall libcholmod.cholmod_copy_dense2(X::Ptr{cholmod_dense}, Y::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_copy_dense2(X::Ptr{cholmod_dense}, Y::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_copy_dense2(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_copy_dense2(arg1::Ptr{cholmod_dense}, arg2::Ptr{cholmod_dense}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_copy_dense2(arg1::Ptr{cholmod_dense},
+                                            arg2::Ptr{cholmod_dense},
+                                            arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_dense_xtype(to_xtype, X, Common)
-    @ccall libcholmod.cholmod_dense_xtype(to_xtype::Cint, X::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_dense_xtype(to_xtype::Cint, X::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_dense_xtype(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_dense_xtype(arg1::Cint, arg2::Ptr{cholmod_dense}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_dense_xtype(arg1::Cint, arg2::Ptr{cholmod_dense},
+                                            arg3::Ptr{cholmod_common})::Cint
 end
 
 mutable struct cholmod_triplet_struct
@@ -764,99 +899,137 @@ end
 const cholmod_triplet = cholmod_triplet_struct
 
 function cholmod_allocate_triplet(nrow, ncol, nzmax, stype, xtype, Common)
-    @ccall libcholmod.cholmod_allocate_triplet(nrow::Csize_t, ncol::Csize_t, nzmax::Csize_t, stype::Cint, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_allocate_triplet(nrow::Csize_t, ncol::Csize_t, nzmax::Csize_t,
+                                               stype::Cint, xtype::Cint,
+                                               Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_l_allocate_triplet(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_allocate_triplet(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t, arg4::Cint, arg5::Cint, arg6::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_l_allocate_triplet(arg1::Csize_t, arg2::Csize_t,
+                                                 arg3::Csize_t, arg4::Cint, arg5::Cint,
+                                                 arg6::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_free_triplet(T, Common)
-    @ccall libcholmod.cholmod_free_triplet(T::Ptr{Ptr{cholmod_triplet}}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_free_triplet(T::Ptr{Ptr{cholmod_triplet}},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_free_triplet(arg1, arg2)
-    @ccall libcholmod.cholmod_l_free_triplet(arg1::Ptr{Ptr{cholmod_triplet}}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_free_triplet(arg1::Ptr{Ptr{cholmod_triplet}},
+                                             arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_reallocate_triplet(nznew, T, Common)
-    @ccall libcholmod.cholmod_reallocate_triplet(nznew::Csize_t, T::Ptr{cholmod_triplet}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_reallocate_triplet(nznew::Csize_t, T::Ptr{cholmod_triplet},
+                                                 Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_reallocate_triplet(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_reallocate_triplet(arg1::Csize_t, arg2::Ptr{cholmod_triplet}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_reallocate_triplet(arg1::Csize_t,
+                                                   arg2::Ptr{cholmod_triplet},
+                                                   arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_sparse_to_triplet(A, Common)
-    @ccall libcholmod.cholmod_sparse_to_triplet(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_sparse_to_triplet(A::Ptr{cholmod_sparse},
+                                                Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_l_sparse_to_triplet(arg1, arg2)
-    @ccall libcholmod.cholmod_l_sparse_to_triplet(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_l_sparse_to_triplet(arg1::Ptr{cholmod_sparse},
+                                                  arg2::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_triplet_to_sparse(T, nzmax, Common)
-    @ccall libcholmod.cholmod_triplet_to_sparse(T::Ptr{cholmod_triplet}, nzmax::Csize_t, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_triplet_to_sparse(T::Ptr{cholmod_triplet}, nzmax::Csize_t,
+                                                Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_triplet_to_sparse(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_triplet_to_sparse(arg1::Ptr{cholmod_triplet}, arg2::Csize_t, arg3::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_triplet_to_sparse(arg1::Ptr{cholmod_triplet}, arg2::Csize_t,
+                                                  arg3::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_copy_triplet(T, Common)
-    @ccall libcholmod.cholmod_copy_triplet(T::Ptr{cholmod_triplet}, Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_copy_triplet(T::Ptr{cholmod_triplet},
+                                           Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_l_copy_triplet(arg1, arg2)
-    @ccall libcholmod.cholmod_l_copy_triplet(arg1::Ptr{cholmod_triplet}, arg2::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_l_copy_triplet(arg1::Ptr{cholmod_triplet},
+                                             arg2::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_triplet_xtype(to_xtype, T, Common)
-    @ccall libcholmod.cholmod_triplet_xtype(to_xtype::Cint, T::Ptr{cholmod_triplet}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_triplet_xtype(to_xtype::Cint, T::Ptr{cholmod_triplet},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_triplet_xtype(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_triplet_xtype(arg1::Cint, arg2::Ptr{cholmod_triplet}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_triplet_xtype(arg1::Cint, arg2::Ptr{cholmod_triplet},
+                                              arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_malloc(n, size, Common)
-    @ccall libcholmod.cholmod_malloc(n::Csize_t, size::Csize_t, Common::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_malloc(n::Csize_t, size::Csize_t,
+                                     Common::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_l_malloc(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_malloc(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_l_malloc(arg1::Csize_t, arg2::Csize_t,
+                                       arg3::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_calloc(n, size, Common)
-    @ccall libcholmod.cholmod_calloc(n::Csize_t, size::Csize_t, Common::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_calloc(n::Csize_t, size::Csize_t,
+                                     Common::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_l_calloc(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_calloc(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_l_calloc(arg1::Csize_t, arg2::Csize_t,
+                                       arg3::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_free(n, size, p, Common)
-    @ccall libcholmod.cholmod_free(n::Csize_t, size::Csize_t, p::Ptr{Cvoid}, Common::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_free(n::Csize_t, size::Csize_t, p::Ptr{Cvoid},
+                                   Common::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_l_free(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_free(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{Cvoid}, arg4::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_l_free(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{Cvoid},
+                                     arg4::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_realloc(nnew, size, p, n, Common)
-    @ccall libcholmod.cholmod_realloc(nnew::Csize_t, size::Csize_t, p::Ptr{Cvoid}, n::Ptr{Csize_t}, Common::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_realloc(nnew::Csize_t, size::Csize_t, p::Ptr{Cvoid},
+                                      n::Ptr{Csize_t},
+                                      Common::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_l_realloc(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_realloc(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{Cvoid}, arg4::Ptr{Csize_t}, arg5::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_l_realloc(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{Cvoid},
+                                        arg4::Ptr{Csize_t},
+                                        arg5::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
-function cholmod_realloc_multiple(nnew, nint, xtype, Iblock, Jblock, Xblock, Zblock, n, Common)
-    @ccall libcholmod.cholmod_realloc_multiple(nnew::Csize_t, nint::Cint, xtype::Cint, Iblock::Ptr{Ptr{Cvoid}}, Jblock::Ptr{Ptr{Cvoid}}, Xblock::Ptr{Ptr{Cvoid}}, Zblock::Ptr{Ptr{Cvoid}}, n::Ptr{Csize_t}, Common::Ptr{cholmod_common})::Cint
+function cholmod_realloc_multiple(nnew, nint, xtype, Iblock, Jblock, Xblock, Zblock, n,
+                                  Common)
+    @ccall libcholmod.cholmod_realloc_multiple(nnew::Csize_t, nint::Cint, xtype::Cint,
+                                               Iblock::Ptr{Ptr{Cvoid}},
+                                               Jblock::Ptr{Ptr{Cvoid}},
+                                               Xblock::Ptr{Ptr{Cvoid}},
+                                               Zblock::Ptr{Ptr{Cvoid}}, n::Ptr{Csize_t},
+                                               Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_realloc_multiple(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
-    @ccall libcholmod.cholmod_l_realloc_multiple(arg1::Csize_t, arg2::Cint, arg3::Cint, arg4::Ptr{Ptr{Cvoid}}, arg5::Ptr{Ptr{Cvoid}}, arg6::Ptr{Ptr{Cvoid}}, arg7::Ptr{Ptr{Cvoid}}, arg8::Ptr{Csize_t}, arg9::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_realloc_multiple(arg1::Csize_t, arg2::Cint, arg3::Cint,
+                                                 arg4::Ptr{Ptr{Cvoid}},
+                                                 arg5::Ptr{Ptr{Cvoid}},
+                                                 arg6::Ptr{Ptr{Cvoid}},
+                                                 arg7::Ptr{Ptr{Cvoid}}, arg8::Ptr{Csize_t},
+                                                 arg9::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_version(version)
@@ -876,11 +1049,13 @@ function cholmod_l_check_common(arg1)
 end
 
 function cholmod_print_common(name, Common)
-    @ccall libcholmod.cholmod_print_common(name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_common(name::Ptr{Cchar},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_common(arg1, arg2)
-    @ccall libcholmod.cholmod_l_print_common(arg1::Ptr{Cchar}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_common(arg1::Ptr{Cchar},
+                                             arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_gpu_stats(arg1)
@@ -892,643 +1067,1047 @@ function cholmod_l_gpu_stats(arg1)
 end
 
 function cholmod_check_sparse(A, Common)
-    @ccall libcholmod.cholmod_check_sparse(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_sparse(A::Ptr{cholmod_sparse},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_sparse(arg1, arg2)
-    @ccall libcholmod.cholmod_l_check_sparse(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_sparse(arg1::Ptr{cholmod_sparse},
+                                             arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_sparse(A, name, Common)
-    @ccall libcholmod.cholmod_print_sparse(A::Ptr{cholmod_sparse}, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_sparse(A::Ptr{cholmod_sparse}, name::Ptr{Cchar},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_sparse(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_print_sparse(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Cchar}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_sparse(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Cchar},
+                                             arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_check_dense(X, Common)
-    @ccall libcholmod.cholmod_check_dense(X::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_dense(X::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_dense(arg1, arg2)
-    @ccall libcholmod.cholmod_l_check_dense(arg1::Ptr{cholmod_dense}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_dense(arg1::Ptr{cholmod_dense},
+                                            arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_dense(X, name, Common)
-    @ccall libcholmod.cholmod_print_dense(X::Ptr{cholmod_dense}, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_dense(X::Ptr{cholmod_dense}, name::Ptr{Cchar},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_dense(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_print_dense(arg1::Ptr{cholmod_dense}, arg2::Ptr{Cchar}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_dense(arg1::Ptr{cholmod_dense}, arg2::Ptr{Cchar},
+                                            arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_check_factor(L, Common)
-    @ccall libcholmod.cholmod_check_factor(L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_factor(L::Ptr{cholmod_factor},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_factor(arg1, arg2)
-    @ccall libcholmod.cholmod_l_check_factor(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_factor(arg1::Ptr{cholmod_factor},
+                                             arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_factor(L, name, Common)
-    @ccall libcholmod.cholmod_print_factor(L::Ptr{cholmod_factor}, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_factor(L::Ptr{cholmod_factor}, name::Ptr{Cchar},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_factor(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_print_factor(arg1::Ptr{cholmod_factor}, arg2::Ptr{Cchar}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_factor(arg1::Ptr{cholmod_factor}, arg2::Ptr{Cchar},
+                                             arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_check_triplet(T, Common)
-    @ccall libcholmod.cholmod_check_triplet(T::Ptr{cholmod_triplet}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_triplet(T::Ptr{cholmod_triplet},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_triplet(arg1, arg2)
-    @ccall libcholmod.cholmod_l_check_triplet(arg1::Ptr{cholmod_triplet}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_triplet(arg1::Ptr{cholmod_triplet},
+                                              arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_triplet(T, name, Common)
-    @ccall libcholmod.cholmod_print_triplet(T::Ptr{cholmod_triplet}, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_triplet(T::Ptr{cholmod_triplet}, name::Ptr{Cchar},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_triplet(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_print_triplet(arg1::Ptr{cholmod_triplet}, arg2::Ptr{Cchar}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_triplet(arg1::Ptr{cholmod_triplet}, arg2::Ptr{Cchar},
+                                              arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_check_subset(Set, len, n, Common)
-    @ccall libcholmod.cholmod_check_subset(Set::Ptr{Int32}, len::Int64, n::Csize_t, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_subset(Set::Ptr{Int32}, len::Int64, n::Csize_t,
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_subset(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_check_subset(arg1::Ptr{Int64}, arg2::Int64, arg3::Csize_t, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_subset(arg1::Ptr{Int64}, arg2::Int64, arg3::Csize_t,
+                                             arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_subset(Set, len, n, name, Common)
-    @ccall libcholmod.cholmod_print_subset(Set::Ptr{Int32}, len::Int64, n::Csize_t, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_subset(Set::Ptr{Int32}, len::Int64, n::Csize_t,
+                                           name::Ptr{Cchar},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_subset(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_print_subset(arg1::Ptr{Int64}, arg2::Int64, arg3::Csize_t, arg4::Ptr{Cchar}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_subset(arg1::Ptr{Int64}, arg2::Int64, arg3::Csize_t,
+                                             arg4::Ptr{Cchar},
+                                             arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_check_perm(Perm, len, n, Common)
-    @ccall libcholmod.cholmod_check_perm(Perm::Ptr{Int32}, len::Csize_t, n::Csize_t, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_perm(Perm::Ptr{Int32}, len::Csize_t, n::Csize_t,
+                                         Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_perm(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_check_perm(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Csize_t, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_perm(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Csize_t,
+                                           arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_perm(Perm, len, n, name, Common)
-    @ccall libcholmod.cholmod_print_perm(Perm::Ptr{Int32}, len::Csize_t, n::Csize_t, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_perm(Perm::Ptr{Int32}, len::Csize_t, n::Csize_t,
+                                         name::Ptr{Cchar},
+                                         Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_perm(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_print_perm(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Csize_t, arg4::Ptr{Cchar}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_perm(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Csize_t,
+                                           arg4::Ptr{Cchar},
+                                           arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_check_parent(Parent, n, Common)
-    @ccall libcholmod.cholmod_check_parent(Parent::Ptr{Int32}, n::Csize_t, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_parent(Parent::Ptr{Int32}, n::Csize_t,
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_parent(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_check_parent(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_parent(arg1::Ptr{Int64}, arg2::Csize_t,
+                                             arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_parent(Parent, n, name, Common)
-    @ccall libcholmod.cholmod_print_parent(Parent::Ptr{Int32}, n::Csize_t, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_parent(Parent::Ptr{Int32}, n::Csize_t, name::Ptr{Cchar},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_parent(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_print_parent(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Ptr{Cchar}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_parent(arg1::Ptr{Int64}, arg2::Csize_t,
+                                             arg3::Ptr{Cchar},
+                                             arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_read_sparse(f, Common)
-    @ccall libcholmod.cholmod_read_sparse(f::Ptr{Libc.FILE}, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_read_sparse(f::Ptr{Libc.FILE},
+                                          Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_read_sparse(arg1, arg2)
-    @ccall libcholmod.cholmod_l_read_sparse(arg1::Ptr{Libc.FILE}, arg2::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_read_sparse(arg1::Ptr{Libc.FILE},
+                                            arg2::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_read_triplet(f, Common)
-    @ccall libcholmod.cholmod_read_triplet(f::Ptr{Libc.FILE}, Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_read_triplet(f::Ptr{Libc.FILE},
+                                           Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_l_read_triplet(arg1, arg2)
-    @ccall libcholmod.cholmod_l_read_triplet(arg1::Ptr{Libc.FILE}, arg2::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_l_read_triplet(arg1::Ptr{Libc.FILE},
+                                             arg2::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_read_dense(f, Common)
-    @ccall libcholmod.cholmod_read_dense(f::Ptr{Libc.FILE}, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_read_dense(f::Ptr{Libc.FILE},
+                                         Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_read_dense(arg1, arg2)
-    @ccall libcholmod.cholmod_l_read_dense(arg1::Ptr{Libc.FILE}, arg2::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_read_dense(arg1::Ptr{Libc.FILE},
+                                           arg2::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_read_matrix(f, prefer, mtype, Common)
-    @ccall libcholmod.cholmod_read_matrix(f::Ptr{Libc.FILE}, prefer::Cint, mtype::Ptr{Cint}, Common::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_read_matrix(f::Ptr{Libc.FILE}, prefer::Cint, mtype::Ptr{Cint},
+                                          Common::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_l_read_matrix(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_read_matrix(arg1::Ptr{Libc.FILE}, arg2::Cint, arg3::Ptr{Cint}, arg4::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_l_read_matrix(arg1::Ptr{Libc.FILE}, arg2::Cint,
+                                            arg3::Ptr{Cint},
+                                            arg4::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_write_sparse(f, A, Z, comments, Common)
-    @ccall libcholmod.cholmod_write_sparse(f::Ptr{Libc.FILE}, A::Ptr{cholmod_sparse}, Z::Ptr{cholmod_sparse}, comments::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_write_sparse(f::Ptr{Libc.FILE}, A::Ptr{cholmod_sparse},
+                                           Z::Ptr{cholmod_sparse}, comments::Ptr{Cchar},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_write_sparse(arg1, arg2, arg3, c, arg5)
-    @ccall libcholmod.cholmod_l_write_sparse(arg1::Ptr{Libc.FILE}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_sparse}, c::Ptr{Cchar}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_write_sparse(arg1::Ptr{Libc.FILE},
+                                             arg2::Ptr{cholmod_sparse},
+                                             arg3::Ptr{cholmod_sparse}, c::Ptr{Cchar},
+                                             arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_write_dense(f, X, comments, Common)
-    @ccall libcholmod.cholmod_write_dense(f::Ptr{Libc.FILE}, X::Ptr{cholmod_dense}, comments::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_write_dense(f::Ptr{Libc.FILE}, X::Ptr{cholmod_dense},
+                                          comments::Ptr{Cchar},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_write_dense(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_write_dense(arg1::Ptr{Libc.FILE}, arg2::Ptr{cholmod_dense}, arg3::Ptr{Cchar}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_write_dense(arg1::Ptr{Libc.FILE}, arg2::Ptr{cholmod_dense},
+                                            arg3::Ptr{Cchar},
+                                            arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_analyze(A, Common)
-    @ccall libcholmod.cholmod_analyze(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_analyze(A::Ptr{cholmod_sparse},
+                                      Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_l_analyze(arg1, arg2)
-    @ccall libcholmod.cholmod_l_analyze(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_l_analyze(arg1::Ptr{cholmod_sparse},
+                                        arg2::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_analyze_p(A, UserPerm, fset, fsize, Common)
-    @ccall libcholmod.cholmod_analyze_p(A::Ptr{cholmod_sparse}, UserPerm::Ptr{Int32}, fset::Ptr{Int32}, fsize::Csize_t, Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_analyze_p(A::Ptr{cholmod_sparse}, UserPerm::Ptr{Int32},
+                                        fset::Ptr{Int32}, fsize::Csize_t,
+                                        Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_l_analyze_p(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_analyze_p(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Ptr{Int64}, arg4::Csize_t, arg5::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_l_analyze_p(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                          arg3::Ptr{Int64}, arg4::Csize_t,
+                                          arg5::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_analyze_p2(for_whom, A, UserPerm, fset, fsize, Common)
-    @ccall libcholmod.cholmod_analyze_p2(for_whom::Cint, A::Ptr{cholmod_sparse}, UserPerm::Ptr{Int32}, fset::Ptr{Int32}, fsize::Csize_t, Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_analyze_p2(for_whom::Cint, A::Ptr{cholmod_sparse},
+                                         UserPerm::Ptr{Int32}, fset::Ptr{Int32},
+                                         fsize::Csize_t,
+                                         Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_l_analyze_p2(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_analyze_p2(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Csize_t, arg6::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_l_analyze_p2(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                           arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                           arg5::Csize_t,
+                                           arg6::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_factorize(A, L, Common)
-    @ccall libcholmod.cholmod_factorize(A::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_factorize(A::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor},
+                                        Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_factorize(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_factorize(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_factorize(arg1::Ptr{cholmod_sparse},
+                                          arg2::Ptr{cholmod_factor},
+                                          arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_factorize_p(A, beta, fset, fsize, L, Common)
-    @ccall libcholmod.cholmod_factorize_p(A::Ptr{cholmod_sparse}, beta::Ptr{Cdouble}, fset::Ptr{Int32}, fsize::Csize_t, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_factorize_p(A::Ptr{cholmod_sparse}, beta::Ptr{Cdouble},
+                                          fset::Ptr{Int32}, fsize::Csize_t,
+                                          L::Ptr{cholmod_factor},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_factorize_p(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_factorize_p(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Cdouble}, arg3::Ptr{Int64}, arg4::Csize_t, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_factorize_p(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Cdouble},
+                                            arg3::Ptr{Int64}, arg4::Csize_t,
+                                            arg5::Ptr{cholmod_factor},
+                                            arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_solve(sys, L, B, Common)
-    @ccall libcholmod.cholmod_solve(sys::Cint, L::Ptr{cholmod_factor}, B::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_solve(sys::Cint, L::Ptr{cholmod_factor},
+                                    B::Ptr{cholmod_dense},
+                                    Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_solve(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_solve(arg1::Cint, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_dense}, arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_solve(arg1::Cint, arg2::Ptr{cholmod_factor},
+                                      arg3::Ptr{cholmod_dense},
+                                      arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_solve2(sys, L, B, Bset, X_Handle, Xset_Handle, Y_Handle, E_Handle, Common)
-    @ccall libcholmod.cholmod_solve2(sys::Cint, L::Ptr{cholmod_factor}, B::Ptr{cholmod_dense}, Bset::Ptr{cholmod_sparse}, X_Handle::Ptr{Ptr{cholmod_dense}}, Xset_Handle::Ptr{Ptr{cholmod_sparse}}, Y_Handle::Ptr{Ptr{cholmod_dense}}, E_Handle::Ptr{Ptr{cholmod_dense}}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_solve2(sys::Cint, L::Ptr{cholmod_factor},
+                                     B::Ptr{cholmod_dense}, Bset::Ptr{cholmod_sparse},
+                                     X_Handle::Ptr{Ptr{cholmod_dense}},
+                                     Xset_Handle::Ptr{Ptr{cholmod_sparse}},
+                                     Y_Handle::Ptr{Ptr{cholmod_dense}},
+                                     E_Handle::Ptr{Ptr{cholmod_dense}},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_solve2(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
-    @ccall libcholmod.cholmod_l_solve2(arg1::Cint, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_dense}, arg4::Ptr{cholmod_sparse}, arg5::Ptr{Ptr{cholmod_dense}}, arg6::Ptr{Ptr{cholmod_sparse}}, arg7::Ptr{Ptr{cholmod_dense}}, arg8::Ptr{Ptr{cholmod_dense}}, arg9::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_solve2(arg1::Cint, arg2::Ptr{cholmod_factor},
+                                       arg3::Ptr{cholmod_dense}, arg4::Ptr{cholmod_sparse},
+                                       arg5::Ptr{Ptr{cholmod_dense}},
+                                       arg6::Ptr{Ptr{cholmod_sparse}},
+                                       arg7::Ptr{Ptr{cholmod_dense}},
+                                       arg8::Ptr{Ptr{cholmod_dense}},
+                                       arg9::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_spsolve(sys, L, B, Common)
-    @ccall libcholmod.cholmod_spsolve(sys::Cint, L::Ptr{cholmod_factor}, B::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_spsolve(sys::Cint, L::Ptr{cholmod_factor},
+                                      B::Ptr{cholmod_sparse},
+                                      Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_spsolve(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_spsolve(arg1::Cint, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_sparse}, arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_spsolve(arg1::Cint, arg2::Ptr{cholmod_factor},
+                                        arg3::Ptr{cholmod_sparse},
+                                        arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_etree(A, Parent, Common)
-    @ccall libcholmod.cholmod_etree(A::Ptr{cholmod_sparse}, Parent::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_etree(A::Ptr{cholmod_sparse}, Parent::Ptr{Int32},
+                                    Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_etree(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_etree(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_etree(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                      arg3::Ptr{cholmod_common})::Cint
 end
 
-function cholmod_rowcolcounts(A, fset, fsize, Parent, Post, RowCount, ColCount, First, Level, Common)
-    @ccall libcholmod.cholmod_rowcolcounts(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, Parent::Ptr{Int32}, Post::Ptr{Int32}, RowCount::Ptr{Int32}, ColCount::Ptr{Int32}, First::Ptr{Int32}, Level::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+function cholmod_rowcolcounts(A, fset, fsize, Parent, Post, RowCount, ColCount, First,
+                              Level, Common)
+    @ccall libcholmod.cholmod_rowcolcounts(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                           fsize::Csize_t, Parent::Ptr{Int32},
+                                           Post::Ptr{Int32}, RowCount::Ptr{Int32},
+                                           ColCount::Ptr{Int32}, First::Ptr{Int32},
+                                           Level::Ptr{Int32},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowcolcounts(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)
-    @ccall libcholmod.cholmod_l_rowcolcounts(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{Int64}, arg6::Ptr{Int64}, arg7::Ptr{Int64}, arg8::Ptr{Int64}, arg9::Ptr{Int64}, arg10::Ptr{cholmod_common})::Cint
-end
-
-function cholmod_analyze_ordering(A, ordering, Perm, fset, fsize, Parent, Post, ColCount, First, Level, Common)
-    @ccall libcholmod.cholmod_analyze_ordering(A::Ptr{cholmod_sparse}, ordering::Cint, Perm::Ptr{Int32}, fset::Ptr{Int32}, fsize::Csize_t, Parent::Ptr{Int32}, Post::Ptr{Int32}, ColCount::Ptr{Int32}, First::Ptr{Int32}, Level::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
-end
-
-function cholmod_l_analyze_ordering(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11)
-    @ccall libcholmod.cholmod_l_analyze_ordering(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Csize_t, arg6::Ptr{Int64}, arg7::Ptr{Int64}, arg8::Ptr{Int64}, arg9::Ptr{Int64}, arg10::Ptr{Int64}, arg11::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowcolcounts(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                             arg3::Csize_t, arg4::Ptr{Int64},
+                                             arg5::Ptr{Int64}, arg6::Ptr{Int64},
+                                             arg7::Ptr{Int64}, arg8::Ptr{Int64},
+                                             arg9::Ptr{Int64},
+                                             arg10::Ptr{cholmod_common})::Cint
+end
+
+function cholmod_analyze_ordering(A, ordering, Perm, fset, fsize, Parent, Post, ColCount,
+                                  First, Level, Common)
+    @ccall libcholmod.cholmod_analyze_ordering(A::Ptr{cholmod_sparse}, ordering::Cint,
+                                               Perm::Ptr{Int32}, fset::Ptr{Int32},
+                                               fsize::Csize_t, Parent::Ptr{Int32},
+                                               Post::Ptr{Int32}, ColCount::Ptr{Int32},
+                                               First::Ptr{Int32}, Level::Ptr{Int32},
+                                               Common::Ptr{cholmod_common})::Cint
+end
+
+function cholmod_l_analyze_ordering(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9,
+                                    arg10, arg11)
+    @ccall libcholmod.cholmod_l_analyze_ordering(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                                 arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                                 arg5::Csize_t, arg6::Ptr{Int64},
+                                                 arg7::Ptr{Int64}, arg8::Ptr{Int64},
+                                                 arg9::Ptr{Int64}, arg10::Ptr{Int64},
+                                                 arg11::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_amd(A, fset, fsize, Perm, Common)
-    @ccall libcholmod.cholmod_amd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_amd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t,
+                                  Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_amd(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_amd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_amd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                    arg3::Csize_t, arg4::Ptr{Int64},
+                                    arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_colamd(A, fset, fsize, postorder, Perm, Common)
-    @ccall libcholmod.cholmod_colamd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, postorder::Cint, Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_colamd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                     fsize::Csize_t, postorder::Cint, Perm::Ptr{Int32},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_colamd(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_colamd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Cint, arg5::Ptr{Int64}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_colamd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                       arg3::Csize_t, arg4::Cint, arg5::Ptr{Int64},
+                                       arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowfac(A, F, beta, kstart, kend, L, Common)
-    @ccall libcholmod.cholmod_rowfac(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, beta::Ptr{Cdouble}, kstart::Csize_t, kend::Csize_t, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowfac(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse},
+                                     beta::Ptr{Cdouble}, kstart::Csize_t, kend::Csize_t,
+                                     L::Ptr{cholmod_factor},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowfac(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_rowfac(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Csize_t, arg5::Csize_t, arg6::Ptr{cholmod_factor}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowfac(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse},
+                                       arg3::Ptr{Cdouble}, arg4::Csize_t, arg5::Csize_t,
+                                       arg6::Ptr{cholmod_factor},
+                                       arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowfac_mask(A, F, beta, kstart, kend, mask, RLinkUp, L, Common)
-    @ccall libcholmod.cholmod_rowfac_mask(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, beta::Ptr{Cdouble}, kstart::Csize_t, kend::Csize_t, mask::Ptr{Int32}, RLinkUp::Ptr{Int32}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowfac_mask(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse},
+                                          beta::Ptr{Cdouble}, kstart::Csize_t,
+                                          kend::Csize_t, mask::Ptr{Int32},
+                                          RLinkUp::Ptr{Int32}, L::Ptr{cholmod_factor},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowfac_mask(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
-    @ccall libcholmod.cholmod_l_rowfac_mask(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Csize_t, arg5::Csize_t, arg6::Ptr{Int64}, arg7::Ptr{Int64}, arg8::Ptr{cholmod_factor}, arg9::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowfac_mask(arg1::Ptr{cholmod_sparse},
+                                            arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble},
+                                            arg4::Csize_t, arg5::Csize_t, arg6::Ptr{Int64},
+                                            arg7::Ptr{Int64}, arg8::Ptr{cholmod_factor},
+                                            arg9::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowfac_mask2(A, F, beta, kstart, kend, mask, maskmark, RLinkUp, L, Common)
-    @ccall libcholmod.cholmod_rowfac_mask2(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, beta::Ptr{Cdouble}, kstart::Csize_t, kend::Csize_t, mask::Ptr{Int32}, maskmark::Int32, RLinkUp::Ptr{Int32}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowfac_mask2(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse},
+                                           beta::Ptr{Cdouble}, kstart::Csize_t,
+                                           kend::Csize_t, mask::Ptr{Int32}, maskmark::Int32,
+                                           RLinkUp::Ptr{Int32}, L::Ptr{cholmod_factor},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowfac_mask2(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)
-    @ccall libcholmod.cholmod_l_rowfac_mask2(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Csize_t, arg5::Csize_t, arg6::Ptr{Int64}, arg7::Int64, arg8::Ptr{Int64}, arg9::Ptr{cholmod_factor}, arg10::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowfac_mask2(arg1::Ptr{cholmod_sparse},
+                                             arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble},
+                                             arg4::Csize_t, arg5::Csize_t, arg6::Ptr{Int64},
+                                             arg7::Int64, arg8::Ptr{Int64},
+                                             arg9::Ptr{cholmod_factor},
+                                             arg10::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_row_subtree(A, F, k, Parent, R, Common)
-    @ccall libcholmod.cholmod_row_subtree(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, k::Csize_t, Parent::Ptr{Int32}, R::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_row_subtree(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse},
+                                          k::Csize_t, Parent::Ptr{Int32},
+                                          R::Ptr{cholmod_sparse},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_row_subtree(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_row_subtree(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{cholmod_sparse}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_row_subtree(arg1::Ptr{cholmod_sparse},
+                                            arg2::Ptr{cholmod_sparse}, arg3::Csize_t,
+                                            arg4::Ptr{Int64}, arg5::Ptr{cholmod_sparse},
+                                            arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_lsolve_pattern(B, L, X, Common)
-    @ccall libcholmod.cholmod_lsolve_pattern(B::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_lsolve_pattern(B::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor},
+                                             X::Ptr{cholmod_sparse},
+                                             Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_lsolve_pattern(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_lsolve_pattern(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_sparse}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_lsolve_pattern(arg1::Ptr{cholmod_sparse},
+                                               arg2::Ptr{cholmod_factor},
+                                               arg3::Ptr{cholmod_sparse},
+                                               arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_row_lsubtree(A, Fi, fnz, k, L, R, Common)
-    @ccall libcholmod.cholmod_row_lsubtree(A::Ptr{cholmod_sparse}, Fi::Ptr{Int32}, fnz::Csize_t, k::Csize_t, L::Ptr{cholmod_factor}, R::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_row_lsubtree(A::Ptr{cholmod_sparse}, Fi::Ptr{Int32},
+                                           fnz::Csize_t, k::Csize_t, L::Ptr{cholmod_factor},
+                                           R::Ptr{cholmod_sparse},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_row_lsubtree(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_row_lsubtree(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Csize_t, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_sparse}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_row_lsubtree(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                             arg3::Csize_t, arg4::Csize_t,
+                                             arg5::Ptr{cholmod_factor},
+                                             arg6::Ptr{cholmod_sparse},
+                                             arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_resymbol(A, fset, fsize, pack, L, Common)
-    @ccall libcholmod.cholmod_resymbol(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, pack::Cint, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_resymbol(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                       fsize::Csize_t, pack::Cint, L::Ptr{cholmod_factor},
+                                       Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_resymbol(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_resymbol(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Cint, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_resymbol(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                         arg3::Csize_t, arg4::Cint,
+                                         arg5::Ptr{cholmod_factor},
+                                         arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_resymbol_noperm(A, fset, fsize, pack, L, Common)
-    @ccall libcholmod.cholmod_resymbol_noperm(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, pack::Cint, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_resymbol_noperm(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                              fsize::Csize_t, pack::Cint,
+                                              L::Ptr{cholmod_factor},
+                                              Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_resymbol_noperm(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_resymbol_noperm(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Cint, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_resymbol_noperm(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                                arg3::Csize_t, arg4::Cint,
+                                                arg5::Ptr{cholmod_factor},
+                                                arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rcond(L, Common)
-    @ccall libcholmod.cholmod_rcond(L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cdouble
+    @ccall libcholmod.cholmod_rcond(L::Ptr{cholmod_factor},
+                                    Common::Ptr{cholmod_common})::Cdouble
 end
 
 function cholmod_l_rcond(arg1, arg2)
-    @ccall libcholmod.cholmod_l_rcond(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_common})::Cdouble
+    @ccall libcholmod.cholmod_l_rcond(arg1::Ptr{cholmod_factor},
+                                      arg2::Ptr{cholmod_common})::Cdouble
 end
 
 function cholmod_postorder(Parent, n, Weight_p, Post, Common)
-    @ccall libcholmod.cholmod_postorder(Parent::Ptr{Int32}, n::Csize_t, Weight_p::Ptr{Int32}, Post::Ptr{Int32}, Common::Ptr{cholmod_common})::Int32
+    @ccall libcholmod.cholmod_postorder(Parent::Ptr{Int32}, n::Csize_t,
+                                        Weight_p::Ptr{Int32}, Post::Ptr{Int32},
+                                        Common::Ptr{cholmod_common})::Int32
 end
 
 function cholmod_l_postorder(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_postorder(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_l_postorder(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Ptr{Int64},
+                                          arg4::Ptr{Int64},
+                                          arg5::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_drop(tol, A, Common)
-    @ccall libcholmod.cholmod_drop(tol::Cdouble, A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_drop(tol::Cdouble, A::Ptr{cholmod_sparse},
+                                   Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_drop(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_drop(arg1::Cdouble, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_drop(arg1::Cdouble, arg2::Ptr{cholmod_sparse},
+                                     arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_norm_dense(X, norm, Common)
-    @ccall libcholmod.cholmod_norm_dense(X::Ptr{cholmod_dense}, norm::Cint, Common::Ptr{cholmod_common})::Cdouble
+    @ccall libcholmod.cholmod_norm_dense(X::Ptr{cholmod_dense}, norm::Cint,
+                                         Common::Ptr{cholmod_common})::Cdouble
 end
 
 function cholmod_l_norm_dense(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_norm_dense(arg1::Ptr{cholmod_dense}, arg2::Cint, arg3::Ptr{cholmod_common})::Cdouble
+    @ccall libcholmod.cholmod_l_norm_dense(arg1::Ptr{cholmod_dense}, arg2::Cint,
+                                           arg3::Ptr{cholmod_common})::Cdouble
 end
 
 function cholmod_norm_sparse(A, norm, Common)
-    @ccall libcholmod.cholmod_norm_sparse(A::Ptr{cholmod_sparse}, norm::Cint, Common::Ptr{cholmod_common})::Cdouble
+    @ccall libcholmod.cholmod_norm_sparse(A::Ptr{cholmod_sparse}, norm::Cint,
+                                          Common::Ptr{cholmod_common})::Cdouble
 end
 
 function cholmod_l_norm_sparse(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_norm_sparse(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{cholmod_common})::Cdouble
+    @ccall libcholmod.cholmod_l_norm_sparse(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                            arg3::Ptr{cholmod_common})::Cdouble
 end
 
 function cholmod_horzcat(A, B, values, Common)
-    @ccall libcholmod.cholmod_horzcat(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse}, values::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_horzcat(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse},
+                                      values::Cint,
+                                      Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_horzcat(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_horzcat(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_horzcat(arg1::Ptr{cholmod_sparse},
+                                        arg2::Ptr{cholmod_sparse}, arg3::Cint,
+                                        arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_scale(S, scale, A, Common)
-    @ccall libcholmod.cholmod_scale(S::Ptr{cholmod_dense}, scale::Cint, A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_scale(S::Ptr{cholmod_dense}, scale::Cint,
+                                    A::Ptr{cholmod_sparse},
+                                    Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_scale(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_scale(arg1::Ptr{cholmod_dense}, arg2::Cint, arg3::Ptr{cholmod_sparse}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_scale(arg1::Ptr{cholmod_dense}, arg2::Cint,
+                                      arg3::Ptr{cholmod_sparse},
+                                      arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_sdmult(A, transpose, alpha, beta, X, Y, Common)
-    @ccall libcholmod.cholmod_sdmult(A::Ptr{cholmod_sparse}, transpose::Cint, alpha::Ptr{Cdouble}, beta::Ptr{Cdouble}, X::Ptr{cholmod_dense}, Y::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_sdmult(A::Ptr{cholmod_sparse}, transpose::Cint,
+                                     alpha::Ptr{Cdouble}, beta::Ptr{Cdouble},
+                                     X::Ptr{cholmod_dense}, Y::Ptr{cholmod_dense},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_sdmult(arg1, arg2, arg3, arg4, arg5, Y, arg7)
-    @ccall libcholmod.cholmod_l_sdmult(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{Cdouble}, arg4::Ptr{Cdouble}, arg5::Ptr{cholmod_dense}, Y::Ptr{cholmod_dense}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_sdmult(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                       arg3::Ptr{Cdouble}, arg4::Ptr{Cdouble},
+                                       arg5::Ptr{cholmod_dense}, Y::Ptr{cholmod_dense},
+                                       arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_ssmult(A, B, stype, values, sorted, Common)
-    @ccall libcholmod.cholmod_ssmult(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse}, stype::Cint, values::Cint, sorted::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_ssmult(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse},
+                                     stype::Cint, values::Cint, sorted::Cint,
+                                     Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_ssmult(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_ssmult(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Cint, arg4::Cint, arg5::Cint, arg6::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_ssmult(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse},
+                                       arg3::Cint, arg4::Cint, arg5::Cint,
+                                       arg6::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_submatrix(A, rset, rsize, cset, csize, values, sorted, Common)
-    @ccall libcholmod.cholmod_submatrix(A::Ptr{cholmod_sparse}, rset::Ptr{Int32}, rsize::Int64, cset::Ptr{Int32}, csize::Int64, values::Cint, sorted::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_submatrix(A::Ptr{cholmod_sparse}, rset::Ptr{Int32},
+                                        rsize::Int64, cset::Ptr{Int32}, csize::Int64,
+                                        values::Cint, sorted::Cint,
+                                        Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_submatrix(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
-    @ccall libcholmod.cholmod_l_submatrix(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Int64, arg4::Ptr{Int64}, arg5::Int64, arg6::Cint, arg7::Cint, arg8::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_submatrix(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                          arg3::Int64, arg4::Ptr{Int64}, arg5::Int64,
+                                          arg6::Cint, arg7::Cint,
+                                          arg8::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_vertcat(A, B, values, Common)
-    @ccall libcholmod.cholmod_vertcat(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse}, values::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_vertcat(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse},
+                                      values::Cint,
+                                      Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_vertcat(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_vertcat(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_vertcat(arg1::Ptr{cholmod_sparse},
+                                        arg2::Ptr{cholmod_sparse}, arg3::Cint,
+                                        arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_symmetry(A, option, xmatched, pmatched, nzoffdiag, nzdiag, Common)
-    @ccall libcholmod.cholmod_symmetry(A::Ptr{cholmod_sparse}, option::Cint, xmatched::Ptr{Int32}, pmatched::Ptr{Int32}, nzoffdiag::Ptr{Int32}, nzdiag::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_symmetry(A::Ptr{cholmod_sparse}, option::Cint,
+                                       xmatched::Ptr{Int32}, pmatched::Ptr{Int32},
+                                       nzoffdiag::Ptr{Int32}, nzdiag::Ptr{Int32},
+                                       Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_symmetry(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_symmetry(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Ptr{Int64}, arg6::Ptr{Int64}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_symmetry(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                         arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                         arg5::Ptr{Int64}, arg6::Ptr{Int64},
+                                         arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_updown(update, C, L, Common)
-    @ccall libcholmod.cholmod_updown(update::Cint, C::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_updown(update::Cint, C::Ptr{cholmod_sparse},
+                                     L::Ptr{cholmod_factor},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_updown(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_updown(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_factor}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_updown(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                       arg3::Ptr{cholmod_factor},
+                                       arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_updown_solve(update, C, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_updown_solve(update::Cint, C::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_updown_solve(update::Cint, C::Ptr{cholmod_sparse},
+                                           L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense},
+                                           DeltaB::Ptr{cholmod_dense},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_updown_solve(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_updown_solve(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_factor}, arg4::Ptr{cholmod_dense}, arg5::Ptr{cholmod_dense}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_updown_solve(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                             arg3::Ptr{cholmod_factor},
+                                             arg4::Ptr{cholmod_dense},
+                                             arg5::Ptr{cholmod_dense},
+                                             arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_updown_mark(update, C, colmark, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_updown_mark(update::Cint, C::Ptr{cholmod_sparse}, colmark::Ptr{Int32}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_updown_mark(update::Cint, C::Ptr{cholmod_sparse},
+                                          colmark::Ptr{Int32}, L::Ptr{cholmod_factor},
+                                          X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_updown_mark(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_updown_mark(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Int64}, arg4::Ptr{cholmod_factor}, arg5::Ptr{cholmod_dense}, arg6::Ptr{cholmod_dense}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_updown_mark(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                            arg3::Ptr{Int64}, arg4::Ptr{cholmod_factor},
+                                            arg5::Ptr{cholmod_dense},
+                                            arg6::Ptr{cholmod_dense},
+                                            arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_updown_mask(update, C, colmark, mask, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_updown_mask(update::Cint, C::Ptr{cholmod_sparse}, colmark::Ptr{Int32}, mask::Ptr{Int32}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_updown_mask(update::Cint, C::Ptr{cholmod_sparse},
+                                          colmark::Ptr{Int32}, mask::Ptr{Int32},
+                                          L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense},
+                                          DeltaB::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_updown_mask(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
-    @ccall libcholmod.cholmod_l_updown_mask(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_dense}, arg7::Ptr{cholmod_dense}, arg8::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_updown_mask(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                            arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                            arg5::Ptr{cholmod_factor},
+                                            arg6::Ptr{cholmod_dense},
+                                            arg7::Ptr{cholmod_dense},
+                                            arg8::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_updown_mask2(update, C, colmark, mask, maskmark, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_updown_mask2(update::Cint, C::Ptr{cholmod_sparse}, colmark::Ptr{Int32}, mask::Ptr{Int32}, maskmark::Int32, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_updown_mask2(update::Cint, C::Ptr{cholmod_sparse},
+                                           colmark::Ptr{Int32}, mask::Ptr{Int32},
+                                           maskmark::Int32, L::Ptr{cholmod_factor},
+                                           X::Ptr{cholmod_dense},
+                                           DeltaB::Ptr{cholmod_dense},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_updown_mask2(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
-    @ccall libcholmod.cholmod_l_updown_mask2(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Int64, arg6::Ptr{cholmod_factor}, arg7::Ptr{cholmod_dense}, arg8::Ptr{cholmod_dense}, arg9::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_updown_mask2(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                             arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                             arg5::Int64, arg6::Ptr{cholmod_factor},
+                                             arg7::Ptr{cholmod_dense},
+                                             arg8::Ptr{cholmod_dense},
+                                             arg9::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowadd(k, R, L, Common)
-    @ccall libcholmod.cholmod_rowadd(k::Csize_t, R::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowadd(k::Csize_t, R::Ptr{cholmod_sparse},
+                                     L::Ptr{cholmod_factor},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowadd(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_rowadd(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_factor}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowadd(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                       arg3::Ptr{cholmod_factor},
+                                       arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowadd_solve(k, R, bk, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_rowadd_solve(k::Csize_t, R::Ptr{cholmod_sparse}, bk::Ptr{Cdouble}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowadd_solve(k::Csize_t, R::Ptr{cholmod_sparse},
+                                           bk::Ptr{Cdouble}, L::Ptr{cholmod_factor},
+                                           X::Ptr{cholmod_dense},
+                                           DeltaB::Ptr{cholmod_dense},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowadd_solve(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_rowadd_solve(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Ptr{cholmod_factor}, arg5::Ptr{cholmod_dense}, arg6::Ptr{cholmod_dense}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowadd_solve(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                             arg3::Ptr{Cdouble}, arg4::Ptr{cholmod_factor},
+                                             arg5::Ptr{cholmod_dense},
+                                             arg6::Ptr{cholmod_dense},
+                                             arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowadd_mark(k, R, bk, colmark, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_rowadd_mark(k::Csize_t, R::Ptr{cholmod_sparse}, bk::Ptr{Cdouble}, colmark::Ptr{Int32}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowadd_mark(k::Csize_t, R::Ptr{cholmod_sparse},
+                                          bk::Ptr{Cdouble}, colmark::Ptr{Int32},
+                                          L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense},
+                                          DeltaB::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowadd_mark(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
-    @ccall libcholmod.cholmod_l_rowadd_mark(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Ptr{Int64}, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_dense}, arg7::Ptr{cholmod_dense}, arg8::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowadd_mark(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                            arg3::Ptr{Cdouble}, arg4::Ptr{Int64},
+                                            arg5::Ptr{cholmod_factor},
+                                            arg6::Ptr{cholmod_dense},
+                                            arg7::Ptr{cholmod_dense},
+                                            arg8::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowdel(k, R, L, Common)
-    @ccall libcholmod.cholmod_rowdel(k::Csize_t, R::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowdel(k::Csize_t, R::Ptr{cholmod_sparse},
+                                     L::Ptr{cholmod_factor},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowdel(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_rowdel(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_factor}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowdel(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                       arg3::Ptr{cholmod_factor},
+                                       arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowdel_solve(k, R, yk, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_rowdel_solve(k::Csize_t, R::Ptr{cholmod_sparse}, yk::Ptr{Cdouble}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowdel_solve(k::Csize_t, R::Ptr{cholmod_sparse},
+                                           yk::Ptr{Cdouble}, L::Ptr{cholmod_factor},
+                                           X::Ptr{cholmod_dense},
+                                           DeltaB::Ptr{cholmod_dense},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowdel_solve(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_rowdel_solve(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Ptr{cholmod_factor}, arg5::Ptr{cholmod_dense}, arg6::Ptr{cholmod_dense}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowdel_solve(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                             arg3::Ptr{Cdouble}, arg4::Ptr{cholmod_factor},
+                                             arg5::Ptr{cholmod_dense},
+                                             arg6::Ptr{cholmod_dense},
+                                             arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowdel_mark(k, R, yk, colmark, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_rowdel_mark(k::Csize_t, R::Ptr{cholmod_sparse}, yk::Ptr{Cdouble}, colmark::Ptr{Int32}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowdel_mark(k::Csize_t, R::Ptr{cholmod_sparse},
+                                          yk::Ptr{Cdouble}, colmark::Ptr{Int32},
+                                          L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense},
+                                          DeltaB::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowdel_mark(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
-    @ccall libcholmod.cholmod_l_rowdel_mark(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Ptr{Int64}, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_dense}, arg7::Ptr{cholmod_dense}, arg8::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowdel_mark(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                            arg3::Ptr{Cdouble}, arg4::Ptr{Int64},
+                                            arg5::Ptr{cholmod_factor},
+                                            arg6::Ptr{cholmod_dense},
+                                            arg7::Ptr{cholmod_dense},
+                                            arg8::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_ccolamd(A, fset, fsize, Cmember, Perm, Common)
-    @ccall libcholmod.cholmod_ccolamd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, Cmember::Ptr{Int32}, Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_ccolamd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                      fsize::Csize_t, Cmember::Ptr{Int32}, Perm::Ptr{Int32},
+                                      Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_ccolamd(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_ccolamd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{Int64}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_ccolamd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                        arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{Int64},
+                                        arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_csymamd(A, Cmember, Perm, Common)
-    @ccall libcholmod.cholmod_csymamd(A::Ptr{cholmod_sparse}, Cmember::Ptr{Int32}, Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_csymamd(A::Ptr{cholmod_sparse}, Cmember::Ptr{Int32},
+                                      Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_csymamd(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_csymamd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Ptr{Int64}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_csymamd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                        arg3::Ptr{Int64}, arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_camd(A, fset, fsize, Cmember, Perm, Common)
-    @ccall libcholmod.cholmod_camd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, Cmember::Ptr{Int32}, Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_camd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t,
+                                   Cmember::Ptr{Int32}, Perm::Ptr{Int32},
+                                   Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_camd(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_camd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{Int64}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_camd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                     arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{Int64},
+                                     arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_nested_dissection(A, fset, fsize, Perm, CParent, Cmember, Common)
-    @ccall libcholmod.cholmod_nested_dissection(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, Perm::Ptr{Int32}, CParent::Ptr{Int32}, Cmember::Ptr{Int32}, Common::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_nested_dissection(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                                fsize::Csize_t, Perm::Ptr{Int32},
+                                                CParent::Ptr{Int32}, Cmember::Ptr{Int32},
+                                                Common::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_l_nested_dissection(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_nested_dissection(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{Int64}, arg6::Ptr{Int64}, arg7::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_l_nested_dissection(arg1::Ptr{cholmod_sparse},
+                                                  arg2::Ptr{Int64}, arg3::Csize_t,
+                                                  arg4::Ptr{Int64}, arg5::Ptr{Int64},
+                                                  arg6::Ptr{Int64},
+                                                  arg7::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_metis(A, fset, fsize, postorder, Perm, Common)
-    @ccall libcholmod.cholmod_metis(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, postorder::Cint, Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_metis(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                    fsize::Csize_t, postorder::Cint, Perm::Ptr{Int32},
+                                    Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_metis(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_metis(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Cint, arg5::Ptr{Int64}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_metis(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                      arg3::Csize_t, arg4::Cint, arg5::Ptr{Int64},
+                                      arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_bisect(A, fset, fsize, compress, Partition, Common)
-    @ccall libcholmod.cholmod_bisect(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, compress::Cint, Partition::Ptr{Int32}, Common::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_bisect(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                     fsize::Csize_t, compress::Cint, Partition::Ptr{Int32},
+                                     Common::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_l_bisect(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_bisect(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Cint, arg5::Ptr{Int64}, arg6::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_l_bisect(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                       arg3::Csize_t, arg4::Cint, arg5::Ptr{Int64},
+                                       arg6::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_metis_bisector(A, Anw, Aew, Partition, Common)
-    @ccall libcholmod.cholmod_metis_bisector(A::Ptr{cholmod_sparse}, Anw::Ptr{Int32}, Aew::Ptr{Int32}, Partition::Ptr{Int32}, Common::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_metis_bisector(A::Ptr{cholmod_sparse}, Anw::Ptr{Int32},
+                                             Aew::Ptr{Int32}, Partition::Ptr{Int32},
+                                             Common::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_l_metis_bisector(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_metis_bisector(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_l_metis_bisector(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                               arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                               arg5::Ptr{cholmod_common})::Int64
 end
 
-function cholmod_collapse_septree(n, ncomponents, nd_oksep, nd_small, CParent, Cmember, Common)
-    @ccall libcholmod.cholmod_collapse_septree(n::Csize_t, ncomponents::Csize_t, nd_oksep::Cdouble, nd_small::Csize_t, CParent::Ptr{Int32}, Cmember::Ptr{Int32}, Common::Ptr{cholmod_common})::Int64
+function cholmod_collapse_septree(n, ncomponents, nd_oksep, nd_small, CParent, Cmember,
+                                  Common)
+    @ccall libcholmod.cholmod_collapse_septree(n::Csize_t, ncomponents::Csize_t,
+                                               nd_oksep::Cdouble, nd_small::Csize_t,
+                                               CParent::Ptr{Int32}, Cmember::Ptr{Int32},
+                                               Common::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_l_collapse_septree(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_collapse_septree(arg1::Csize_t, arg2::Csize_t, arg3::Cdouble, arg4::Csize_t, arg5::Ptr{Int64}, arg6::Ptr{Int64}, arg7::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_l_collapse_septree(arg1::Csize_t, arg2::Csize_t,
+                                                 arg3::Cdouble, arg4::Csize_t,
+                                                 arg5::Ptr{Int64}, arg6::Ptr{Int64},
+                                                 arg7::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_super_symbolic(A, F, Parent, L, Common)
-    @ccall libcholmod.cholmod_super_symbolic(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, Parent::Ptr{Int32}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_super_symbolic(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse},
+                                             Parent::Ptr{Int32}, L::Ptr{cholmod_factor},
+                                             Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_super_symbolic(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_super_symbolic(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Int64}, arg4::Ptr{cholmod_factor}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_super_symbolic(arg1::Ptr{cholmod_sparse},
+                                               arg2::Ptr{cholmod_sparse}, arg3::Ptr{Int64},
+                                               arg4::Ptr{cholmod_factor},
+                                               arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_super_symbolic2(for_whom, A, F, Parent, L, Common)
-    @ccall libcholmod.cholmod_super_symbolic2(for_whom::Cint, A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, Parent::Ptr{Int32}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_super_symbolic2(for_whom::Cint, A::Ptr{cholmod_sparse},
+                                              F::Ptr{cholmod_sparse}, Parent::Ptr{Int32},
+                                              L::Ptr{cholmod_factor},
+                                              Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_super_symbolic2(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_super_symbolic2(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_sparse}, arg4::Ptr{Int64}, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_super_symbolic2(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                                arg3::Ptr{cholmod_sparse}, arg4::Ptr{Int64},
+                                                arg5::Ptr{cholmod_factor},
+                                                arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_super_numeric(A, F, beta, L, Common)
-    @ccall libcholmod.cholmod_super_numeric(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, beta::Ptr{Cdouble}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_super_numeric(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse},
+                                            beta::Ptr{Cdouble}, L::Ptr{cholmod_factor},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_super_numeric(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_super_numeric(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Ptr{cholmod_factor}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_super_numeric(arg1::Ptr{cholmod_sparse},
+                                              arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble},
+                                              arg4::Ptr{cholmod_factor},
+                                              arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_super_lsolve(L, X, E, Common)
-    @ccall libcholmod.cholmod_super_lsolve(L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, E::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_super_lsolve(L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense},
+                                           E::Ptr{cholmod_dense},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_super_lsolve(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_super_lsolve(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_dense}, arg3::Ptr{cholmod_dense}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_super_lsolve(arg1::Ptr{cholmod_factor},
+                                             arg2::Ptr{cholmod_dense},
+                                             arg3::Ptr{cholmod_dense},
+                                             arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_super_ltsolve(L, X, E, Common)
-    @ccall libcholmod.cholmod_super_ltsolve(L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, E::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_super_ltsolve(L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense},
+                                            E::Ptr{cholmod_dense},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_super_ltsolve(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_super_ltsolve(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_dense}, arg3::Ptr{cholmod_dense}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_super_ltsolve(arg1::Ptr{cholmod_factor},
+                                              arg2::Ptr{cholmod_dense},
+                                              arg3::Ptr{cholmod_dense},
+                                              arg4::Ptr{cholmod_common})::Cint
+end
+
+function SuiteSparseQR_C(ordering, tol, econ, getCTX, A, Bsparse, Bdense, Zsparse, Zdense,
+                         R, E, H, HPinv, HTau, cc)
+    @ccall libspqr.SuiteSparseQR_C(ordering::Cint, tol::Cdouble, econ::Int64, getCTX::Cint,
+                                   A::Ptr{cholmod_sparse}, Bsparse::Ptr{cholmod_sparse},
+                                   Bdense::Ptr{cholmod_dense},
+                                   Zsparse::Ptr{Ptr{cholmod_sparse}},
+                                   Zdense::Ptr{Ptr{cholmod_dense}},
+                                   R::Ptr{Ptr{cholmod_sparse}}, E::Ptr{Ptr{Int64}},
+                                   H::Ptr{Ptr{cholmod_sparse}}, HPinv::Ptr{Ptr{Int64}},
+                                   HTau::Ptr{Ptr{cholmod_dense}},
+                                   cc::Ptr{cholmod_common})::Int64
+end
+
+function SuiteSparseQR_i_C(ordering, tol, econ, getCTX, A, Bsparse, Bdense, Zsparse, Zdense,
+                           R, E, H, HPinv, HTau, cc)
+    @ccall libspqr.SuiteSparseQR_i_C(ordering::Cint, tol::Cdouble, econ::Int32,
+                                     getCTX::Cint, A::Ptr{cholmod_sparse},
+                                     Bsparse::Ptr{cholmod_sparse},
+                                     Bdense::Ptr{cholmod_dense},
+                                     Zsparse::Ptr{Ptr{cholmod_sparse}},
+                                     Zdense::Ptr{Ptr{cholmod_dense}},
+                                     R::Ptr{Ptr{cholmod_sparse}}, E::Ptr{Ptr{Int32}},
+                                     H::Ptr{Ptr{cholmod_sparse}}, HPinv::Ptr{Ptr{Int32}},
+                                     HTau::Ptr{Ptr{cholmod_dense}},
+                                     cc::Ptr{cholmod_common})::Int32
 end
 
-function SuiteSparseQR_C(ordering, tol, econ, getCTX, A, Bsparse, Bdense, Zsparse, Zdense, R, E, H, HPinv, HTau, cc)
-    @ccall libspqr.SuiteSparseQR_C(ordering::Cint, tol::Cdouble, econ::Int64, getCTX::Cint, A::Ptr{cholmod_sparse}, Bsparse::Ptr{cholmod_sparse}, Bdense::Ptr{cholmod_dense}, Zsparse::Ptr{Ptr{cholmod_sparse}}, Zdense::Ptr{Ptr{cholmod_dense}}, R::Ptr{Ptr{cholmod_sparse}}, E::Ptr{Ptr{Int64}}, H::Ptr{Ptr{cholmod_sparse}}, HPinv::Ptr{Ptr{Int64}}, HTau::Ptr{Ptr{cholmod_dense}}, cc::Ptr{cholmod_common})::Int64
+function SuiteSparseQR_C_QR(ordering, tol, econ, A, Q, R, E, cc)
+    @ccall libspqr.SuiteSparseQR_C_QR(ordering::Cint, tol::Cdouble, econ::Int64,
+                                      A::Ptr{cholmod_sparse}, Q::Ptr{Ptr{cholmod_sparse}},
+                                      R::Ptr{Ptr{cholmod_sparse}}, E::Ptr{Ptr{Int64}},
+                                      cc::Ptr{cholmod_common})::Int64
 end
 
-function SuiteSparseQR_C_QR(ordering, tol, econ, A, Q, R, E, cc)
-    @ccall libspqr.SuiteSparseQR_C_QR(ordering::Cint, tol::Cdouble, econ::Int64, A::Ptr{cholmod_sparse}, Q::Ptr{Ptr{cholmod_sparse}}, R::Ptr{Ptr{cholmod_sparse}}, E::Ptr{Ptr{Int64}}, cc::Ptr{cholmod_common})::Int64
+function SuiteSparseQR_i_C_QR(ordering, tol, econ, A, Q, R, E, cc)
+    @ccall libspqr.SuiteSparseQR_i_C_QR(ordering::Cint, tol::Cdouble, econ::Int32,
+                                        A::Ptr{cholmod_sparse}, Q::Ptr{Ptr{cholmod_sparse}},
+                                        R::Ptr{Ptr{cholmod_sparse}}, E::Ptr{Ptr{Int32}},
+                                        cc::Ptr{cholmod_common})::Int32
 end
 
 function SuiteSparseQR_C_backslash(ordering, tol, A, B, cc)
-    @ccall libspqr.SuiteSparseQR_C_backslash(ordering::Cint, tol::Cdouble, A::Ptr{cholmod_sparse}, B::Ptr{cholmod_dense}, cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libspqr.SuiteSparseQR_C_backslash(ordering::Cint, tol::Cdouble,
+                                             A::Ptr{cholmod_sparse}, B::Ptr{cholmod_dense},
+                                             cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function SuiteSparseQR_C_backslash_default(A, B, cc)
-    @ccall libspqr.SuiteSparseQR_C_backslash_default(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_dense}, cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libspqr.SuiteSparseQR_C_backslash_default(A::Ptr{cholmod_sparse},
+                                                     B::Ptr{cholmod_dense},
+                                                     cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function SuiteSparseQR_C_backslash_sparse(ordering, tol, A, B, cc)
-    @ccall libspqr.SuiteSparseQR_C_backslash_sparse(ordering::Cint, tol::Cdouble, A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse}, cc::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libspqr.SuiteSparseQR_C_backslash_sparse(ordering::Cint, tol::Cdouble,
+                                                    A::Ptr{cholmod_sparse},
+                                                    B::Ptr{cholmod_sparse},
+                                                    cc::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 mutable struct SuiteSparseQR_C_factorization_struct
     xtype::Cint
+    itype::Cint
     factors::Ptr{Cvoid}
     SuiteSparseQR_C_factorization_struct() = new()
 end
@@ -1536,51 +2115,78 @@ end
 const SuiteSparseQR_C_factorization = SuiteSparseQR_C_factorization_struct
 
 function SuiteSparseQR_C_factorize(ordering, tol, A, cc)
-    @ccall libspqr.SuiteSparseQR_C_factorize(ordering::Cint, tol::Cdouble, A::Ptr{cholmod_sparse}, cc::Ptr{cholmod_common})::Ptr{SuiteSparseQR_C_factorization}
+    @ccall libspqr.SuiteSparseQR_C_factorize(ordering::Cint, tol::Cdouble,
+                                             A::Ptr{cholmod_sparse},
+                                             cc::Ptr{cholmod_common})::Ptr{SuiteSparseQR_C_factorization}
 end
 
 function SuiteSparseQR_C_symbolic(ordering, allow_tol, A, cc)
-    @ccall libspqr.SuiteSparseQR_C_symbolic(ordering::Cint, allow_tol::Cint, A::Ptr{cholmod_sparse}, cc::Ptr{cholmod_common})::Ptr{SuiteSparseQR_C_factorization}
+    @ccall libspqr.SuiteSparseQR_C_symbolic(ordering::Cint, allow_tol::Cint,
+                                            A::Ptr{cholmod_sparse},
+                                            cc::Ptr{cholmod_common})::Ptr{SuiteSparseQR_C_factorization}
 end
 
 function SuiteSparseQR_C_numeric(tol, A, QR, cc)
-    @ccall libspqr.SuiteSparseQR_C_numeric(tol::Cdouble, A::Ptr{cholmod_sparse}, QR::Ptr{SuiteSparseQR_C_factorization}, cc::Ptr{cholmod_common})::Cint
+    @ccall libspqr.SuiteSparseQR_C_numeric(tol::Cdouble, A::Ptr{cholmod_sparse},
+                                           QR::Ptr{SuiteSparseQR_C_factorization},
+                                           cc::Ptr{cholmod_common})::Cint
 end
 
 function SuiteSparseQR_C_free(QR, cc)
-    @ccall libspqr.SuiteSparseQR_C_free(QR::Ptr{Ptr{SuiteSparseQR_C_factorization}}, cc::Ptr{cholmod_common})::Cint
+    @ccall libspqr.SuiteSparseQR_C_free(QR::Ptr{Ptr{SuiteSparseQR_C_factorization}},
+                                        cc::Ptr{cholmod_common})::Cint
 end
 
 function SuiteSparseQR_C_solve(system, QR, B, cc)
-    @ccall libspqr.SuiteSparseQR_C_solve(system::Cint, QR::Ptr{SuiteSparseQR_C_factorization}, B::Ptr{cholmod_dense}, cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libspqr.SuiteSparseQR_C_solve(system::Cint,
+                                         QR::Ptr{SuiteSparseQR_C_factorization},
+                                         B::Ptr{cholmod_dense},
+                                         cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function SuiteSparseQR_C_qmult(method, QR, X, cc)
-    @ccall libspqr.SuiteSparseQR_C_qmult(method::Cint, QR::Ptr{SuiteSparseQR_C_factorization}, X::Ptr{cholmod_dense}, cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libspqr.SuiteSparseQR_C_qmult(method::Cint,
+                                         QR::Ptr{SuiteSparseQR_C_factorization},
+                                         X::Ptr{cholmod_dense},
+                                         cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function amd_order(n, Ap, Ai, P, Control, Info)
-    @ccall libamd.amd_order(n::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, P::Ptr{Int32}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libamd.amd_order(n::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, P::Ptr{Int32},
+                            Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function amd_l_order(n, Ap, Ai, P, Control, Info)
-    @ccall libamd.amd_l_order(n::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, P::Ptr{Int64}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libamd.amd_l_order(n::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, P::Ptr{Int64},
+                              Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
-function amd_2(n, Pe, Iw, Len, iwlen, pfree, Nv, Next, Last, Head, Elen, Degree, W, Control, Info)
-    @ccall libamd.amd_2(n::Int32, Pe::Ptr{Int32}, Iw::Ptr{Int32}, Len::Ptr{Int32}, iwlen::Int32, pfree::Int32, Nv::Ptr{Int32}, Next::Ptr{Int32}, Last::Ptr{Int32}, Head::Ptr{Int32}, Elen::Ptr{Int32}, Degree::Ptr{Int32}, W::Ptr{Int32}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cvoid
+function amd_2(n, Pe, Iw, Len, iwlen, pfree, Nv, Next, Last, Head, Elen, Degree, W, Control,
+               Info)
+    @ccall libamd.amd_2(n::Int32, Pe::Ptr{Int32}, Iw::Ptr{Int32}, Len::Ptr{Int32},
+                        iwlen::Int32, pfree::Int32, Nv::Ptr{Int32}, Next::Ptr{Int32},
+                        Last::Ptr{Int32}, Head::Ptr{Int32}, Elen::Ptr{Int32},
+                        Degree::Ptr{Int32}, W::Ptr{Int32}, Control::Ptr{Cdouble},
+                        Info::Ptr{Cdouble})::Cvoid
 end
 
-function amd_l2(n, Pe, Iw, Len, iwlen, pfree, Nv, Next, Last, Head, Elen, Degree, W, Control, Info)
-    @ccall libamd.amd_l2(n::Int64, Pe::Ptr{Int64}, Iw::Ptr{Int64}, Len::Ptr{Int64}, iwlen::Int64, pfree::Int64, Nv::Ptr{Int64}, Next::Ptr{Int64}, Last::Ptr{Int64}, Head::Ptr{Int64}, Elen::Ptr{Int64}, Degree::Ptr{Int64}, W::Ptr{Int64}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cvoid
+function amd_l2(n, Pe, Iw, Len, iwlen, pfree, Nv, Next, Last, Head, Elen, Degree, W,
+                Control, Info)
+    @ccall libamd.amd_l2(n::Int64, Pe::Ptr{Int64}, Iw::Ptr{Int64}, Len::Ptr{Int64},
+                         iwlen::Int64, pfree::Int64, Nv::Ptr{Int64}, Next::Ptr{Int64},
+                         Last::Ptr{Int64}, Head::Ptr{Int64}, Elen::Ptr{Int64},
+                         Degree::Ptr{Int64}, W::Ptr{Int64}, Control::Ptr{Cdouble},
+                         Info::Ptr{Cdouble})::Cvoid
 end
 
 function amd_valid(n_row, n_col, Ap, Ai)
-    @ccall libamd.amd_valid(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32})::Cint
+    @ccall libamd.amd_valid(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                            Ai::Ptr{Int32})::Cint
 end
 
 function amd_l_valid(n_row, n_col, Ap, Ai)
-    @ccall libamd.amd_l_valid(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64})::Cint
+    @ccall libamd.amd_l_valid(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                              Ai::Ptr{Int64})::Cint
 end
 
 function amd_defaults(Control)
@@ -1607,188 +2213,88 @@ function amd_l_info(Info)
     @ccall libamd.amd_l_info(Info::Ptr{Cdouble})::Cvoid
 end
 
-function colamd_recommended(nnz, n_row, n_col)
-    @ccall libcolamd.colamd_recommended(nnz::Int32, n_row::Int32, n_col::Int32)::Csize_t
-end
-
-function colamd_l_recommended(nnz, n_row, n_col)
-    @ccall libcolamd.colamd_l_recommended(nnz::Int64, n_row::Int64, n_col::Int64)::Csize_t
-end
-
-function colamd_set_defaults(knobs)
-    @ccall libcolamd.colamd_set_defaults(knobs::Ptr{Cdouble})::Cvoid
-end
-
-function colamd_l_set_defaults(knobs)
-    @ccall libcolamd.colamd_l_set_defaults(knobs::Ptr{Cdouble})::Cvoid
-end
-
-function colamd(n_row, n_col, Alen, A, p, knobs, stats)
-    @ccall libcolamd.colamd(n_row::Int32, n_col::Int32, Alen::Int32, A::Ptr{Int32}, p::Ptr{Int32}, knobs::Ptr{Cdouble}, stats::Ptr{Int32})::Cint
-end
-
-function colamd_l(n_row, n_col, Alen, A, p, knobs, stats)
-    @ccall libcolamd.colamd_l(n_row::Int64, n_col::Int64, Alen::Int64, A::Ptr{Int64}, p::Ptr{Int64}, knobs::Ptr{Cdouble}, stats::Ptr{Int64})::Cint
-end
-
-function symamd(n, A, p, perm, knobs, stats, allocate, release)
-    @ccall libcolamd.symamd(n::Int32, A::Ptr{Int32}, p::Ptr{Int32}, perm::Ptr{Int32}, knobs::Ptr{Cdouble}, stats::Ptr{Int32}, allocate::Ptr{Cvoid}, release::Ptr{Cvoid})::Cint
-end
-
-function symamd_l(n, A, p, perm, knobs, stats, allocate, release)
-    @ccall libcolamd.symamd_l(n::Int64, A::Ptr{Int64}, p::Ptr{Int64}, perm::Ptr{Int64}, knobs::Ptr{Cdouble}, stats::Ptr{Int64}, allocate::Ptr{Cvoid}, release::Ptr{Cvoid})::Cint
-end
-
-function colamd_report(stats)
-    @ccall libcolamd.colamd_report(stats::Ptr{Int32})::Cvoid
-end
-
-function colamd_l_report(stats)
-    @ccall libcolamd.colamd_l_report(stats::Ptr{Int64})::Cvoid
-end
-
-function symamd_report(stats)
-    @ccall libcolamd.symamd_report(stats::Ptr{Int32})::Cvoid
-end
-
-function symamd_l_report(stats)
-    @ccall libcolamd.symamd_l_report(stats::Ptr{Int64})::Cvoid
-end
-
-function ccolamd_recommended(nnz, n_row, n_col)
-    @ccall libcolamd.ccolamd_recommended(nnz::Cint, n_row::Cint, n_col::Cint)::Csize_t
-end
-
-function ccolamd_l_recommended(nnz, n_row, n_col)
-    @ccall libcolamd.ccolamd_l_recommended(nnz::Int64, n_row::Int64, n_col::Int64)::Csize_t
-end
-
-function ccolamd_set_defaults(knobs)
-    @ccall libcolamd.ccolamd_set_defaults(knobs::Ptr{Cdouble})::Cvoid
-end
-
-function ccolamd_l_set_defaults(knobs)
-    @ccall libcolamd.ccolamd_l_set_defaults(knobs::Ptr{Cdouble})::Cvoid
-end
-
-function ccolamd(n_row, n_col, Alen, A, p, knobs, stats, cmember)
-    @ccall libcolamd.ccolamd(n_row::Cint, n_col::Cint, Alen::Cint, A::Ptr{Cint}, p::Ptr{Cint}, knobs::Ptr{Cdouble}, stats::Ptr{Cint}, cmember::Ptr{Cint})::Cint
-end
-
-function ccolamd_l(n_row, n_col, Alen, A, p, knobs, stats, cmember)
-    @ccall libcolamd.ccolamd_l(n_row::Int64, n_col::Int64, Alen::Int64, A::Ptr{Int64}, p::Ptr{Int64}, knobs::Ptr{Cdouble}, stats::Ptr{Int64}, cmember::Ptr{Int64})::Cint
-end
-
-function csymamd(n, A, p, perm, knobs, stats, allocate, release, cmember, stype)
-    @ccall libcolamd.csymamd(n::Cint, A::Ptr{Cint}, p::Ptr{Cint}, perm::Ptr{Cint}, knobs::Ptr{Cdouble}, stats::Ptr{Cint}, allocate::Ptr{Cvoid}, release::Ptr{Cvoid}, cmember::Ptr{Cint}, stype::Cint)::Cint
-end
-
-function csymamd_l(n, A, p, perm, knobs, stats, allocate, release, cmember, stype)
-    @ccall libcolamd.csymamd_l(n::Int64, A::Ptr{Int64}, p::Ptr{Int64}, perm::Ptr{Int64}, knobs::Ptr{Cdouble}, stats::Ptr{Int64}, allocate::Ptr{Cvoid}, release::Ptr{Cvoid}, cmember::Ptr{Int64}, stype::Int64)::Cint
-end
-
-function ccolamd_report(stats)
-    @ccall libcolamd.ccolamd_report(stats::Ptr{Cint})::Cvoid
-end
-
-function ccolamd_l_report(stats)
-    @ccall libcolamd.ccolamd_l_report(stats::Ptr{Int64})::Cvoid
-end
-
-function csymamd_report(stats)
-    @ccall libcolamd.csymamd_report(stats::Ptr{Cint})::Cvoid
-end
-
-function csymamd_l_report(stats)
-    @ccall libcolamd.csymamd_l_report(stats::Ptr{Int64})::Cvoid
-end
-
-function ccolamd2(n_row, n_col, Alen, A, p, knobs, stats, Front_npivcol, Front_nrows, Front_ncols, Front_parent, Front_cols, p_nfr, InFront, cmember)
-    @ccall libcolamd.ccolamd2(n_row::Cint, n_col::Cint, Alen::Cint, A::Ptr{Cint}, p::Ptr{Cint}, knobs::Ptr{Cdouble}, stats::Ptr{Cint}, Front_npivcol::Ptr{Cint}, Front_nrows::Ptr{Cint}, Front_ncols::Ptr{Cint}, Front_parent::Ptr{Cint}, Front_cols::Ptr{Cint}, p_nfr::Ptr{Cint}, InFront::Ptr{Cint}, cmember::Ptr{Cint})::Cint
-end
-
-function ccolamd2_l(n_row, n_col, Alen, A, p, knobs, stats, Front_npivcol, Front_nrows, Front_ncols, Front_parent, Front_cols, p_nfr, InFront, cmember)
-    @ccall libcolamd.ccolamd2_l(n_row::Int64, n_col::Int64, Alen::Int64, A::Ptr{Int64}, p::Ptr{Int64}, knobs::Ptr{Cdouble}, stats::Ptr{Int64}, Front_npivcol::Ptr{Int64}, Front_nrows::Ptr{Int64}, Front_ncols::Ptr{Int64}, Front_parent::Ptr{Int64}, Front_cols::Ptr{Int64}, p_nfr::Ptr{Int64}, InFront::Ptr{Int64}, cmember::Ptr{Int64})::Cint
-end
-
-function ccolamd_apply_order(Front, Order, Temp, nn, nfr)
-    @ccall libcolamd.ccolamd_apply_order(Front::Ptr{Cint}, Order::Ptr{Cint}, Temp::Ptr{Cint}, nn::Cint, nfr::Cint)::Cvoid
-end
-
-function ccolamd_l_apply_order(Front, Order, Temp, nn, nfr)
-    @ccall libcolamd.ccolamd_l_apply_order(Front::Ptr{Int64}, Order::Ptr{Int64}, Temp::Ptr{Int64}, nn::Int64, nfr::Int64)::Cvoid
-end
-
-function ccolamd_fsize(nn, MaxFsize, Fnrows, Fncols, Parent, Npiv)
-    @ccall libcolamd.ccolamd_fsize(nn::Cint, MaxFsize::Ptr{Cint}, Fnrows::Ptr{Cint}, Fncols::Ptr{Cint}, Parent::Ptr{Cint}, Npiv::Ptr{Cint})::Cvoid
-end
-
-function ccolamd_l_fsize(nn, MaxFsize, Fnrows, Fncols, Parent, Npiv)
-    @ccall libcolamd.ccolamd_l_fsize(nn::Int64, MaxFsize::Ptr{Int64}, Fnrows::Ptr{Int64}, Fncols::Ptr{Int64}, Parent::Ptr{Int64}, Npiv::Ptr{Int64})::Cvoid
-end
-
-function ccolamd_postorder(nn, Parent, Npiv, Fsize, Order, Child, Sibling, Stack, Front_cols, cmember)
-    @ccall libcolamd.ccolamd_postorder(nn::Cint, Parent::Ptr{Cint}, Npiv::Ptr{Cint}, Fsize::Ptr{Cint}, Order::Ptr{Cint}, Child::Ptr{Cint}, Sibling::Ptr{Cint}, Stack::Ptr{Cint}, Front_cols::Ptr{Cint}, cmember::Ptr{Cint})::Cvoid
-end
-
-function ccolamd_l_postorder(nn, Parent, Npiv, Fsize, Order, Child, Sibling, Stack, Front_cols, cmember)
-    @ccall libcolamd.ccolamd_l_postorder(nn::Int64, Parent::Ptr{Int64}, Npiv::Ptr{Int64}, Fsize::Ptr{Int64}, Order::Ptr{Int64}, Child::Ptr{Int64}, Sibling::Ptr{Int64}, Stack::Ptr{Int64}, Front_cols::Ptr{Int64}, cmember::Ptr{Int64})::Cvoid
-end
-
-function ccolamd_post_tree(root, k, Child, Sibling, Order, Stack)
-    @ccall libcolamd.ccolamd_post_tree(root::Cint, k::Cint, Child::Ptr{Cint}, Sibling::Ptr{Cint}, Order::Ptr{Cint}, Stack::Ptr{Cint})::Cint
-end
-
-function ccolamd_l_post_tree(root, k, Child, Sibling, Order, Stack)
-    @ccall libcolamd.ccolamd_l_post_tree(root::Int64, k::Int64, Child::Ptr{Int64}, Sibling::Ptr{Int64}, Order::Ptr{Int64}, Stack::Ptr{Int64})::Int64
-end
-
 function umfpack_di_symbolic(n_row, n_col, Ap, Ai, Ax, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_di_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                          Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                          Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                          Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_symbolic(n_row, n_col, Ap, Ai, Ax, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_dl_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                          Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                          Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                          Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_symbolic(n_row, n_col, Ap, Ai, Ax, Az, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_zi_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                          Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                          Az::Ptr{Cdouble}, Symbolic::Ptr{Ptr{Cvoid}},
+                                          Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_symbolic(n_row, n_col, Ap, Ai, Ax, Az, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_zl_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                          Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                          Az::Ptr{Cdouble}, Symbolic::Ptr{Ptr{Cvoid}},
+                                          Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_numeric(Ap, Ai, Ax, Symbolic, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_di_numeric(Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Symbolic::Ptr{Cvoid}, Numeric::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_numeric(Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                         Symbolic::Ptr{Cvoid}, Numeric::Ptr{Ptr{Cvoid}},
+                                         Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_numeric(Ap, Ai, Ax, Symbolic, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_dl_numeric(Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Symbolic::Ptr{Cvoid}, Numeric::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_numeric(Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                         Symbolic::Ptr{Cvoid}, Numeric::Ptr{Ptr{Cvoid}},
+                                         Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_numeric(Ap, Ai, Ax, Az, Symbolic, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_zi_numeric(Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Symbolic::Ptr{Cvoid}, Numeric::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_numeric(Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                         Az::Ptr{Cdouble}, Symbolic::Ptr{Cvoid},
+                                         Numeric::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                         Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_numeric(Ap, Ai, Ax, Az, Symbolic, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_zl_numeric(Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Symbolic::Ptr{Cvoid}, Numeric::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_numeric(Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                         Az::Ptr{Cdouble}, Symbolic::Ptr{Cvoid},
+                                         Numeric::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                         Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_solve(sys, Ap, Ai, Ax, X, B, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_di_solve(sys::Cint, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_solve(sys::Cint, Ap::Ptr{Int32}, Ai::Ptr{Int32},
+                                       Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble},
+                                       Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                       Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_solve(sys, Ap, Ai, Ax, X, B, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_dl_solve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_solve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64},
+                                       Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble},
+                                       Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                       Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_solve(sys, Ap, Ai, Ax, Az, Xx, Xz, Bx, Bz, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_zi_solve(sys::Cint, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_solve(sys::Cint, Ap::Ptr{Int32}, Ai::Ptr{Int32},
+                                       Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Xx::Ptr{Cdouble},
+                                       Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble},
+                                       Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                       Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_solve(sys, Ap, Ai, Ax, Az, Xx, Xz, Bx, Bz, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_zl_solve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_solve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64},
+                                       Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Xx::Ptr{Cdouble},
+                                       Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble},
+                                       Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                       Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_free_symbolic(Symbolic)
@@ -1840,51 +2346,119 @@ function umfpack_zl_defaults(Control)
 end
 
 function umfpack_di_qsymbolic(n_row, n_col, Ap, Ai, Ax, Qinit, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_di_qsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Qinit::Ptr{Int32}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_qsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                           Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                           Qinit::Ptr{Int32}, Symbolic::Ptr{Ptr{Cvoid}},
+                                           Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_qsymbolic(n_row, n_col, Ap, Ai, Ax, Qinit, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_dl_qsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Qinit::Ptr{Int64}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_qsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                           Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                           Qinit::Ptr{Int64}, Symbolic::Ptr{Ptr{Cvoid}},
+                                           Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_qsymbolic(n_row, n_col, Ap, Ai, Ax, Az, Qinit, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_zi_qsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Qinit::Ptr{Int32}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_qsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                           Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                           Az::Ptr{Cdouble}, Qinit::Ptr{Int32},
+                                           Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                           Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_qsymbolic(n_row, n_col, Ap, Ai, Ax, Az, Qinit, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_zl_qsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Qinit::Ptr{Int64}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_di_fsymbolic(n_row, n_col, Ap, Ai, Ax, user_ordering, user_params, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_di_fsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_dl_fsymbolic(n_row, n_col, Ap, Ai, Ax, user_ordering, user_params, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_dl_fsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_zi_fsymbolic(n_row, n_col, Ap, Ai, Ax, Az, user_ordering, user_params, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_zi_fsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_zl_fsymbolic(n_row, n_col, Ap, Ai, Ax, Az, user_ordering, user_params, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_zl_fsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_di_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Qinit, user_ordering, user_params, Symbolic, SW, Control, Info)
-    @ccall libumfpack.umfpack_di_paru_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Qinit::Ptr{Int32}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_dl_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Qinit, user_ordering, user_params, Symbolic, SW, Control, Info)
-    @ccall libumfpack.umfpack_dl_paru_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Qinit::Ptr{Int64}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_zi_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Az, Qinit, user_ordering, user_params, Symbolic, SW, Control, Info)
-    @ccall libumfpack.umfpack_zi_paru_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Qinit::Ptr{Int32}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_zl_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Az, Qinit, user_ordering, user_params, Symbolic, SW, Control, Info)
-    @ccall libumfpack.umfpack_zl_paru_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Qinit::Ptr{Int64}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_qsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                           Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                           Az::Ptr{Cdouble}, Qinit::Ptr{Int64},
+                                           Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                           Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_di_fsymbolic(n_row, n_col, Ap, Ai, Ax, user_ordering, user_params,
+                              Symbolic, Control, Info)
+    @ccall libumfpack.umfpack_di_fsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                           Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                           user_ordering::Ptr{Cvoid},
+                                           user_params::Ptr{Cvoid},
+                                           Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                           Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_dl_fsymbolic(n_row, n_col, Ap, Ai, Ax, user_ordering, user_params,
+                              Symbolic, Control, Info)
+    @ccall libumfpack.umfpack_dl_fsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                           Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                           user_ordering::Ptr{Cvoid},
+                                           user_params::Ptr{Cvoid},
+                                           Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                           Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_zi_fsymbolic(n_row, n_col, Ap, Ai, Ax, Az, user_ordering, user_params,
+                              Symbolic, Control, Info)
+    @ccall libumfpack.umfpack_zi_fsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                           Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                           Az::Ptr{Cdouble}, user_ordering::Ptr{Cvoid},
+                                           user_params::Ptr{Cvoid},
+                                           Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                           Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_zl_fsymbolic(n_row, n_col, Ap, Ai, Ax, Az, user_ordering, user_params,
+                              Symbolic, Control, Info)
+    @ccall libumfpack.umfpack_zl_fsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                           Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                           Az::Ptr{Cdouble}, user_ordering::Ptr{Cvoid},
+                                           user_params::Ptr{Cvoid},
+                                           Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                           Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_di_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Qinit, user_ordering,
+                                  user_params, Symbolic, SW, Control, Info)
+    @ccall libumfpack.umfpack_di_paru_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                               Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                               Qinit::Ptr{Int32}, user_ordering::Ptr{Cvoid},
+                                               user_params::Ptr{Cvoid},
+                                               Symbolic::Ptr{Ptr{Cvoid}},
+                                               SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                               Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_dl_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Qinit, user_ordering,
+                                  user_params, Symbolic, SW, Control, Info)
+    @ccall libumfpack.umfpack_dl_paru_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                               Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                               Qinit::Ptr{Int64}, user_ordering::Ptr{Cvoid},
+                                               user_params::Ptr{Cvoid},
+                                               Symbolic::Ptr{Ptr{Cvoid}},
+                                               SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                               Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_zi_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Az, Qinit, user_ordering,
+                                  user_params, Symbolic, SW, Control, Info)
+    @ccall libumfpack.umfpack_zi_paru_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                               Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                               Az::Ptr{Cdouble}, Qinit::Ptr{Int32},
+                                               user_ordering::Ptr{Cvoid},
+                                               user_params::Ptr{Cvoid},
+                                               Symbolic::Ptr{Ptr{Cvoid}},
+                                               SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                               Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_zl_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Az, Qinit, user_ordering,
+                                  user_params, Symbolic, SW, Control, Info)
+    @ccall libumfpack.umfpack_zl_paru_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                               Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                               Az::Ptr{Cdouble}, Qinit::Ptr{Int64},
+                                               user_ordering::Ptr{Cvoid},
+                                               user_params::Ptr{Cvoid},
+                                               Symbolic::Ptr{Ptr{Cvoid}},
+                                               SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                               Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_paru_free_sw(SW)
@@ -1904,339 +2478,547 @@ function umfpack_zl_paru_free_sw(SW)
 end
 
 function umfpack_di_wsolve(sys, Ap, Ai, Ax, X, B, Numeric, Control, Info, Wi, W)
-    @ccall libumfpack.umfpack_di_wsolve(sys::Cint, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble}, Wi::Ptr{Int32}, W::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_wsolve(sys::Cint, Ap::Ptr{Int32}, Ai::Ptr{Int32},
+                                        Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble},
+                                        Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                        Info::Ptr{Cdouble}, Wi::Ptr{Int32},
+                                        W::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_wsolve(sys, Ap, Ai, Ax, X, B, Numeric, Control, Info, Wi, W)
-    @ccall libumfpack.umfpack_dl_wsolve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble}, Wi::Ptr{Int64}, W::Ptr{Cdouble})::Cint
-end
-
-function umfpack_zi_wsolve(sys, Ap, Ai, Ax, Az, Xx, Xz, Bx, Bz, Numeric, Control, Info, Wi, W)
-    @ccall libumfpack.umfpack_zi_wsolve(sys::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble}, Wi::Ptr{Int32}, W::Ptr{Cdouble})::Cint
-end
-
-function umfpack_zl_wsolve(sys, Ap, Ai, Ax, Az, Xx, Xz, Bx, Bz, Numeric, Control, Info, Wi, W)
-    @ccall libumfpack.umfpack_zl_wsolve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble}, Wi::Ptr{Int64}, W::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_wsolve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64},
+                                        Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble},
+                                        Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                        Info::Ptr{Cdouble}, Wi::Ptr{Int64},
+                                        W::Ptr{Cdouble})::Cint
+end
+
+function umfpack_zi_wsolve(sys, Ap, Ai, Ax, Az, Xx, Xz, Bx, Bz, Numeric, Control, Info, Wi,
+                           W)
+    @ccall libumfpack.umfpack_zi_wsolve(sys::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32},
+                                        Ax::Ptr{Cdouble}, Az::Ptr{Cdouble},
+                                        Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble},
+                                        Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble},
+                                        Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                        Info::Ptr{Cdouble}, Wi::Ptr{Int32},
+                                        W::Ptr{Cdouble})::Cint
+end
+
+function umfpack_zl_wsolve(sys, Ap, Ai, Ax, Az, Xx, Xz, Bx, Bz, Numeric, Control, Info, Wi,
+                           W)
+    @ccall libumfpack.umfpack_zl_wsolve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64},
+                                        Ax::Ptr{Cdouble}, Az::Ptr{Cdouble},
+                                        Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble},
+                                        Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble},
+                                        Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                        Info::Ptr{Cdouble}, Wi::Ptr{Int64},
+                                        W::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_triplet_to_col(n_row, n_col, nz, Ti, Tj, Tx, Ap, Ai, Ax, Map)
-    @ccall libumfpack.umfpack_di_triplet_to_col(n_row::Int32, n_col::Int32, nz::Int32, Ti::Ptr{Int32}, Tj::Ptr{Int32}, Tx::Ptr{Cdouble}, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Map::Ptr{Int32})::Cint
+    @ccall libumfpack.umfpack_di_triplet_to_col(n_row::Int32, n_col::Int32, nz::Int32,
+                                                Ti::Ptr{Int32}, Tj::Ptr{Int32},
+                                                Tx::Ptr{Cdouble}, Ap::Ptr{Int32},
+                                                Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                                Map::Ptr{Int32})::Cint
 end
 
 function umfpack_dl_triplet_to_col(n_row, n_col, nz, Ti, Tj, Tx, Ap, Ai, Ax, Map)
-    @ccall libumfpack.umfpack_dl_triplet_to_col(n_row::Int64, n_col::Int64, nz::Int64, Ti::Ptr{Int64}, Tj::Ptr{Int64}, Tx::Ptr{Cdouble}, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Map::Ptr{Int64})::Cint
+    @ccall libumfpack.umfpack_dl_triplet_to_col(n_row::Int64, n_col::Int64, nz::Int64,
+                                                Ti::Ptr{Int64}, Tj::Ptr{Int64},
+                                                Tx::Ptr{Cdouble}, Ap::Ptr{Int64},
+                                                Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                                Map::Ptr{Int64})::Cint
 end
 
 function umfpack_zi_triplet_to_col(n_row, n_col, nz, Ti, Tj, Tx, Tz, Ap, Ai, Ax, Az, Map)
-    @ccall libumfpack.umfpack_zi_triplet_to_col(n_row::Int32, n_col::Int32, nz::Int32, Ti::Ptr{Int32}, Tj::Ptr{Int32}, Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble}, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Map::Ptr{Int32})::Cint
+    @ccall libumfpack.umfpack_zi_triplet_to_col(n_row::Int32, n_col::Int32, nz::Int32,
+                                                Ti::Ptr{Int32}, Tj::Ptr{Int32},
+                                                Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble},
+                                                Ap::Ptr{Int32}, Ai::Ptr{Int32},
+                                                Ax::Ptr{Cdouble}, Az::Ptr{Cdouble},
+                                                Map::Ptr{Int32})::Cint
 end
 
 function umfpack_zl_triplet_to_col(n_row, n_col, nz, Ti, Tj, Tx, Tz, Ap, Ai, Ax, Az, Map)
-    @ccall libumfpack.umfpack_zl_triplet_to_col(n_row::Int64, n_col::Int64, nz::Int64, Ti::Ptr{Int64}, Tj::Ptr{Int64}, Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble}, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Map::Ptr{Int64})::Cint
+    @ccall libumfpack.umfpack_zl_triplet_to_col(n_row::Int64, n_col::Int64, nz::Int64,
+                                                Ti::Ptr{Int64}, Tj::Ptr{Int64},
+                                                Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble},
+                                                Ap::Ptr{Int64}, Ai::Ptr{Int64},
+                                                Ax::Ptr{Cdouble}, Az::Ptr{Cdouble},
+                                                Map::Ptr{Int64})::Cint
 end
 
 function umfpack_di_col_to_triplet(n_col, Ap, Tj)
-    @ccall libumfpack.umfpack_di_col_to_triplet(n_col::Int32, Ap::Ptr{Int32}, Tj::Ptr{Int32})::Cint
+    @ccall libumfpack.umfpack_di_col_to_triplet(n_col::Int32, Ap::Ptr{Int32},
+                                                Tj::Ptr{Int32})::Cint
 end
 
 function umfpack_dl_col_to_triplet(n_col, Ap, Tj)
-    @ccall libumfpack.umfpack_dl_col_to_triplet(n_col::Int64, Ap::Ptr{Int64}, Tj::Ptr{Int64})::Cint
+    @ccall libumfpack.umfpack_dl_col_to_triplet(n_col::Int64, Ap::Ptr{Int64},
+                                                Tj::Ptr{Int64})::Cint
 end
 
 function umfpack_zi_col_to_triplet(n_col, Ap, Tj)
-    @ccall libumfpack.umfpack_zi_col_to_triplet(n_col::Int32, Ap::Ptr{Int32}, Tj::Ptr{Int32})::Cint
+    @ccall libumfpack.umfpack_zi_col_to_triplet(n_col::Int32, Ap::Ptr{Int32},
+                                                Tj::Ptr{Int32})::Cint
 end
 
 function umfpack_zl_col_to_triplet(n_col, Ap, Tj)
-    @ccall libumfpack.umfpack_zl_col_to_triplet(n_col::Int64, Ap::Ptr{Int64}, Tj::Ptr{Int64})::Cint
+    @ccall libumfpack.umfpack_zl_col_to_triplet(n_col::Int64, Ap::Ptr{Int64},
+                                                Tj::Ptr{Int64})::Cint
 end
 
 function umfpack_di_transpose(n_row, n_col, Ap, Ai, Ax, P, Q, Rp, Ri, Rx)
-    @ccall libumfpack.umfpack_di_transpose(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, P::Ptr{Int32}, Q::Ptr{Int32}, Rp::Ptr{Int32}, Ri::Ptr{Int32}, Rx::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_transpose(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                           Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, P::Ptr{Int32},
+                                           Q::Ptr{Int32}, Rp::Ptr{Int32}, Ri::Ptr{Int32},
+                                           Rx::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_transpose(n_row, n_col, Ap, Ai, Ax, P, Q, Rp, Ri, Rx)
-    @ccall libumfpack.umfpack_dl_transpose(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, P::Ptr{Int64}, Q::Ptr{Int64}, Rp::Ptr{Int64}, Ri::Ptr{Int64}, Rx::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_transpose(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                           Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, P::Ptr{Int64},
+                                           Q::Ptr{Int64}, Rp::Ptr{Int64}, Ri::Ptr{Int64},
+                                           Rx::Ptr{Cdouble})::Cint
 end
 
-function umfpack_zi_transpose(n_row, n_col, Ap, Ai, Ax, Az, P, Q, Rp, Ri, Rx, Rz, do_conjugate)
-    @ccall libumfpack.umfpack_zi_transpose(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, P::Ptr{Int32}, Q::Ptr{Int32}, Rp::Ptr{Int32}, Ri::Ptr{Int32}, Rx::Ptr{Cdouble}, Rz::Ptr{Cdouble}, do_conjugate::Cint)::Cint
+function umfpack_zi_transpose(n_row, n_col, Ap, Ai, Ax, Az, P, Q, Rp, Ri, Rx, Rz,
+                              do_conjugate)
+    @ccall libumfpack.umfpack_zi_transpose(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                           Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                           Az::Ptr{Cdouble}, P::Ptr{Int32}, Q::Ptr{Int32},
+                                           Rp::Ptr{Int32}, Ri::Ptr{Int32}, Rx::Ptr{Cdouble},
+                                           Rz::Ptr{Cdouble}, do_conjugate::Cint)::Cint
 end
 
-function umfpack_zl_transpose(n_row, n_col, Ap, Ai, Ax, Az, P, Q, Rp, Ri, Rx, Rz, do_conjugate)
-    @ccall libumfpack.umfpack_zl_transpose(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, P::Ptr{Int64}, Q::Ptr{Int64}, Rp::Ptr{Int64}, Ri::Ptr{Int64}, Rx::Ptr{Cdouble}, Rz::Ptr{Cdouble}, do_conjugate::Cint)::Cint
+function umfpack_zl_transpose(n_row, n_col, Ap, Ai, Ax, Az, P, Q, Rp, Ri, Rx, Rz,
+                              do_conjugate)
+    @ccall libumfpack.umfpack_zl_transpose(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                           Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                           Az::Ptr{Cdouble}, P::Ptr{Int64}, Q::Ptr{Int64},
+                                           Rp::Ptr{Int64}, Ri::Ptr{Int64}, Rx::Ptr{Cdouble},
+                                           Rz::Ptr{Cdouble}, do_conjugate::Cint)::Cint
 end
 
 function umfpack_di_scale(X, B, Numeric)
-    @ccall libumfpack.umfpack_di_scale(X::Ptr{Cdouble}, B::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_scale(X::Ptr{Cdouble}, B::Ptr{Cdouble},
+                                       Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_scale(X, B, Numeric)
-    @ccall libumfpack.umfpack_dl_scale(X::Ptr{Cdouble}, B::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_scale(X::Ptr{Cdouble}, B::Ptr{Cdouble},
+                                       Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_scale(Xx, Xz, Bx, Bz, Numeric)
-    @ccall libumfpack.umfpack_zi_scale(Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_scale(Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble},
+                                       Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_scale(Xx, Xz, Bx, Bz, Numeric)
-    @ccall libumfpack.umfpack_zl_scale(Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_scale(Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble},
+                                       Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_get_lunz(lnz, unz, n_row, n_col, nz_udiag, Numeric)
-    @ccall libumfpack.umfpack_di_get_lunz(lnz::Ptr{Int32}, unz::Ptr{Int32}, n_row::Ptr{Int32}, n_col::Ptr{Int32}, nz_udiag::Ptr{Int32}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_get_lunz(lnz::Ptr{Int32}, unz::Ptr{Int32},
+                                          n_row::Ptr{Int32}, n_col::Ptr{Int32},
+                                          nz_udiag::Ptr{Int32}, Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_get_lunz(lnz, unz, n_row, n_col, nz_udiag, Numeric)
-    @ccall libumfpack.umfpack_dl_get_lunz(lnz::Ptr{Int64}, unz::Ptr{Int64}, n_row::Ptr{Int64}, n_col::Ptr{Int64}, nz_udiag::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_get_lunz(lnz::Ptr{Int64}, unz::Ptr{Int64},
+                                          n_row::Ptr{Int64}, n_col::Ptr{Int64},
+                                          nz_udiag::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_get_lunz(lnz, unz, n_row, n_col, nz_udiag, Numeric)
-    @ccall libumfpack.umfpack_zi_get_lunz(lnz::Ptr{Int32}, unz::Ptr{Int32}, n_row::Ptr{Int32}, n_col::Ptr{Int32}, nz_udiag::Ptr{Int32}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_get_lunz(lnz::Ptr{Int32}, unz::Ptr{Int32},
+                                          n_row::Ptr{Int32}, n_col::Ptr{Int32},
+                                          nz_udiag::Ptr{Int32}, Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_get_lunz(lnz, unz, n_row, n_col, nz_udiag, Numeric)
-    @ccall libumfpack.umfpack_zl_get_lunz(lnz::Ptr{Int64}, unz::Ptr{Int64}, n_row::Ptr{Int64}, n_col::Ptr{Int64}, nz_udiag::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_get_lunz(lnz::Ptr{Int64}, unz::Ptr{Int64},
+                                          n_row::Ptr{Int64}, n_col::Ptr{Int64},
+                                          nz_udiag::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_get_numeric(Lp, Lj, Lx, Up, Ui, Ux, P, Q, Dx, do_recip, Rs, Numeric)
-    @ccall libumfpack.umfpack_di_get_numeric(Lp::Ptr{Int32}, Lj::Ptr{Int32}, Lx::Ptr{Cdouble}, Up::Ptr{Int32}, Ui::Ptr{Int32}, Ux::Ptr{Cdouble}, P::Ptr{Int32}, Q::Ptr{Int32}, Dx::Ptr{Cdouble}, do_recip::Ptr{Int32}, Rs::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_get_numeric(Lp::Ptr{Int32}, Lj::Ptr{Int32},
+                                             Lx::Ptr{Cdouble}, Up::Ptr{Int32},
+                                             Ui::Ptr{Int32}, Ux::Ptr{Cdouble},
+                                             P::Ptr{Int32}, Q::Ptr{Int32}, Dx::Ptr{Cdouble},
+                                             do_recip::Ptr{Int32}, Rs::Ptr{Cdouble},
+                                             Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_get_numeric(Lp, Lj, Lx, Up, Ui, Ux, P, Q, Dx, do_recip, Rs, Numeric)
-    @ccall libumfpack.umfpack_dl_get_numeric(Lp::Ptr{Int64}, Lj::Ptr{Int64}, Lx::Ptr{Cdouble}, Up::Ptr{Int64}, Ui::Ptr{Int64}, Ux::Ptr{Cdouble}, P::Ptr{Int64}, Q::Ptr{Int64}, Dx::Ptr{Cdouble}, do_recip::Ptr{Int64}, Rs::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
-end
-
-function umfpack_zi_get_numeric(Lp, Lj, Lx, Lz, Up, Ui, Ux, Uz, P, Q, Dx, Dz, do_recip, Rs, Numeric)
-    @ccall libumfpack.umfpack_zi_get_numeric(Lp::Ptr{Int32}, Lj::Ptr{Int32}, Lx::Ptr{Cdouble}, Lz::Ptr{Cdouble}, Up::Ptr{Int32}, Ui::Ptr{Int32}, Ux::Ptr{Cdouble}, Uz::Ptr{Cdouble}, P::Ptr{Int32}, Q::Ptr{Int32}, Dx::Ptr{Cdouble}, Dz::Ptr{Cdouble}, do_recip::Ptr{Int32}, Rs::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
-end
-
-function umfpack_zl_get_numeric(Lp, Lj, Lx, Lz, Up, Ui, Ux, Uz, P, Q, Dx, Dz, do_recip, Rs, Numeric)
-    @ccall libumfpack.umfpack_zl_get_numeric(Lp::Ptr{Int64}, Lj::Ptr{Int64}, Lx::Ptr{Cdouble}, Lz::Ptr{Cdouble}, Up::Ptr{Int64}, Ui::Ptr{Int64}, Ux::Ptr{Cdouble}, Uz::Ptr{Cdouble}, P::Ptr{Int64}, Q::Ptr{Int64}, Dx::Ptr{Cdouble}, Dz::Ptr{Cdouble}, do_recip::Ptr{Int64}, Rs::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
-end
-
-function umfpack_di_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol, Front_parent, Front_1strow, Front_leftmostdesc, Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
-    @ccall libumfpack.umfpack_di_get_symbolic(n_row::Ptr{Int32}, n_col::Ptr{Int32}, n1::Ptr{Int32}, nz::Ptr{Int32}, nfr::Ptr{Int32}, nchains::Ptr{Int32}, P::Ptr{Int32}, Q::Ptr{Int32}, Front_npivcol::Ptr{Int32}, Front_parent::Ptr{Int32}, Front_1strow::Ptr{Int32}, Front_leftmostdesc::Ptr{Int32}, Chain_start::Ptr{Int32}, Chain_maxrows::Ptr{Int32}, Chain_maxcols::Ptr{Int32}, Dmap::Ptr{Int32}, Symbolic::Ptr{Cvoid})::Cint
-end
-
-function umfpack_dl_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol, Front_parent, Front_1strow, Front_leftmostdesc, Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
-    @ccall libumfpack.umfpack_dl_get_symbolic(n_row::Ptr{Int64}, n_col::Ptr{Int64}, n1::Ptr{Int64}, nz::Ptr{Int64}, nfr::Ptr{Int64}, nchains::Ptr{Int64}, P::Ptr{Int64}, Q::Ptr{Int64}, Front_npivcol::Ptr{Int64}, Front_parent::Ptr{Int64}, Front_1strow::Ptr{Int64}, Front_leftmostdesc::Ptr{Int64}, Chain_start::Ptr{Int64}, Chain_maxrows::Ptr{Int64}, Chain_maxcols::Ptr{Int64}, Dmap::Ptr{Int64}, Symbolic::Ptr{Cvoid})::Cint
-end
-
-function umfpack_zi_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol, Front_parent, Front_1strow, Front_leftmostdesc, Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
-    @ccall libumfpack.umfpack_zi_get_symbolic(n_row::Ptr{Int32}, n_col::Ptr{Int32}, n1::Ptr{Int32}, nz::Ptr{Int32}, nfr::Ptr{Int32}, nchains::Ptr{Int32}, P::Ptr{Int32}, Q::Ptr{Int32}, Front_npivcol::Ptr{Int32}, Front_parent::Ptr{Int32}, Front_1strow::Ptr{Int32}, Front_leftmostdesc::Ptr{Int32}, Chain_start::Ptr{Int32}, Chain_maxrows::Ptr{Int32}, Chain_maxcols::Ptr{Int32}, Dmap::Ptr{Int32}, Symbolic::Ptr{Cvoid})::Cint
-end
-
-function umfpack_zl_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol, Front_parent, Front_1strow, Front_leftmostdesc, Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
-    @ccall libumfpack.umfpack_zl_get_symbolic(n_row::Ptr{Int64}, n_col::Ptr{Int64}, n1::Ptr{Int64}, nz::Ptr{Int64}, nfr::Ptr{Int64}, nchains::Ptr{Int64}, P::Ptr{Int64}, Q::Ptr{Int64}, Front_npivcol::Ptr{Int64}, Front_parent::Ptr{Int64}, Front_1strow::Ptr{Int64}, Front_leftmostdesc::Ptr{Int64}, Chain_start::Ptr{Int64}, Chain_maxrows::Ptr{Int64}, Chain_maxcols::Ptr{Int64}, Dmap::Ptr{Int64}, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_get_numeric(Lp::Ptr{Int64}, Lj::Ptr{Int64},
+                                             Lx::Ptr{Cdouble}, Up::Ptr{Int64},
+                                             Ui::Ptr{Int64}, Ux::Ptr{Cdouble},
+                                             P::Ptr{Int64}, Q::Ptr{Int64}, Dx::Ptr{Cdouble},
+                                             do_recip::Ptr{Int64}, Rs::Ptr{Cdouble},
+                                             Numeric::Ptr{Cvoid})::Cint
+end
+
+function umfpack_zi_get_numeric(Lp, Lj, Lx, Lz, Up, Ui, Ux, Uz, P, Q, Dx, Dz, do_recip, Rs,
+                                Numeric)
+    @ccall libumfpack.umfpack_zi_get_numeric(Lp::Ptr{Int32}, Lj::Ptr{Int32},
+                                             Lx::Ptr{Cdouble}, Lz::Ptr{Cdouble},
+                                             Up::Ptr{Int32}, Ui::Ptr{Int32},
+                                             Ux::Ptr{Cdouble}, Uz::Ptr{Cdouble},
+                                             P::Ptr{Int32}, Q::Ptr{Int32}, Dx::Ptr{Cdouble},
+                                             Dz::Ptr{Cdouble}, do_recip::Ptr{Int32},
+                                             Rs::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+end
+
+function umfpack_zl_get_numeric(Lp, Lj, Lx, Lz, Up, Ui, Ux, Uz, P, Q, Dx, Dz, do_recip, Rs,
+                                Numeric)
+    @ccall libumfpack.umfpack_zl_get_numeric(Lp::Ptr{Int64}, Lj::Ptr{Int64},
+                                             Lx::Ptr{Cdouble}, Lz::Ptr{Cdouble},
+                                             Up::Ptr{Int64}, Ui::Ptr{Int64},
+                                             Ux::Ptr{Cdouble}, Uz::Ptr{Cdouble},
+                                             P::Ptr{Int64}, Q::Ptr{Int64}, Dx::Ptr{Cdouble},
+                                             Dz::Ptr{Cdouble}, do_recip::Ptr{Int64},
+                                             Rs::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+end
+
+function umfpack_di_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol,
+                                 Front_parent, Front_1strow, Front_leftmostdesc,
+                                 Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
+    @ccall libumfpack.umfpack_di_get_symbolic(n_row::Ptr{Int32}, n_col::Ptr{Int32},
+                                              n1::Ptr{Int32}, nz::Ptr{Int32},
+                                              nfr::Ptr{Int32}, nchains::Ptr{Int32},
+                                              P::Ptr{Int32}, Q::Ptr{Int32},
+                                              Front_npivcol::Ptr{Int32},
+                                              Front_parent::Ptr{Int32},
+                                              Front_1strow::Ptr{Int32},
+                                              Front_leftmostdesc::Ptr{Int32},
+                                              Chain_start::Ptr{Int32},
+                                              Chain_maxrows::Ptr{Int32},
+                                              Chain_maxcols::Ptr{Int32}, Dmap::Ptr{Int32},
+                                              Symbolic::Ptr{Cvoid})::Cint
+end
+
+function umfpack_dl_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol,
+                                 Front_parent, Front_1strow, Front_leftmostdesc,
+                                 Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
+    @ccall libumfpack.umfpack_dl_get_symbolic(n_row::Ptr{Int64}, n_col::Ptr{Int64},
+                                              n1::Ptr{Int64}, nz::Ptr{Int64},
+                                              nfr::Ptr{Int64}, nchains::Ptr{Int64},
+                                              P::Ptr{Int64}, Q::Ptr{Int64},
+                                              Front_npivcol::Ptr{Int64},
+                                              Front_parent::Ptr{Int64},
+                                              Front_1strow::Ptr{Int64},
+                                              Front_leftmostdesc::Ptr{Int64},
+                                              Chain_start::Ptr{Int64},
+                                              Chain_maxrows::Ptr{Int64},
+                                              Chain_maxcols::Ptr{Int64}, Dmap::Ptr{Int64},
+                                              Symbolic::Ptr{Cvoid})::Cint
+end
+
+function umfpack_zi_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol,
+                                 Front_parent, Front_1strow, Front_leftmostdesc,
+                                 Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
+    @ccall libumfpack.umfpack_zi_get_symbolic(n_row::Ptr{Int32}, n_col::Ptr{Int32},
+                                              n1::Ptr{Int32}, nz::Ptr{Int32},
+                                              nfr::Ptr{Int32}, nchains::Ptr{Int32},
+                                              P::Ptr{Int32}, Q::Ptr{Int32},
+                                              Front_npivcol::Ptr{Int32},
+                                              Front_parent::Ptr{Int32},
+                                              Front_1strow::Ptr{Int32},
+                                              Front_leftmostdesc::Ptr{Int32},
+                                              Chain_start::Ptr{Int32},
+                                              Chain_maxrows::Ptr{Int32},
+                                              Chain_maxcols::Ptr{Int32}, Dmap::Ptr{Int32},
+                                              Symbolic::Ptr{Cvoid})::Cint
+end
+
+function umfpack_zl_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol,
+                                 Front_parent, Front_1strow, Front_leftmostdesc,
+                                 Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
+    @ccall libumfpack.umfpack_zl_get_symbolic(n_row::Ptr{Int64}, n_col::Ptr{Int64},
+                                              n1::Ptr{Int64}, nz::Ptr{Int64},
+                                              nfr::Ptr{Int64}, nchains::Ptr{Int64},
+                                              P::Ptr{Int64}, Q::Ptr{Int64},
+                                              Front_npivcol::Ptr{Int64},
+                                              Front_parent::Ptr{Int64},
+                                              Front_1strow::Ptr{Int64},
+                                              Front_leftmostdesc::Ptr{Int64},
+                                              Chain_start::Ptr{Int64},
+                                              Chain_maxrows::Ptr{Int64},
+                                              Chain_maxcols::Ptr{Int64}, Dmap::Ptr{Int64},
+                                              Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_save_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_di_save_numeric(Numeric::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_di_save_numeric(Numeric::Ptr{Cvoid},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_dl_save_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_dl_save_numeric(Numeric::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_dl_save_numeric(Numeric::Ptr{Cvoid},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zi_save_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_zi_save_numeric(Numeric::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zi_save_numeric(Numeric::Ptr{Cvoid},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zl_save_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_zl_save_numeric(Numeric::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zl_save_numeric(Numeric::Ptr{Cvoid},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_di_load_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_di_load_numeric(Numeric::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_di_load_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_dl_load_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_dl_load_numeric(Numeric::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_dl_load_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zi_load_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_zi_load_numeric(Numeric::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zi_load_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zl_load_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_zl_load_numeric(Numeric::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zl_load_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_di_copy_numeric(Numeric, Original)
-    @ccall libumfpack.umfpack_di_copy_numeric(Numeric::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_copy_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_copy_numeric(Numeric, Original)
-    @ccall libumfpack.umfpack_dl_copy_numeric(Numeric::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_copy_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_copy_numeric(Numeric, Original)
-    @ccall libumfpack.umfpack_zi_copy_numeric(Numeric::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_copy_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_copy_numeric(Numeric, Original)
-    @ccall libumfpack.umfpack_zl_copy_numeric(Numeric::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_copy_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_serialize_numeric_size(blobsize, Numeric)
-    @ccall libumfpack.umfpack_di_serialize_numeric_size(blobsize::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_serialize_numeric_size(blobsize::Ptr{Int64},
+                                                        Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_serialize_numeric_size(blobsize, Numeric)
-    @ccall libumfpack.umfpack_dl_serialize_numeric_size(blobsize::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_serialize_numeric_size(blobsize::Ptr{Int64},
+                                                        Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_serialize_numeric_size(blobsize, Numeric)
-    @ccall libumfpack.umfpack_zi_serialize_numeric_size(blobsize::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_serialize_numeric_size(blobsize::Ptr{Int64},
+                                                        Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_serialize_numeric_size(blobsize, Numeric)
-    @ccall libumfpack.umfpack_zl_serialize_numeric_size(blobsize::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_serialize_numeric_size(blobsize::Ptr{Int64},
+                                                        Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_serialize_numeric(blob, blobsize, Numeric)
-    @ccall libumfpack.umfpack_di_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64,
+                                                   Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_serialize_numeric(blob, blobsize, Numeric)
-    @ccall libumfpack.umfpack_dl_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64,
+                                                   Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_serialize_numeric(blob, blobsize, Numeric)
-    @ccall libumfpack.umfpack_zi_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64,
+                                                   Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_serialize_numeric(blob, blobsize, Numeric)
-    @ccall libumfpack.umfpack_zl_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64,
+                                                   Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_deserialize_numeric(Numeric, blob, blobsize)
-    @ccall libumfpack.umfpack_di_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_di_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                                     blob::Ptr{Int8}, blobsize::Int64)::Cint
 end
 
 function umfpack_dl_deserialize_numeric(Numeric, blob, blobsize)
-    @ccall libumfpack.umfpack_dl_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_dl_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                                     blob::Ptr{Int8}, blobsize::Int64)::Cint
 end
 
 function umfpack_zi_deserialize_numeric(Numeric, blob, blobsize)
-    @ccall libumfpack.umfpack_zi_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_zi_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                                     blob::Ptr{Int8}, blobsize::Int64)::Cint
 end
 
 function umfpack_zl_deserialize_numeric(Numeric, blob, blobsize)
-    @ccall libumfpack.umfpack_zl_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_zl_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                                     blob::Ptr{Int8}, blobsize::Int64)::Cint
 end
 
 function umfpack_di_save_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_di_save_symbolic(Symbolic::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_di_save_symbolic(Symbolic::Ptr{Cvoid},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_dl_save_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_dl_save_symbolic(Symbolic::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_dl_save_symbolic(Symbolic::Ptr{Cvoid},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zi_save_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_zi_save_symbolic(Symbolic::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zi_save_symbolic(Symbolic::Ptr{Cvoid},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zl_save_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_zl_save_symbolic(Symbolic::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zl_save_symbolic(Symbolic::Ptr{Cvoid},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_di_load_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_di_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_di_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_dl_load_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_dl_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_dl_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zi_load_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_zi_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zi_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zl_load_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_zl_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zl_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_di_copy_symbolic(Symbolic, Original)
-    @ccall libumfpack.umfpack_di_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_copy_symbolic(Symbolic, Original)
-    @ccall libumfpack.umfpack_dl_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_copy_symbolic(Symbolic, Original)
-    @ccall libumfpack.umfpack_zi_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_copy_symbolic(Symbolic, Original)
-    @ccall libumfpack.umfpack_zl_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_serialize_symbolic_size(blobsize, Symbolic)
-    @ccall libumfpack.umfpack_di_serialize_symbolic_size(blobsize::Ptr{Int64}, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_serialize_symbolic_size(blobsize::Ptr{Int64},
+                                                         Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_serialize_symbolic_size(blobsize, Symbolic)
-    @ccall libumfpack.umfpack_dl_serialize_symbolic_size(blobsize::Ptr{Int64}, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_serialize_symbolic_size(blobsize::Ptr{Int64},
+                                                         Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_serialize_symbolic_size(blobsize, Symbolic)
-    @ccall libumfpack.umfpack_zi_serialize_symbolic_size(blobsize::Ptr{Int64}, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_serialize_symbolic_size(blobsize::Ptr{Int64},
+                                                         Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_serialize_symbolic_size(blobsize, Symbolic)
-    @ccall libumfpack.umfpack_zl_serialize_symbolic_size(blobsize::Ptr{Int64}, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_serialize_symbolic_size(blobsize::Ptr{Int64},
+                                                         Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_serialize_symbolic(blob, blobsize, Symbolic)
-    @ccall libumfpack.umfpack_di_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64,
+                                                    Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_serialize_symbolic(blob, blobsize, Symbolic)
-    @ccall libumfpack.umfpack_dl_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64,
+                                                    Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_serialize_symbolic(blob, blobsize, Symbolic)
-    @ccall libumfpack.umfpack_zi_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64,
+                                                    Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_serialize_symbolic(blob, blobsize, Symbolic)
-    @ccall libumfpack.umfpack_zl_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64,
+                                                    Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_deserialize_symbolic(Symbolic, blob, blobsize)
-    @ccall libumfpack.umfpack_di_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_di_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                                      blob::Ptr{Int8},
+                                                      blobsize::Int64)::Cint
 end
 
 function umfpack_dl_deserialize_symbolic(Symbolic, blob, blobsize)
-    @ccall libumfpack.umfpack_dl_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_dl_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                                      blob::Ptr{Int8},
+                                                      blobsize::Int64)::Cint
 end
 
 function umfpack_zi_deserialize_symbolic(Symbolic, blob, blobsize)
-    @ccall libumfpack.umfpack_zi_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_zi_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                                      blob::Ptr{Int8},
+                                                      blobsize::Int64)::Cint
 end
 
 function umfpack_zl_deserialize_symbolic(Symbolic, blob, blobsize)
-    @ccall libumfpack.umfpack_zl_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_zl_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                                      blob::Ptr{Int8},
+                                                      blobsize::Int64)::Cint
 end
 
 function umfpack_di_get_determinant(Mx, Ex, Numeric, User_Info)
-    @ccall libumfpack.umfpack_di_get_determinant(Mx::Ptr{Cdouble}, Ex::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, User_Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_get_determinant(Mx::Ptr{Cdouble}, Ex::Ptr{Cdouble},
+                                                 Numeric::Ptr{Cvoid},
+                                                 User_Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_get_determinant(Mx, Ex, Numeric, User_Info)
-    @ccall libumfpack.umfpack_dl_get_determinant(Mx::Ptr{Cdouble}, Ex::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, User_Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_get_determinant(Mx::Ptr{Cdouble}, Ex::Ptr{Cdouble},
+                                                 Numeric::Ptr{Cvoid},
+                                                 User_Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_get_determinant(Mx, Mz, Ex, Numeric, User_Info)
-    @ccall libumfpack.umfpack_zi_get_determinant(Mx::Ptr{Cdouble}, Mz::Ptr{Cdouble}, Ex::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, User_Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_get_determinant(Mx::Ptr{Cdouble}, Mz::Ptr{Cdouble},
+                                                 Ex::Ptr{Cdouble}, Numeric::Ptr{Cvoid},
+                                                 User_Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_get_determinant(Mx, Mz, Ex, Numeric, User_Info)
-    @ccall libumfpack.umfpack_zl_get_determinant(Mx::Ptr{Cdouble}, Mz::Ptr{Cdouble}, Ex::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, User_Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_get_determinant(Mx::Ptr{Cdouble}, Mz::Ptr{Cdouble},
+                                                 Ex::Ptr{Cdouble}, Numeric::Ptr{Cvoid},
+                                                 User_Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_report_status(Control, status)
@@ -2256,19 +3038,23 @@ function umfpack_zl_report_status(Control, status)
 end
 
 function umfpack_di_report_info(Control, Info)
-    @ccall libumfpack.umfpack_di_report_info(Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cvoid
+    @ccall libumfpack.umfpack_di_report_info(Control::Ptr{Cdouble},
+                                             Info::Ptr{Cdouble})::Cvoid
 end
 
 function umfpack_dl_report_info(Control, Info)
-    @ccall libumfpack.umfpack_dl_report_info(Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cvoid
+    @ccall libumfpack.umfpack_dl_report_info(Control::Ptr{Cdouble},
+                                             Info::Ptr{Cdouble})::Cvoid
 end
 
 function umfpack_zi_report_info(Control, Info)
-    @ccall libumfpack.umfpack_zi_report_info(Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cvoid
+    @ccall libumfpack.umfpack_zi_report_info(Control::Ptr{Cdouble},
+                                             Info::Ptr{Cdouble})::Cvoid
 end
 
 function umfpack_zl_report_info(Control, Info)
-    @ccall libumfpack.umfpack_zl_report_info(Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cvoid
+    @ccall libumfpack.umfpack_zl_report_info(Control::Ptr{Cdouble},
+                                             Info::Ptr{Cdouble})::Cvoid
 end
 
 function umfpack_di_report_control(Control)
@@ -2288,99 +3074,137 @@ function umfpack_zl_report_control(Control)
 end
 
 function umfpack_di_report_matrix(n_row, n_col, Ap, Ai, Ax, col_form, Control)
-    @ccall libumfpack.umfpack_di_report_matrix(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, col_form::Cint, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_report_matrix(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                               Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                               col_form::Cint, Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_report_matrix(n_row, n_col, Ap, Ai, Ax, col_form, Control)
-    @ccall libumfpack.umfpack_dl_report_matrix(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, col_form::Cint, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_report_matrix(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                               Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                               col_form::Cint, Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_report_matrix(n_row, n_col, Ap, Ai, Ax, Az, col_form, Control)
-    @ccall libumfpack.umfpack_zi_report_matrix(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, col_form::Cint, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_report_matrix(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                               Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                               Az::Ptr{Cdouble}, col_form::Cint,
+                                               Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_report_matrix(n_row, n_col, Ap, Ai, Ax, Az, col_form, Control)
-    @ccall libumfpack.umfpack_zl_report_matrix(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, col_form::Cint, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_report_matrix(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                               Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                               Az::Ptr{Cdouble}, col_form::Cint,
+                                               Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_report_triplet(n_row, n_col, nz, Ti, Tj, Tx, Control)
-    @ccall libumfpack.umfpack_di_report_triplet(n_row::Int32, n_col::Int32, nz::Int32, Ti::Ptr{Int32}, Tj::Ptr{Int32}, Tx::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_report_triplet(n_row::Int32, n_col::Int32, nz::Int32,
+                                                Ti::Ptr{Int32}, Tj::Ptr{Int32},
+                                                Tx::Ptr{Cdouble},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_report_triplet(n_row, n_col, nz, Ti, Tj, Tx, Control)
-    @ccall libumfpack.umfpack_dl_report_triplet(n_row::Int64, n_col::Int64, nz::Int64, Ti::Ptr{Int64}, Tj::Ptr{Int64}, Tx::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_report_triplet(n_row::Int64, n_col::Int64, nz::Int64,
+                                                Ti::Ptr{Int64}, Tj::Ptr{Int64},
+                                                Tx::Ptr{Cdouble},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_report_triplet(n_row, n_col, nz, Ti, Tj, Tx, Tz, Control)
-    @ccall libumfpack.umfpack_zi_report_triplet(n_row::Int32, n_col::Int32, nz::Int32, Ti::Ptr{Int32}, Tj::Ptr{Int32}, Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_report_triplet(n_row::Int32, n_col::Int32, nz::Int32,
+                                                Ti::Ptr{Int32}, Tj::Ptr{Int32},
+                                                Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_report_triplet(n_row, n_col, nz, Ti, Tj, Tx, Tz, Control)
-    @ccall libumfpack.umfpack_zl_report_triplet(n_row::Int64, n_col::Int64, nz::Int64, Ti::Ptr{Int64}, Tj::Ptr{Int64}, Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_report_triplet(n_row::Int64, n_col::Int64, nz::Int64,
+                                                Ti::Ptr{Int64}, Tj::Ptr{Int64},
+                                                Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_report_vector(n, X, Control)
-    @ccall libumfpack.umfpack_di_report_vector(n::Int32, X::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_report_vector(n::Int32, X::Ptr{Cdouble},
+                                               Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_report_vector(n, X, Control)
-    @ccall libumfpack.umfpack_dl_report_vector(n::Int64, X::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_report_vector(n::Int64, X::Ptr{Cdouble},
+                                               Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_report_vector(n, Xx, Xz, Control)
-    @ccall libumfpack.umfpack_zi_report_vector(n::Int32, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_report_vector(n::Int32, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble},
+                                               Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_report_vector(n, Xx, Xz, Control)
-    @ccall libumfpack.umfpack_zl_report_vector(n::Int64, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_report_vector(n::Int64, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble},
+                                               Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_report_symbolic(Symbolic, Control)
-    @ccall libumfpack.umfpack_di_report_symbolic(Symbolic::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_report_symbolic(Symbolic::Ptr{Cvoid},
+                                                 Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_report_symbolic(Symbolic, Control)
-    @ccall libumfpack.umfpack_dl_report_symbolic(Symbolic::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_report_symbolic(Symbolic::Ptr{Cvoid},
+                                                 Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_report_symbolic(Symbolic, Control)
-    @ccall libumfpack.umfpack_zi_report_symbolic(Symbolic::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_report_symbolic(Symbolic::Ptr{Cvoid},
+                                                 Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_report_symbolic(Symbolic, Control)
-    @ccall libumfpack.umfpack_zl_report_symbolic(Symbolic::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_report_symbolic(Symbolic::Ptr{Cvoid},
+                                                 Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_report_numeric(Numeric, Control)
-    @ccall libumfpack.umfpack_di_report_numeric(Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_report_numeric(Numeric::Ptr{Cvoid},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_report_numeric(Numeric, Control)
-    @ccall libumfpack.umfpack_dl_report_numeric(Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_report_numeric(Numeric::Ptr{Cvoid},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_report_numeric(Numeric, Control)
-    @ccall libumfpack.umfpack_zi_report_numeric(Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_report_numeric(Numeric::Ptr{Cvoid},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_report_numeric(Numeric, Control)
-    @ccall libumfpack.umfpack_zl_report_numeric(Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_report_numeric(Numeric::Ptr{Cvoid},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_report_perm(np, Perm, Control)
-    @ccall libumfpack.umfpack_di_report_perm(np::Int32, Perm::Ptr{Int32}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_report_perm(np::Int32, Perm::Ptr{Int32},
+                                             Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_report_perm(np, Perm, Control)
-    @ccall libumfpack.umfpack_dl_report_perm(np::Int64, Perm::Ptr{Int64}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_report_perm(np::Int64, Perm::Ptr{Int64},
+                                             Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_report_perm(np, Perm, Control)
-    @ccall libumfpack.umfpack_zi_report_perm(np::Int32, Perm::Ptr{Int32}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_report_perm(np::Int32, Perm::Ptr{Int32},
+                                             Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_report_perm(np, Perm, Control)
-    @ccall libumfpack.umfpack_zl_report_perm(np::Int64, Perm::Ptr{Int64}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_report_perm(np::Int64, Perm::Ptr{Int64},
+                                             Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_timer()
@@ -2395,13 +3219,13 @@ function umfpack_toc(stats)
     @ccall libumfpack.umfpack_toc(stats::Ptr{Cdouble})::Cvoid
 end
 
-const CHOLMOD_DATE = "Jan 17, 2023"
+const CHOLMOD_DATE = "June 16, 2023"
 
 const CHOLMOD_MAIN_VERSION = 4
 
 const CHOLMOD_SUB_VERSION = 0
 
-const CHOLMOD_SUBSUB_VERSION = 3
+const CHOLMOD_SUBSUB_VERSION = 4
 
 const _FILE_OFFSET_BITS = 64
 
@@ -2427,17 +3251,18 @@ const SUITESPARSE_COMPILER_MSC = 0
 
 const SUITESPARSE_COMPILER_XLC = 0
 
-const SUITESPARSE_DATE = "Jan 20, 2023"
+const SUITESPARSE_DATE = "June 29, 2023"
 
 const SUITESPARSE_MAIN_VERSION = 7
 
-const SUITESPARSE_SUB_VERSION = 0
+const SUITESPARSE_SUB_VERSION = 1
 
-const SUITESPARSE_SUBSUB_VERSION = 1
+const SUITESPARSE_SUBSUB_VERSION = 0
 
 SUITESPARSE_VER_CODE(main, sub) = main * 1000 + sub
 
-const SUITESPARSE_VERSION = SUITESPARSE_VER_CODE(SUITESPARSE_MAIN_VERSION, SUITESPARSE_SUB_VERSION)
+const SUITESPARSE_VERSION = SUITESPARSE_VER_CODE(SUITESPARSE_MAIN_VERSION,
+                                                 SUITESPARSE_SUB_VERSION)
 
 CHOLMOD_VER_CODE(main, sub) = main * 1000 + sub
 
@@ -2601,20 +3426,18 @@ const SPQR_RTX_EQUALS_B = 2
 
 const SPQR_RTX_EQUALS_ETB = 3
 
-const SPQR_DATE = "Jan 17, 2023"
+const SPQR_DATE = "July FIXME, 2023"
 
-const SPQR_MAIN_VERSION = 3
+const SPQR_MAIN_VERSION = 4
 
 const SPQR_SUB_VERSION = 0
 
-const SPQR_SUBSUB_VERSION = 3
+const SPQR_SUBSUB_VERSION = 0
 
 SPQR_VER_CODE(main, sub) = main * 1000 + sub
 
 const SPQR_VERSION = SPQR_VER_CODE(SPQR_MAIN_VERSION, SPQR_SUB_VERSION)
 
-const Complex = Float64
-
 const AMD_CONTROL = 5
 
 const AMD_INFO = 20
@@ -2663,172 +3486,29 @@ const AMD_INVALID = -2
 
 const AMD_OK_BUT_JUMBLED = 1
 
-const AMD_DATE = "Jan 17, 2023"
+const AMD_DATE = "June 16, 2023"
 
 const AMD_MAIN_VERSION = 3
 
 const AMD_SUB_VERSION = 0
 
-const AMD_SUBSUB_VERSION = 3
+const AMD_SUBSUB_VERSION = 4
 
 AMD_VERSION_CODE(main, sub) = main * 1000 + sub
 
 const AMD_VERSION = AMD_VERSION_CODE(AMD_MAIN_VERSION, AMD_SUB_VERSION)
 
-const COLAMD_DATE = "Jan 17, 2023"
-
-const COLAMD_MAIN_VERSION = 3
-
-const COLAMD_SUB_VERSION = 0
-
-const COLAMD_SUBSUB_VERSION = 3
-
-COLAMD_VERSION_CODE(main, sub) = main * 1000 + sub
-
-const COLAMD_VERSION = COLAMD_VERSION_CODE(COLAMD_MAIN_VERSION, COLAMD_SUB_VERSION)
-
-const COLAMD_KNOBS = 20
-
-const COLAMD_STATS = 20
-
-const COLAMD_DENSE_ROW = 0
-
-const COLAMD_DENSE_COL = 1
-
-const COLAMD_AGGRESSIVE = 2
-
-const COLAMD_DEFRAG_COUNT = 2
-
-const COLAMD_STATUS = 3
-
-const COLAMD_INFO1 = 4
-
-const COLAMD_INFO2 = 5
-
-const COLAMD_INFO3 = 6
-
-const COLAMD_OK = 0
-
-const COLAMD_OK_BUT_JUMBLED = 1
-
-const COLAMD_ERROR_A_not_present = -1
-
-const COLAMD_ERROR_p_not_present = -2
-
-const COLAMD_ERROR_nrow_negative = -3
-
-const COLAMD_ERROR_ncol_negative = -4
-
-const COLAMD_ERROR_nnz_negative = -5
-
-const COLAMD_ERROR_p0_nonzero = -6
-
-const COLAMD_ERROR_A_too_small = -7
-
-const COLAMD_ERROR_col_length_negative = -8
-
-const COLAMD_ERROR_row_index_out_of_bounds = -9
-
-const COLAMD_ERROR_out_of_memory = -10
-
-const COLAMD_ERROR_internal_error = -999
-
-const CCOLAMD_DATE = "Jan 17, 2023"
-
-const CCOLAMD_MAIN_VERSION = 3
-
-const CCOLAMD_SUB_VERSION = 0
-
-const CCOLAMD_SUBSUB_VERSION = 3
-
-CCOLAMD_VERSION_CODE(main, sub) = main * 1000 + sub
-
-const CCOLAMD_VERSION = CCOLAMD_VERSION_CODE(CCOLAMD_MAIN_VERSION, CCOLAMD_SUB_VERSION)
-
-const CCOLAMD_KNOBS = 20
-
-const CCOLAMD_STATS = 20
-
-const CCOLAMD_DENSE_ROW = 0
-
-const CCOLAMD_DENSE_COL = 1
-
-const CCOLAMD_AGGRESSIVE = 2
-
-const CCOLAMD_LU = 3
-
-const CCOLAMD_DEFRAG_COUNT = 2
-
-const CCOLAMD_STATUS = 3
-
-const CCOLAMD_INFO1 = 4
-
-const CCOLAMD_INFO2 = 5
-
-const CCOLAMD_INFO3 = 6
-
-const CCOLAMD_EMPTY_ROW = 7
-
-const CCOLAMD_EMPTY_COL = 8
-
-const CCOLAMD_NEWLY_EMPTY_ROW = 9
-
-const CCOLAMD_NEWLY_EMPTY_COL = 10
-
-const CCOLAMD_OK = 0
-
-const CCOLAMD_OK_BUT_JUMBLED = 1
-
-const CCOLAMD_ERROR_A_not_present = -1
-
-const CCOLAMD_ERROR_p_not_present = -2
-
-const CCOLAMD_ERROR_nrow_negative = -3
-
-const CCOLAMD_ERROR_ncol_negative = -4
-
-const CCOLAMD_ERROR_nnz_negative = -5
-
-const CCOLAMD_ERROR_p0_nonzero = -6
-
-const CCOLAMD_ERROR_A_too_small = -7
-
-const CCOLAMD_ERROR_col_length_negative = -8
-
-const CCOLAMD_ERROR_row_index_out_of_bounds = -9
-
-const CCOLAMD_ERROR_out_of_memory = -10
-
-const CCOLAMD_ERROR_invalid_cmember = -11
-
-const CCOLAMD_ERROR_internal_error = -999
-
 const UMFPACK_INFO = 90
 
 const UMFPACK_CONTROL = 20
 
-# Skipping MacroDefinition: UMFPACK_COPYRIGHT \
-#"UMFPACK:  Copyright (c) 2005-2023 by Timothy A. Davis.  All Rights Reserved.\n"
-
-# Skipping MacroDefinition: UMFPACK_LICENSE_PART1 \
-#"\nUMFPACK License: SPDX-License-Identifier: GPL-2.0+\n" \
-#"   UMFPACK is available under alternate licenses,\n" \
-#"   contact T. Davis for details.\n"
-
-const UMFPACK_LICENSE_PART2 = "\n"
-
-# Skipping MacroDefinition: UMFPACK_LICENSE_PART3 \
-#"\n" \
-#"Availability: http://www.suitesparse.com" \
-#"\n"
-
-const UMFPACK_DATE = "Jan 17, 2023"
+const UMFPACK_DATE = "June 16, 2023"
 
 const UMFPACK_MAIN_VERSION = 6
 
 const UMFPACK_SUB_VERSION = 1
 
-const UMFPACK_SUBSUB_VERSION = 0
+const UMFPACK_SUBSUB_VERSION = 1
 
 UMFPACK_VER_CODE(main, sub) = main * 1000 + sub
 
@@ -3169,4 +3849,3 @@ const UMFPACK_Q_Uat = 12
 const UMFPACK_Ut = 13
 
 const UMFPACK_Uat = 14
-
diff --git a/src/solvers/lib/aarch64-linux-gnu.jl b/src/solvers/lib/aarch64-linux-gnu.jl
index fcf756d2..a5aa4e44 100644
--- a/src/solvers/lib/aarch64-linux-gnu.jl
+++ b/src/solvers/lib/aarch64-linux-gnu.jl
@@ -1,137 +1,150 @@
 function SuiteSparse_config_printf_func_get()
-    @ccall libcholmod.SuiteSparse_config_printf_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_printf_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_malloc_func_get()
-    @ccall libcholmod.SuiteSparse_config_malloc_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_malloc_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_calloc_func_get()
-    @ccall libcholmod.SuiteSparse_config_calloc_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_calloc_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_realloc_func_get()
-    @ccall libcholmod.SuiteSparse_config_realloc_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_realloc_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_free_func_get()
-    @ccall libcholmod.SuiteSparse_config_free_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_free_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_hypot_func_get()
-    @ccall libcholmod.SuiteSparse_config_hypot_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_hypot_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_divcomplex_func_get()
-    @ccall libcholmod.SuiteSparse_config_divcomplex_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_divcomplex_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_malloc_func_set(malloc_func)
-    @ccall libcholmod.SuiteSparse_config_malloc_func_set(malloc_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_malloc_func_set(malloc_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_calloc_func_set(calloc_func)
-    @ccall libcholmod.SuiteSparse_config_calloc_func_set(calloc_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_calloc_func_set(calloc_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_realloc_func_set(realloc_func)
-    @ccall libcholmod.SuiteSparse_config_realloc_func_set(realloc_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_realloc_func_set(realloc_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_free_func_set(free_func)
-    @ccall libcholmod.SuiteSparse_config_free_func_set(free_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_free_func_set(free_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_printf_func_set(printf_func)
-    @ccall libcholmod.SuiteSparse_config_printf_func_set(printf_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_printf_func_set(printf_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_hypot_func_set(hypot_func)
-    @ccall libcholmod.SuiteSparse_config_hypot_func_set(hypot_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_hypot_func_set(hypot_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_divcomplex_func_set(divcomplex_func)
-    @ccall libcholmod.SuiteSparse_config_divcomplex_func_set(divcomplex_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_divcomplex_func_set(divcomplex_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_malloc(s)
-    @ccall libcholmod.SuiteSparse_config_malloc(s::Csize_t)::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_malloc(s::Csize_t)::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_calloc(n, s)
-    @ccall libcholmod.SuiteSparse_config_calloc(n::Csize_t, s::Csize_t)::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_calloc(n::Csize_t,
+                                                          s::Csize_t)::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_realloc(arg1, s)
-    @ccall libcholmod.SuiteSparse_config_realloc(arg1::Ptr{Cvoid}, s::Csize_t)::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_realloc(arg1::Ptr{Cvoid},
+                                                           s::Csize_t)::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_free(arg1)
-    @ccall libcholmod.SuiteSparse_config_free(arg1::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_free(arg1::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_hypot(x, y)
-    @ccall libcholmod.SuiteSparse_config_hypot(x::Cdouble, y::Cdouble)::Cdouble
+    @ccall libsuitesparseconfig.SuiteSparse_config_hypot(x::Cdouble, y::Cdouble)::Cdouble
 end
 
 function SuiteSparse_config_divcomplex(xr, xi, yr, yi, zr, zi)
-    @ccall libcholmod.SuiteSparse_config_divcomplex(xr::Cdouble, xi::Cdouble, yr::Cdouble, yi::Cdouble, zr::Ptr{Cdouble}, zi::Ptr{Cdouble})::Cint
+    @ccall libsuitesparseconfig.SuiteSparse_config_divcomplex(xr::Cdouble, xi::Cdouble,
+                                                              yr::Cdouble, yi::Cdouble,
+                                                              zr::Ptr{Cdouble},
+                                                              zi::Ptr{Cdouble})::Cint
 end
 
 function SuiteSparse_start()
-    @ccall libcholmod.SuiteSparse_start()::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_start()::Cvoid
 end
 
 function SuiteSparse_finish()
-    @ccall libcholmod.SuiteSparse_finish()::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_finish()::Cvoid
 end
 
 function SuiteSparse_malloc(nitems, size_of_item)
-    @ccall libcholmod.SuiteSparse_malloc(nitems::Csize_t, size_of_item::Csize_t)::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_malloc(nitems::Csize_t,
+                                                   size_of_item::Csize_t)::Ptr{Cvoid}
 end
 
 function SuiteSparse_calloc(nitems, size_of_item)
-    @ccall libcholmod.SuiteSparse_calloc(nitems::Csize_t, size_of_item::Csize_t)::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_calloc(nitems::Csize_t,
+                                                   size_of_item::Csize_t)::Ptr{Cvoid}
 end
 
 function SuiteSparse_realloc(nitems_new, nitems_old, size_of_item, p, ok)
-    @ccall libcholmod.SuiteSparse_realloc(nitems_new::Csize_t, nitems_old::Csize_t, size_of_item::Csize_t, p::Ptr{Cvoid}, ok::Ptr{Cint})::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_realloc(nitems_new::Csize_t,
+                                                    nitems_old::Csize_t,
+                                                    size_of_item::Csize_t, p::Ptr{Cvoid},
+                                                    ok::Ptr{Cint})::Ptr{Cvoid}
 end
 
 function SuiteSparse_free(p)
-    @ccall libcholmod.SuiteSparse_free(p::Ptr{Cvoid})::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_free(p::Ptr{Cvoid})::Ptr{Cvoid}
 end
 
 function SuiteSparse_tic(tic)
-    @ccall libcholmod.SuiteSparse_tic(tic::Ptr{Cdouble})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_tic(tic::Ptr{Cdouble})::Cvoid
 end
 
 function SuiteSparse_toc(tic)
-    @ccall libcholmod.SuiteSparse_toc(tic::Ptr{Cdouble})::Cdouble
+    @ccall libsuitesparseconfig.SuiteSparse_toc(tic::Ptr{Cdouble})::Cdouble
 end
 
 function SuiteSparse_time()
-    @ccall libcholmod.SuiteSparse_time()::Cdouble
+    @ccall libsuitesparseconfig.SuiteSparse_time()::Cdouble
 end
 
 function SuiteSparse_hypot(x, y)
-    @ccall libcholmod.SuiteSparse_hypot(x::Cdouble, y::Cdouble)::Cdouble
+    @ccall libsuitesparseconfig.SuiteSparse_hypot(x::Cdouble, y::Cdouble)::Cdouble
 end
 
 function SuiteSparse_divcomplex(ar, ai, br, bi, cr, ci)
-    @ccall libcholmod.SuiteSparse_divcomplex(ar::Cdouble, ai::Cdouble, br::Cdouble, bi::Cdouble, cr::Ptr{Cdouble}, ci::Ptr{Cdouble})::Cint
+    @ccall libsuitesparseconfig.SuiteSparse_divcomplex(ar::Cdouble, ai::Cdouble,
+                                                       br::Cdouble, bi::Cdouble,
+                                                       cr::Ptr{Cdouble},
+                                                       ci::Ptr{Cdouble})::Cint
 end
 
 function SuiteSparse_version(version)
-    @ccall libcholmod.SuiteSparse_version(version::Ptr{Cint})::Cint
+    @ccall libsuitesparseconfig.SuiteSparse_version(version::Ptr{Cint})::Cint
 end
 
 function SuiteSparse_BLAS_library()
-    @ccall libcholmod.SuiteSparse_BLAS_library()::Ptr{Cchar}
+    @ccall libsuitesparseconfig.SuiteSparse_BLAS_library()::Ptr{Cchar}
 end
 
 function SuiteSparse_BLAS_integer_size()
-    @ccall libcholmod.SuiteSparse_BLAS_integer_size()::Csize_t
+    @ccall libsuitesparseconfig.SuiteSparse_BLAS_integer_size()::Csize_t
 end
 
 struct cholmod_method_struct
@@ -140,16 +153,16 @@ struct cholmod_method_struct
     prune_dense::Cdouble
     prune_dense2::Cdouble
     nd_oksep::Cdouble
-    other_1::NTuple{4, Cdouble}
+    other_1::NTuple{4,Cdouble}
     nd_small::Csize_t
-    other_2::NTuple{4, Csize_t}
+    other_2::NTuple{4,Csize_t}
     aggressive::Cint
     order_for_lu::Cint
     nd_compress::Cint
     nd_camd::Cint
     nd_components::Cint
     ordering::Cint
-    other_3::NTuple{4, Csize_t}
+    other_3::NTuple{4,Csize_t}
 end
 
 mutable struct cholmod_common_struct
@@ -166,8 +179,8 @@ mutable struct cholmod_common_struct
     final_pack::Cint
     final_monotonic::Cint
     final_resymbol::Cint
-    zrelax::NTuple{3, Cdouble}
-    nrelax::NTuple{3, Csize_t}
+    zrelax::NTuple{3,Cdouble}
+    nrelax::NTuple{3,Csize_t}
     prefer_zomplex::Cint
     prefer_upper::Cint
     quick_return_if_not_posdef::Cint
@@ -179,7 +192,7 @@ mutable struct cholmod_common_struct
     nmethods::Cint
     current::Cint
     selected::Cint
-    method::NTuple{10, cholmod_method_struct}
+    method::NTuple{10,cholmod_method_struct}
     postorder::Cint
     default_nesdis::Cint
     metis_memory::Cdouble
@@ -222,7 +235,7 @@ mutable struct cholmod_common_struct
     SPQR_flopcount_bound::Cdouble
     SPQR_tol_used::Cdouble
     SPQR_norm_E_fro::Cdouble
-    SPQR_istat::NTuple{10, Int64}
+    SPQR_istat::NTuple{10,Int64}
     useGPU::Cint
     maxGpuMemBytes::Csize_t
     maxGpuMemFraction::Cdouble
@@ -231,10 +244,10 @@ mutable struct cholmod_common_struct
     gpuFlops::Int64
     gpuNumKernelLaunches::Cint
     cublasHandle::Ptr{Cvoid}
-    gpuStream::NTuple{8, Ptr{Cvoid}}
-    cublasEventPotrf::NTuple{3, Ptr{Cvoid}}
+    gpuStream::NTuple{8,Ptr{Cvoid}}
+    cublasEventPotrf::NTuple{3,Ptr{Cvoid}}
     updateCKernelsComplete::Ptr{Cvoid}
-    updateCBuffersFree::NTuple{8, Ptr{Cvoid}}
+    updateCBuffersFree::NTuple{8,Ptr{Cvoid}}
     dev_mempool::Ptr{Cvoid}
     dev_mempool_size::Csize_t
     host_pinned_mempool::Ptr{Cvoid}
@@ -300,11 +313,14 @@ function cholmod_l_maxrank(arg1, arg2)
 end
 
 function cholmod_allocate_work(nrow, iworksize, xworksize, Common)
-    @ccall libcholmod.cholmod_allocate_work(nrow::Csize_t, iworksize::Csize_t, xworksize::Csize_t, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_allocate_work(nrow::Csize_t, iworksize::Csize_t,
+                                            xworksize::Csize_t,
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_allocate_work(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_allocate_work(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_allocate_work(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t,
+                                              arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_free_work(Common)
@@ -324,11 +340,13 @@ function cholmod_l_clear_flag(arg1)
 end
 
 function cholmod_error(status, file, line, message, Common)
-    @ccall libcholmod.cholmod_error(status::Cint, file::Ptr{Cchar}, line::Cint, message::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_error(status::Cint, file::Ptr{Cchar}, line::Cint,
+                                    message::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_error(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_error(arg1::Cint, arg2::Ptr{Cchar}, arg3::Cint, arg4::Ptr{Cchar}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_error(arg1::Cint, arg2::Ptr{Cchar}, arg3::Cint,
+                                      arg4::Ptr{Cchar}, arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_dbound(dj, Common)
@@ -348,11 +366,14 @@ function cholmod_l_hypot(arg1, arg2)
 end
 
 function cholmod_divcomplex(ar, ai, br, bi, cr, ci)
-    @ccall libcholmod.cholmod_divcomplex(ar::Cdouble, ai::Cdouble, br::Cdouble, bi::Cdouble, cr::Ptr{Cdouble}, ci::Ptr{Cdouble})::Cint
+    @ccall libcholmod.cholmod_divcomplex(ar::Cdouble, ai::Cdouble, br::Cdouble, bi::Cdouble,
+                                         cr::Ptr{Cdouble}, ci::Ptr{Cdouble})::Cint
 end
 
 function cholmod_l_divcomplex(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_divcomplex(arg1::Cdouble, arg2::Cdouble, arg3::Cdouble, arg4::Cdouble, arg5::Ptr{Cdouble}, arg6::Ptr{Cdouble})::Cint
+    @ccall libcholmod.cholmod_l_divcomplex(arg1::Cdouble, arg2::Cdouble, arg3::Cdouble,
+                                           arg4::Cdouble, arg5::Ptr{Cdouble},
+                                           arg6::Ptr{Cdouble})::Cint
 end
 
 mutable struct cholmod_sparse_struct
@@ -384,155 +405,217 @@ end
 const descendantScore = cholmod_descendant_score_t
 
 function cholmod_score_comp(i, j)
-    @ccall libcholmod.cholmod_score_comp(i::Ptr{cholmod_descendant_score_t}, j::Ptr{cholmod_descendant_score_t})::Cint
+    @ccall libcholmod.cholmod_score_comp(i::Ptr{cholmod_descendant_score_t},
+                                         j::Ptr{cholmod_descendant_score_t})::Cint
 end
 
 function cholmod_l_score_comp(i, j)
-    @ccall libcholmod.cholmod_l_score_comp(i::Ptr{cholmod_descendant_score_t}, j::Ptr{cholmod_descendant_score_t})::Cint
+    @ccall libcholmod.cholmod_l_score_comp(i::Ptr{cholmod_descendant_score_t},
+                                           j::Ptr{cholmod_descendant_score_t})::Cint
 end
 
 function cholmod_allocate_sparse(nrow, ncol, nzmax, sorted, packed, stype, xtype, Common)
-    @ccall libcholmod.cholmod_allocate_sparse(nrow::Csize_t, ncol::Csize_t, nzmax::Csize_t, sorted::Cint, packed::Cint, stype::Cint, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_allocate_sparse(nrow::Csize_t, ncol::Csize_t, nzmax::Csize_t,
+                                              sorted::Cint, packed::Cint, stype::Cint,
+                                              xtype::Cint,
+                                              Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_allocate_sparse(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
-    @ccall libcholmod.cholmod_l_allocate_sparse(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t, arg4::Cint, arg5::Cint, arg6::Cint, arg7::Cint, arg8::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_allocate_sparse(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t,
+                                                arg4::Cint, arg5::Cint, arg6::Cint,
+                                                arg7::Cint,
+                                                arg8::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_free_sparse(A, Common)
-    @ccall libcholmod.cholmod_free_sparse(A::Ptr{Ptr{cholmod_sparse}}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_free_sparse(A::Ptr{Ptr{cholmod_sparse}},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_free_sparse(arg1, arg2)
-    @ccall libcholmod.cholmod_l_free_sparse(arg1::Ptr{Ptr{cholmod_sparse}}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_free_sparse(arg1::Ptr{Ptr{cholmod_sparse}},
+                                            arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_reallocate_sparse(nznew, A, Common)
-    @ccall libcholmod.cholmod_reallocate_sparse(nznew::Csize_t, A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_reallocate_sparse(nznew::Csize_t, A::Ptr{cholmod_sparse},
+                                                Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_reallocate_sparse(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_reallocate_sparse(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_reallocate_sparse(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                                  arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_nnz(A, Common)
-    @ccall libcholmod.cholmod_nnz(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_nnz(A::Ptr{cholmod_sparse},
+                                  Common::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_l_nnz(arg1, arg2)
-    @ccall libcholmod.cholmod_l_nnz(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_l_nnz(arg1::Ptr{cholmod_sparse},
+                                    arg2::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_speye(nrow, ncol, xtype, Common)
-    @ccall libcholmod.cholmod_speye(nrow::Csize_t, ncol::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_speye(nrow::Csize_t, ncol::Csize_t, xtype::Cint,
+                                    Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_speye(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_speye(arg1::Csize_t, arg2::Csize_t, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_speye(arg1::Csize_t, arg2::Csize_t, arg3::Cint,
+                                      arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_spzeros(nrow, ncol, nzmax, xtype, Common)
-    @ccall libcholmod.cholmod_spzeros(nrow::Csize_t, ncol::Csize_t, nzmax::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_spzeros(nrow::Csize_t, ncol::Csize_t, nzmax::Csize_t,
+                                      xtype::Cint,
+                                      Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_spzeros(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_spzeros(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t, arg4::Cint, arg5::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_spzeros(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t,
+                                        arg4::Cint,
+                                        arg5::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_transpose(A, values, Common)
-    @ccall libcholmod.cholmod_transpose(A::Ptr{cholmod_sparse}, values::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_transpose(A::Ptr{cholmod_sparse}, values::Cint,
+                                        Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_transpose(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_transpose(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_transpose(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                          arg3::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_transpose_unsym(A, values, Perm, fset, fsize, F, Common)
-    @ccall libcholmod.cholmod_transpose_unsym(A::Ptr{cholmod_sparse}, values::Cint, Perm::Ptr{Int32}, fset::Ptr{Int32}, fsize::Csize_t, F::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_transpose_unsym(A::Ptr{cholmod_sparse}, values::Cint,
+                                              Perm::Ptr{Int32}, fset::Ptr{Int32},
+                                              fsize::Csize_t, F::Ptr{cholmod_sparse},
+                                              Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_transpose_unsym(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_transpose_unsym(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Csize_t, arg6::Ptr{cholmod_sparse}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_transpose_unsym(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                                arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                                arg5::Csize_t, arg6::Ptr{cholmod_sparse},
+                                                arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_transpose_sym(A, values, Perm, F, Common)
-    @ccall libcholmod.cholmod_transpose_sym(A::Ptr{cholmod_sparse}, values::Cint, Perm::Ptr{Int32}, F::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_transpose_sym(A::Ptr{cholmod_sparse}, values::Cint,
+                                            Perm::Ptr{Int32}, F::Ptr{cholmod_sparse},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_transpose_sym(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_transpose_sym(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{Int64}, arg4::Ptr{cholmod_sparse}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_transpose_sym(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                              arg3::Ptr{Int64}, arg4::Ptr{cholmod_sparse},
+                                              arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_ptranspose(A, values, Perm, fset, fsize, Common)
-    @ccall libcholmod.cholmod_ptranspose(A::Ptr{cholmod_sparse}, values::Cint, Perm::Ptr{Int32}, fset::Ptr{Int32}, fsize::Csize_t, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_ptranspose(A::Ptr{cholmod_sparse}, values::Cint,
+                                         Perm::Ptr{Int32}, fset::Ptr{Int32}, fsize::Csize_t,
+                                         Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_ptranspose(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_ptranspose(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Csize_t, arg6::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_ptranspose(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                           arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                           arg5::Csize_t,
+                                           arg6::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_sort(A, Common)
-    @ccall libcholmod.cholmod_sort(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_sort(A::Ptr{cholmod_sparse},
+                                   Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_sort(arg1, arg2)
-    @ccall libcholmod.cholmod_l_sort(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_sort(arg1::Ptr{cholmod_sparse},
+                                     arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_band(A, k1, k2, mode, Common)
-    @ccall libcholmod.cholmod_band(A::Ptr{cholmod_sparse}, k1::Int64, k2::Int64, mode::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_band(A::Ptr{cholmod_sparse}, k1::Int64, k2::Int64, mode::Cint,
+                                   Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_band(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_band(arg1::Ptr{cholmod_sparse}, arg2::Int64, arg3::Int64, arg4::Cint, arg5::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_band(arg1::Ptr{cholmod_sparse}, arg2::Int64, arg3::Int64,
+                                     arg4::Cint,
+                                     arg5::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_band_inplace(k1, k2, mode, A, Common)
-    @ccall libcholmod.cholmod_band_inplace(k1::Int64, k2::Int64, mode::Cint, A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_band_inplace(k1::Int64, k2::Int64, mode::Cint,
+                                           A::Ptr{cholmod_sparse},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_band_inplace(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_band_inplace(arg1::Int64, arg2::Int64, arg3::Cint, arg4::Ptr{cholmod_sparse}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_band_inplace(arg1::Int64, arg2::Int64, arg3::Cint,
+                                             arg4::Ptr{cholmod_sparse},
+                                             arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_aat(A, fset, fsize, mode, Common)
-    @ccall libcholmod.cholmod_aat(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, mode::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_aat(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t,
+                                  mode::Cint,
+                                  Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_aat(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_aat(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Cint, arg5::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_aat(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                    arg3::Csize_t, arg4::Cint,
+                                    arg5::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_copy_sparse(A, Common)
-    @ccall libcholmod.cholmod_copy_sparse(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_copy_sparse(A::Ptr{cholmod_sparse},
+                                          Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_copy_sparse(arg1, arg2)
-    @ccall libcholmod.cholmod_l_copy_sparse(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_copy_sparse(arg1::Ptr{cholmod_sparse},
+                                            arg2::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_copy(A, stype, mode, Common)
-    @ccall libcholmod.cholmod_copy(A::Ptr{cholmod_sparse}, stype::Cint, mode::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_copy(A::Ptr{cholmod_sparse}, stype::Cint, mode::Cint,
+                                   Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_copy(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_copy(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_copy(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Cint,
+                                     arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_add(A, B, alpha, beta, values, sorted, Common)
-    @ccall libcholmod.cholmod_add(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse}, alpha::Ptr{Cdouble}, beta::Ptr{Cdouble}, values::Cint, sorted::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_add(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse},
+                                  alpha::Ptr{Cdouble}, beta::Ptr{Cdouble}, values::Cint,
+                                  sorted::Cint,
+                                  Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_add(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_add(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Ptr{Cdouble}, arg5::Cint, arg6::Cint, arg7::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_add(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse},
+                                    arg3::Ptr{Cdouble}, arg4::Ptr{Cdouble}, arg5::Cint,
+                                    arg6::Cint,
+                                    arg7::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_sparse_xtype(to_xtype, A, Common)
-    @ccall libcholmod.cholmod_sparse_xtype(to_xtype::Cint, A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_sparse_xtype(to_xtype::Cint, A::Ptr{cholmod_sparse},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_sparse_xtype(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_sparse_xtype(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_sparse_xtype(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                             arg3::Ptr{cholmod_common})::Cint
 end
 
 mutable struct cholmod_factor_struct
@@ -572,75 +655,100 @@ end
 const cholmod_factor = cholmod_factor_struct
 
 function cholmod_allocate_factor(n, Common)
-    @ccall libcholmod.cholmod_allocate_factor(n::Csize_t, Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_allocate_factor(n::Csize_t,
+                                              Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_l_allocate_factor(arg1, arg2)
-    @ccall libcholmod.cholmod_l_allocate_factor(arg1::Csize_t, arg2::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_l_allocate_factor(arg1::Csize_t,
+                                                arg2::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_free_factor(L, Common)
-    @ccall libcholmod.cholmod_free_factor(L::Ptr{Ptr{cholmod_factor}}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_free_factor(L::Ptr{Ptr{cholmod_factor}},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_free_factor(arg1, arg2)
-    @ccall libcholmod.cholmod_l_free_factor(arg1::Ptr{Ptr{cholmod_factor}}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_free_factor(arg1::Ptr{Ptr{cholmod_factor}},
+                                            arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_reallocate_factor(nznew, L, Common)
-    @ccall libcholmod.cholmod_reallocate_factor(nznew::Csize_t, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_reallocate_factor(nznew::Csize_t, L::Ptr{cholmod_factor},
+                                                Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_reallocate_factor(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_reallocate_factor(arg1::Csize_t, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_reallocate_factor(arg1::Csize_t, arg2::Ptr{cholmod_factor},
+                                                  arg3::Ptr{cholmod_common})::Cint
 end
 
-function cholmod_change_factor(to_xtype, to_ll, to_super, to_packed, to_monotonic, L, Common)
-    @ccall libcholmod.cholmod_change_factor(to_xtype::Cint, to_ll::Cint, to_super::Cint, to_packed::Cint, to_monotonic::Cint, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+function cholmod_change_factor(to_xtype, to_ll, to_super, to_packed, to_monotonic, L,
+                               Common)
+    @ccall libcholmod.cholmod_change_factor(to_xtype::Cint, to_ll::Cint, to_super::Cint,
+                                            to_packed::Cint, to_monotonic::Cint,
+                                            L::Ptr{cholmod_factor},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_change_factor(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_change_factor(arg1::Cint, arg2::Cint, arg3::Cint, arg4::Cint, arg5::Cint, arg6::Ptr{cholmod_factor}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_change_factor(arg1::Cint, arg2::Cint, arg3::Cint,
+                                              arg4::Cint, arg5::Cint,
+                                              arg6::Ptr{cholmod_factor},
+                                              arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_pack_factor(L, Common)
-    @ccall libcholmod.cholmod_pack_factor(L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_pack_factor(L::Ptr{cholmod_factor},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_pack_factor(arg1, arg2)
-    @ccall libcholmod.cholmod_l_pack_factor(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_pack_factor(arg1::Ptr{cholmod_factor},
+                                            arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_reallocate_column(j, need, L, Common)
-    @ccall libcholmod.cholmod_reallocate_column(j::Csize_t, need::Csize_t, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_reallocate_column(j::Csize_t, need::Csize_t,
+                                                L::Ptr{cholmod_factor},
+                                                Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_reallocate_column(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_reallocate_column(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{cholmod_factor}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_reallocate_column(arg1::Csize_t, arg2::Csize_t,
+                                                  arg3::Ptr{cholmod_factor},
+                                                  arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_factor_to_sparse(L, Common)
-    @ccall libcholmod.cholmod_factor_to_sparse(L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_factor_to_sparse(L::Ptr{cholmod_factor},
+                                               Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_factor_to_sparse(arg1, arg2)
-    @ccall libcholmod.cholmod_l_factor_to_sparse(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_factor_to_sparse(arg1::Ptr{cholmod_factor},
+                                                 arg2::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_copy_factor(L, Common)
-    @ccall libcholmod.cholmod_copy_factor(L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_copy_factor(L::Ptr{cholmod_factor},
+                                          Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_l_copy_factor(arg1, arg2)
-    @ccall libcholmod.cholmod_l_copy_factor(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_l_copy_factor(arg1::Ptr{cholmod_factor},
+                                            arg2::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_factor_xtype(to_xtype, L, Common)
-    @ccall libcholmod.cholmod_factor_xtype(to_xtype::Cint, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_factor_xtype(to_xtype::Cint, L::Ptr{cholmod_factor},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_factor_xtype(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_factor_xtype(arg1::Cint, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_factor_xtype(arg1::Cint, arg2::Ptr{cholmod_factor},
+                                             arg3::Ptr{cholmod_common})::Cint
 end
 
 mutable struct cholmod_dense_struct
@@ -658,91 +766,118 @@ end
 const cholmod_dense = cholmod_dense_struct
 
 function cholmod_allocate_dense(nrow, ncol, d, xtype, Common)
-    @ccall libcholmod.cholmod_allocate_dense(nrow::Csize_t, ncol::Csize_t, d::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_allocate_dense(nrow::Csize_t, ncol::Csize_t, d::Csize_t,
+                                             xtype::Cint,
+                                             Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_allocate_dense(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_allocate_dense(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t, arg4::Cint, arg5::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_allocate_dense(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t,
+                                               arg4::Cint,
+                                               arg5::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_zeros(nrow, ncol, xtype, Common)
-    @ccall libcholmod.cholmod_zeros(nrow::Csize_t, ncol::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_zeros(nrow::Csize_t, ncol::Csize_t, xtype::Cint,
+                                    Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_zeros(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_zeros(arg1::Csize_t, arg2::Csize_t, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_zeros(arg1::Csize_t, arg2::Csize_t, arg3::Cint,
+                                      arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_ones(nrow, ncol, xtype, Common)
-    @ccall libcholmod.cholmod_ones(nrow::Csize_t, ncol::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_ones(nrow::Csize_t, ncol::Csize_t, xtype::Cint,
+                                   Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_ones(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_ones(arg1::Csize_t, arg2::Csize_t, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_ones(arg1::Csize_t, arg2::Csize_t, arg3::Cint,
+                                     arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_eye(nrow, ncol, xtype, Common)
-    @ccall libcholmod.cholmod_eye(nrow::Csize_t, ncol::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_eye(nrow::Csize_t, ncol::Csize_t, xtype::Cint,
+                                  Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_eye(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_eye(arg1::Csize_t, arg2::Csize_t, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_eye(arg1::Csize_t, arg2::Csize_t, arg3::Cint,
+                                    arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_free_dense(X, Common)
-    @ccall libcholmod.cholmod_free_dense(X::Ptr{Ptr{cholmod_dense}}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_free_dense(X::Ptr{Ptr{cholmod_dense}},
+                                         Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_free_dense(arg1, arg2)
-    @ccall libcholmod.cholmod_l_free_dense(arg1::Ptr{Ptr{cholmod_dense}}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_free_dense(arg1::Ptr{Ptr{cholmod_dense}},
+                                           arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_ensure_dense(XHandle, nrow, ncol, d, xtype, Common)
-    @ccall libcholmod.cholmod_ensure_dense(XHandle::Ptr{Ptr{cholmod_dense}}, nrow::Csize_t, ncol::Csize_t, d::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_ensure_dense(XHandle::Ptr{Ptr{cholmod_dense}}, nrow::Csize_t,
+                                           ncol::Csize_t, d::Csize_t, xtype::Cint,
+                                           Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_ensure_dense(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_ensure_dense(arg1::Ptr{Ptr{cholmod_dense}}, arg2::Csize_t, arg3::Csize_t, arg4::Csize_t, arg5::Cint, arg6::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_ensure_dense(arg1::Ptr{Ptr{cholmod_dense}}, arg2::Csize_t,
+                                             arg3::Csize_t, arg4::Csize_t, arg5::Cint,
+                                             arg6::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_sparse_to_dense(A, Common)
-    @ccall libcholmod.cholmod_sparse_to_dense(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_sparse_to_dense(A::Ptr{cholmod_sparse},
+                                              Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_sparse_to_dense(arg1, arg2)
-    @ccall libcholmod.cholmod_l_sparse_to_dense(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_sparse_to_dense(arg1::Ptr{cholmod_sparse},
+                                                arg2::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_dense_to_sparse(X, values, Common)
-    @ccall libcholmod.cholmod_dense_to_sparse(X::Ptr{cholmod_dense}, values::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_dense_to_sparse(X::Ptr{cholmod_dense}, values::Cint,
+                                              Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_dense_to_sparse(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_dense_to_sparse(arg1::Ptr{cholmod_dense}, arg2::Cint, arg3::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_dense_to_sparse(arg1::Ptr{cholmod_dense}, arg2::Cint,
+                                                arg3::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_copy_dense(X, Common)
-    @ccall libcholmod.cholmod_copy_dense(X::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_copy_dense(X::Ptr{cholmod_dense},
+                                         Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_copy_dense(arg1, arg2)
-    @ccall libcholmod.cholmod_l_copy_dense(arg1::Ptr{cholmod_dense}, arg2::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_copy_dense(arg1::Ptr{cholmod_dense},
+                                           arg2::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_copy_dense2(X, Y, Common)
-    @ccall libcholmod.cholmod_copy_dense2(X::Ptr{cholmod_dense}, Y::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_copy_dense2(X::Ptr{cholmod_dense}, Y::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_copy_dense2(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_copy_dense2(arg1::Ptr{cholmod_dense}, arg2::Ptr{cholmod_dense}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_copy_dense2(arg1::Ptr{cholmod_dense},
+                                            arg2::Ptr{cholmod_dense},
+                                            arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_dense_xtype(to_xtype, X, Common)
-    @ccall libcholmod.cholmod_dense_xtype(to_xtype::Cint, X::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_dense_xtype(to_xtype::Cint, X::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_dense_xtype(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_dense_xtype(arg1::Cint, arg2::Ptr{cholmod_dense}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_dense_xtype(arg1::Cint, arg2::Ptr{cholmod_dense},
+                                            arg3::Ptr{cholmod_common})::Cint
 end
 
 mutable struct cholmod_triplet_struct
@@ -764,99 +899,137 @@ end
 const cholmod_triplet = cholmod_triplet_struct
 
 function cholmod_allocate_triplet(nrow, ncol, nzmax, stype, xtype, Common)
-    @ccall libcholmod.cholmod_allocate_triplet(nrow::Csize_t, ncol::Csize_t, nzmax::Csize_t, stype::Cint, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_allocate_triplet(nrow::Csize_t, ncol::Csize_t, nzmax::Csize_t,
+                                               stype::Cint, xtype::Cint,
+                                               Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_l_allocate_triplet(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_allocate_triplet(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t, arg4::Cint, arg5::Cint, arg6::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_l_allocate_triplet(arg1::Csize_t, arg2::Csize_t,
+                                                 arg3::Csize_t, arg4::Cint, arg5::Cint,
+                                                 arg6::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_free_triplet(T, Common)
-    @ccall libcholmod.cholmod_free_triplet(T::Ptr{Ptr{cholmod_triplet}}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_free_triplet(T::Ptr{Ptr{cholmod_triplet}},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_free_triplet(arg1, arg2)
-    @ccall libcholmod.cholmod_l_free_triplet(arg1::Ptr{Ptr{cholmod_triplet}}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_free_triplet(arg1::Ptr{Ptr{cholmod_triplet}},
+                                             arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_reallocate_triplet(nznew, T, Common)
-    @ccall libcholmod.cholmod_reallocate_triplet(nznew::Csize_t, T::Ptr{cholmod_triplet}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_reallocate_triplet(nznew::Csize_t, T::Ptr{cholmod_triplet},
+                                                 Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_reallocate_triplet(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_reallocate_triplet(arg1::Csize_t, arg2::Ptr{cholmod_triplet}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_reallocate_triplet(arg1::Csize_t,
+                                                   arg2::Ptr{cholmod_triplet},
+                                                   arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_sparse_to_triplet(A, Common)
-    @ccall libcholmod.cholmod_sparse_to_triplet(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_sparse_to_triplet(A::Ptr{cholmod_sparse},
+                                                Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_l_sparse_to_triplet(arg1, arg2)
-    @ccall libcholmod.cholmod_l_sparse_to_triplet(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_l_sparse_to_triplet(arg1::Ptr{cholmod_sparse},
+                                                  arg2::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_triplet_to_sparse(T, nzmax, Common)
-    @ccall libcholmod.cholmod_triplet_to_sparse(T::Ptr{cholmod_triplet}, nzmax::Csize_t, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_triplet_to_sparse(T::Ptr{cholmod_triplet}, nzmax::Csize_t,
+                                                Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_triplet_to_sparse(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_triplet_to_sparse(arg1::Ptr{cholmod_triplet}, arg2::Csize_t, arg3::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_triplet_to_sparse(arg1::Ptr{cholmod_triplet}, arg2::Csize_t,
+                                                  arg3::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_copy_triplet(T, Common)
-    @ccall libcholmod.cholmod_copy_triplet(T::Ptr{cholmod_triplet}, Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_copy_triplet(T::Ptr{cholmod_triplet},
+                                           Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_l_copy_triplet(arg1, arg2)
-    @ccall libcholmod.cholmod_l_copy_triplet(arg1::Ptr{cholmod_triplet}, arg2::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_l_copy_triplet(arg1::Ptr{cholmod_triplet},
+                                             arg2::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_triplet_xtype(to_xtype, T, Common)
-    @ccall libcholmod.cholmod_triplet_xtype(to_xtype::Cint, T::Ptr{cholmod_triplet}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_triplet_xtype(to_xtype::Cint, T::Ptr{cholmod_triplet},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_triplet_xtype(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_triplet_xtype(arg1::Cint, arg2::Ptr{cholmod_triplet}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_triplet_xtype(arg1::Cint, arg2::Ptr{cholmod_triplet},
+                                              arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_malloc(n, size, Common)
-    @ccall libcholmod.cholmod_malloc(n::Csize_t, size::Csize_t, Common::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_malloc(n::Csize_t, size::Csize_t,
+                                     Common::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_l_malloc(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_malloc(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_l_malloc(arg1::Csize_t, arg2::Csize_t,
+                                       arg3::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_calloc(n, size, Common)
-    @ccall libcholmod.cholmod_calloc(n::Csize_t, size::Csize_t, Common::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_calloc(n::Csize_t, size::Csize_t,
+                                     Common::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_l_calloc(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_calloc(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_l_calloc(arg1::Csize_t, arg2::Csize_t,
+                                       arg3::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_free(n, size, p, Common)
-    @ccall libcholmod.cholmod_free(n::Csize_t, size::Csize_t, p::Ptr{Cvoid}, Common::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_free(n::Csize_t, size::Csize_t, p::Ptr{Cvoid},
+                                   Common::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_l_free(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_free(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{Cvoid}, arg4::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_l_free(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{Cvoid},
+                                     arg4::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_realloc(nnew, size, p, n, Common)
-    @ccall libcholmod.cholmod_realloc(nnew::Csize_t, size::Csize_t, p::Ptr{Cvoid}, n::Ptr{Csize_t}, Common::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_realloc(nnew::Csize_t, size::Csize_t, p::Ptr{Cvoid},
+                                      n::Ptr{Csize_t},
+                                      Common::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_l_realloc(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_realloc(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{Cvoid}, arg4::Ptr{Csize_t}, arg5::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_l_realloc(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{Cvoid},
+                                        arg4::Ptr{Csize_t},
+                                        arg5::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
-function cholmod_realloc_multiple(nnew, nint, xtype, Iblock, Jblock, Xblock, Zblock, n, Common)
-    @ccall libcholmod.cholmod_realloc_multiple(nnew::Csize_t, nint::Cint, xtype::Cint, Iblock::Ptr{Ptr{Cvoid}}, Jblock::Ptr{Ptr{Cvoid}}, Xblock::Ptr{Ptr{Cvoid}}, Zblock::Ptr{Ptr{Cvoid}}, n::Ptr{Csize_t}, Common::Ptr{cholmod_common})::Cint
+function cholmod_realloc_multiple(nnew, nint, xtype, Iblock, Jblock, Xblock, Zblock, n,
+                                  Common)
+    @ccall libcholmod.cholmod_realloc_multiple(nnew::Csize_t, nint::Cint, xtype::Cint,
+                                               Iblock::Ptr{Ptr{Cvoid}},
+                                               Jblock::Ptr{Ptr{Cvoid}},
+                                               Xblock::Ptr{Ptr{Cvoid}},
+                                               Zblock::Ptr{Ptr{Cvoid}}, n::Ptr{Csize_t},
+                                               Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_realloc_multiple(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
-    @ccall libcholmod.cholmod_l_realloc_multiple(arg1::Csize_t, arg2::Cint, arg3::Cint, arg4::Ptr{Ptr{Cvoid}}, arg5::Ptr{Ptr{Cvoid}}, arg6::Ptr{Ptr{Cvoid}}, arg7::Ptr{Ptr{Cvoid}}, arg8::Ptr{Csize_t}, arg9::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_realloc_multiple(arg1::Csize_t, arg2::Cint, arg3::Cint,
+                                                 arg4::Ptr{Ptr{Cvoid}},
+                                                 arg5::Ptr{Ptr{Cvoid}},
+                                                 arg6::Ptr{Ptr{Cvoid}},
+                                                 arg7::Ptr{Ptr{Cvoid}}, arg8::Ptr{Csize_t},
+                                                 arg9::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_version(version)
@@ -876,11 +1049,13 @@ function cholmod_l_check_common(arg1)
 end
 
 function cholmod_print_common(name, Common)
-    @ccall libcholmod.cholmod_print_common(name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_common(name::Ptr{Cchar},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_common(arg1, arg2)
-    @ccall libcholmod.cholmod_l_print_common(arg1::Ptr{Cchar}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_common(arg1::Ptr{Cchar},
+                                             arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_gpu_stats(arg1)
@@ -892,643 +1067,1047 @@ function cholmod_l_gpu_stats(arg1)
 end
 
 function cholmod_check_sparse(A, Common)
-    @ccall libcholmod.cholmod_check_sparse(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_sparse(A::Ptr{cholmod_sparse},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_sparse(arg1, arg2)
-    @ccall libcholmod.cholmod_l_check_sparse(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_sparse(arg1::Ptr{cholmod_sparse},
+                                             arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_sparse(A, name, Common)
-    @ccall libcholmod.cholmod_print_sparse(A::Ptr{cholmod_sparse}, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_sparse(A::Ptr{cholmod_sparse}, name::Ptr{Cchar},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_sparse(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_print_sparse(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Cchar}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_sparse(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Cchar},
+                                             arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_check_dense(X, Common)
-    @ccall libcholmod.cholmod_check_dense(X::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_dense(X::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_dense(arg1, arg2)
-    @ccall libcholmod.cholmod_l_check_dense(arg1::Ptr{cholmod_dense}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_dense(arg1::Ptr{cholmod_dense},
+                                            arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_dense(X, name, Common)
-    @ccall libcholmod.cholmod_print_dense(X::Ptr{cholmod_dense}, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_dense(X::Ptr{cholmod_dense}, name::Ptr{Cchar},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_dense(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_print_dense(arg1::Ptr{cholmod_dense}, arg2::Ptr{Cchar}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_dense(arg1::Ptr{cholmod_dense}, arg2::Ptr{Cchar},
+                                            arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_check_factor(L, Common)
-    @ccall libcholmod.cholmod_check_factor(L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_factor(L::Ptr{cholmod_factor},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_factor(arg1, arg2)
-    @ccall libcholmod.cholmod_l_check_factor(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_factor(arg1::Ptr{cholmod_factor},
+                                             arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_factor(L, name, Common)
-    @ccall libcholmod.cholmod_print_factor(L::Ptr{cholmod_factor}, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_factor(L::Ptr{cholmod_factor}, name::Ptr{Cchar},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_factor(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_print_factor(arg1::Ptr{cholmod_factor}, arg2::Ptr{Cchar}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_factor(arg1::Ptr{cholmod_factor}, arg2::Ptr{Cchar},
+                                             arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_check_triplet(T, Common)
-    @ccall libcholmod.cholmod_check_triplet(T::Ptr{cholmod_triplet}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_triplet(T::Ptr{cholmod_triplet},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_triplet(arg1, arg2)
-    @ccall libcholmod.cholmod_l_check_triplet(arg1::Ptr{cholmod_triplet}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_triplet(arg1::Ptr{cholmod_triplet},
+                                              arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_triplet(T, name, Common)
-    @ccall libcholmod.cholmod_print_triplet(T::Ptr{cholmod_triplet}, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_triplet(T::Ptr{cholmod_triplet}, name::Ptr{Cchar},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_triplet(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_print_triplet(arg1::Ptr{cholmod_triplet}, arg2::Ptr{Cchar}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_triplet(arg1::Ptr{cholmod_triplet}, arg2::Ptr{Cchar},
+                                              arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_check_subset(Set, len, n, Common)
-    @ccall libcholmod.cholmod_check_subset(Set::Ptr{Int32}, len::Int64, n::Csize_t, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_subset(Set::Ptr{Int32}, len::Int64, n::Csize_t,
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_subset(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_check_subset(arg1::Ptr{Int64}, arg2::Int64, arg3::Csize_t, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_subset(arg1::Ptr{Int64}, arg2::Int64, arg3::Csize_t,
+                                             arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_subset(Set, len, n, name, Common)
-    @ccall libcholmod.cholmod_print_subset(Set::Ptr{Int32}, len::Int64, n::Csize_t, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_subset(Set::Ptr{Int32}, len::Int64, n::Csize_t,
+                                           name::Ptr{Cchar},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_subset(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_print_subset(arg1::Ptr{Int64}, arg2::Int64, arg3::Csize_t, arg4::Ptr{Cchar}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_subset(arg1::Ptr{Int64}, arg2::Int64, arg3::Csize_t,
+                                             arg4::Ptr{Cchar},
+                                             arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_check_perm(Perm, len, n, Common)
-    @ccall libcholmod.cholmod_check_perm(Perm::Ptr{Int32}, len::Csize_t, n::Csize_t, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_perm(Perm::Ptr{Int32}, len::Csize_t, n::Csize_t,
+                                         Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_perm(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_check_perm(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Csize_t, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_perm(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Csize_t,
+                                           arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_perm(Perm, len, n, name, Common)
-    @ccall libcholmod.cholmod_print_perm(Perm::Ptr{Int32}, len::Csize_t, n::Csize_t, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_perm(Perm::Ptr{Int32}, len::Csize_t, n::Csize_t,
+                                         name::Ptr{Cchar},
+                                         Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_perm(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_print_perm(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Csize_t, arg4::Ptr{Cchar}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_perm(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Csize_t,
+                                           arg4::Ptr{Cchar},
+                                           arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_check_parent(Parent, n, Common)
-    @ccall libcholmod.cholmod_check_parent(Parent::Ptr{Int32}, n::Csize_t, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_parent(Parent::Ptr{Int32}, n::Csize_t,
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_parent(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_check_parent(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_parent(arg1::Ptr{Int64}, arg2::Csize_t,
+                                             arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_parent(Parent, n, name, Common)
-    @ccall libcholmod.cholmod_print_parent(Parent::Ptr{Int32}, n::Csize_t, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_parent(Parent::Ptr{Int32}, n::Csize_t, name::Ptr{Cchar},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_parent(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_print_parent(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Ptr{Cchar}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_parent(arg1::Ptr{Int64}, arg2::Csize_t,
+                                             arg3::Ptr{Cchar},
+                                             arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_read_sparse(f, Common)
-    @ccall libcholmod.cholmod_read_sparse(f::Ptr{Libc.FILE}, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_read_sparse(f::Ptr{Libc.FILE},
+                                          Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_read_sparse(arg1, arg2)
-    @ccall libcholmod.cholmod_l_read_sparse(arg1::Ptr{Libc.FILE}, arg2::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_read_sparse(arg1::Ptr{Libc.FILE},
+                                            arg2::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_read_triplet(f, Common)
-    @ccall libcholmod.cholmod_read_triplet(f::Ptr{Libc.FILE}, Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_read_triplet(f::Ptr{Libc.FILE},
+                                           Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_l_read_triplet(arg1, arg2)
-    @ccall libcholmod.cholmod_l_read_triplet(arg1::Ptr{Libc.FILE}, arg2::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_l_read_triplet(arg1::Ptr{Libc.FILE},
+                                             arg2::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_read_dense(f, Common)
-    @ccall libcholmod.cholmod_read_dense(f::Ptr{Libc.FILE}, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_read_dense(f::Ptr{Libc.FILE},
+                                         Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_read_dense(arg1, arg2)
-    @ccall libcholmod.cholmod_l_read_dense(arg1::Ptr{Libc.FILE}, arg2::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_read_dense(arg1::Ptr{Libc.FILE},
+                                           arg2::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_read_matrix(f, prefer, mtype, Common)
-    @ccall libcholmod.cholmod_read_matrix(f::Ptr{Libc.FILE}, prefer::Cint, mtype::Ptr{Cint}, Common::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_read_matrix(f::Ptr{Libc.FILE}, prefer::Cint, mtype::Ptr{Cint},
+                                          Common::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_l_read_matrix(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_read_matrix(arg1::Ptr{Libc.FILE}, arg2::Cint, arg3::Ptr{Cint}, arg4::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_l_read_matrix(arg1::Ptr{Libc.FILE}, arg2::Cint,
+                                            arg3::Ptr{Cint},
+                                            arg4::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_write_sparse(f, A, Z, comments, Common)
-    @ccall libcholmod.cholmod_write_sparse(f::Ptr{Libc.FILE}, A::Ptr{cholmod_sparse}, Z::Ptr{cholmod_sparse}, comments::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_write_sparse(f::Ptr{Libc.FILE}, A::Ptr{cholmod_sparse},
+                                           Z::Ptr{cholmod_sparse}, comments::Ptr{Cchar},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_write_sparse(arg1, arg2, arg3, c, arg5)
-    @ccall libcholmod.cholmod_l_write_sparse(arg1::Ptr{Libc.FILE}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_sparse}, c::Ptr{Cchar}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_write_sparse(arg1::Ptr{Libc.FILE},
+                                             arg2::Ptr{cholmod_sparse},
+                                             arg3::Ptr{cholmod_sparse}, c::Ptr{Cchar},
+                                             arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_write_dense(f, X, comments, Common)
-    @ccall libcholmod.cholmod_write_dense(f::Ptr{Libc.FILE}, X::Ptr{cholmod_dense}, comments::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_write_dense(f::Ptr{Libc.FILE}, X::Ptr{cholmod_dense},
+                                          comments::Ptr{Cchar},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_write_dense(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_write_dense(arg1::Ptr{Libc.FILE}, arg2::Ptr{cholmod_dense}, arg3::Ptr{Cchar}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_write_dense(arg1::Ptr{Libc.FILE}, arg2::Ptr{cholmod_dense},
+                                            arg3::Ptr{Cchar},
+                                            arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_analyze(A, Common)
-    @ccall libcholmod.cholmod_analyze(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_analyze(A::Ptr{cholmod_sparse},
+                                      Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_l_analyze(arg1, arg2)
-    @ccall libcholmod.cholmod_l_analyze(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_l_analyze(arg1::Ptr{cholmod_sparse},
+                                        arg2::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_analyze_p(A, UserPerm, fset, fsize, Common)
-    @ccall libcholmod.cholmod_analyze_p(A::Ptr{cholmod_sparse}, UserPerm::Ptr{Int32}, fset::Ptr{Int32}, fsize::Csize_t, Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_analyze_p(A::Ptr{cholmod_sparse}, UserPerm::Ptr{Int32},
+                                        fset::Ptr{Int32}, fsize::Csize_t,
+                                        Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_l_analyze_p(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_analyze_p(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Ptr{Int64}, arg4::Csize_t, arg5::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_l_analyze_p(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                          arg3::Ptr{Int64}, arg4::Csize_t,
+                                          arg5::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_analyze_p2(for_whom, A, UserPerm, fset, fsize, Common)
-    @ccall libcholmod.cholmod_analyze_p2(for_whom::Cint, A::Ptr{cholmod_sparse}, UserPerm::Ptr{Int32}, fset::Ptr{Int32}, fsize::Csize_t, Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_analyze_p2(for_whom::Cint, A::Ptr{cholmod_sparse},
+                                         UserPerm::Ptr{Int32}, fset::Ptr{Int32},
+                                         fsize::Csize_t,
+                                         Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_l_analyze_p2(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_analyze_p2(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Csize_t, arg6::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_l_analyze_p2(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                           arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                           arg5::Csize_t,
+                                           arg6::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_factorize(A, L, Common)
-    @ccall libcholmod.cholmod_factorize(A::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_factorize(A::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor},
+                                        Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_factorize(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_factorize(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_factorize(arg1::Ptr{cholmod_sparse},
+                                          arg2::Ptr{cholmod_factor},
+                                          arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_factorize_p(A, beta, fset, fsize, L, Common)
-    @ccall libcholmod.cholmod_factorize_p(A::Ptr{cholmod_sparse}, beta::Ptr{Cdouble}, fset::Ptr{Int32}, fsize::Csize_t, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_factorize_p(A::Ptr{cholmod_sparse}, beta::Ptr{Cdouble},
+                                          fset::Ptr{Int32}, fsize::Csize_t,
+                                          L::Ptr{cholmod_factor},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_factorize_p(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_factorize_p(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Cdouble}, arg3::Ptr{Int64}, arg4::Csize_t, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_factorize_p(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Cdouble},
+                                            arg3::Ptr{Int64}, arg4::Csize_t,
+                                            arg5::Ptr{cholmod_factor},
+                                            arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_solve(sys, L, B, Common)
-    @ccall libcholmod.cholmod_solve(sys::Cint, L::Ptr{cholmod_factor}, B::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_solve(sys::Cint, L::Ptr{cholmod_factor},
+                                    B::Ptr{cholmod_dense},
+                                    Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_solve(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_solve(arg1::Cint, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_dense}, arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_solve(arg1::Cint, arg2::Ptr{cholmod_factor},
+                                      arg3::Ptr{cholmod_dense},
+                                      arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_solve2(sys, L, B, Bset, X_Handle, Xset_Handle, Y_Handle, E_Handle, Common)
-    @ccall libcholmod.cholmod_solve2(sys::Cint, L::Ptr{cholmod_factor}, B::Ptr{cholmod_dense}, Bset::Ptr{cholmod_sparse}, X_Handle::Ptr{Ptr{cholmod_dense}}, Xset_Handle::Ptr{Ptr{cholmod_sparse}}, Y_Handle::Ptr{Ptr{cholmod_dense}}, E_Handle::Ptr{Ptr{cholmod_dense}}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_solve2(sys::Cint, L::Ptr{cholmod_factor},
+                                     B::Ptr{cholmod_dense}, Bset::Ptr{cholmod_sparse},
+                                     X_Handle::Ptr{Ptr{cholmod_dense}},
+                                     Xset_Handle::Ptr{Ptr{cholmod_sparse}},
+                                     Y_Handle::Ptr{Ptr{cholmod_dense}},
+                                     E_Handle::Ptr{Ptr{cholmod_dense}},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_solve2(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
-    @ccall libcholmod.cholmod_l_solve2(arg1::Cint, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_dense}, arg4::Ptr{cholmod_sparse}, arg5::Ptr{Ptr{cholmod_dense}}, arg6::Ptr{Ptr{cholmod_sparse}}, arg7::Ptr{Ptr{cholmod_dense}}, arg8::Ptr{Ptr{cholmod_dense}}, arg9::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_solve2(arg1::Cint, arg2::Ptr{cholmod_factor},
+                                       arg3::Ptr{cholmod_dense}, arg4::Ptr{cholmod_sparse},
+                                       arg5::Ptr{Ptr{cholmod_dense}},
+                                       arg6::Ptr{Ptr{cholmod_sparse}},
+                                       arg7::Ptr{Ptr{cholmod_dense}},
+                                       arg8::Ptr{Ptr{cholmod_dense}},
+                                       arg9::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_spsolve(sys, L, B, Common)
-    @ccall libcholmod.cholmod_spsolve(sys::Cint, L::Ptr{cholmod_factor}, B::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_spsolve(sys::Cint, L::Ptr{cholmod_factor},
+                                      B::Ptr{cholmod_sparse},
+                                      Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_spsolve(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_spsolve(arg1::Cint, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_sparse}, arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_spsolve(arg1::Cint, arg2::Ptr{cholmod_factor},
+                                        arg3::Ptr{cholmod_sparse},
+                                        arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_etree(A, Parent, Common)
-    @ccall libcholmod.cholmod_etree(A::Ptr{cholmod_sparse}, Parent::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_etree(A::Ptr{cholmod_sparse}, Parent::Ptr{Int32},
+                                    Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_etree(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_etree(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_etree(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                      arg3::Ptr{cholmod_common})::Cint
 end
 
-function cholmod_rowcolcounts(A, fset, fsize, Parent, Post, RowCount, ColCount, First, Level, Common)
-    @ccall libcholmod.cholmod_rowcolcounts(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, Parent::Ptr{Int32}, Post::Ptr{Int32}, RowCount::Ptr{Int32}, ColCount::Ptr{Int32}, First::Ptr{Int32}, Level::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+function cholmod_rowcolcounts(A, fset, fsize, Parent, Post, RowCount, ColCount, First,
+                              Level, Common)
+    @ccall libcholmod.cholmod_rowcolcounts(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                           fsize::Csize_t, Parent::Ptr{Int32},
+                                           Post::Ptr{Int32}, RowCount::Ptr{Int32},
+                                           ColCount::Ptr{Int32}, First::Ptr{Int32},
+                                           Level::Ptr{Int32},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowcolcounts(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)
-    @ccall libcholmod.cholmod_l_rowcolcounts(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{Int64}, arg6::Ptr{Int64}, arg7::Ptr{Int64}, arg8::Ptr{Int64}, arg9::Ptr{Int64}, arg10::Ptr{cholmod_common})::Cint
-end
-
-function cholmod_analyze_ordering(A, ordering, Perm, fset, fsize, Parent, Post, ColCount, First, Level, Common)
-    @ccall libcholmod.cholmod_analyze_ordering(A::Ptr{cholmod_sparse}, ordering::Cint, Perm::Ptr{Int32}, fset::Ptr{Int32}, fsize::Csize_t, Parent::Ptr{Int32}, Post::Ptr{Int32}, ColCount::Ptr{Int32}, First::Ptr{Int32}, Level::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
-end
-
-function cholmod_l_analyze_ordering(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11)
-    @ccall libcholmod.cholmod_l_analyze_ordering(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Csize_t, arg6::Ptr{Int64}, arg7::Ptr{Int64}, arg8::Ptr{Int64}, arg9::Ptr{Int64}, arg10::Ptr{Int64}, arg11::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowcolcounts(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                             arg3::Csize_t, arg4::Ptr{Int64},
+                                             arg5::Ptr{Int64}, arg6::Ptr{Int64},
+                                             arg7::Ptr{Int64}, arg8::Ptr{Int64},
+                                             arg9::Ptr{Int64},
+                                             arg10::Ptr{cholmod_common})::Cint
+end
+
+function cholmod_analyze_ordering(A, ordering, Perm, fset, fsize, Parent, Post, ColCount,
+                                  First, Level, Common)
+    @ccall libcholmod.cholmod_analyze_ordering(A::Ptr{cholmod_sparse}, ordering::Cint,
+                                               Perm::Ptr{Int32}, fset::Ptr{Int32},
+                                               fsize::Csize_t, Parent::Ptr{Int32},
+                                               Post::Ptr{Int32}, ColCount::Ptr{Int32},
+                                               First::Ptr{Int32}, Level::Ptr{Int32},
+                                               Common::Ptr{cholmod_common})::Cint
+end
+
+function cholmod_l_analyze_ordering(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9,
+                                    arg10, arg11)
+    @ccall libcholmod.cholmod_l_analyze_ordering(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                                 arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                                 arg5::Csize_t, arg6::Ptr{Int64},
+                                                 arg7::Ptr{Int64}, arg8::Ptr{Int64},
+                                                 arg9::Ptr{Int64}, arg10::Ptr{Int64},
+                                                 arg11::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_amd(A, fset, fsize, Perm, Common)
-    @ccall libcholmod.cholmod_amd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_amd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t,
+                                  Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_amd(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_amd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_amd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                    arg3::Csize_t, arg4::Ptr{Int64},
+                                    arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_colamd(A, fset, fsize, postorder, Perm, Common)
-    @ccall libcholmod.cholmod_colamd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, postorder::Cint, Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_colamd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                     fsize::Csize_t, postorder::Cint, Perm::Ptr{Int32},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_colamd(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_colamd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Cint, arg5::Ptr{Int64}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_colamd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                       arg3::Csize_t, arg4::Cint, arg5::Ptr{Int64},
+                                       arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowfac(A, F, beta, kstart, kend, L, Common)
-    @ccall libcholmod.cholmod_rowfac(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, beta::Ptr{Cdouble}, kstart::Csize_t, kend::Csize_t, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowfac(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse},
+                                     beta::Ptr{Cdouble}, kstart::Csize_t, kend::Csize_t,
+                                     L::Ptr{cholmod_factor},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowfac(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_rowfac(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Csize_t, arg5::Csize_t, arg6::Ptr{cholmod_factor}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowfac(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse},
+                                       arg3::Ptr{Cdouble}, arg4::Csize_t, arg5::Csize_t,
+                                       arg6::Ptr{cholmod_factor},
+                                       arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowfac_mask(A, F, beta, kstart, kend, mask, RLinkUp, L, Common)
-    @ccall libcholmod.cholmod_rowfac_mask(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, beta::Ptr{Cdouble}, kstart::Csize_t, kend::Csize_t, mask::Ptr{Int32}, RLinkUp::Ptr{Int32}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowfac_mask(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse},
+                                          beta::Ptr{Cdouble}, kstart::Csize_t,
+                                          kend::Csize_t, mask::Ptr{Int32},
+                                          RLinkUp::Ptr{Int32}, L::Ptr{cholmod_factor},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowfac_mask(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
-    @ccall libcholmod.cholmod_l_rowfac_mask(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Csize_t, arg5::Csize_t, arg6::Ptr{Int64}, arg7::Ptr{Int64}, arg8::Ptr{cholmod_factor}, arg9::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowfac_mask(arg1::Ptr{cholmod_sparse},
+                                            arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble},
+                                            arg4::Csize_t, arg5::Csize_t, arg6::Ptr{Int64},
+                                            arg7::Ptr{Int64}, arg8::Ptr{cholmod_factor},
+                                            arg9::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowfac_mask2(A, F, beta, kstart, kend, mask, maskmark, RLinkUp, L, Common)
-    @ccall libcholmod.cholmod_rowfac_mask2(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, beta::Ptr{Cdouble}, kstart::Csize_t, kend::Csize_t, mask::Ptr{Int32}, maskmark::Int32, RLinkUp::Ptr{Int32}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowfac_mask2(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse},
+                                           beta::Ptr{Cdouble}, kstart::Csize_t,
+                                           kend::Csize_t, mask::Ptr{Int32}, maskmark::Int32,
+                                           RLinkUp::Ptr{Int32}, L::Ptr{cholmod_factor},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowfac_mask2(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)
-    @ccall libcholmod.cholmod_l_rowfac_mask2(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Csize_t, arg5::Csize_t, arg6::Ptr{Int64}, arg7::Int64, arg8::Ptr{Int64}, arg9::Ptr{cholmod_factor}, arg10::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowfac_mask2(arg1::Ptr{cholmod_sparse},
+                                             arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble},
+                                             arg4::Csize_t, arg5::Csize_t, arg6::Ptr{Int64},
+                                             arg7::Int64, arg8::Ptr{Int64},
+                                             arg9::Ptr{cholmod_factor},
+                                             arg10::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_row_subtree(A, F, k, Parent, R, Common)
-    @ccall libcholmod.cholmod_row_subtree(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, k::Csize_t, Parent::Ptr{Int32}, R::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_row_subtree(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse},
+                                          k::Csize_t, Parent::Ptr{Int32},
+                                          R::Ptr{cholmod_sparse},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_row_subtree(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_row_subtree(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{cholmod_sparse}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_row_subtree(arg1::Ptr{cholmod_sparse},
+                                            arg2::Ptr{cholmod_sparse}, arg3::Csize_t,
+                                            arg4::Ptr{Int64}, arg5::Ptr{cholmod_sparse},
+                                            arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_lsolve_pattern(B, L, X, Common)
-    @ccall libcholmod.cholmod_lsolve_pattern(B::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_lsolve_pattern(B::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor},
+                                             X::Ptr{cholmod_sparse},
+                                             Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_lsolve_pattern(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_lsolve_pattern(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_sparse}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_lsolve_pattern(arg1::Ptr{cholmod_sparse},
+                                               arg2::Ptr{cholmod_factor},
+                                               arg3::Ptr{cholmod_sparse},
+                                               arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_row_lsubtree(A, Fi, fnz, k, L, R, Common)
-    @ccall libcholmod.cholmod_row_lsubtree(A::Ptr{cholmod_sparse}, Fi::Ptr{Int32}, fnz::Csize_t, k::Csize_t, L::Ptr{cholmod_factor}, R::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_row_lsubtree(A::Ptr{cholmod_sparse}, Fi::Ptr{Int32},
+                                           fnz::Csize_t, k::Csize_t, L::Ptr{cholmod_factor},
+                                           R::Ptr{cholmod_sparse},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_row_lsubtree(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_row_lsubtree(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Csize_t, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_sparse}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_row_lsubtree(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                             arg3::Csize_t, arg4::Csize_t,
+                                             arg5::Ptr{cholmod_factor},
+                                             arg6::Ptr{cholmod_sparse},
+                                             arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_resymbol(A, fset, fsize, pack, L, Common)
-    @ccall libcholmod.cholmod_resymbol(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, pack::Cint, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_resymbol(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                       fsize::Csize_t, pack::Cint, L::Ptr{cholmod_factor},
+                                       Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_resymbol(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_resymbol(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Cint, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_resymbol(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                         arg3::Csize_t, arg4::Cint,
+                                         arg5::Ptr{cholmod_factor},
+                                         arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_resymbol_noperm(A, fset, fsize, pack, L, Common)
-    @ccall libcholmod.cholmod_resymbol_noperm(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, pack::Cint, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_resymbol_noperm(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                              fsize::Csize_t, pack::Cint,
+                                              L::Ptr{cholmod_factor},
+                                              Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_resymbol_noperm(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_resymbol_noperm(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Cint, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_resymbol_noperm(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                                arg3::Csize_t, arg4::Cint,
+                                                arg5::Ptr{cholmod_factor},
+                                                arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rcond(L, Common)
-    @ccall libcholmod.cholmod_rcond(L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cdouble
+    @ccall libcholmod.cholmod_rcond(L::Ptr{cholmod_factor},
+                                    Common::Ptr{cholmod_common})::Cdouble
 end
 
 function cholmod_l_rcond(arg1, arg2)
-    @ccall libcholmod.cholmod_l_rcond(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_common})::Cdouble
+    @ccall libcholmod.cholmod_l_rcond(arg1::Ptr{cholmod_factor},
+                                      arg2::Ptr{cholmod_common})::Cdouble
 end
 
 function cholmod_postorder(Parent, n, Weight_p, Post, Common)
-    @ccall libcholmod.cholmod_postorder(Parent::Ptr{Int32}, n::Csize_t, Weight_p::Ptr{Int32}, Post::Ptr{Int32}, Common::Ptr{cholmod_common})::Int32
+    @ccall libcholmod.cholmod_postorder(Parent::Ptr{Int32}, n::Csize_t,
+                                        Weight_p::Ptr{Int32}, Post::Ptr{Int32},
+                                        Common::Ptr{cholmod_common})::Int32
 end
 
 function cholmod_l_postorder(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_postorder(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_l_postorder(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Ptr{Int64},
+                                          arg4::Ptr{Int64},
+                                          arg5::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_drop(tol, A, Common)
-    @ccall libcholmod.cholmod_drop(tol::Cdouble, A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_drop(tol::Cdouble, A::Ptr{cholmod_sparse},
+                                   Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_drop(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_drop(arg1::Cdouble, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_drop(arg1::Cdouble, arg2::Ptr{cholmod_sparse},
+                                     arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_norm_dense(X, norm, Common)
-    @ccall libcholmod.cholmod_norm_dense(X::Ptr{cholmod_dense}, norm::Cint, Common::Ptr{cholmod_common})::Cdouble
+    @ccall libcholmod.cholmod_norm_dense(X::Ptr{cholmod_dense}, norm::Cint,
+                                         Common::Ptr{cholmod_common})::Cdouble
 end
 
 function cholmod_l_norm_dense(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_norm_dense(arg1::Ptr{cholmod_dense}, arg2::Cint, arg3::Ptr{cholmod_common})::Cdouble
+    @ccall libcholmod.cholmod_l_norm_dense(arg1::Ptr{cholmod_dense}, arg2::Cint,
+                                           arg3::Ptr{cholmod_common})::Cdouble
 end
 
 function cholmod_norm_sparse(A, norm, Common)
-    @ccall libcholmod.cholmod_norm_sparse(A::Ptr{cholmod_sparse}, norm::Cint, Common::Ptr{cholmod_common})::Cdouble
+    @ccall libcholmod.cholmod_norm_sparse(A::Ptr{cholmod_sparse}, norm::Cint,
+                                          Common::Ptr{cholmod_common})::Cdouble
 end
 
 function cholmod_l_norm_sparse(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_norm_sparse(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{cholmod_common})::Cdouble
+    @ccall libcholmod.cholmod_l_norm_sparse(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                            arg3::Ptr{cholmod_common})::Cdouble
 end
 
 function cholmod_horzcat(A, B, values, Common)
-    @ccall libcholmod.cholmod_horzcat(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse}, values::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_horzcat(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse},
+                                      values::Cint,
+                                      Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_horzcat(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_horzcat(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_horzcat(arg1::Ptr{cholmod_sparse},
+                                        arg2::Ptr{cholmod_sparse}, arg3::Cint,
+                                        arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_scale(S, scale, A, Common)
-    @ccall libcholmod.cholmod_scale(S::Ptr{cholmod_dense}, scale::Cint, A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_scale(S::Ptr{cholmod_dense}, scale::Cint,
+                                    A::Ptr{cholmod_sparse},
+                                    Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_scale(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_scale(arg1::Ptr{cholmod_dense}, arg2::Cint, arg3::Ptr{cholmod_sparse}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_scale(arg1::Ptr{cholmod_dense}, arg2::Cint,
+                                      arg3::Ptr{cholmod_sparse},
+                                      arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_sdmult(A, transpose, alpha, beta, X, Y, Common)
-    @ccall libcholmod.cholmod_sdmult(A::Ptr{cholmod_sparse}, transpose::Cint, alpha::Ptr{Cdouble}, beta::Ptr{Cdouble}, X::Ptr{cholmod_dense}, Y::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_sdmult(A::Ptr{cholmod_sparse}, transpose::Cint,
+                                     alpha::Ptr{Cdouble}, beta::Ptr{Cdouble},
+                                     X::Ptr{cholmod_dense}, Y::Ptr{cholmod_dense},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_sdmult(arg1, arg2, arg3, arg4, arg5, Y, arg7)
-    @ccall libcholmod.cholmod_l_sdmult(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{Cdouble}, arg4::Ptr{Cdouble}, arg5::Ptr{cholmod_dense}, Y::Ptr{cholmod_dense}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_sdmult(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                       arg3::Ptr{Cdouble}, arg4::Ptr{Cdouble},
+                                       arg5::Ptr{cholmod_dense}, Y::Ptr{cholmod_dense},
+                                       arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_ssmult(A, B, stype, values, sorted, Common)
-    @ccall libcholmod.cholmod_ssmult(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse}, stype::Cint, values::Cint, sorted::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_ssmult(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse},
+                                     stype::Cint, values::Cint, sorted::Cint,
+                                     Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_ssmult(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_ssmult(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Cint, arg4::Cint, arg5::Cint, arg6::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_ssmult(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse},
+                                       arg3::Cint, arg4::Cint, arg5::Cint,
+                                       arg6::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_submatrix(A, rset, rsize, cset, csize, values, sorted, Common)
-    @ccall libcholmod.cholmod_submatrix(A::Ptr{cholmod_sparse}, rset::Ptr{Int32}, rsize::Int64, cset::Ptr{Int32}, csize::Int64, values::Cint, sorted::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_submatrix(A::Ptr{cholmod_sparse}, rset::Ptr{Int32},
+                                        rsize::Int64, cset::Ptr{Int32}, csize::Int64,
+                                        values::Cint, sorted::Cint,
+                                        Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_submatrix(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
-    @ccall libcholmod.cholmod_l_submatrix(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Int64, arg4::Ptr{Int64}, arg5::Int64, arg6::Cint, arg7::Cint, arg8::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_submatrix(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                          arg3::Int64, arg4::Ptr{Int64}, arg5::Int64,
+                                          arg6::Cint, arg7::Cint,
+                                          arg8::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_vertcat(A, B, values, Common)
-    @ccall libcholmod.cholmod_vertcat(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse}, values::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_vertcat(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse},
+                                      values::Cint,
+                                      Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_vertcat(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_vertcat(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_vertcat(arg1::Ptr{cholmod_sparse},
+                                        arg2::Ptr{cholmod_sparse}, arg3::Cint,
+                                        arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_symmetry(A, option, xmatched, pmatched, nzoffdiag, nzdiag, Common)
-    @ccall libcholmod.cholmod_symmetry(A::Ptr{cholmod_sparse}, option::Cint, xmatched::Ptr{Int32}, pmatched::Ptr{Int32}, nzoffdiag::Ptr{Int32}, nzdiag::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_symmetry(A::Ptr{cholmod_sparse}, option::Cint,
+                                       xmatched::Ptr{Int32}, pmatched::Ptr{Int32},
+                                       nzoffdiag::Ptr{Int32}, nzdiag::Ptr{Int32},
+                                       Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_symmetry(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_symmetry(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Ptr{Int64}, arg6::Ptr{Int64}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_symmetry(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                         arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                         arg5::Ptr{Int64}, arg6::Ptr{Int64},
+                                         arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_updown(update, C, L, Common)
-    @ccall libcholmod.cholmod_updown(update::Cint, C::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_updown(update::Cint, C::Ptr{cholmod_sparse},
+                                     L::Ptr{cholmod_factor},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_updown(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_updown(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_factor}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_updown(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                       arg3::Ptr{cholmod_factor},
+                                       arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_updown_solve(update, C, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_updown_solve(update::Cint, C::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_updown_solve(update::Cint, C::Ptr{cholmod_sparse},
+                                           L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense},
+                                           DeltaB::Ptr{cholmod_dense},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_updown_solve(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_updown_solve(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_factor}, arg4::Ptr{cholmod_dense}, arg5::Ptr{cholmod_dense}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_updown_solve(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                             arg3::Ptr{cholmod_factor},
+                                             arg4::Ptr{cholmod_dense},
+                                             arg5::Ptr{cholmod_dense},
+                                             arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_updown_mark(update, C, colmark, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_updown_mark(update::Cint, C::Ptr{cholmod_sparse}, colmark::Ptr{Int32}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_updown_mark(update::Cint, C::Ptr{cholmod_sparse},
+                                          colmark::Ptr{Int32}, L::Ptr{cholmod_factor},
+                                          X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_updown_mark(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_updown_mark(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Int64}, arg4::Ptr{cholmod_factor}, arg5::Ptr{cholmod_dense}, arg6::Ptr{cholmod_dense}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_updown_mark(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                            arg3::Ptr{Int64}, arg4::Ptr{cholmod_factor},
+                                            arg5::Ptr{cholmod_dense},
+                                            arg6::Ptr{cholmod_dense},
+                                            arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_updown_mask(update, C, colmark, mask, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_updown_mask(update::Cint, C::Ptr{cholmod_sparse}, colmark::Ptr{Int32}, mask::Ptr{Int32}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_updown_mask(update::Cint, C::Ptr{cholmod_sparse},
+                                          colmark::Ptr{Int32}, mask::Ptr{Int32},
+                                          L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense},
+                                          DeltaB::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_updown_mask(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
-    @ccall libcholmod.cholmod_l_updown_mask(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_dense}, arg7::Ptr{cholmod_dense}, arg8::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_updown_mask(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                            arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                            arg5::Ptr{cholmod_factor},
+                                            arg6::Ptr{cholmod_dense},
+                                            arg7::Ptr{cholmod_dense},
+                                            arg8::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_updown_mask2(update, C, colmark, mask, maskmark, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_updown_mask2(update::Cint, C::Ptr{cholmod_sparse}, colmark::Ptr{Int32}, mask::Ptr{Int32}, maskmark::Int32, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_updown_mask2(update::Cint, C::Ptr{cholmod_sparse},
+                                           colmark::Ptr{Int32}, mask::Ptr{Int32},
+                                           maskmark::Int32, L::Ptr{cholmod_factor},
+                                           X::Ptr{cholmod_dense},
+                                           DeltaB::Ptr{cholmod_dense},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_updown_mask2(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
-    @ccall libcholmod.cholmod_l_updown_mask2(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Int64, arg6::Ptr{cholmod_factor}, arg7::Ptr{cholmod_dense}, arg8::Ptr{cholmod_dense}, arg9::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_updown_mask2(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                             arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                             arg5::Int64, arg6::Ptr{cholmod_factor},
+                                             arg7::Ptr{cholmod_dense},
+                                             arg8::Ptr{cholmod_dense},
+                                             arg9::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowadd(k, R, L, Common)
-    @ccall libcholmod.cholmod_rowadd(k::Csize_t, R::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowadd(k::Csize_t, R::Ptr{cholmod_sparse},
+                                     L::Ptr{cholmod_factor},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowadd(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_rowadd(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_factor}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowadd(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                       arg3::Ptr{cholmod_factor},
+                                       arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowadd_solve(k, R, bk, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_rowadd_solve(k::Csize_t, R::Ptr{cholmod_sparse}, bk::Ptr{Cdouble}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowadd_solve(k::Csize_t, R::Ptr{cholmod_sparse},
+                                           bk::Ptr{Cdouble}, L::Ptr{cholmod_factor},
+                                           X::Ptr{cholmod_dense},
+                                           DeltaB::Ptr{cholmod_dense},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowadd_solve(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_rowadd_solve(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Ptr{cholmod_factor}, arg5::Ptr{cholmod_dense}, arg6::Ptr{cholmod_dense}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowadd_solve(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                             arg3::Ptr{Cdouble}, arg4::Ptr{cholmod_factor},
+                                             arg5::Ptr{cholmod_dense},
+                                             arg6::Ptr{cholmod_dense},
+                                             arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowadd_mark(k, R, bk, colmark, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_rowadd_mark(k::Csize_t, R::Ptr{cholmod_sparse}, bk::Ptr{Cdouble}, colmark::Ptr{Int32}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowadd_mark(k::Csize_t, R::Ptr{cholmod_sparse},
+                                          bk::Ptr{Cdouble}, colmark::Ptr{Int32},
+                                          L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense},
+                                          DeltaB::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowadd_mark(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
-    @ccall libcholmod.cholmod_l_rowadd_mark(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Ptr{Int64}, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_dense}, arg7::Ptr{cholmod_dense}, arg8::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowadd_mark(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                            arg3::Ptr{Cdouble}, arg4::Ptr{Int64},
+                                            arg5::Ptr{cholmod_factor},
+                                            arg6::Ptr{cholmod_dense},
+                                            arg7::Ptr{cholmod_dense},
+                                            arg8::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowdel(k, R, L, Common)
-    @ccall libcholmod.cholmod_rowdel(k::Csize_t, R::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowdel(k::Csize_t, R::Ptr{cholmod_sparse},
+                                     L::Ptr{cholmod_factor},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowdel(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_rowdel(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_factor}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowdel(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                       arg3::Ptr{cholmod_factor},
+                                       arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowdel_solve(k, R, yk, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_rowdel_solve(k::Csize_t, R::Ptr{cholmod_sparse}, yk::Ptr{Cdouble}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowdel_solve(k::Csize_t, R::Ptr{cholmod_sparse},
+                                           yk::Ptr{Cdouble}, L::Ptr{cholmod_factor},
+                                           X::Ptr{cholmod_dense},
+                                           DeltaB::Ptr{cholmod_dense},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowdel_solve(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_rowdel_solve(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Ptr{cholmod_factor}, arg5::Ptr{cholmod_dense}, arg6::Ptr{cholmod_dense}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowdel_solve(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                             arg3::Ptr{Cdouble}, arg4::Ptr{cholmod_factor},
+                                             arg5::Ptr{cholmod_dense},
+                                             arg6::Ptr{cholmod_dense},
+                                             arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowdel_mark(k, R, yk, colmark, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_rowdel_mark(k::Csize_t, R::Ptr{cholmod_sparse}, yk::Ptr{Cdouble}, colmark::Ptr{Int32}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowdel_mark(k::Csize_t, R::Ptr{cholmod_sparse},
+                                          yk::Ptr{Cdouble}, colmark::Ptr{Int32},
+                                          L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense},
+                                          DeltaB::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowdel_mark(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
-    @ccall libcholmod.cholmod_l_rowdel_mark(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Ptr{Int64}, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_dense}, arg7::Ptr{cholmod_dense}, arg8::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowdel_mark(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                            arg3::Ptr{Cdouble}, arg4::Ptr{Int64},
+                                            arg5::Ptr{cholmod_factor},
+                                            arg6::Ptr{cholmod_dense},
+                                            arg7::Ptr{cholmod_dense},
+                                            arg8::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_ccolamd(A, fset, fsize, Cmember, Perm, Common)
-    @ccall libcholmod.cholmod_ccolamd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, Cmember::Ptr{Int32}, Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_ccolamd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                      fsize::Csize_t, Cmember::Ptr{Int32}, Perm::Ptr{Int32},
+                                      Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_ccolamd(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_ccolamd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{Int64}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_ccolamd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                        arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{Int64},
+                                        arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_csymamd(A, Cmember, Perm, Common)
-    @ccall libcholmod.cholmod_csymamd(A::Ptr{cholmod_sparse}, Cmember::Ptr{Int32}, Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_csymamd(A::Ptr{cholmod_sparse}, Cmember::Ptr{Int32},
+                                      Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_csymamd(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_csymamd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Ptr{Int64}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_csymamd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                        arg3::Ptr{Int64}, arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_camd(A, fset, fsize, Cmember, Perm, Common)
-    @ccall libcholmod.cholmod_camd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, Cmember::Ptr{Int32}, Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_camd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t,
+                                   Cmember::Ptr{Int32}, Perm::Ptr{Int32},
+                                   Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_camd(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_camd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{Int64}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_camd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                     arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{Int64},
+                                     arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_nested_dissection(A, fset, fsize, Perm, CParent, Cmember, Common)
-    @ccall libcholmod.cholmod_nested_dissection(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, Perm::Ptr{Int32}, CParent::Ptr{Int32}, Cmember::Ptr{Int32}, Common::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_nested_dissection(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                                fsize::Csize_t, Perm::Ptr{Int32},
+                                                CParent::Ptr{Int32}, Cmember::Ptr{Int32},
+                                                Common::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_l_nested_dissection(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_nested_dissection(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{Int64}, arg6::Ptr{Int64}, arg7::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_l_nested_dissection(arg1::Ptr{cholmod_sparse},
+                                                  arg2::Ptr{Int64}, arg3::Csize_t,
+                                                  arg4::Ptr{Int64}, arg5::Ptr{Int64},
+                                                  arg6::Ptr{Int64},
+                                                  arg7::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_metis(A, fset, fsize, postorder, Perm, Common)
-    @ccall libcholmod.cholmod_metis(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, postorder::Cint, Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_metis(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                    fsize::Csize_t, postorder::Cint, Perm::Ptr{Int32},
+                                    Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_metis(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_metis(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Cint, arg5::Ptr{Int64}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_metis(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                      arg3::Csize_t, arg4::Cint, arg5::Ptr{Int64},
+                                      arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_bisect(A, fset, fsize, compress, Partition, Common)
-    @ccall libcholmod.cholmod_bisect(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, compress::Cint, Partition::Ptr{Int32}, Common::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_bisect(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                     fsize::Csize_t, compress::Cint, Partition::Ptr{Int32},
+                                     Common::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_l_bisect(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_bisect(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Cint, arg5::Ptr{Int64}, arg6::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_l_bisect(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                       arg3::Csize_t, arg4::Cint, arg5::Ptr{Int64},
+                                       arg6::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_metis_bisector(A, Anw, Aew, Partition, Common)
-    @ccall libcholmod.cholmod_metis_bisector(A::Ptr{cholmod_sparse}, Anw::Ptr{Int32}, Aew::Ptr{Int32}, Partition::Ptr{Int32}, Common::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_metis_bisector(A::Ptr{cholmod_sparse}, Anw::Ptr{Int32},
+                                             Aew::Ptr{Int32}, Partition::Ptr{Int32},
+                                             Common::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_l_metis_bisector(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_metis_bisector(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_l_metis_bisector(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                               arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                               arg5::Ptr{cholmod_common})::Int64
 end
 
-function cholmod_collapse_septree(n, ncomponents, nd_oksep, nd_small, CParent, Cmember, Common)
-    @ccall libcholmod.cholmod_collapse_septree(n::Csize_t, ncomponents::Csize_t, nd_oksep::Cdouble, nd_small::Csize_t, CParent::Ptr{Int32}, Cmember::Ptr{Int32}, Common::Ptr{cholmod_common})::Int64
+function cholmod_collapse_septree(n, ncomponents, nd_oksep, nd_small, CParent, Cmember,
+                                  Common)
+    @ccall libcholmod.cholmod_collapse_septree(n::Csize_t, ncomponents::Csize_t,
+                                               nd_oksep::Cdouble, nd_small::Csize_t,
+                                               CParent::Ptr{Int32}, Cmember::Ptr{Int32},
+                                               Common::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_l_collapse_septree(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_collapse_septree(arg1::Csize_t, arg2::Csize_t, arg3::Cdouble, arg4::Csize_t, arg5::Ptr{Int64}, arg6::Ptr{Int64}, arg7::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_l_collapse_septree(arg1::Csize_t, arg2::Csize_t,
+                                                 arg3::Cdouble, arg4::Csize_t,
+                                                 arg5::Ptr{Int64}, arg6::Ptr{Int64},
+                                                 arg7::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_super_symbolic(A, F, Parent, L, Common)
-    @ccall libcholmod.cholmod_super_symbolic(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, Parent::Ptr{Int32}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_super_symbolic(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse},
+                                             Parent::Ptr{Int32}, L::Ptr{cholmod_factor},
+                                             Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_super_symbolic(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_super_symbolic(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Int64}, arg4::Ptr{cholmod_factor}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_super_symbolic(arg1::Ptr{cholmod_sparse},
+                                               arg2::Ptr{cholmod_sparse}, arg3::Ptr{Int64},
+                                               arg4::Ptr{cholmod_factor},
+                                               arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_super_symbolic2(for_whom, A, F, Parent, L, Common)
-    @ccall libcholmod.cholmod_super_symbolic2(for_whom::Cint, A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, Parent::Ptr{Int32}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_super_symbolic2(for_whom::Cint, A::Ptr{cholmod_sparse},
+                                              F::Ptr{cholmod_sparse}, Parent::Ptr{Int32},
+                                              L::Ptr{cholmod_factor},
+                                              Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_super_symbolic2(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_super_symbolic2(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_sparse}, arg4::Ptr{Int64}, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_super_symbolic2(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                                arg3::Ptr{cholmod_sparse}, arg4::Ptr{Int64},
+                                                arg5::Ptr{cholmod_factor},
+                                                arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_super_numeric(A, F, beta, L, Common)
-    @ccall libcholmod.cholmod_super_numeric(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, beta::Ptr{Cdouble}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_super_numeric(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse},
+                                            beta::Ptr{Cdouble}, L::Ptr{cholmod_factor},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_super_numeric(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_super_numeric(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Ptr{cholmod_factor}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_super_numeric(arg1::Ptr{cholmod_sparse},
+                                              arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble},
+                                              arg4::Ptr{cholmod_factor},
+                                              arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_super_lsolve(L, X, E, Common)
-    @ccall libcholmod.cholmod_super_lsolve(L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, E::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_super_lsolve(L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense},
+                                           E::Ptr{cholmod_dense},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_super_lsolve(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_super_lsolve(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_dense}, arg3::Ptr{cholmod_dense}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_super_lsolve(arg1::Ptr{cholmod_factor},
+                                             arg2::Ptr{cholmod_dense},
+                                             arg3::Ptr{cholmod_dense},
+                                             arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_super_ltsolve(L, X, E, Common)
-    @ccall libcholmod.cholmod_super_ltsolve(L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, E::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_super_ltsolve(L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense},
+                                            E::Ptr{cholmod_dense},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_super_ltsolve(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_super_ltsolve(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_dense}, arg3::Ptr{cholmod_dense}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_super_ltsolve(arg1::Ptr{cholmod_factor},
+                                              arg2::Ptr{cholmod_dense},
+                                              arg3::Ptr{cholmod_dense},
+                                              arg4::Ptr{cholmod_common})::Cint
+end
+
+function SuiteSparseQR_C(ordering, tol, econ, getCTX, A, Bsparse, Bdense, Zsparse, Zdense,
+                         R, E, H, HPinv, HTau, cc)
+    @ccall libspqr.SuiteSparseQR_C(ordering::Cint, tol::Cdouble, econ::Int64, getCTX::Cint,
+                                   A::Ptr{cholmod_sparse}, Bsparse::Ptr{cholmod_sparse},
+                                   Bdense::Ptr{cholmod_dense},
+                                   Zsparse::Ptr{Ptr{cholmod_sparse}},
+                                   Zdense::Ptr{Ptr{cholmod_dense}},
+                                   R::Ptr{Ptr{cholmod_sparse}}, E::Ptr{Ptr{Int64}},
+                                   H::Ptr{Ptr{cholmod_sparse}}, HPinv::Ptr{Ptr{Int64}},
+                                   HTau::Ptr{Ptr{cholmod_dense}},
+                                   cc::Ptr{cholmod_common})::Int64
+end
+
+function SuiteSparseQR_i_C(ordering, tol, econ, getCTX, A, Bsparse, Bdense, Zsparse, Zdense,
+                           R, E, H, HPinv, HTau, cc)
+    @ccall libspqr.SuiteSparseQR_i_C(ordering::Cint, tol::Cdouble, econ::Int32,
+                                     getCTX::Cint, A::Ptr{cholmod_sparse},
+                                     Bsparse::Ptr{cholmod_sparse},
+                                     Bdense::Ptr{cholmod_dense},
+                                     Zsparse::Ptr{Ptr{cholmod_sparse}},
+                                     Zdense::Ptr{Ptr{cholmod_dense}},
+                                     R::Ptr{Ptr{cholmod_sparse}}, E::Ptr{Ptr{Int32}},
+                                     H::Ptr{Ptr{cholmod_sparse}}, HPinv::Ptr{Ptr{Int32}},
+                                     HTau::Ptr{Ptr{cholmod_dense}},
+                                     cc::Ptr{cholmod_common})::Int32
 end
 
-function SuiteSparseQR_C(ordering, tol, econ, getCTX, A, Bsparse, Bdense, Zsparse, Zdense, R, E, H, HPinv, HTau, cc)
-    @ccall libspqr.SuiteSparseQR_C(ordering::Cint, tol::Cdouble, econ::Int64, getCTX::Cint, A::Ptr{cholmod_sparse}, Bsparse::Ptr{cholmod_sparse}, Bdense::Ptr{cholmod_dense}, Zsparse::Ptr{Ptr{cholmod_sparse}}, Zdense::Ptr{Ptr{cholmod_dense}}, R::Ptr{Ptr{cholmod_sparse}}, E::Ptr{Ptr{Int64}}, H::Ptr{Ptr{cholmod_sparse}}, HPinv::Ptr{Ptr{Int64}}, HTau::Ptr{Ptr{cholmod_dense}}, cc::Ptr{cholmod_common})::Int64
+function SuiteSparseQR_C_QR(ordering, tol, econ, A, Q, R, E, cc)
+    @ccall libspqr.SuiteSparseQR_C_QR(ordering::Cint, tol::Cdouble, econ::Int64,
+                                      A::Ptr{cholmod_sparse}, Q::Ptr{Ptr{cholmod_sparse}},
+                                      R::Ptr{Ptr{cholmod_sparse}}, E::Ptr{Ptr{Int64}},
+                                      cc::Ptr{cholmod_common})::Int64
 end
 
-function SuiteSparseQR_C_QR(ordering, tol, econ, A, Q, R, E, cc)
-    @ccall libspqr.SuiteSparseQR_C_QR(ordering::Cint, tol::Cdouble, econ::Int64, A::Ptr{cholmod_sparse}, Q::Ptr{Ptr{cholmod_sparse}}, R::Ptr{Ptr{cholmod_sparse}}, E::Ptr{Ptr{Int64}}, cc::Ptr{cholmod_common})::Int64
+function SuiteSparseQR_i_C_QR(ordering, tol, econ, A, Q, R, E, cc)
+    @ccall libspqr.SuiteSparseQR_i_C_QR(ordering::Cint, tol::Cdouble, econ::Int32,
+                                        A::Ptr{cholmod_sparse}, Q::Ptr{Ptr{cholmod_sparse}},
+                                        R::Ptr{Ptr{cholmod_sparse}}, E::Ptr{Ptr{Int32}},
+                                        cc::Ptr{cholmod_common})::Int32
 end
 
 function SuiteSparseQR_C_backslash(ordering, tol, A, B, cc)
-    @ccall libspqr.SuiteSparseQR_C_backslash(ordering::Cint, tol::Cdouble, A::Ptr{cholmod_sparse}, B::Ptr{cholmod_dense}, cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libspqr.SuiteSparseQR_C_backslash(ordering::Cint, tol::Cdouble,
+                                             A::Ptr{cholmod_sparse}, B::Ptr{cholmod_dense},
+                                             cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function SuiteSparseQR_C_backslash_default(A, B, cc)
-    @ccall libspqr.SuiteSparseQR_C_backslash_default(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_dense}, cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libspqr.SuiteSparseQR_C_backslash_default(A::Ptr{cholmod_sparse},
+                                                     B::Ptr{cholmod_dense},
+                                                     cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function SuiteSparseQR_C_backslash_sparse(ordering, tol, A, B, cc)
-    @ccall libspqr.SuiteSparseQR_C_backslash_sparse(ordering::Cint, tol::Cdouble, A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse}, cc::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libspqr.SuiteSparseQR_C_backslash_sparse(ordering::Cint, tol::Cdouble,
+                                                    A::Ptr{cholmod_sparse},
+                                                    B::Ptr{cholmod_sparse},
+                                                    cc::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 mutable struct SuiteSparseQR_C_factorization_struct
     xtype::Cint
+    itype::Cint
     factors::Ptr{Cvoid}
     SuiteSparseQR_C_factorization_struct() = new()
 end
@@ -1536,51 +2115,78 @@ end
 const SuiteSparseQR_C_factorization = SuiteSparseQR_C_factorization_struct
 
 function SuiteSparseQR_C_factorize(ordering, tol, A, cc)
-    @ccall libspqr.SuiteSparseQR_C_factorize(ordering::Cint, tol::Cdouble, A::Ptr{cholmod_sparse}, cc::Ptr{cholmod_common})::Ptr{SuiteSparseQR_C_factorization}
+    @ccall libspqr.SuiteSparseQR_C_factorize(ordering::Cint, tol::Cdouble,
+                                             A::Ptr{cholmod_sparse},
+                                             cc::Ptr{cholmod_common})::Ptr{SuiteSparseQR_C_factorization}
 end
 
 function SuiteSparseQR_C_symbolic(ordering, allow_tol, A, cc)
-    @ccall libspqr.SuiteSparseQR_C_symbolic(ordering::Cint, allow_tol::Cint, A::Ptr{cholmod_sparse}, cc::Ptr{cholmod_common})::Ptr{SuiteSparseQR_C_factorization}
+    @ccall libspqr.SuiteSparseQR_C_symbolic(ordering::Cint, allow_tol::Cint,
+                                            A::Ptr{cholmod_sparse},
+                                            cc::Ptr{cholmod_common})::Ptr{SuiteSparseQR_C_factorization}
 end
 
 function SuiteSparseQR_C_numeric(tol, A, QR, cc)
-    @ccall libspqr.SuiteSparseQR_C_numeric(tol::Cdouble, A::Ptr{cholmod_sparse}, QR::Ptr{SuiteSparseQR_C_factorization}, cc::Ptr{cholmod_common})::Cint
+    @ccall libspqr.SuiteSparseQR_C_numeric(tol::Cdouble, A::Ptr{cholmod_sparse},
+                                           QR::Ptr{SuiteSparseQR_C_factorization},
+                                           cc::Ptr{cholmod_common})::Cint
 end
 
 function SuiteSparseQR_C_free(QR, cc)
-    @ccall libspqr.SuiteSparseQR_C_free(QR::Ptr{Ptr{SuiteSparseQR_C_factorization}}, cc::Ptr{cholmod_common})::Cint
+    @ccall libspqr.SuiteSparseQR_C_free(QR::Ptr{Ptr{SuiteSparseQR_C_factorization}},
+                                        cc::Ptr{cholmod_common})::Cint
 end
 
 function SuiteSparseQR_C_solve(system, QR, B, cc)
-    @ccall libspqr.SuiteSparseQR_C_solve(system::Cint, QR::Ptr{SuiteSparseQR_C_factorization}, B::Ptr{cholmod_dense}, cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libspqr.SuiteSparseQR_C_solve(system::Cint,
+                                         QR::Ptr{SuiteSparseQR_C_factorization},
+                                         B::Ptr{cholmod_dense},
+                                         cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function SuiteSparseQR_C_qmult(method, QR, X, cc)
-    @ccall libspqr.SuiteSparseQR_C_qmult(method::Cint, QR::Ptr{SuiteSparseQR_C_factorization}, X::Ptr{cholmod_dense}, cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libspqr.SuiteSparseQR_C_qmult(method::Cint,
+                                         QR::Ptr{SuiteSparseQR_C_factorization},
+                                         X::Ptr{cholmod_dense},
+                                         cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function amd_order(n, Ap, Ai, P, Control, Info)
-    @ccall libamd.amd_order(n::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, P::Ptr{Int32}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libamd.amd_order(n::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, P::Ptr{Int32},
+                            Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function amd_l_order(n, Ap, Ai, P, Control, Info)
-    @ccall libamd.amd_l_order(n::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, P::Ptr{Int64}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libamd.amd_l_order(n::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, P::Ptr{Int64},
+                              Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
-function amd_2(n, Pe, Iw, Len, iwlen, pfree, Nv, Next, Last, Head, Elen, Degree, W, Control, Info)
-    @ccall libamd.amd_2(n::Int32, Pe::Ptr{Int32}, Iw::Ptr{Int32}, Len::Ptr{Int32}, iwlen::Int32, pfree::Int32, Nv::Ptr{Int32}, Next::Ptr{Int32}, Last::Ptr{Int32}, Head::Ptr{Int32}, Elen::Ptr{Int32}, Degree::Ptr{Int32}, W::Ptr{Int32}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cvoid
+function amd_2(n, Pe, Iw, Len, iwlen, pfree, Nv, Next, Last, Head, Elen, Degree, W, Control,
+               Info)
+    @ccall libamd.amd_2(n::Int32, Pe::Ptr{Int32}, Iw::Ptr{Int32}, Len::Ptr{Int32},
+                        iwlen::Int32, pfree::Int32, Nv::Ptr{Int32}, Next::Ptr{Int32},
+                        Last::Ptr{Int32}, Head::Ptr{Int32}, Elen::Ptr{Int32},
+                        Degree::Ptr{Int32}, W::Ptr{Int32}, Control::Ptr{Cdouble},
+                        Info::Ptr{Cdouble})::Cvoid
 end
 
-function amd_l2(n, Pe, Iw, Len, iwlen, pfree, Nv, Next, Last, Head, Elen, Degree, W, Control, Info)
-    @ccall libamd.amd_l2(n::Int64, Pe::Ptr{Int64}, Iw::Ptr{Int64}, Len::Ptr{Int64}, iwlen::Int64, pfree::Int64, Nv::Ptr{Int64}, Next::Ptr{Int64}, Last::Ptr{Int64}, Head::Ptr{Int64}, Elen::Ptr{Int64}, Degree::Ptr{Int64}, W::Ptr{Int64}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cvoid
+function amd_l2(n, Pe, Iw, Len, iwlen, pfree, Nv, Next, Last, Head, Elen, Degree, W,
+                Control, Info)
+    @ccall libamd.amd_l2(n::Int64, Pe::Ptr{Int64}, Iw::Ptr{Int64}, Len::Ptr{Int64},
+                         iwlen::Int64, pfree::Int64, Nv::Ptr{Int64}, Next::Ptr{Int64},
+                         Last::Ptr{Int64}, Head::Ptr{Int64}, Elen::Ptr{Int64},
+                         Degree::Ptr{Int64}, W::Ptr{Int64}, Control::Ptr{Cdouble},
+                         Info::Ptr{Cdouble})::Cvoid
 end
 
 function amd_valid(n_row, n_col, Ap, Ai)
-    @ccall libamd.amd_valid(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32})::Cint
+    @ccall libamd.amd_valid(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                            Ai::Ptr{Int32})::Cint
 end
 
 function amd_l_valid(n_row, n_col, Ap, Ai)
-    @ccall libamd.amd_l_valid(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64})::Cint
+    @ccall libamd.amd_l_valid(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                              Ai::Ptr{Int64})::Cint
 end
 
 function amd_defaults(Control)
@@ -1607,188 +2213,88 @@ function amd_l_info(Info)
     @ccall libamd.amd_l_info(Info::Ptr{Cdouble})::Cvoid
 end
 
-function colamd_recommended(nnz, n_row, n_col)
-    @ccall libcolamd.colamd_recommended(nnz::Int32, n_row::Int32, n_col::Int32)::Csize_t
-end
-
-function colamd_l_recommended(nnz, n_row, n_col)
-    @ccall libcolamd.colamd_l_recommended(nnz::Int64, n_row::Int64, n_col::Int64)::Csize_t
-end
-
-function colamd_set_defaults(knobs)
-    @ccall libcolamd.colamd_set_defaults(knobs::Ptr{Cdouble})::Cvoid
-end
-
-function colamd_l_set_defaults(knobs)
-    @ccall libcolamd.colamd_l_set_defaults(knobs::Ptr{Cdouble})::Cvoid
-end
-
-function colamd(n_row, n_col, Alen, A, p, knobs, stats)
-    @ccall libcolamd.colamd(n_row::Int32, n_col::Int32, Alen::Int32, A::Ptr{Int32}, p::Ptr{Int32}, knobs::Ptr{Cdouble}, stats::Ptr{Int32})::Cint
-end
-
-function colamd_l(n_row, n_col, Alen, A, p, knobs, stats)
-    @ccall libcolamd.colamd_l(n_row::Int64, n_col::Int64, Alen::Int64, A::Ptr{Int64}, p::Ptr{Int64}, knobs::Ptr{Cdouble}, stats::Ptr{Int64})::Cint
-end
-
-function symamd(n, A, p, perm, knobs, stats, allocate, release)
-    @ccall libcolamd.symamd(n::Int32, A::Ptr{Int32}, p::Ptr{Int32}, perm::Ptr{Int32}, knobs::Ptr{Cdouble}, stats::Ptr{Int32}, allocate::Ptr{Cvoid}, release::Ptr{Cvoid})::Cint
-end
-
-function symamd_l(n, A, p, perm, knobs, stats, allocate, release)
-    @ccall libcolamd.symamd_l(n::Int64, A::Ptr{Int64}, p::Ptr{Int64}, perm::Ptr{Int64}, knobs::Ptr{Cdouble}, stats::Ptr{Int64}, allocate::Ptr{Cvoid}, release::Ptr{Cvoid})::Cint
-end
-
-function colamd_report(stats)
-    @ccall libcolamd.colamd_report(stats::Ptr{Int32})::Cvoid
-end
-
-function colamd_l_report(stats)
-    @ccall libcolamd.colamd_l_report(stats::Ptr{Int64})::Cvoid
-end
-
-function symamd_report(stats)
-    @ccall libcolamd.symamd_report(stats::Ptr{Int32})::Cvoid
-end
-
-function symamd_l_report(stats)
-    @ccall libcolamd.symamd_l_report(stats::Ptr{Int64})::Cvoid
-end
-
-function ccolamd_recommended(nnz, n_row, n_col)
-    @ccall libcolamd.ccolamd_recommended(nnz::Cint, n_row::Cint, n_col::Cint)::Csize_t
-end
-
-function ccolamd_l_recommended(nnz, n_row, n_col)
-    @ccall libcolamd.ccolamd_l_recommended(nnz::Int64, n_row::Int64, n_col::Int64)::Csize_t
-end
-
-function ccolamd_set_defaults(knobs)
-    @ccall libcolamd.ccolamd_set_defaults(knobs::Ptr{Cdouble})::Cvoid
-end
-
-function ccolamd_l_set_defaults(knobs)
-    @ccall libcolamd.ccolamd_l_set_defaults(knobs::Ptr{Cdouble})::Cvoid
-end
-
-function ccolamd(n_row, n_col, Alen, A, p, knobs, stats, cmember)
-    @ccall libcolamd.ccolamd(n_row::Cint, n_col::Cint, Alen::Cint, A::Ptr{Cint}, p::Ptr{Cint}, knobs::Ptr{Cdouble}, stats::Ptr{Cint}, cmember::Ptr{Cint})::Cint
-end
-
-function ccolamd_l(n_row, n_col, Alen, A, p, knobs, stats, cmember)
-    @ccall libcolamd.ccolamd_l(n_row::Int64, n_col::Int64, Alen::Int64, A::Ptr{Int64}, p::Ptr{Int64}, knobs::Ptr{Cdouble}, stats::Ptr{Int64}, cmember::Ptr{Int64})::Cint
-end
-
-function csymamd(n, A, p, perm, knobs, stats, allocate, release, cmember, stype)
-    @ccall libcolamd.csymamd(n::Cint, A::Ptr{Cint}, p::Ptr{Cint}, perm::Ptr{Cint}, knobs::Ptr{Cdouble}, stats::Ptr{Cint}, allocate::Ptr{Cvoid}, release::Ptr{Cvoid}, cmember::Ptr{Cint}, stype::Cint)::Cint
-end
-
-function csymamd_l(n, A, p, perm, knobs, stats, allocate, release, cmember, stype)
-    @ccall libcolamd.csymamd_l(n::Int64, A::Ptr{Int64}, p::Ptr{Int64}, perm::Ptr{Int64}, knobs::Ptr{Cdouble}, stats::Ptr{Int64}, allocate::Ptr{Cvoid}, release::Ptr{Cvoid}, cmember::Ptr{Int64}, stype::Int64)::Cint
-end
-
-function ccolamd_report(stats)
-    @ccall libcolamd.ccolamd_report(stats::Ptr{Cint})::Cvoid
-end
-
-function ccolamd_l_report(stats)
-    @ccall libcolamd.ccolamd_l_report(stats::Ptr{Int64})::Cvoid
-end
-
-function csymamd_report(stats)
-    @ccall libcolamd.csymamd_report(stats::Ptr{Cint})::Cvoid
-end
-
-function csymamd_l_report(stats)
-    @ccall libcolamd.csymamd_l_report(stats::Ptr{Int64})::Cvoid
-end
-
-function ccolamd2(n_row, n_col, Alen, A, p, knobs, stats, Front_npivcol, Front_nrows, Front_ncols, Front_parent, Front_cols, p_nfr, InFront, cmember)
-    @ccall libcolamd.ccolamd2(n_row::Cint, n_col::Cint, Alen::Cint, A::Ptr{Cint}, p::Ptr{Cint}, knobs::Ptr{Cdouble}, stats::Ptr{Cint}, Front_npivcol::Ptr{Cint}, Front_nrows::Ptr{Cint}, Front_ncols::Ptr{Cint}, Front_parent::Ptr{Cint}, Front_cols::Ptr{Cint}, p_nfr::Ptr{Cint}, InFront::Ptr{Cint}, cmember::Ptr{Cint})::Cint
-end
-
-function ccolamd2_l(n_row, n_col, Alen, A, p, knobs, stats, Front_npivcol, Front_nrows, Front_ncols, Front_parent, Front_cols, p_nfr, InFront, cmember)
-    @ccall libcolamd.ccolamd2_l(n_row::Int64, n_col::Int64, Alen::Int64, A::Ptr{Int64}, p::Ptr{Int64}, knobs::Ptr{Cdouble}, stats::Ptr{Int64}, Front_npivcol::Ptr{Int64}, Front_nrows::Ptr{Int64}, Front_ncols::Ptr{Int64}, Front_parent::Ptr{Int64}, Front_cols::Ptr{Int64}, p_nfr::Ptr{Int64}, InFront::Ptr{Int64}, cmember::Ptr{Int64})::Cint
-end
-
-function ccolamd_apply_order(Front, Order, Temp, nn, nfr)
-    @ccall libcolamd.ccolamd_apply_order(Front::Ptr{Cint}, Order::Ptr{Cint}, Temp::Ptr{Cint}, nn::Cint, nfr::Cint)::Cvoid
-end
-
-function ccolamd_l_apply_order(Front, Order, Temp, nn, nfr)
-    @ccall libcolamd.ccolamd_l_apply_order(Front::Ptr{Int64}, Order::Ptr{Int64}, Temp::Ptr{Int64}, nn::Int64, nfr::Int64)::Cvoid
-end
-
-function ccolamd_fsize(nn, MaxFsize, Fnrows, Fncols, Parent, Npiv)
-    @ccall libcolamd.ccolamd_fsize(nn::Cint, MaxFsize::Ptr{Cint}, Fnrows::Ptr{Cint}, Fncols::Ptr{Cint}, Parent::Ptr{Cint}, Npiv::Ptr{Cint})::Cvoid
-end
-
-function ccolamd_l_fsize(nn, MaxFsize, Fnrows, Fncols, Parent, Npiv)
-    @ccall libcolamd.ccolamd_l_fsize(nn::Int64, MaxFsize::Ptr{Int64}, Fnrows::Ptr{Int64}, Fncols::Ptr{Int64}, Parent::Ptr{Int64}, Npiv::Ptr{Int64})::Cvoid
-end
-
-function ccolamd_postorder(nn, Parent, Npiv, Fsize, Order, Child, Sibling, Stack, Front_cols, cmember)
-    @ccall libcolamd.ccolamd_postorder(nn::Cint, Parent::Ptr{Cint}, Npiv::Ptr{Cint}, Fsize::Ptr{Cint}, Order::Ptr{Cint}, Child::Ptr{Cint}, Sibling::Ptr{Cint}, Stack::Ptr{Cint}, Front_cols::Ptr{Cint}, cmember::Ptr{Cint})::Cvoid
-end
-
-function ccolamd_l_postorder(nn, Parent, Npiv, Fsize, Order, Child, Sibling, Stack, Front_cols, cmember)
-    @ccall libcolamd.ccolamd_l_postorder(nn::Int64, Parent::Ptr{Int64}, Npiv::Ptr{Int64}, Fsize::Ptr{Int64}, Order::Ptr{Int64}, Child::Ptr{Int64}, Sibling::Ptr{Int64}, Stack::Ptr{Int64}, Front_cols::Ptr{Int64}, cmember::Ptr{Int64})::Cvoid
-end
-
-function ccolamd_post_tree(root, k, Child, Sibling, Order, Stack)
-    @ccall libcolamd.ccolamd_post_tree(root::Cint, k::Cint, Child::Ptr{Cint}, Sibling::Ptr{Cint}, Order::Ptr{Cint}, Stack::Ptr{Cint})::Cint
-end
-
-function ccolamd_l_post_tree(root, k, Child, Sibling, Order, Stack)
-    @ccall libcolamd.ccolamd_l_post_tree(root::Int64, k::Int64, Child::Ptr{Int64}, Sibling::Ptr{Int64}, Order::Ptr{Int64}, Stack::Ptr{Int64})::Int64
-end
-
 function umfpack_di_symbolic(n_row, n_col, Ap, Ai, Ax, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_di_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                          Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                          Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                          Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_symbolic(n_row, n_col, Ap, Ai, Ax, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_dl_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                          Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                          Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                          Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_symbolic(n_row, n_col, Ap, Ai, Ax, Az, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_zi_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                          Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                          Az::Ptr{Cdouble}, Symbolic::Ptr{Ptr{Cvoid}},
+                                          Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_symbolic(n_row, n_col, Ap, Ai, Ax, Az, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_zl_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                          Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                          Az::Ptr{Cdouble}, Symbolic::Ptr{Ptr{Cvoid}},
+                                          Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_numeric(Ap, Ai, Ax, Symbolic, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_di_numeric(Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Symbolic::Ptr{Cvoid}, Numeric::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_numeric(Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                         Symbolic::Ptr{Cvoid}, Numeric::Ptr{Ptr{Cvoid}},
+                                         Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_numeric(Ap, Ai, Ax, Symbolic, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_dl_numeric(Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Symbolic::Ptr{Cvoid}, Numeric::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_numeric(Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                         Symbolic::Ptr{Cvoid}, Numeric::Ptr{Ptr{Cvoid}},
+                                         Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_numeric(Ap, Ai, Ax, Az, Symbolic, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_zi_numeric(Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Symbolic::Ptr{Cvoid}, Numeric::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_numeric(Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                         Az::Ptr{Cdouble}, Symbolic::Ptr{Cvoid},
+                                         Numeric::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                         Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_numeric(Ap, Ai, Ax, Az, Symbolic, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_zl_numeric(Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Symbolic::Ptr{Cvoid}, Numeric::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_numeric(Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                         Az::Ptr{Cdouble}, Symbolic::Ptr{Cvoid},
+                                         Numeric::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                         Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_solve(sys, Ap, Ai, Ax, X, B, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_di_solve(sys::Cint, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_solve(sys::Cint, Ap::Ptr{Int32}, Ai::Ptr{Int32},
+                                       Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble},
+                                       Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                       Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_solve(sys, Ap, Ai, Ax, X, B, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_dl_solve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_solve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64},
+                                       Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble},
+                                       Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                       Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_solve(sys, Ap, Ai, Ax, Az, Xx, Xz, Bx, Bz, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_zi_solve(sys::Cint, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_solve(sys::Cint, Ap::Ptr{Int32}, Ai::Ptr{Int32},
+                                       Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Xx::Ptr{Cdouble},
+                                       Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble},
+                                       Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                       Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_solve(sys, Ap, Ai, Ax, Az, Xx, Xz, Bx, Bz, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_zl_solve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_solve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64},
+                                       Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Xx::Ptr{Cdouble},
+                                       Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble},
+                                       Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                       Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_free_symbolic(Symbolic)
@@ -1840,51 +2346,119 @@ function umfpack_zl_defaults(Control)
 end
 
 function umfpack_di_qsymbolic(n_row, n_col, Ap, Ai, Ax, Qinit, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_di_qsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Qinit::Ptr{Int32}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_qsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                           Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                           Qinit::Ptr{Int32}, Symbolic::Ptr{Ptr{Cvoid}},
+                                           Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_qsymbolic(n_row, n_col, Ap, Ai, Ax, Qinit, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_dl_qsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Qinit::Ptr{Int64}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_qsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                           Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                           Qinit::Ptr{Int64}, Symbolic::Ptr{Ptr{Cvoid}},
+                                           Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_qsymbolic(n_row, n_col, Ap, Ai, Ax, Az, Qinit, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_zi_qsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Qinit::Ptr{Int32}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_qsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                           Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                           Az::Ptr{Cdouble}, Qinit::Ptr{Int32},
+                                           Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                           Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_qsymbolic(n_row, n_col, Ap, Ai, Ax, Az, Qinit, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_zl_qsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Qinit::Ptr{Int64}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_di_fsymbolic(n_row, n_col, Ap, Ai, Ax, user_ordering, user_params, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_di_fsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_dl_fsymbolic(n_row, n_col, Ap, Ai, Ax, user_ordering, user_params, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_dl_fsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_zi_fsymbolic(n_row, n_col, Ap, Ai, Ax, Az, user_ordering, user_params, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_zi_fsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_zl_fsymbolic(n_row, n_col, Ap, Ai, Ax, Az, user_ordering, user_params, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_zl_fsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_di_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Qinit, user_ordering, user_params, Symbolic, SW, Control, Info)
-    @ccall libumfpack.umfpack_di_paru_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Qinit::Ptr{Int32}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_dl_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Qinit, user_ordering, user_params, Symbolic, SW, Control, Info)
-    @ccall libumfpack.umfpack_dl_paru_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Qinit::Ptr{Int64}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_zi_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Az, Qinit, user_ordering, user_params, Symbolic, SW, Control, Info)
-    @ccall libumfpack.umfpack_zi_paru_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Qinit::Ptr{Int32}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_zl_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Az, Qinit, user_ordering, user_params, Symbolic, SW, Control, Info)
-    @ccall libumfpack.umfpack_zl_paru_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Qinit::Ptr{Int64}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_qsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                           Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                           Az::Ptr{Cdouble}, Qinit::Ptr{Int64},
+                                           Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                           Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_di_fsymbolic(n_row, n_col, Ap, Ai, Ax, user_ordering, user_params,
+                              Symbolic, Control, Info)
+    @ccall libumfpack.umfpack_di_fsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                           Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                           user_ordering::Ptr{Cvoid},
+                                           user_params::Ptr{Cvoid},
+                                           Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                           Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_dl_fsymbolic(n_row, n_col, Ap, Ai, Ax, user_ordering, user_params,
+                              Symbolic, Control, Info)
+    @ccall libumfpack.umfpack_dl_fsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                           Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                           user_ordering::Ptr{Cvoid},
+                                           user_params::Ptr{Cvoid},
+                                           Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                           Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_zi_fsymbolic(n_row, n_col, Ap, Ai, Ax, Az, user_ordering, user_params,
+                              Symbolic, Control, Info)
+    @ccall libumfpack.umfpack_zi_fsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                           Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                           Az::Ptr{Cdouble}, user_ordering::Ptr{Cvoid},
+                                           user_params::Ptr{Cvoid},
+                                           Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                           Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_zl_fsymbolic(n_row, n_col, Ap, Ai, Ax, Az, user_ordering, user_params,
+                              Symbolic, Control, Info)
+    @ccall libumfpack.umfpack_zl_fsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                           Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                           Az::Ptr{Cdouble}, user_ordering::Ptr{Cvoid},
+                                           user_params::Ptr{Cvoid},
+                                           Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                           Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_di_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Qinit, user_ordering,
+                                  user_params, Symbolic, SW, Control, Info)
+    @ccall libumfpack.umfpack_di_paru_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                               Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                               Qinit::Ptr{Int32}, user_ordering::Ptr{Cvoid},
+                                               user_params::Ptr{Cvoid},
+                                               Symbolic::Ptr{Ptr{Cvoid}},
+                                               SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                               Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_dl_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Qinit, user_ordering,
+                                  user_params, Symbolic, SW, Control, Info)
+    @ccall libumfpack.umfpack_dl_paru_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                               Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                               Qinit::Ptr{Int64}, user_ordering::Ptr{Cvoid},
+                                               user_params::Ptr{Cvoid},
+                                               Symbolic::Ptr{Ptr{Cvoid}},
+                                               SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                               Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_zi_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Az, Qinit, user_ordering,
+                                  user_params, Symbolic, SW, Control, Info)
+    @ccall libumfpack.umfpack_zi_paru_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                               Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                               Az::Ptr{Cdouble}, Qinit::Ptr{Int32},
+                                               user_ordering::Ptr{Cvoid},
+                                               user_params::Ptr{Cvoid},
+                                               Symbolic::Ptr{Ptr{Cvoid}},
+                                               SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                               Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_zl_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Az, Qinit, user_ordering,
+                                  user_params, Symbolic, SW, Control, Info)
+    @ccall libumfpack.umfpack_zl_paru_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                               Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                               Az::Ptr{Cdouble}, Qinit::Ptr{Int64},
+                                               user_ordering::Ptr{Cvoid},
+                                               user_params::Ptr{Cvoid},
+                                               Symbolic::Ptr{Ptr{Cvoid}},
+                                               SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                               Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_paru_free_sw(SW)
@@ -1904,339 +2478,547 @@ function umfpack_zl_paru_free_sw(SW)
 end
 
 function umfpack_di_wsolve(sys, Ap, Ai, Ax, X, B, Numeric, Control, Info, Wi, W)
-    @ccall libumfpack.umfpack_di_wsolve(sys::Cint, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble}, Wi::Ptr{Int32}, W::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_wsolve(sys::Cint, Ap::Ptr{Int32}, Ai::Ptr{Int32},
+                                        Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble},
+                                        Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                        Info::Ptr{Cdouble}, Wi::Ptr{Int32},
+                                        W::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_wsolve(sys, Ap, Ai, Ax, X, B, Numeric, Control, Info, Wi, W)
-    @ccall libumfpack.umfpack_dl_wsolve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble}, Wi::Ptr{Int64}, W::Ptr{Cdouble})::Cint
-end
-
-function umfpack_zi_wsolve(sys, Ap, Ai, Ax, Az, Xx, Xz, Bx, Bz, Numeric, Control, Info, Wi, W)
-    @ccall libumfpack.umfpack_zi_wsolve(sys::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble}, Wi::Ptr{Int32}, W::Ptr{Cdouble})::Cint
-end
-
-function umfpack_zl_wsolve(sys, Ap, Ai, Ax, Az, Xx, Xz, Bx, Bz, Numeric, Control, Info, Wi, W)
-    @ccall libumfpack.umfpack_zl_wsolve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble}, Wi::Ptr{Int64}, W::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_wsolve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64},
+                                        Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble},
+                                        Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                        Info::Ptr{Cdouble}, Wi::Ptr{Int64},
+                                        W::Ptr{Cdouble})::Cint
+end
+
+function umfpack_zi_wsolve(sys, Ap, Ai, Ax, Az, Xx, Xz, Bx, Bz, Numeric, Control, Info, Wi,
+                           W)
+    @ccall libumfpack.umfpack_zi_wsolve(sys::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32},
+                                        Ax::Ptr{Cdouble}, Az::Ptr{Cdouble},
+                                        Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble},
+                                        Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble},
+                                        Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                        Info::Ptr{Cdouble}, Wi::Ptr{Int32},
+                                        W::Ptr{Cdouble})::Cint
+end
+
+function umfpack_zl_wsolve(sys, Ap, Ai, Ax, Az, Xx, Xz, Bx, Bz, Numeric, Control, Info, Wi,
+                           W)
+    @ccall libumfpack.umfpack_zl_wsolve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64},
+                                        Ax::Ptr{Cdouble}, Az::Ptr{Cdouble},
+                                        Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble},
+                                        Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble},
+                                        Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                        Info::Ptr{Cdouble}, Wi::Ptr{Int64},
+                                        W::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_triplet_to_col(n_row, n_col, nz, Ti, Tj, Tx, Ap, Ai, Ax, Map)
-    @ccall libumfpack.umfpack_di_triplet_to_col(n_row::Int32, n_col::Int32, nz::Int32, Ti::Ptr{Int32}, Tj::Ptr{Int32}, Tx::Ptr{Cdouble}, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Map::Ptr{Int32})::Cint
+    @ccall libumfpack.umfpack_di_triplet_to_col(n_row::Int32, n_col::Int32, nz::Int32,
+                                                Ti::Ptr{Int32}, Tj::Ptr{Int32},
+                                                Tx::Ptr{Cdouble}, Ap::Ptr{Int32},
+                                                Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                                Map::Ptr{Int32})::Cint
 end
 
 function umfpack_dl_triplet_to_col(n_row, n_col, nz, Ti, Tj, Tx, Ap, Ai, Ax, Map)
-    @ccall libumfpack.umfpack_dl_triplet_to_col(n_row::Int64, n_col::Int64, nz::Int64, Ti::Ptr{Int64}, Tj::Ptr{Int64}, Tx::Ptr{Cdouble}, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Map::Ptr{Int64})::Cint
+    @ccall libumfpack.umfpack_dl_triplet_to_col(n_row::Int64, n_col::Int64, nz::Int64,
+                                                Ti::Ptr{Int64}, Tj::Ptr{Int64},
+                                                Tx::Ptr{Cdouble}, Ap::Ptr{Int64},
+                                                Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                                Map::Ptr{Int64})::Cint
 end
 
 function umfpack_zi_triplet_to_col(n_row, n_col, nz, Ti, Tj, Tx, Tz, Ap, Ai, Ax, Az, Map)
-    @ccall libumfpack.umfpack_zi_triplet_to_col(n_row::Int32, n_col::Int32, nz::Int32, Ti::Ptr{Int32}, Tj::Ptr{Int32}, Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble}, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Map::Ptr{Int32})::Cint
+    @ccall libumfpack.umfpack_zi_triplet_to_col(n_row::Int32, n_col::Int32, nz::Int32,
+                                                Ti::Ptr{Int32}, Tj::Ptr{Int32},
+                                                Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble},
+                                                Ap::Ptr{Int32}, Ai::Ptr{Int32},
+                                                Ax::Ptr{Cdouble}, Az::Ptr{Cdouble},
+                                                Map::Ptr{Int32})::Cint
 end
 
 function umfpack_zl_triplet_to_col(n_row, n_col, nz, Ti, Tj, Tx, Tz, Ap, Ai, Ax, Az, Map)
-    @ccall libumfpack.umfpack_zl_triplet_to_col(n_row::Int64, n_col::Int64, nz::Int64, Ti::Ptr{Int64}, Tj::Ptr{Int64}, Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble}, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Map::Ptr{Int64})::Cint
+    @ccall libumfpack.umfpack_zl_triplet_to_col(n_row::Int64, n_col::Int64, nz::Int64,
+                                                Ti::Ptr{Int64}, Tj::Ptr{Int64},
+                                                Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble},
+                                                Ap::Ptr{Int64}, Ai::Ptr{Int64},
+                                                Ax::Ptr{Cdouble}, Az::Ptr{Cdouble},
+                                                Map::Ptr{Int64})::Cint
 end
 
 function umfpack_di_col_to_triplet(n_col, Ap, Tj)
-    @ccall libumfpack.umfpack_di_col_to_triplet(n_col::Int32, Ap::Ptr{Int32}, Tj::Ptr{Int32})::Cint
+    @ccall libumfpack.umfpack_di_col_to_triplet(n_col::Int32, Ap::Ptr{Int32},
+                                                Tj::Ptr{Int32})::Cint
 end
 
 function umfpack_dl_col_to_triplet(n_col, Ap, Tj)
-    @ccall libumfpack.umfpack_dl_col_to_triplet(n_col::Int64, Ap::Ptr{Int64}, Tj::Ptr{Int64})::Cint
+    @ccall libumfpack.umfpack_dl_col_to_triplet(n_col::Int64, Ap::Ptr{Int64},
+                                                Tj::Ptr{Int64})::Cint
 end
 
 function umfpack_zi_col_to_triplet(n_col, Ap, Tj)
-    @ccall libumfpack.umfpack_zi_col_to_triplet(n_col::Int32, Ap::Ptr{Int32}, Tj::Ptr{Int32})::Cint
+    @ccall libumfpack.umfpack_zi_col_to_triplet(n_col::Int32, Ap::Ptr{Int32},
+                                                Tj::Ptr{Int32})::Cint
 end
 
 function umfpack_zl_col_to_triplet(n_col, Ap, Tj)
-    @ccall libumfpack.umfpack_zl_col_to_triplet(n_col::Int64, Ap::Ptr{Int64}, Tj::Ptr{Int64})::Cint
+    @ccall libumfpack.umfpack_zl_col_to_triplet(n_col::Int64, Ap::Ptr{Int64},
+                                                Tj::Ptr{Int64})::Cint
 end
 
 function umfpack_di_transpose(n_row, n_col, Ap, Ai, Ax, P, Q, Rp, Ri, Rx)
-    @ccall libumfpack.umfpack_di_transpose(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, P::Ptr{Int32}, Q::Ptr{Int32}, Rp::Ptr{Int32}, Ri::Ptr{Int32}, Rx::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_transpose(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                           Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, P::Ptr{Int32},
+                                           Q::Ptr{Int32}, Rp::Ptr{Int32}, Ri::Ptr{Int32},
+                                           Rx::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_transpose(n_row, n_col, Ap, Ai, Ax, P, Q, Rp, Ri, Rx)
-    @ccall libumfpack.umfpack_dl_transpose(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, P::Ptr{Int64}, Q::Ptr{Int64}, Rp::Ptr{Int64}, Ri::Ptr{Int64}, Rx::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_transpose(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                           Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, P::Ptr{Int64},
+                                           Q::Ptr{Int64}, Rp::Ptr{Int64}, Ri::Ptr{Int64},
+                                           Rx::Ptr{Cdouble})::Cint
 end
 
-function umfpack_zi_transpose(n_row, n_col, Ap, Ai, Ax, Az, P, Q, Rp, Ri, Rx, Rz, do_conjugate)
-    @ccall libumfpack.umfpack_zi_transpose(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, P::Ptr{Int32}, Q::Ptr{Int32}, Rp::Ptr{Int32}, Ri::Ptr{Int32}, Rx::Ptr{Cdouble}, Rz::Ptr{Cdouble}, do_conjugate::Cint)::Cint
+function umfpack_zi_transpose(n_row, n_col, Ap, Ai, Ax, Az, P, Q, Rp, Ri, Rx, Rz,
+                              do_conjugate)
+    @ccall libumfpack.umfpack_zi_transpose(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                           Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                           Az::Ptr{Cdouble}, P::Ptr{Int32}, Q::Ptr{Int32},
+                                           Rp::Ptr{Int32}, Ri::Ptr{Int32}, Rx::Ptr{Cdouble},
+                                           Rz::Ptr{Cdouble}, do_conjugate::Cint)::Cint
 end
 
-function umfpack_zl_transpose(n_row, n_col, Ap, Ai, Ax, Az, P, Q, Rp, Ri, Rx, Rz, do_conjugate)
-    @ccall libumfpack.umfpack_zl_transpose(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, P::Ptr{Int64}, Q::Ptr{Int64}, Rp::Ptr{Int64}, Ri::Ptr{Int64}, Rx::Ptr{Cdouble}, Rz::Ptr{Cdouble}, do_conjugate::Cint)::Cint
+function umfpack_zl_transpose(n_row, n_col, Ap, Ai, Ax, Az, P, Q, Rp, Ri, Rx, Rz,
+                              do_conjugate)
+    @ccall libumfpack.umfpack_zl_transpose(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                           Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                           Az::Ptr{Cdouble}, P::Ptr{Int64}, Q::Ptr{Int64},
+                                           Rp::Ptr{Int64}, Ri::Ptr{Int64}, Rx::Ptr{Cdouble},
+                                           Rz::Ptr{Cdouble}, do_conjugate::Cint)::Cint
 end
 
 function umfpack_di_scale(X, B, Numeric)
-    @ccall libumfpack.umfpack_di_scale(X::Ptr{Cdouble}, B::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_scale(X::Ptr{Cdouble}, B::Ptr{Cdouble},
+                                       Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_scale(X, B, Numeric)
-    @ccall libumfpack.umfpack_dl_scale(X::Ptr{Cdouble}, B::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_scale(X::Ptr{Cdouble}, B::Ptr{Cdouble},
+                                       Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_scale(Xx, Xz, Bx, Bz, Numeric)
-    @ccall libumfpack.umfpack_zi_scale(Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_scale(Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble},
+                                       Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_scale(Xx, Xz, Bx, Bz, Numeric)
-    @ccall libumfpack.umfpack_zl_scale(Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_scale(Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble},
+                                       Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_get_lunz(lnz, unz, n_row, n_col, nz_udiag, Numeric)
-    @ccall libumfpack.umfpack_di_get_lunz(lnz::Ptr{Int32}, unz::Ptr{Int32}, n_row::Ptr{Int32}, n_col::Ptr{Int32}, nz_udiag::Ptr{Int32}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_get_lunz(lnz::Ptr{Int32}, unz::Ptr{Int32},
+                                          n_row::Ptr{Int32}, n_col::Ptr{Int32},
+                                          nz_udiag::Ptr{Int32}, Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_get_lunz(lnz, unz, n_row, n_col, nz_udiag, Numeric)
-    @ccall libumfpack.umfpack_dl_get_lunz(lnz::Ptr{Int64}, unz::Ptr{Int64}, n_row::Ptr{Int64}, n_col::Ptr{Int64}, nz_udiag::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_get_lunz(lnz::Ptr{Int64}, unz::Ptr{Int64},
+                                          n_row::Ptr{Int64}, n_col::Ptr{Int64},
+                                          nz_udiag::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_get_lunz(lnz, unz, n_row, n_col, nz_udiag, Numeric)
-    @ccall libumfpack.umfpack_zi_get_lunz(lnz::Ptr{Int32}, unz::Ptr{Int32}, n_row::Ptr{Int32}, n_col::Ptr{Int32}, nz_udiag::Ptr{Int32}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_get_lunz(lnz::Ptr{Int32}, unz::Ptr{Int32},
+                                          n_row::Ptr{Int32}, n_col::Ptr{Int32},
+                                          nz_udiag::Ptr{Int32}, Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_get_lunz(lnz, unz, n_row, n_col, nz_udiag, Numeric)
-    @ccall libumfpack.umfpack_zl_get_lunz(lnz::Ptr{Int64}, unz::Ptr{Int64}, n_row::Ptr{Int64}, n_col::Ptr{Int64}, nz_udiag::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_get_lunz(lnz::Ptr{Int64}, unz::Ptr{Int64},
+                                          n_row::Ptr{Int64}, n_col::Ptr{Int64},
+                                          nz_udiag::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_get_numeric(Lp, Lj, Lx, Up, Ui, Ux, P, Q, Dx, do_recip, Rs, Numeric)
-    @ccall libumfpack.umfpack_di_get_numeric(Lp::Ptr{Int32}, Lj::Ptr{Int32}, Lx::Ptr{Cdouble}, Up::Ptr{Int32}, Ui::Ptr{Int32}, Ux::Ptr{Cdouble}, P::Ptr{Int32}, Q::Ptr{Int32}, Dx::Ptr{Cdouble}, do_recip::Ptr{Int32}, Rs::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_get_numeric(Lp::Ptr{Int32}, Lj::Ptr{Int32},
+                                             Lx::Ptr{Cdouble}, Up::Ptr{Int32},
+                                             Ui::Ptr{Int32}, Ux::Ptr{Cdouble},
+                                             P::Ptr{Int32}, Q::Ptr{Int32}, Dx::Ptr{Cdouble},
+                                             do_recip::Ptr{Int32}, Rs::Ptr{Cdouble},
+                                             Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_get_numeric(Lp, Lj, Lx, Up, Ui, Ux, P, Q, Dx, do_recip, Rs, Numeric)
-    @ccall libumfpack.umfpack_dl_get_numeric(Lp::Ptr{Int64}, Lj::Ptr{Int64}, Lx::Ptr{Cdouble}, Up::Ptr{Int64}, Ui::Ptr{Int64}, Ux::Ptr{Cdouble}, P::Ptr{Int64}, Q::Ptr{Int64}, Dx::Ptr{Cdouble}, do_recip::Ptr{Int64}, Rs::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
-end
-
-function umfpack_zi_get_numeric(Lp, Lj, Lx, Lz, Up, Ui, Ux, Uz, P, Q, Dx, Dz, do_recip, Rs, Numeric)
-    @ccall libumfpack.umfpack_zi_get_numeric(Lp::Ptr{Int32}, Lj::Ptr{Int32}, Lx::Ptr{Cdouble}, Lz::Ptr{Cdouble}, Up::Ptr{Int32}, Ui::Ptr{Int32}, Ux::Ptr{Cdouble}, Uz::Ptr{Cdouble}, P::Ptr{Int32}, Q::Ptr{Int32}, Dx::Ptr{Cdouble}, Dz::Ptr{Cdouble}, do_recip::Ptr{Int32}, Rs::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
-end
-
-function umfpack_zl_get_numeric(Lp, Lj, Lx, Lz, Up, Ui, Ux, Uz, P, Q, Dx, Dz, do_recip, Rs, Numeric)
-    @ccall libumfpack.umfpack_zl_get_numeric(Lp::Ptr{Int64}, Lj::Ptr{Int64}, Lx::Ptr{Cdouble}, Lz::Ptr{Cdouble}, Up::Ptr{Int64}, Ui::Ptr{Int64}, Ux::Ptr{Cdouble}, Uz::Ptr{Cdouble}, P::Ptr{Int64}, Q::Ptr{Int64}, Dx::Ptr{Cdouble}, Dz::Ptr{Cdouble}, do_recip::Ptr{Int64}, Rs::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
-end
-
-function umfpack_di_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol, Front_parent, Front_1strow, Front_leftmostdesc, Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
-    @ccall libumfpack.umfpack_di_get_symbolic(n_row::Ptr{Int32}, n_col::Ptr{Int32}, n1::Ptr{Int32}, nz::Ptr{Int32}, nfr::Ptr{Int32}, nchains::Ptr{Int32}, P::Ptr{Int32}, Q::Ptr{Int32}, Front_npivcol::Ptr{Int32}, Front_parent::Ptr{Int32}, Front_1strow::Ptr{Int32}, Front_leftmostdesc::Ptr{Int32}, Chain_start::Ptr{Int32}, Chain_maxrows::Ptr{Int32}, Chain_maxcols::Ptr{Int32}, Dmap::Ptr{Int32}, Symbolic::Ptr{Cvoid})::Cint
-end
-
-function umfpack_dl_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol, Front_parent, Front_1strow, Front_leftmostdesc, Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
-    @ccall libumfpack.umfpack_dl_get_symbolic(n_row::Ptr{Int64}, n_col::Ptr{Int64}, n1::Ptr{Int64}, nz::Ptr{Int64}, nfr::Ptr{Int64}, nchains::Ptr{Int64}, P::Ptr{Int64}, Q::Ptr{Int64}, Front_npivcol::Ptr{Int64}, Front_parent::Ptr{Int64}, Front_1strow::Ptr{Int64}, Front_leftmostdesc::Ptr{Int64}, Chain_start::Ptr{Int64}, Chain_maxrows::Ptr{Int64}, Chain_maxcols::Ptr{Int64}, Dmap::Ptr{Int64}, Symbolic::Ptr{Cvoid})::Cint
-end
-
-function umfpack_zi_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol, Front_parent, Front_1strow, Front_leftmostdesc, Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
-    @ccall libumfpack.umfpack_zi_get_symbolic(n_row::Ptr{Int32}, n_col::Ptr{Int32}, n1::Ptr{Int32}, nz::Ptr{Int32}, nfr::Ptr{Int32}, nchains::Ptr{Int32}, P::Ptr{Int32}, Q::Ptr{Int32}, Front_npivcol::Ptr{Int32}, Front_parent::Ptr{Int32}, Front_1strow::Ptr{Int32}, Front_leftmostdesc::Ptr{Int32}, Chain_start::Ptr{Int32}, Chain_maxrows::Ptr{Int32}, Chain_maxcols::Ptr{Int32}, Dmap::Ptr{Int32}, Symbolic::Ptr{Cvoid})::Cint
-end
-
-function umfpack_zl_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol, Front_parent, Front_1strow, Front_leftmostdesc, Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
-    @ccall libumfpack.umfpack_zl_get_symbolic(n_row::Ptr{Int64}, n_col::Ptr{Int64}, n1::Ptr{Int64}, nz::Ptr{Int64}, nfr::Ptr{Int64}, nchains::Ptr{Int64}, P::Ptr{Int64}, Q::Ptr{Int64}, Front_npivcol::Ptr{Int64}, Front_parent::Ptr{Int64}, Front_1strow::Ptr{Int64}, Front_leftmostdesc::Ptr{Int64}, Chain_start::Ptr{Int64}, Chain_maxrows::Ptr{Int64}, Chain_maxcols::Ptr{Int64}, Dmap::Ptr{Int64}, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_get_numeric(Lp::Ptr{Int64}, Lj::Ptr{Int64},
+                                             Lx::Ptr{Cdouble}, Up::Ptr{Int64},
+                                             Ui::Ptr{Int64}, Ux::Ptr{Cdouble},
+                                             P::Ptr{Int64}, Q::Ptr{Int64}, Dx::Ptr{Cdouble},
+                                             do_recip::Ptr{Int64}, Rs::Ptr{Cdouble},
+                                             Numeric::Ptr{Cvoid})::Cint
+end
+
+function umfpack_zi_get_numeric(Lp, Lj, Lx, Lz, Up, Ui, Ux, Uz, P, Q, Dx, Dz, do_recip, Rs,
+                                Numeric)
+    @ccall libumfpack.umfpack_zi_get_numeric(Lp::Ptr{Int32}, Lj::Ptr{Int32},
+                                             Lx::Ptr{Cdouble}, Lz::Ptr{Cdouble},
+                                             Up::Ptr{Int32}, Ui::Ptr{Int32},
+                                             Ux::Ptr{Cdouble}, Uz::Ptr{Cdouble},
+                                             P::Ptr{Int32}, Q::Ptr{Int32}, Dx::Ptr{Cdouble},
+                                             Dz::Ptr{Cdouble}, do_recip::Ptr{Int32},
+                                             Rs::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+end
+
+function umfpack_zl_get_numeric(Lp, Lj, Lx, Lz, Up, Ui, Ux, Uz, P, Q, Dx, Dz, do_recip, Rs,
+                                Numeric)
+    @ccall libumfpack.umfpack_zl_get_numeric(Lp::Ptr{Int64}, Lj::Ptr{Int64},
+                                             Lx::Ptr{Cdouble}, Lz::Ptr{Cdouble},
+                                             Up::Ptr{Int64}, Ui::Ptr{Int64},
+                                             Ux::Ptr{Cdouble}, Uz::Ptr{Cdouble},
+                                             P::Ptr{Int64}, Q::Ptr{Int64}, Dx::Ptr{Cdouble},
+                                             Dz::Ptr{Cdouble}, do_recip::Ptr{Int64},
+                                             Rs::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+end
+
+function umfpack_di_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol,
+                                 Front_parent, Front_1strow, Front_leftmostdesc,
+                                 Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
+    @ccall libumfpack.umfpack_di_get_symbolic(n_row::Ptr{Int32}, n_col::Ptr{Int32},
+                                              n1::Ptr{Int32}, nz::Ptr{Int32},
+                                              nfr::Ptr{Int32}, nchains::Ptr{Int32},
+                                              P::Ptr{Int32}, Q::Ptr{Int32},
+                                              Front_npivcol::Ptr{Int32},
+                                              Front_parent::Ptr{Int32},
+                                              Front_1strow::Ptr{Int32},
+                                              Front_leftmostdesc::Ptr{Int32},
+                                              Chain_start::Ptr{Int32},
+                                              Chain_maxrows::Ptr{Int32},
+                                              Chain_maxcols::Ptr{Int32}, Dmap::Ptr{Int32},
+                                              Symbolic::Ptr{Cvoid})::Cint
+end
+
+function umfpack_dl_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol,
+                                 Front_parent, Front_1strow, Front_leftmostdesc,
+                                 Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
+    @ccall libumfpack.umfpack_dl_get_symbolic(n_row::Ptr{Int64}, n_col::Ptr{Int64},
+                                              n1::Ptr{Int64}, nz::Ptr{Int64},
+                                              nfr::Ptr{Int64}, nchains::Ptr{Int64},
+                                              P::Ptr{Int64}, Q::Ptr{Int64},
+                                              Front_npivcol::Ptr{Int64},
+                                              Front_parent::Ptr{Int64},
+                                              Front_1strow::Ptr{Int64},
+                                              Front_leftmostdesc::Ptr{Int64},
+                                              Chain_start::Ptr{Int64},
+                                              Chain_maxrows::Ptr{Int64},
+                                              Chain_maxcols::Ptr{Int64}, Dmap::Ptr{Int64},
+                                              Symbolic::Ptr{Cvoid})::Cint
+end
+
+function umfpack_zi_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol,
+                                 Front_parent, Front_1strow, Front_leftmostdesc,
+                                 Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
+    @ccall libumfpack.umfpack_zi_get_symbolic(n_row::Ptr{Int32}, n_col::Ptr{Int32},
+                                              n1::Ptr{Int32}, nz::Ptr{Int32},
+                                              nfr::Ptr{Int32}, nchains::Ptr{Int32},
+                                              P::Ptr{Int32}, Q::Ptr{Int32},
+                                              Front_npivcol::Ptr{Int32},
+                                              Front_parent::Ptr{Int32},
+                                              Front_1strow::Ptr{Int32},
+                                              Front_leftmostdesc::Ptr{Int32},
+                                              Chain_start::Ptr{Int32},
+                                              Chain_maxrows::Ptr{Int32},
+                                              Chain_maxcols::Ptr{Int32}, Dmap::Ptr{Int32},
+                                              Symbolic::Ptr{Cvoid})::Cint
+end
+
+function umfpack_zl_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol,
+                                 Front_parent, Front_1strow, Front_leftmostdesc,
+                                 Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
+    @ccall libumfpack.umfpack_zl_get_symbolic(n_row::Ptr{Int64}, n_col::Ptr{Int64},
+                                              n1::Ptr{Int64}, nz::Ptr{Int64},
+                                              nfr::Ptr{Int64}, nchains::Ptr{Int64},
+                                              P::Ptr{Int64}, Q::Ptr{Int64},
+                                              Front_npivcol::Ptr{Int64},
+                                              Front_parent::Ptr{Int64},
+                                              Front_1strow::Ptr{Int64},
+                                              Front_leftmostdesc::Ptr{Int64},
+                                              Chain_start::Ptr{Int64},
+                                              Chain_maxrows::Ptr{Int64},
+                                              Chain_maxcols::Ptr{Int64}, Dmap::Ptr{Int64},
+                                              Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_save_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_di_save_numeric(Numeric::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_di_save_numeric(Numeric::Ptr{Cvoid},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_dl_save_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_dl_save_numeric(Numeric::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_dl_save_numeric(Numeric::Ptr{Cvoid},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zi_save_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_zi_save_numeric(Numeric::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zi_save_numeric(Numeric::Ptr{Cvoid},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zl_save_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_zl_save_numeric(Numeric::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zl_save_numeric(Numeric::Ptr{Cvoid},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_di_load_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_di_load_numeric(Numeric::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_di_load_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_dl_load_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_dl_load_numeric(Numeric::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_dl_load_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zi_load_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_zi_load_numeric(Numeric::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zi_load_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zl_load_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_zl_load_numeric(Numeric::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zl_load_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_di_copy_numeric(Numeric, Original)
-    @ccall libumfpack.umfpack_di_copy_numeric(Numeric::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_copy_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_copy_numeric(Numeric, Original)
-    @ccall libumfpack.umfpack_dl_copy_numeric(Numeric::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_copy_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_copy_numeric(Numeric, Original)
-    @ccall libumfpack.umfpack_zi_copy_numeric(Numeric::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_copy_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_copy_numeric(Numeric, Original)
-    @ccall libumfpack.umfpack_zl_copy_numeric(Numeric::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_copy_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_serialize_numeric_size(blobsize, Numeric)
-    @ccall libumfpack.umfpack_di_serialize_numeric_size(blobsize::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_serialize_numeric_size(blobsize::Ptr{Int64},
+                                                        Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_serialize_numeric_size(blobsize, Numeric)
-    @ccall libumfpack.umfpack_dl_serialize_numeric_size(blobsize::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_serialize_numeric_size(blobsize::Ptr{Int64},
+                                                        Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_serialize_numeric_size(blobsize, Numeric)
-    @ccall libumfpack.umfpack_zi_serialize_numeric_size(blobsize::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_serialize_numeric_size(blobsize::Ptr{Int64},
+                                                        Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_serialize_numeric_size(blobsize, Numeric)
-    @ccall libumfpack.umfpack_zl_serialize_numeric_size(blobsize::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_serialize_numeric_size(blobsize::Ptr{Int64},
+                                                        Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_serialize_numeric(blob, blobsize, Numeric)
-    @ccall libumfpack.umfpack_di_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64,
+                                                   Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_serialize_numeric(blob, blobsize, Numeric)
-    @ccall libumfpack.umfpack_dl_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64,
+                                                   Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_serialize_numeric(blob, blobsize, Numeric)
-    @ccall libumfpack.umfpack_zi_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64,
+                                                   Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_serialize_numeric(blob, blobsize, Numeric)
-    @ccall libumfpack.umfpack_zl_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64,
+                                                   Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_deserialize_numeric(Numeric, blob, blobsize)
-    @ccall libumfpack.umfpack_di_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_di_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                                     blob::Ptr{Int8}, blobsize::Int64)::Cint
 end
 
 function umfpack_dl_deserialize_numeric(Numeric, blob, blobsize)
-    @ccall libumfpack.umfpack_dl_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_dl_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                                     blob::Ptr{Int8}, blobsize::Int64)::Cint
 end
 
 function umfpack_zi_deserialize_numeric(Numeric, blob, blobsize)
-    @ccall libumfpack.umfpack_zi_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_zi_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                                     blob::Ptr{Int8}, blobsize::Int64)::Cint
 end
 
 function umfpack_zl_deserialize_numeric(Numeric, blob, blobsize)
-    @ccall libumfpack.umfpack_zl_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_zl_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                                     blob::Ptr{Int8}, blobsize::Int64)::Cint
 end
 
 function umfpack_di_save_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_di_save_symbolic(Symbolic::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_di_save_symbolic(Symbolic::Ptr{Cvoid},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_dl_save_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_dl_save_symbolic(Symbolic::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_dl_save_symbolic(Symbolic::Ptr{Cvoid},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zi_save_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_zi_save_symbolic(Symbolic::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zi_save_symbolic(Symbolic::Ptr{Cvoid},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zl_save_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_zl_save_symbolic(Symbolic::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zl_save_symbolic(Symbolic::Ptr{Cvoid},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_di_load_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_di_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_di_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_dl_load_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_dl_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_dl_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zi_load_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_zi_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zi_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zl_load_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_zl_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zl_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_di_copy_symbolic(Symbolic, Original)
-    @ccall libumfpack.umfpack_di_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_copy_symbolic(Symbolic, Original)
-    @ccall libumfpack.umfpack_dl_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_copy_symbolic(Symbolic, Original)
-    @ccall libumfpack.umfpack_zi_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_copy_symbolic(Symbolic, Original)
-    @ccall libumfpack.umfpack_zl_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_serialize_symbolic_size(blobsize, Symbolic)
-    @ccall libumfpack.umfpack_di_serialize_symbolic_size(blobsize::Ptr{Int64}, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_serialize_symbolic_size(blobsize::Ptr{Int64},
+                                                         Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_serialize_symbolic_size(blobsize, Symbolic)
-    @ccall libumfpack.umfpack_dl_serialize_symbolic_size(blobsize::Ptr{Int64}, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_serialize_symbolic_size(blobsize::Ptr{Int64},
+                                                         Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_serialize_symbolic_size(blobsize, Symbolic)
-    @ccall libumfpack.umfpack_zi_serialize_symbolic_size(blobsize::Ptr{Int64}, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_serialize_symbolic_size(blobsize::Ptr{Int64},
+                                                         Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_serialize_symbolic_size(blobsize, Symbolic)
-    @ccall libumfpack.umfpack_zl_serialize_symbolic_size(blobsize::Ptr{Int64}, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_serialize_symbolic_size(blobsize::Ptr{Int64},
+                                                         Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_serialize_symbolic(blob, blobsize, Symbolic)
-    @ccall libumfpack.umfpack_di_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64,
+                                                    Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_serialize_symbolic(blob, blobsize, Symbolic)
-    @ccall libumfpack.umfpack_dl_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64,
+                                                    Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_serialize_symbolic(blob, blobsize, Symbolic)
-    @ccall libumfpack.umfpack_zi_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64,
+                                                    Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_serialize_symbolic(blob, blobsize, Symbolic)
-    @ccall libumfpack.umfpack_zl_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64,
+                                                    Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_deserialize_symbolic(Symbolic, blob, blobsize)
-    @ccall libumfpack.umfpack_di_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_di_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                                      blob::Ptr{Int8},
+                                                      blobsize::Int64)::Cint
 end
 
 function umfpack_dl_deserialize_symbolic(Symbolic, blob, blobsize)
-    @ccall libumfpack.umfpack_dl_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_dl_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                                      blob::Ptr{Int8},
+                                                      blobsize::Int64)::Cint
 end
 
 function umfpack_zi_deserialize_symbolic(Symbolic, blob, blobsize)
-    @ccall libumfpack.umfpack_zi_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_zi_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                                      blob::Ptr{Int8},
+                                                      blobsize::Int64)::Cint
 end
 
 function umfpack_zl_deserialize_symbolic(Symbolic, blob, blobsize)
-    @ccall libumfpack.umfpack_zl_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_zl_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                                      blob::Ptr{Int8},
+                                                      blobsize::Int64)::Cint
 end
 
 function umfpack_di_get_determinant(Mx, Ex, Numeric, User_Info)
-    @ccall libumfpack.umfpack_di_get_determinant(Mx::Ptr{Cdouble}, Ex::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, User_Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_get_determinant(Mx::Ptr{Cdouble}, Ex::Ptr{Cdouble},
+                                                 Numeric::Ptr{Cvoid},
+                                                 User_Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_get_determinant(Mx, Ex, Numeric, User_Info)
-    @ccall libumfpack.umfpack_dl_get_determinant(Mx::Ptr{Cdouble}, Ex::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, User_Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_get_determinant(Mx::Ptr{Cdouble}, Ex::Ptr{Cdouble},
+                                                 Numeric::Ptr{Cvoid},
+                                                 User_Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_get_determinant(Mx, Mz, Ex, Numeric, User_Info)
-    @ccall libumfpack.umfpack_zi_get_determinant(Mx::Ptr{Cdouble}, Mz::Ptr{Cdouble}, Ex::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, User_Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_get_determinant(Mx::Ptr{Cdouble}, Mz::Ptr{Cdouble},
+                                                 Ex::Ptr{Cdouble}, Numeric::Ptr{Cvoid},
+                                                 User_Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_get_determinant(Mx, Mz, Ex, Numeric, User_Info)
-    @ccall libumfpack.umfpack_zl_get_determinant(Mx::Ptr{Cdouble}, Mz::Ptr{Cdouble}, Ex::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, User_Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_get_determinant(Mx::Ptr{Cdouble}, Mz::Ptr{Cdouble},
+                                                 Ex::Ptr{Cdouble}, Numeric::Ptr{Cvoid},
+                                                 User_Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_report_status(Control, status)
@@ -2256,19 +3038,23 @@ function umfpack_zl_report_status(Control, status)
 end
 
 function umfpack_di_report_info(Control, Info)
-    @ccall libumfpack.umfpack_di_report_info(Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cvoid
+    @ccall libumfpack.umfpack_di_report_info(Control::Ptr{Cdouble},
+                                             Info::Ptr{Cdouble})::Cvoid
 end
 
 function umfpack_dl_report_info(Control, Info)
-    @ccall libumfpack.umfpack_dl_report_info(Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cvoid
+    @ccall libumfpack.umfpack_dl_report_info(Control::Ptr{Cdouble},
+                                             Info::Ptr{Cdouble})::Cvoid
 end
 
 function umfpack_zi_report_info(Control, Info)
-    @ccall libumfpack.umfpack_zi_report_info(Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cvoid
+    @ccall libumfpack.umfpack_zi_report_info(Control::Ptr{Cdouble},
+                                             Info::Ptr{Cdouble})::Cvoid
 end
 
 function umfpack_zl_report_info(Control, Info)
-    @ccall libumfpack.umfpack_zl_report_info(Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cvoid
+    @ccall libumfpack.umfpack_zl_report_info(Control::Ptr{Cdouble},
+                                             Info::Ptr{Cdouble})::Cvoid
 end
 
 function umfpack_di_report_control(Control)
@@ -2288,99 +3074,137 @@ function umfpack_zl_report_control(Control)
 end
 
 function umfpack_di_report_matrix(n_row, n_col, Ap, Ai, Ax, col_form, Control)
-    @ccall libumfpack.umfpack_di_report_matrix(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, col_form::Cint, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_report_matrix(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                               Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                               col_form::Cint, Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_report_matrix(n_row, n_col, Ap, Ai, Ax, col_form, Control)
-    @ccall libumfpack.umfpack_dl_report_matrix(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, col_form::Cint, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_report_matrix(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                               Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                               col_form::Cint, Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_report_matrix(n_row, n_col, Ap, Ai, Ax, Az, col_form, Control)
-    @ccall libumfpack.umfpack_zi_report_matrix(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, col_form::Cint, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_report_matrix(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                               Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                               Az::Ptr{Cdouble}, col_form::Cint,
+                                               Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_report_matrix(n_row, n_col, Ap, Ai, Ax, Az, col_form, Control)
-    @ccall libumfpack.umfpack_zl_report_matrix(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, col_form::Cint, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_report_matrix(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                               Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                               Az::Ptr{Cdouble}, col_form::Cint,
+                                               Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_report_triplet(n_row, n_col, nz, Ti, Tj, Tx, Control)
-    @ccall libumfpack.umfpack_di_report_triplet(n_row::Int32, n_col::Int32, nz::Int32, Ti::Ptr{Int32}, Tj::Ptr{Int32}, Tx::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_report_triplet(n_row::Int32, n_col::Int32, nz::Int32,
+                                                Ti::Ptr{Int32}, Tj::Ptr{Int32},
+                                                Tx::Ptr{Cdouble},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_report_triplet(n_row, n_col, nz, Ti, Tj, Tx, Control)
-    @ccall libumfpack.umfpack_dl_report_triplet(n_row::Int64, n_col::Int64, nz::Int64, Ti::Ptr{Int64}, Tj::Ptr{Int64}, Tx::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_report_triplet(n_row::Int64, n_col::Int64, nz::Int64,
+                                                Ti::Ptr{Int64}, Tj::Ptr{Int64},
+                                                Tx::Ptr{Cdouble},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_report_triplet(n_row, n_col, nz, Ti, Tj, Tx, Tz, Control)
-    @ccall libumfpack.umfpack_zi_report_triplet(n_row::Int32, n_col::Int32, nz::Int32, Ti::Ptr{Int32}, Tj::Ptr{Int32}, Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_report_triplet(n_row::Int32, n_col::Int32, nz::Int32,
+                                                Ti::Ptr{Int32}, Tj::Ptr{Int32},
+                                                Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_report_triplet(n_row, n_col, nz, Ti, Tj, Tx, Tz, Control)
-    @ccall libumfpack.umfpack_zl_report_triplet(n_row::Int64, n_col::Int64, nz::Int64, Ti::Ptr{Int64}, Tj::Ptr{Int64}, Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_report_triplet(n_row::Int64, n_col::Int64, nz::Int64,
+                                                Ti::Ptr{Int64}, Tj::Ptr{Int64},
+                                                Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_report_vector(n, X, Control)
-    @ccall libumfpack.umfpack_di_report_vector(n::Int32, X::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_report_vector(n::Int32, X::Ptr{Cdouble},
+                                               Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_report_vector(n, X, Control)
-    @ccall libumfpack.umfpack_dl_report_vector(n::Int64, X::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_report_vector(n::Int64, X::Ptr{Cdouble},
+                                               Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_report_vector(n, Xx, Xz, Control)
-    @ccall libumfpack.umfpack_zi_report_vector(n::Int32, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_report_vector(n::Int32, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble},
+                                               Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_report_vector(n, Xx, Xz, Control)
-    @ccall libumfpack.umfpack_zl_report_vector(n::Int64, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_report_vector(n::Int64, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble},
+                                               Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_report_symbolic(Symbolic, Control)
-    @ccall libumfpack.umfpack_di_report_symbolic(Symbolic::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_report_symbolic(Symbolic::Ptr{Cvoid},
+                                                 Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_report_symbolic(Symbolic, Control)
-    @ccall libumfpack.umfpack_dl_report_symbolic(Symbolic::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_report_symbolic(Symbolic::Ptr{Cvoid},
+                                                 Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_report_symbolic(Symbolic, Control)
-    @ccall libumfpack.umfpack_zi_report_symbolic(Symbolic::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_report_symbolic(Symbolic::Ptr{Cvoid},
+                                                 Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_report_symbolic(Symbolic, Control)
-    @ccall libumfpack.umfpack_zl_report_symbolic(Symbolic::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_report_symbolic(Symbolic::Ptr{Cvoid},
+                                                 Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_report_numeric(Numeric, Control)
-    @ccall libumfpack.umfpack_di_report_numeric(Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_report_numeric(Numeric::Ptr{Cvoid},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_report_numeric(Numeric, Control)
-    @ccall libumfpack.umfpack_dl_report_numeric(Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_report_numeric(Numeric::Ptr{Cvoid},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_report_numeric(Numeric, Control)
-    @ccall libumfpack.umfpack_zi_report_numeric(Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_report_numeric(Numeric::Ptr{Cvoid},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_report_numeric(Numeric, Control)
-    @ccall libumfpack.umfpack_zl_report_numeric(Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_report_numeric(Numeric::Ptr{Cvoid},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_report_perm(np, Perm, Control)
-    @ccall libumfpack.umfpack_di_report_perm(np::Int32, Perm::Ptr{Int32}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_report_perm(np::Int32, Perm::Ptr{Int32},
+                                             Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_report_perm(np, Perm, Control)
-    @ccall libumfpack.umfpack_dl_report_perm(np::Int64, Perm::Ptr{Int64}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_report_perm(np::Int64, Perm::Ptr{Int64},
+                                             Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_report_perm(np, Perm, Control)
-    @ccall libumfpack.umfpack_zi_report_perm(np::Int32, Perm::Ptr{Int32}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_report_perm(np::Int32, Perm::Ptr{Int32},
+                                             Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_report_perm(np, Perm, Control)
-    @ccall libumfpack.umfpack_zl_report_perm(np::Int64, Perm::Ptr{Int64}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_report_perm(np::Int64, Perm::Ptr{Int64},
+                                             Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_timer()
@@ -2395,13 +3219,13 @@ function umfpack_toc(stats)
     @ccall libumfpack.umfpack_toc(stats::Ptr{Cdouble})::Cvoid
 end
 
-const CHOLMOD_DATE = "Jan 17, 2023"
+const CHOLMOD_DATE = "June 16, 2023"
 
 const CHOLMOD_MAIN_VERSION = 4
 
 const CHOLMOD_SUB_VERSION = 0
 
-const CHOLMOD_SUBSUB_VERSION = 3
+const CHOLMOD_SUBSUB_VERSION = 4
 
 const _FILE_OFFSET_BITS = 64
 
@@ -2427,17 +3251,18 @@ const SUITESPARSE_COMPILER_MSC = 0
 
 const SUITESPARSE_COMPILER_XLC = 0
 
-const SUITESPARSE_DATE = "Jan 20, 2023"
+const SUITESPARSE_DATE = "June 29, 2023"
 
 const SUITESPARSE_MAIN_VERSION = 7
 
-const SUITESPARSE_SUB_VERSION = 0
+const SUITESPARSE_SUB_VERSION = 1
 
-const SUITESPARSE_SUBSUB_VERSION = 1
+const SUITESPARSE_SUBSUB_VERSION = 0
 
 SUITESPARSE_VER_CODE(main, sub) = main * 1000 + sub
 
-const SUITESPARSE_VERSION = SUITESPARSE_VER_CODE(SUITESPARSE_MAIN_VERSION, SUITESPARSE_SUB_VERSION)
+const SUITESPARSE_VERSION = SUITESPARSE_VER_CODE(SUITESPARSE_MAIN_VERSION,
+                                                 SUITESPARSE_SUB_VERSION)
 
 CHOLMOD_VER_CODE(main, sub) = main * 1000 + sub
 
@@ -2601,20 +3426,18 @@ const SPQR_RTX_EQUALS_B = 2
 
 const SPQR_RTX_EQUALS_ETB = 3
 
-const SPQR_DATE = "Jan 17, 2023"
+const SPQR_DATE = "July FIXME, 2023"
 
-const SPQR_MAIN_VERSION = 3
+const SPQR_MAIN_VERSION = 4
 
 const SPQR_SUB_VERSION = 0
 
-const SPQR_SUBSUB_VERSION = 3
+const SPQR_SUBSUB_VERSION = 0
 
 SPQR_VER_CODE(main, sub) = main * 1000 + sub
 
 const SPQR_VERSION = SPQR_VER_CODE(SPQR_MAIN_VERSION, SPQR_SUB_VERSION)
 
-const Complex = Float64
-
 const AMD_CONTROL = 5
 
 const AMD_INFO = 20
@@ -2663,172 +3486,29 @@ const AMD_INVALID = -2
 
 const AMD_OK_BUT_JUMBLED = 1
 
-const AMD_DATE = "Jan 17, 2023"
+const AMD_DATE = "June 16, 2023"
 
 const AMD_MAIN_VERSION = 3
 
 const AMD_SUB_VERSION = 0
 
-const AMD_SUBSUB_VERSION = 3
+const AMD_SUBSUB_VERSION = 4
 
 AMD_VERSION_CODE(main, sub) = main * 1000 + sub
 
 const AMD_VERSION = AMD_VERSION_CODE(AMD_MAIN_VERSION, AMD_SUB_VERSION)
 
-const COLAMD_DATE = "Jan 17, 2023"
-
-const COLAMD_MAIN_VERSION = 3
-
-const COLAMD_SUB_VERSION = 0
-
-const COLAMD_SUBSUB_VERSION = 3
-
-COLAMD_VERSION_CODE(main, sub) = main * 1000 + sub
-
-const COLAMD_VERSION = COLAMD_VERSION_CODE(COLAMD_MAIN_VERSION, COLAMD_SUB_VERSION)
-
-const COLAMD_KNOBS = 20
-
-const COLAMD_STATS = 20
-
-const COLAMD_DENSE_ROW = 0
-
-const COLAMD_DENSE_COL = 1
-
-const COLAMD_AGGRESSIVE = 2
-
-const COLAMD_DEFRAG_COUNT = 2
-
-const COLAMD_STATUS = 3
-
-const COLAMD_INFO1 = 4
-
-const COLAMD_INFO2 = 5
-
-const COLAMD_INFO3 = 6
-
-const COLAMD_OK = 0
-
-const COLAMD_OK_BUT_JUMBLED = 1
-
-const COLAMD_ERROR_A_not_present = -1
-
-const COLAMD_ERROR_p_not_present = -2
-
-const COLAMD_ERROR_nrow_negative = -3
-
-const COLAMD_ERROR_ncol_negative = -4
-
-const COLAMD_ERROR_nnz_negative = -5
-
-const COLAMD_ERROR_p0_nonzero = -6
-
-const COLAMD_ERROR_A_too_small = -7
-
-const COLAMD_ERROR_col_length_negative = -8
-
-const COLAMD_ERROR_row_index_out_of_bounds = -9
-
-const COLAMD_ERROR_out_of_memory = -10
-
-const COLAMD_ERROR_internal_error = -999
-
-const CCOLAMD_DATE = "Jan 17, 2023"
-
-const CCOLAMD_MAIN_VERSION = 3
-
-const CCOLAMD_SUB_VERSION = 0
-
-const CCOLAMD_SUBSUB_VERSION = 3
-
-CCOLAMD_VERSION_CODE(main, sub) = main * 1000 + sub
-
-const CCOLAMD_VERSION = CCOLAMD_VERSION_CODE(CCOLAMD_MAIN_VERSION, CCOLAMD_SUB_VERSION)
-
-const CCOLAMD_KNOBS = 20
-
-const CCOLAMD_STATS = 20
-
-const CCOLAMD_DENSE_ROW = 0
-
-const CCOLAMD_DENSE_COL = 1
-
-const CCOLAMD_AGGRESSIVE = 2
-
-const CCOLAMD_LU = 3
-
-const CCOLAMD_DEFRAG_COUNT = 2
-
-const CCOLAMD_STATUS = 3
-
-const CCOLAMD_INFO1 = 4
-
-const CCOLAMD_INFO2 = 5
-
-const CCOLAMD_INFO3 = 6
-
-const CCOLAMD_EMPTY_ROW = 7
-
-const CCOLAMD_EMPTY_COL = 8
-
-const CCOLAMD_NEWLY_EMPTY_ROW = 9
-
-const CCOLAMD_NEWLY_EMPTY_COL = 10
-
-const CCOLAMD_OK = 0
-
-const CCOLAMD_OK_BUT_JUMBLED = 1
-
-const CCOLAMD_ERROR_A_not_present = -1
-
-const CCOLAMD_ERROR_p_not_present = -2
-
-const CCOLAMD_ERROR_nrow_negative = -3
-
-const CCOLAMD_ERROR_ncol_negative = -4
-
-const CCOLAMD_ERROR_nnz_negative = -5
-
-const CCOLAMD_ERROR_p0_nonzero = -6
-
-const CCOLAMD_ERROR_A_too_small = -7
-
-const CCOLAMD_ERROR_col_length_negative = -8
-
-const CCOLAMD_ERROR_row_index_out_of_bounds = -9
-
-const CCOLAMD_ERROR_out_of_memory = -10
-
-const CCOLAMD_ERROR_invalid_cmember = -11
-
-const CCOLAMD_ERROR_internal_error = -999
-
 const UMFPACK_INFO = 90
 
 const UMFPACK_CONTROL = 20
 
-# Skipping MacroDefinition: UMFPACK_COPYRIGHT \
-#"UMFPACK:  Copyright (c) 2005-2023 by Timothy A. Davis.  All Rights Reserved.\n"
-
-# Skipping MacroDefinition: UMFPACK_LICENSE_PART1 \
-#"\nUMFPACK License: SPDX-License-Identifier: GPL-2.0+\n" \
-#"   UMFPACK is available under alternate licenses,\n" \
-#"   contact T. Davis for details.\n"
-
-const UMFPACK_LICENSE_PART2 = "\n"
-
-# Skipping MacroDefinition: UMFPACK_LICENSE_PART3 \
-#"\n" \
-#"Availability: http://www.suitesparse.com" \
-#"\n"
-
-const UMFPACK_DATE = "Jan 17, 2023"
+const UMFPACK_DATE = "June 16, 2023"
 
 const UMFPACK_MAIN_VERSION = 6
 
 const UMFPACK_SUB_VERSION = 1
 
-const UMFPACK_SUBSUB_VERSION = 0
+const UMFPACK_SUBSUB_VERSION = 1
 
 UMFPACK_VER_CODE(main, sub) = main * 1000 + sub
 
@@ -3169,4 +3849,3 @@ const UMFPACK_Q_Uat = 12
 const UMFPACK_Ut = 13
 
 const UMFPACK_Uat = 14
-
diff --git a/src/solvers/lib/aarch64-linux-musl.jl b/src/solvers/lib/aarch64-linux-musl.jl
index fcf756d2..a5aa4e44 100644
--- a/src/solvers/lib/aarch64-linux-musl.jl
+++ b/src/solvers/lib/aarch64-linux-musl.jl
@@ -1,137 +1,150 @@
 function SuiteSparse_config_printf_func_get()
-    @ccall libcholmod.SuiteSparse_config_printf_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_printf_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_malloc_func_get()
-    @ccall libcholmod.SuiteSparse_config_malloc_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_malloc_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_calloc_func_get()
-    @ccall libcholmod.SuiteSparse_config_calloc_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_calloc_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_realloc_func_get()
-    @ccall libcholmod.SuiteSparse_config_realloc_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_realloc_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_free_func_get()
-    @ccall libcholmod.SuiteSparse_config_free_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_free_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_hypot_func_get()
-    @ccall libcholmod.SuiteSparse_config_hypot_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_hypot_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_divcomplex_func_get()
-    @ccall libcholmod.SuiteSparse_config_divcomplex_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_divcomplex_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_malloc_func_set(malloc_func)
-    @ccall libcholmod.SuiteSparse_config_malloc_func_set(malloc_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_malloc_func_set(malloc_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_calloc_func_set(calloc_func)
-    @ccall libcholmod.SuiteSparse_config_calloc_func_set(calloc_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_calloc_func_set(calloc_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_realloc_func_set(realloc_func)
-    @ccall libcholmod.SuiteSparse_config_realloc_func_set(realloc_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_realloc_func_set(realloc_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_free_func_set(free_func)
-    @ccall libcholmod.SuiteSparse_config_free_func_set(free_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_free_func_set(free_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_printf_func_set(printf_func)
-    @ccall libcholmod.SuiteSparse_config_printf_func_set(printf_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_printf_func_set(printf_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_hypot_func_set(hypot_func)
-    @ccall libcholmod.SuiteSparse_config_hypot_func_set(hypot_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_hypot_func_set(hypot_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_divcomplex_func_set(divcomplex_func)
-    @ccall libcholmod.SuiteSparse_config_divcomplex_func_set(divcomplex_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_divcomplex_func_set(divcomplex_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_malloc(s)
-    @ccall libcholmod.SuiteSparse_config_malloc(s::Csize_t)::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_malloc(s::Csize_t)::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_calloc(n, s)
-    @ccall libcholmod.SuiteSparse_config_calloc(n::Csize_t, s::Csize_t)::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_calloc(n::Csize_t,
+                                                          s::Csize_t)::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_realloc(arg1, s)
-    @ccall libcholmod.SuiteSparse_config_realloc(arg1::Ptr{Cvoid}, s::Csize_t)::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_realloc(arg1::Ptr{Cvoid},
+                                                           s::Csize_t)::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_free(arg1)
-    @ccall libcholmod.SuiteSparse_config_free(arg1::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_free(arg1::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_hypot(x, y)
-    @ccall libcholmod.SuiteSparse_config_hypot(x::Cdouble, y::Cdouble)::Cdouble
+    @ccall libsuitesparseconfig.SuiteSparse_config_hypot(x::Cdouble, y::Cdouble)::Cdouble
 end
 
 function SuiteSparse_config_divcomplex(xr, xi, yr, yi, zr, zi)
-    @ccall libcholmod.SuiteSparse_config_divcomplex(xr::Cdouble, xi::Cdouble, yr::Cdouble, yi::Cdouble, zr::Ptr{Cdouble}, zi::Ptr{Cdouble})::Cint
+    @ccall libsuitesparseconfig.SuiteSparse_config_divcomplex(xr::Cdouble, xi::Cdouble,
+                                                              yr::Cdouble, yi::Cdouble,
+                                                              zr::Ptr{Cdouble},
+                                                              zi::Ptr{Cdouble})::Cint
 end
 
 function SuiteSparse_start()
-    @ccall libcholmod.SuiteSparse_start()::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_start()::Cvoid
 end
 
 function SuiteSparse_finish()
-    @ccall libcholmod.SuiteSparse_finish()::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_finish()::Cvoid
 end
 
 function SuiteSparse_malloc(nitems, size_of_item)
-    @ccall libcholmod.SuiteSparse_malloc(nitems::Csize_t, size_of_item::Csize_t)::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_malloc(nitems::Csize_t,
+                                                   size_of_item::Csize_t)::Ptr{Cvoid}
 end
 
 function SuiteSparse_calloc(nitems, size_of_item)
-    @ccall libcholmod.SuiteSparse_calloc(nitems::Csize_t, size_of_item::Csize_t)::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_calloc(nitems::Csize_t,
+                                                   size_of_item::Csize_t)::Ptr{Cvoid}
 end
 
 function SuiteSparse_realloc(nitems_new, nitems_old, size_of_item, p, ok)
-    @ccall libcholmod.SuiteSparse_realloc(nitems_new::Csize_t, nitems_old::Csize_t, size_of_item::Csize_t, p::Ptr{Cvoid}, ok::Ptr{Cint})::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_realloc(nitems_new::Csize_t,
+                                                    nitems_old::Csize_t,
+                                                    size_of_item::Csize_t, p::Ptr{Cvoid},
+                                                    ok::Ptr{Cint})::Ptr{Cvoid}
 end
 
 function SuiteSparse_free(p)
-    @ccall libcholmod.SuiteSparse_free(p::Ptr{Cvoid})::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_free(p::Ptr{Cvoid})::Ptr{Cvoid}
 end
 
 function SuiteSparse_tic(tic)
-    @ccall libcholmod.SuiteSparse_tic(tic::Ptr{Cdouble})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_tic(tic::Ptr{Cdouble})::Cvoid
 end
 
 function SuiteSparse_toc(tic)
-    @ccall libcholmod.SuiteSparse_toc(tic::Ptr{Cdouble})::Cdouble
+    @ccall libsuitesparseconfig.SuiteSparse_toc(tic::Ptr{Cdouble})::Cdouble
 end
 
 function SuiteSparse_time()
-    @ccall libcholmod.SuiteSparse_time()::Cdouble
+    @ccall libsuitesparseconfig.SuiteSparse_time()::Cdouble
 end
 
 function SuiteSparse_hypot(x, y)
-    @ccall libcholmod.SuiteSparse_hypot(x::Cdouble, y::Cdouble)::Cdouble
+    @ccall libsuitesparseconfig.SuiteSparse_hypot(x::Cdouble, y::Cdouble)::Cdouble
 end
 
 function SuiteSparse_divcomplex(ar, ai, br, bi, cr, ci)
-    @ccall libcholmod.SuiteSparse_divcomplex(ar::Cdouble, ai::Cdouble, br::Cdouble, bi::Cdouble, cr::Ptr{Cdouble}, ci::Ptr{Cdouble})::Cint
+    @ccall libsuitesparseconfig.SuiteSparse_divcomplex(ar::Cdouble, ai::Cdouble,
+                                                       br::Cdouble, bi::Cdouble,
+                                                       cr::Ptr{Cdouble},
+                                                       ci::Ptr{Cdouble})::Cint
 end
 
 function SuiteSparse_version(version)
-    @ccall libcholmod.SuiteSparse_version(version::Ptr{Cint})::Cint
+    @ccall libsuitesparseconfig.SuiteSparse_version(version::Ptr{Cint})::Cint
 end
 
 function SuiteSparse_BLAS_library()
-    @ccall libcholmod.SuiteSparse_BLAS_library()::Ptr{Cchar}
+    @ccall libsuitesparseconfig.SuiteSparse_BLAS_library()::Ptr{Cchar}
 end
 
 function SuiteSparse_BLAS_integer_size()
-    @ccall libcholmod.SuiteSparse_BLAS_integer_size()::Csize_t
+    @ccall libsuitesparseconfig.SuiteSparse_BLAS_integer_size()::Csize_t
 end
 
 struct cholmod_method_struct
@@ -140,16 +153,16 @@ struct cholmod_method_struct
     prune_dense::Cdouble
     prune_dense2::Cdouble
     nd_oksep::Cdouble
-    other_1::NTuple{4, Cdouble}
+    other_1::NTuple{4,Cdouble}
     nd_small::Csize_t
-    other_2::NTuple{4, Csize_t}
+    other_2::NTuple{4,Csize_t}
     aggressive::Cint
     order_for_lu::Cint
     nd_compress::Cint
     nd_camd::Cint
     nd_components::Cint
     ordering::Cint
-    other_3::NTuple{4, Csize_t}
+    other_3::NTuple{4,Csize_t}
 end
 
 mutable struct cholmod_common_struct
@@ -166,8 +179,8 @@ mutable struct cholmod_common_struct
     final_pack::Cint
     final_monotonic::Cint
     final_resymbol::Cint
-    zrelax::NTuple{3, Cdouble}
-    nrelax::NTuple{3, Csize_t}
+    zrelax::NTuple{3,Cdouble}
+    nrelax::NTuple{3,Csize_t}
     prefer_zomplex::Cint
     prefer_upper::Cint
     quick_return_if_not_posdef::Cint
@@ -179,7 +192,7 @@ mutable struct cholmod_common_struct
     nmethods::Cint
     current::Cint
     selected::Cint
-    method::NTuple{10, cholmod_method_struct}
+    method::NTuple{10,cholmod_method_struct}
     postorder::Cint
     default_nesdis::Cint
     metis_memory::Cdouble
@@ -222,7 +235,7 @@ mutable struct cholmod_common_struct
     SPQR_flopcount_bound::Cdouble
     SPQR_tol_used::Cdouble
     SPQR_norm_E_fro::Cdouble
-    SPQR_istat::NTuple{10, Int64}
+    SPQR_istat::NTuple{10,Int64}
     useGPU::Cint
     maxGpuMemBytes::Csize_t
     maxGpuMemFraction::Cdouble
@@ -231,10 +244,10 @@ mutable struct cholmod_common_struct
     gpuFlops::Int64
     gpuNumKernelLaunches::Cint
     cublasHandle::Ptr{Cvoid}
-    gpuStream::NTuple{8, Ptr{Cvoid}}
-    cublasEventPotrf::NTuple{3, Ptr{Cvoid}}
+    gpuStream::NTuple{8,Ptr{Cvoid}}
+    cublasEventPotrf::NTuple{3,Ptr{Cvoid}}
     updateCKernelsComplete::Ptr{Cvoid}
-    updateCBuffersFree::NTuple{8, Ptr{Cvoid}}
+    updateCBuffersFree::NTuple{8,Ptr{Cvoid}}
     dev_mempool::Ptr{Cvoid}
     dev_mempool_size::Csize_t
     host_pinned_mempool::Ptr{Cvoid}
@@ -300,11 +313,14 @@ function cholmod_l_maxrank(arg1, arg2)
 end
 
 function cholmod_allocate_work(nrow, iworksize, xworksize, Common)
-    @ccall libcholmod.cholmod_allocate_work(nrow::Csize_t, iworksize::Csize_t, xworksize::Csize_t, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_allocate_work(nrow::Csize_t, iworksize::Csize_t,
+                                            xworksize::Csize_t,
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_allocate_work(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_allocate_work(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_allocate_work(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t,
+                                              arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_free_work(Common)
@@ -324,11 +340,13 @@ function cholmod_l_clear_flag(arg1)
 end
 
 function cholmod_error(status, file, line, message, Common)
-    @ccall libcholmod.cholmod_error(status::Cint, file::Ptr{Cchar}, line::Cint, message::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_error(status::Cint, file::Ptr{Cchar}, line::Cint,
+                                    message::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_error(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_error(arg1::Cint, arg2::Ptr{Cchar}, arg3::Cint, arg4::Ptr{Cchar}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_error(arg1::Cint, arg2::Ptr{Cchar}, arg3::Cint,
+                                      arg4::Ptr{Cchar}, arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_dbound(dj, Common)
@@ -348,11 +366,14 @@ function cholmod_l_hypot(arg1, arg2)
 end
 
 function cholmod_divcomplex(ar, ai, br, bi, cr, ci)
-    @ccall libcholmod.cholmod_divcomplex(ar::Cdouble, ai::Cdouble, br::Cdouble, bi::Cdouble, cr::Ptr{Cdouble}, ci::Ptr{Cdouble})::Cint
+    @ccall libcholmod.cholmod_divcomplex(ar::Cdouble, ai::Cdouble, br::Cdouble, bi::Cdouble,
+                                         cr::Ptr{Cdouble}, ci::Ptr{Cdouble})::Cint
 end
 
 function cholmod_l_divcomplex(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_divcomplex(arg1::Cdouble, arg2::Cdouble, arg3::Cdouble, arg4::Cdouble, arg5::Ptr{Cdouble}, arg6::Ptr{Cdouble})::Cint
+    @ccall libcholmod.cholmod_l_divcomplex(arg1::Cdouble, arg2::Cdouble, arg3::Cdouble,
+                                           arg4::Cdouble, arg5::Ptr{Cdouble},
+                                           arg6::Ptr{Cdouble})::Cint
 end
 
 mutable struct cholmod_sparse_struct
@@ -384,155 +405,217 @@ end
 const descendantScore = cholmod_descendant_score_t
 
 function cholmod_score_comp(i, j)
-    @ccall libcholmod.cholmod_score_comp(i::Ptr{cholmod_descendant_score_t}, j::Ptr{cholmod_descendant_score_t})::Cint
+    @ccall libcholmod.cholmod_score_comp(i::Ptr{cholmod_descendant_score_t},
+                                         j::Ptr{cholmod_descendant_score_t})::Cint
 end
 
 function cholmod_l_score_comp(i, j)
-    @ccall libcholmod.cholmod_l_score_comp(i::Ptr{cholmod_descendant_score_t}, j::Ptr{cholmod_descendant_score_t})::Cint
+    @ccall libcholmod.cholmod_l_score_comp(i::Ptr{cholmod_descendant_score_t},
+                                           j::Ptr{cholmod_descendant_score_t})::Cint
 end
 
 function cholmod_allocate_sparse(nrow, ncol, nzmax, sorted, packed, stype, xtype, Common)
-    @ccall libcholmod.cholmod_allocate_sparse(nrow::Csize_t, ncol::Csize_t, nzmax::Csize_t, sorted::Cint, packed::Cint, stype::Cint, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_allocate_sparse(nrow::Csize_t, ncol::Csize_t, nzmax::Csize_t,
+                                              sorted::Cint, packed::Cint, stype::Cint,
+                                              xtype::Cint,
+                                              Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_allocate_sparse(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
-    @ccall libcholmod.cholmod_l_allocate_sparse(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t, arg4::Cint, arg5::Cint, arg6::Cint, arg7::Cint, arg8::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_allocate_sparse(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t,
+                                                arg4::Cint, arg5::Cint, arg6::Cint,
+                                                arg7::Cint,
+                                                arg8::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_free_sparse(A, Common)
-    @ccall libcholmod.cholmod_free_sparse(A::Ptr{Ptr{cholmod_sparse}}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_free_sparse(A::Ptr{Ptr{cholmod_sparse}},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_free_sparse(arg1, arg2)
-    @ccall libcholmod.cholmod_l_free_sparse(arg1::Ptr{Ptr{cholmod_sparse}}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_free_sparse(arg1::Ptr{Ptr{cholmod_sparse}},
+                                            arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_reallocate_sparse(nznew, A, Common)
-    @ccall libcholmod.cholmod_reallocate_sparse(nznew::Csize_t, A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_reallocate_sparse(nznew::Csize_t, A::Ptr{cholmod_sparse},
+                                                Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_reallocate_sparse(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_reallocate_sparse(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_reallocate_sparse(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                                  arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_nnz(A, Common)
-    @ccall libcholmod.cholmod_nnz(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_nnz(A::Ptr{cholmod_sparse},
+                                  Common::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_l_nnz(arg1, arg2)
-    @ccall libcholmod.cholmod_l_nnz(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_l_nnz(arg1::Ptr{cholmod_sparse},
+                                    arg2::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_speye(nrow, ncol, xtype, Common)
-    @ccall libcholmod.cholmod_speye(nrow::Csize_t, ncol::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_speye(nrow::Csize_t, ncol::Csize_t, xtype::Cint,
+                                    Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_speye(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_speye(arg1::Csize_t, arg2::Csize_t, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_speye(arg1::Csize_t, arg2::Csize_t, arg3::Cint,
+                                      arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_spzeros(nrow, ncol, nzmax, xtype, Common)
-    @ccall libcholmod.cholmod_spzeros(nrow::Csize_t, ncol::Csize_t, nzmax::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_spzeros(nrow::Csize_t, ncol::Csize_t, nzmax::Csize_t,
+                                      xtype::Cint,
+                                      Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_spzeros(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_spzeros(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t, arg4::Cint, arg5::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_spzeros(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t,
+                                        arg4::Cint,
+                                        arg5::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_transpose(A, values, Common)
-    @ccall libcholmod.cholmod_transpose(A::Ptr{cholmod_sparse}, values::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_transpose(A::Ptr{cholmod_sparse}, values::Cint,
+                                        Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_transpose(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_transpose(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_transpose(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                          arg3::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_transpose_unsym(A, values, Perm, fset, fsize, F, Common)
-    @ccall libcholmod.cholmod_transpose_unsym(A::Ptr{cholmod_sparse}, values::Cint, Perm::Ptr{Int32}, fset::Ptr{Int32}, fsize::Csize_t, F::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_transpose_unsym(A::Ptr{cholmod_sparse}, values::Cint,
+                                              Perm::Ptr{Int32}, fset::Ptr{Int32},
+                                              fsize::Csize_t, F::Ptr{cholmod_sparse},
+                                              Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_transpose_unsym(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_transpose_unsym(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Csize_t, arg6::Ptr{cholmod_sparse}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_transpose_unsym(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                                arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                                arg5::Csize_t, arg6::Ptr{cholmod_sparse},
+                                                arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_transpose_sym(A, values, Perm, F, Common)
-    @ccall libcholmod.cholmod_transpose_sym(A::Ptr{cholmod_sparse}, values::Cint, Perm::Ptr{Int32}, F::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_transpose_sym(A::Ptr{cholmod_sparse}, values::Cint,
+                                            Perm::Ptr{Int32}, F::Ptr{cholmod_sparse},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_transpose_sym(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_transpose_sym(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{Int64}, arg4::Ptr{cholmod_sparse}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_transpose_sym(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                              arg3::Ptr{Int64}, arg4::Ptr{cholmod_sparse},
+                                              arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_ptranspose(A, values, Perm, fset, fsize, Common)
-    @ccall libcholmod.cholmod_ptranspose(A::Ptr{cholmod_sparse}, values::Cint, Perm::Ptr{Int32}, fset::Ptr{Int32}, fsize::Csize_t, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_ptranspose(A::Ptr{cholmod_sparse}, values::Cint,
+                                         Perm::Ptr{Int32}, fset::Ptr{Int32}, fsize::Csize_t,
+                                         Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_ptranspose(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_ptranspose(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Csize_t, arg6::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_ptranspose(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                           arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                           arg5::Csize_t,
+                                           arg6::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_sort(A, Common)
-    @ccall libcholmod.cholmod_sort(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_sort(A::Ptr{cholmod_sparse},
+                                   Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_sort(arg1, arg2)
-    @ccall libcholmod.cholmod_l_sort(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_sort(arg1::Ptr{cholmod_sparse},
+                                     arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_band(A, k1, k2, mode, Common)
-    @ccall libcholmod.cholmod_band(A::Ptr{cholmod_sparse}, k1::Int64, k2::Int64, mode::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_band(A::Ptr{cholmod_sparse}, k1::Int64, k2::Int64, mode::Cint,
+                                   Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_band(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_band(arg1::Ptr{cholmod_sparse}, arg2::Int64, arg3::Int64, arg4::Cint, arg5::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_band(arg1::Ptr{cholmod_sparse}, arg2::Int64, arg3::Int64,
+                                     arg4::Cint,
+                                     arg5::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_band_inplace(k1, k2, mode, A, Common)
-    @ccall libcholmod.cholmod_band_inplace(k1::Int64, k2::Int64, mode::Cint, A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_band_inplace(k1::Int64, k2::Int64, mode::Cint,
+                                           A::Ptr{cholmod_sparse},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_band_inplace(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_band_inplace(arg1::Int64, arg2::Int64, arg3::Cint, arg4::Ptr{cholmod_sparse}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_band_inplace(arg1::Int64, arg2::Int64, arg3::Cint,
+                                             arg4::Ptr{cholmod_sparse},
+                                             arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_aat(A, fset, fsize, mode, Common)
-    @ccall libcholmod.cholmod_aat(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, mode::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_aat(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t,
+                                  mode::Cint,
+                                  Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_aat(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_aat(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Cint, arg5::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_aat(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                    arg3::Csize_t, arg4::Cint,
+                                    arg5::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_copy_sparse(A, Common)
-    @ccall libcholmod.cholmod_copy_sparse(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_copy_sparse(A::Ptr{cholmod_sparse},
+                                          Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_copy_sparse(arg1, arg2)
-    @ccall libcholmod.cholmod_l_copy_sparse(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_copy_sparse(arg1::Ptr{cholmod_sparse},
+                                            arg2::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_copy(A, stype, mode, Common)
-    @ccall libcholmod.cholmod_copy(A::Ptr{cholmod_sparse}, stype::Cint, mode::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_copy(A::Ptr{cholmod_sparse}, stype::Cint, mode::Cint,
+                                   Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_copy(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_copy(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_copy(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Cint,
+                                     arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_add(A, B, alpha, beta, values, sorted, Common)
-    @ccall libcholmod.cholmod_add(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse}, alpha::Ptr{Cdouble}, beta::Ptr{Cdouble}, values::Cint, sorted::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_add(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse},
+                                  alpha::Ptr{Cdouble}, beta::Ptr{Cdouble}, values::Cint,
+                                  sorted::Cint,
+                                  Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_add(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_add(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Ptr{Cdouble}, arg5::Cint, arg6::Cint, arg7::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_add(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse},
+                                    arg3::Ptr{Cdouble}, arg4::Ptr{Cdouble}, arg5::Cint,
+                                    arg6::Cint,
+                                    arg7::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_sparse_xtype(to_xtype, A, Common)
-    @ccall libcholmod.cholmod_sparse_xtype(to_xtype::Cint, A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_sparse_xtype(to_xtype::Cint, A::Ptr{cholmod_sparse},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_sparse_xtype(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_sparse_xtype(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_sparse_xtype(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                             arg3::Ptr{cholmod_common})::Cint
 end
 
 mutable struct cholmod_factor_struct
@@ -572,75 +655,100 @@ end
 const cholmod_factor = cholmod_factor_struct
 
 function cholmod_allocate_factor(n, Common)
-    @ccall libcholmod.cholmod_allocate_factor(n::Csize_t, Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_allocate_factor(n::Csize_t,
+                                              Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_l_allocate_factor(arg1, arg2)
-    @ccall libcholmod.cholmod_l_allocate_factor(arg1::Csize_t, arg2::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_l_allocate_factor(arg1::Csize_t,
+                                                arg2::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_free_factor(L, Common)
-    @ccall libcholmod.cholmod_free_factor(L::Ptr{Ptr{cholmod_factor}}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_free_factor(L::Ptr{Ptr{cholmod_factor}},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_free_factor(arg1, arg2)
-    @ccall libcholmod.cholmod_l_free_factor(arg1::Ptr{Ptr{cholmod_factor}}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_free_factor(arg1::Ptr{Ptr{cholmod_factor}},
+                                            arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_reallocate_factor(nznew, L, Common)
-    @ccall libcholmod.cholmod_reallocate_factor(nznew::Csize_t, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_reallocate_factor(nznew::Csize_t, L::Ptr{cholmod_factor},
+                                                Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_reallocate_factor(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_reallocate_factor(arg1::Csize_t, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_reallocate_factor(arg1::Csize_t, arg2::Ptr{cholmod_factor},
+                                                  arg3::Ptr{cholmod_common})::Cint
 end
 
-function cholmod_change_factor(to_xtype, to_ll, to_super, to_packed, to_monotonic, L, Common)
-    @ccall libcholmod.cholmod_change_factor(to_xtype::Cint, to_ll::Cint, to_super::Cint, to_packed::Cint, to_monotonic::Cint, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+function cholmod_change_factor(to_xtype, to_ll, to_super, to_packed, to_monotonic, L,
+                               Common)
+    @ccall libcholmod.cholmod_change_factor(to_xtype::Cint, to_ll::Cint, to_super::Cint,
+                                            to_packed::Cint, to_monotonic::Cint,
+                                            L::Ptr{cholmod_factor},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_change_factor(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_change_factor(arg1::Cint, arg2::Cint, arg3::Cint, arg4::Cint, arg5::Cint, arg6::Ptr{cholmod_factor}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_change_factor(arg1::Cint, arg2::Cint, arg3::Cint,
+                                              arg4::Cint, arg5::Cint,
+                                              arg6::Ptr{cholmod_factor},
+                                              arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_pack_factor(L, Common)
-    @ccall libcholmod.cholmod_pack_factor(L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_pack_factor(L::Ptr{cholmod_factor},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_pack_factor(arg1, arg2)
-    @ccall libcholmod.cholmod_l_pack_factor(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_pack_factor(arg1::Ptr{cholmod_factor},
+                                            arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_reallocate_column(j, need, L, Common)
-    @ccall libcholmod.cholmod_reallocate_column(j::Csize_t, need::Csize_t, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_reallocate_column(j::Csize_t, need::Csize_t,
+                                                L::Ptr{cholmod_factor},
+                                                Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_reallocate_column(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_reallocate_column(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{cholmod_factor}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_reallocate_column(arg1::Csize_t, arg2::Csize_t,
+                                                  arg3::Ptr{cholmod_factor},
+                                                  arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_factor_to_sparse(L, Common)
-    @ccall libcholmod.cholmod_factor_to_sparse(L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_factor_to_sparse(L::Ptr{cholmod_factor},
+                                               Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_factor_to_sparse(arg1, arg2)
-    @ccall libcholmod.cholmod_l_factor_to_sparse(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_factor_to_sparse(arg1::Ptr{cholmod_factor},
+                                                 arg2::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_copy_factor(L, Common)
-    @ccall libcholmod.cholmod_copy_factor(L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_copy_factor(L::Ptr{cholmod_factor},
+                                          Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_l_copy_factor(arg1, arg2)
-    @ccall libcholmod.cholmod_l_copy_factor(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_l_copy_factor(arg1::Ptr{cholmod_factor},
+                                            arg2::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_factor_xtype(to_xtype, L, Common)
-    @ccall libcholmod.cholmod_factor_xtype(to_xtype::Cint, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_factor_xtype(to_xtype::Cint, L::Ptr{cholmod_factor},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_factor_xtype(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_factor_xtype(arg1::Cint, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_factor_xtype(arg1::Cint, arg2::Ptr{cholmod_factor},
+                                             arg3::Ptr{cholmod_common})::Cint
 end
 
 mutable struct cholmod_dense_struct
@@ -658,91 +766,118 @@ end
 const cholmod_dense = cholmod_dense_struct
 
 function cholmod_allocate_dense(nrow, ncol, d, xtype, Common)
-    @ccall libcholmod.cholmod_allocate_dense(nrow::Csize_t, ncol::Csize_t, d::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_allocate_dense(nrow::Csize_t, ncol::Csize_t, d::Csize_t,
+                                             xtype::Cint,
+                                             Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_allocate_dense(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_allocate_dense(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t, arg4::Cint, arg5::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_allocate_dense(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t,
+                                               arg4::Cint,
+                                               arg5::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_zeros(nrow, ncol, xtype, Common)
-    @ccall libcholmod.cholmod_zeros(nrow::Csize_t, ncol::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_zeros(nrow::Csize_t, ncol::Csize_t, xtype::Cint,
+                                    Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_zeros(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_zeros(arg1::Csize_t, arg2::Csize_t, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_zeros(arg1::Csize_t, arg2::Csize_t, arg3::Cint,
+                                      arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_ones(nrow, ncol, xtype, Common)
-    @ccall libcholmod.cholmod_ones(nrow::Csize_t, ncol::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_ones(nrow::Csize_t, ncol::Csize_t, xtype::Cint,
+                                   Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_ones(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_ones(arg1::Csize_t, arg2::Csize_t, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_ones(arg1::Csize_t, arg2::Csize_t, arg3::Cint,
+                                     arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_eye(nrow, ncol, xtype, Common)
-    @ccall libcholmod.cholmod_eye(nrow::Csize_t, ncol::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_eye(nrow::Csize_t, ncol::Csize_t, xtype::Cint,
+                                  Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_eye(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_eye(arg1::Csize_t, arg2::Csize_t, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_eye(arg1::Csize_t, arg2::Csize_t, arg3::Cint,
+                                    arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_free_dense(X, Common)
-    @ccall libcholmod.cholmod_free_dense(X::Ptr{Ptr{cholmod_dense}}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_free_dense(X::Ptr{Ptr{cholmod_dense}},
+                                         Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_free_dense(arg1, arg2)
-    @ccall libcholmod.cholmod_l_free_dense(arg1::Ptr{Ptr{cholmod_dense}}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_free_dense(arg1::Ptr{Ptr{cholmod_dense}},
+                                           arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_ensure_dense(XHandle, nrow, ncol, d, xtype, Common)
-    @ccall libcholmod.cholmod_ensure_dense(XHandle::Ptr{Ptr{cholmod_dense}}, nrow::Csize_t, ncol::Csize_t, d::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_ensure_dense(XHandle::Ptr{Ptr{cholmod_dense}}, nrow::Csize_t,
+                                           ncol::Csize_t, d::Csize_t, xtype::Cint,
+                                           Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_ensure_dense(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_ensure_dense(arg1::Ptr{Ptr{cholmod_dense}}, arg2::Csize_t, arg3::Csize_t, arg4::Csize_t, arg5::Cint, arg6::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_ensure_dense(arg1::Ptr{Ptr{cholmod_dense}}, arg2::Csize_t,
+                                             arg3::Csize_t, arg4::Csize_t, arg5::Cint,
+                                             arg6::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_sparse_to_dense(A, Common)
-    @ccall libcholmod.cholmod_sparse_to_dense(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_sparse_to_dense(A::Ptr{cholmod_sparse},
+                                              Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_sparse_to_dense(arg1, arg2)
-    @ccall libcholmod.cholmod_l_sparse_to_dense(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_sparse_to_dense(arg1::Ptr{cholmod_sparse},
+                                                arg2::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_dense_to_sparse(X, values, Common)
-    @ccall libcholmod.cholmod_dense_to_sparse(X::Ptr{cholmod_dense}, values::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_dense_to_sparse(X::Ptr{cholmod_dense}, values::Cint,
+                                              Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_dense_to_sparse(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_dense_to_sparse(arg1::Ptr{cholmod_dense}, arg2::Cint, arg3::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_dense_to_sparse(arg1::Ptr{cholmod_dense}, arg2::Cint,
+                                                arg3::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_copy_dense(X, Common)
-    @ccall libcholmod.cholmod_copy_dense(X::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_copy_dense(X::Ptr{cholmod_dense},
+                                         Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_copy_dense(arg1, arg2)
-    @ccall libcholmod.cholmod_l_copy_dense(arg1::Ptr{cholmod_dense}, arg2::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_copy_dense(arg1::Ptr{cholmod_dense},
+                                           arg2::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_copy_dense2(X, Y, Common)
-    @ccall libcholmod.cholmod_copy_dense2(X::Ptr{cholmod_dense}, Y::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_copy_dense2(X::Ptr{cholmod_dense}, Y::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_copy_dense2(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_copy_dense2(arg1::Ptr{cholmod_dense}, arg2::Ptr{cholmod_dense}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_copy_dense2(arg1::Ptr{cholmod_dense},
+                                            arg2::Ptr{cholmod_dense},
+                                            arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_dense_xtype(to_xtype, X, Common)
-    @ccall libcholmod.cholmod_dense_xtype(to_xtype::Cint, X::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_dense_xtype(to_xtype::Cint, X::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_dense_xtype(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_dense_xtype(arg1::Cint, arg2::Ptr{cholmod_dense}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_dense_xtype(arg1::Cint, arg2::Ptr{cholmod_dense},
+                                            arg3::Ptr{cholmod_common})::Cint
 end
 
 mutable struct cholmod_triplet_struct
@@ -764,99 +899,137 @@ end
 const cholmod_triplet = cholmod_triplet_struct
 
 function cholmod_allocate_triplet(nrow, ncol, nzmax, stype, xtype, Common)
-    @ccall libcholmod.cholmod_allocate_triplet(nrow::Csize_t, ncol::Csize_t, nzmax::Csize_t, stype::Cint, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_allocate_triplet(nrow::Csize_t, ncol::Csize_t, nzmax::Csize_t,
+                                               stype::Cint, xtype::Cint,
+                                               Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_l_allocate_triplet(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_allocate_triplet(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t, arg4::Cint, arg5::Cint, arg6::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_l_allocate_triplet(arg1::Csize_t, arg2::Csize_t,
+                                                 arg3::Csize_t, arg4::Cint, arg5::Cint,
+                                                 arg6::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_free_triplet(T, Common)
-    @ccall libcholmod.cholmod_free_triplet(T::Ptr{Ptr{cholmod_triplet}}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_free_triplet(T::Ptr{Ptr{cholmod_triplet}},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_free_triplet(arg1, arg2)
-    @ccall libcholmod.cholmod_l_free_triplet(arg1::Ptr{Ptr{cholmod_triplet}}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_free_triplet(arg1::Ptr{Ptr{cholmod_triplet}},
+                                             arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_reallocate_triplet(nznew, T, Common)
-    @ccall libcholmod.cholmod_reallocate_triplet(nznew::Csize_t, T::Ptr{cholmod_triplet}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_reallocate_triplet(nznew::Csize_t, T::Ptr{cholmod_triplet},
+                                                 Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_reallocate_triplet(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_reallocate_triplet(arg1::Csize_t, arg2::Ptr{cholmod_triplet}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_reallocate_triplet(arg1::Csize_t,
+                                                   arg2::Ptr{cholmod_triplet},
+                                                   arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_sparse_to_triplet(A, Common)
-    @ccall libcholmod.cholmod_sparse_to_triplet(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_sparse_to_triplet(A::Ptr{cholmod_sparse},
+                                                Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_l_sparse_to_triplet(arg1, arg2)
-    @ccall libcholmod.cholmod_l_sparse_to_triplet(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_l_sparse_to_triplet(arg1::Ptr{cholmod_sparse},
+                                                  arg2::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_triplet_to_sparse(T, nzmax, Common)
-    @ccall libcholmod.cholmod_triplet_to_sparse(T::Ptr{cholmod_triplet}, nzmax::Csize_t, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_triplet_to_sparse(T::Ptr{cholmod_triplet}, nzmax::Csize_t,
+                                                Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_triplet_to_sparse(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_triplet_to_sparse(arg1::Ptr{cholmod_triplet}, arg2::Csize_t, arg3::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_triplet_to_sparse(arg1::Ptr{cholmod_triplet}, arg2::Csize_t,
+                                                  arg3::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_copy_triplet(T, Common)
-    @ccall libcholmod.cholmod_copy_triplet(T::Ptr{cholmod_triplet}, Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_copy_triplet(T::Ptr{cholmod_triplet},
+                                           Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_l_copy_triplet(arg1, arg2)
-    @ccall libcholmod.cholmod_l_copy_triplet(arg1::Ptr{cholmod_triplet}, arg2::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_l_copy_triplet(arg1::Ptr{cholmod_triplet},
+                                             arg2::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_triplet_xtype(to_xtype, T, Common)
-    @ccall libcholmod.cholmod_triplet_xtype(to_xtype::Cint, T::Ptr{cholmod_triplet}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_triplet_xtype(to_xtype::Cint, T::Ptr{cholmod_triplet},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_triplet_xtype(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_triplet_xtype(arg1::Cint, arg2::Ptr{cholmod_triplet}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_triplet_xtype(arg1::Cint, arg2::Ptr{cholmod_triplet},
+                                              arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_malloc(n, size, Common)
-    @ccall libcholmod.cholmod_malloc(n::Csize_t, size::Csize_t, Common::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_malloc(n::Csize_t, size::Csize_t,
+                                     Common::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_l_malloc(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_malloc(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_l_malloc(arg1::Csize_t, arg2::Csize_t,
+                                       arg3::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_calloc(n, size, Common)
-    @ccall libcholmod.cholmod_calloc(n::Csize_t, size::Csize_t, Common::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_calloc(n::Csize_t, size::Csize_t,
+                                     Common::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_l_calloc(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_calloc(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_l_calloc(arg1::Csize_t, arg2::Csize_t,
+                                       arg3::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_free(n, size, p, Common)
-    @ccall libcholmod.cholmod_free(n::Csize_t, size::Csize_t, p::Ptr{Cvoid}, Common::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_free(n::Csize_t, size::Csize_t, p::Ptr{Cvoid},
+                                   Common::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_l_free(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_free(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{Cvoid}, arg4::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_l_free(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{Cvoid},
+                                     arg4::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_realloc(nnew, size, p, n, Common)
-    @ccall libcholmod.cholmod_realloc(nnew::Csize_t, size::Csize_t, p::Ptr{Cvoid}, n::Ptr{Csize_t}, Common::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_realloc(nnew::Csize_t, size::Csize_t, p::Ptr{Cvoid},
+                                      n::Ptr{Csize_t},
+                                      Common::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_l_realloc(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_realloc(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{Cvoid}, arg4::Ptr{Csize_t}, arg5::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_l_realloc(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{Cvoid},
+                                        arg4::Ptr{Csize_t},
+                                        arg5::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
-function cholmod_realloc_multiple(nnew, nint, xtype, Iblock, Jblock, Xblock, Zblock, n, Common)
-    @ccall libcholmod.cholmod_realloc_multiple(nnew::Csize_t, nint::Cint, xtype::Cint, Iblock::Ptr{Ptr{Cvoid}}, Jblock::Ptr{Ptr{Cvoid}}, Xblock::Ptr{Ptr{Cvoid}}, Zblock::Ptr{Ptr{Cvoid}}, n::Ptr{Csize_t}, Common::Ptr{cholmod_common})::Cint
+function cholmod_realloc_multiple(nnew, nint, xtype, Iblock, Jblock, Xblock, Zblock, n,
+                                  Common)
+    @ccall libcholmod.cholmod_realloc_multiple(nnew::Csize_t, nint::Cint, xtype::Cint,
+                                               Iblock::Ptr{Ptr{Cvoid}},
+                                               Jblock::Ptr{Ptr{Cvoid}},
+                                               Xblock::Ptr{Ptr{Cvoid}},
+                                               Zblock::Ptr{Ptr{Cvoid}}, n::Ptr{Csize_t},
+                                               Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_realloc_multiple(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
-    @ccall libcholmod.cholmod_l_realloc_multiple(arg1::Csize_t, arg2::Cint, arg3::Cint, arg4::Ptr{Ptr{Cvoid}}, arg5::Ptr{Ptr{Cvoid}}, arg6::Ptr{Ptr{Cvoid}}, arg7::Ptr{Ptr{Cvoid}}, arg8::Ptr{Csize_t}, arg9::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_realloc_multiple(arg1::Csize_t, arg2::Cint, arg3::Cint,
+                                                 arg4::Ptr{Ptr{Cvoid}},
+                                                 arg5::Ptr{Ptr{Cvoid}},
+                                                 arg6::Ptr{Ptr{Cvoid}},
+                                                 arg7::Ptr{Ptr{Cvoid}}, arg8::Ptr{Csize_t},
+                                                 arg9::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_version(version)
@@ -876,11 +1049,13 @@ function cholmod_l_check_common(arg1)
 end
 
 function cholmod_print_common(name, Common)
-    @ccall libcholmod.cholmod_print_common(name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_common(name::Ptr{Cchar},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_common(arg1, arg2)
-    @ccall libcholmod.cholmod_l_print_common(arg1::Ptr{Cchar}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_common(arg1::Ptr{Cchar},
+                                             arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_gpu_stats(arg1)
@@ -892,643 +1067,1047 @@ function cholmod_l_gpu_stats(arg1)
 end
 
 function cholmod_check_sparse(A, Common)
-    @ccall libcholmod.cholmod_check_sparse(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_sparse(A::Ptr{cholmod_sparse},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_sparse(arg1, arg2)
-    @ccall libcholmod.cholmod_l_check_sparse(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_sparse(arg1::Ptr{cholmod_sparse},
+                                             arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_sparse(A, name, Common)
-    @ccall libcholmod.cholmod_print_sparse(A::Ptr{cholmod_sparse}, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_sparse(A::Ptr{cholmod_sparse}, name::Ptr{Cchar},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_sparse(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_print_sparse(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Cchar}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_sparse(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Cchar},
+                                             arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_check_dense(X, Common)
-    @ccall libcholmod.cholmod_check_dense(X::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_dense(X::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_dense(arg1, arg2)
-    @ccall libcholmod.cholmod_l_check_dense(arg1::Ptr{cholmod_dense}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_dense(arg1::Ptr{cholmod_dense},
+                                            arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_dense(X, name, Common)
-    @ccall libcholmod.cholmod_print_dense(X::Ptr{cholmod_dense}, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_dense(X::Ptr{cholmod_dense}, name::Ptr{Cchar},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_dense(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_print_dense(arg1::Ptr{cholmod_dense}, arg2::Ptr{Cchar}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_dense(arg1::Ptr{cholmod_dense}, arg2::Ptr{Cchar},
+                                            arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_check_factor(L, Common)
-    @ccall libcholmod.cholmod_check_factor(L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_factor(L::Ptr{cholmod_factor},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_factor(arg1, arg2)
-    @ccall libcholmod.cholmod_l_check_factor(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_factor(arg1::Ptr{cholmod_factor},
+                                             arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_factor(L, name, Common)
-    @ccall libcholmod.cholmod_print_factor(L::Ptr{cholmod_factor}, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_factor(L::Ptr{cholmod_factor}, name::Ptr{Cchar},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_factor(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_print_factor(arg1::Ptr{cholmod_factor}, arg2::Ptr{Cchar}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_factor(arg1::Ptr{cholmod_factor}, arg2::Ptr{Cchar},
+                                             arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_check_triplet(T, Common)
-    @ccall libcholmod.cholmod_check_triplet(T::Ptr{cholmod_triplet}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_triplet(T::Ptr{cholmod_triplet},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_triplet(arg1, arg2)
-    @ccall libcholmod.cholmod_l_check_triplet(arg1::Ptr{cholmod_triplet}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_triplet(arg1::Ptr{cholmod_triplet},
+                                              arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_triplet(T, name, Common)
-    @ccall libcholmod.cholmod_print_triplet(T::Ptr{cholmod_triplet}, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_triplet(T::Ptr{cholmod_triplet}, name::Ptr{Cchar},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_triplet(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_print_triplet(arg1::Ptr{cholmod_triplet}, arg2::Ptr{Cchar}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_triplet(arg1::Ptr{cholmod_triplet}, arg2::Ptr{Cchar},
+                                              arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_check_subset(Set, len, n, Common)
-    @ccall libcholmod.cholmod_check_subset(Set::Ptr{Int32}, len::Int64, n::Csize_t, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_subset(Set::Ptr{Int32}, len::Int64, n::Csize_t,
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_subset(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_check_subset(arg1::Ptr{Int64}, arg2::Int64, arg3::Csize_t, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_subset(arg1::Ptr{Int64}, arg2::Int64, arg3::Csize_t,
+                                             arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_subset(Set, len, n, name, Common)
-    @ccall libcholmod.cholmod_print_subset(Set::Ptr{Int32}, len::Int64, n::Csize_t, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_subset(Set::Ptr{Int32}, len::Int64, n::Csize_t,
+                                           name::Ptr{Cchar},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_subset(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_print_subset(arg1::Ptr{Int64}, arg2::Int64, arg3::Csize_t, arg4::Ptr{Cchar}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_subset(arg1::Ptr{Int64}, arg2::Int64, arg3::Csize_t,
+                                             arg4::Ptr{Cchar},
+                                             arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_check_perm(Perm, len, n, Common)
-    @ccall libcholmod.cholmod_check_perm(Perm::Ptr{Int32}, len::Csize_t, n::Csize_t, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_perm(Perm::Ptr{Int32}, len::Csize_t, n::Csize_t,
+                                         Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_perm(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_check_perm(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Csize_t, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_perm(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Csize_t,
+                                           arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_perm(Perm, len, n, name, Common)
-    @ccall libcholmod.cholmod_print_perm(Perm::Ptr{Int32}, len::Csize_t, n::Csize_t, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_perm(Perm::Ptr{Int32}, len::Csize_t, n::Csize_t,
+                                         name::Ptr{Cchar},
+                                         Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_perm(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_print_perm(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Csize_t, arg4::Ptr{Cchar}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_perm(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Csize_t,
+                                           arg4::Ptr{Cchar},
+                                           arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_check_parent(Parent, n, Common)
-    @ccall libcholmod.cholmod_check_parent(Parent::Ptr{Int32}, n::Csize_t, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_parent(Parent::Ptr{Int32}, n::Csize_t,
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_parent(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_check_parent(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_parent(arg1::Ptr{Int64}, arg2::Csize_t,
+                                             arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_parent(Parent, n, name, Common)
-    @ccall libcholmod.cholmod_print_parent(Parent::Ptr{Int32}, n::Csize_t, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_parent(Parent::Ptr{Int32}, n::Csize_t, name::Ptr{Cchar},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_parent(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_print_parent(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Ptr{Cchar}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_parent(arg1::Ptr{Int64}, arg2::Csize_t,
+                                             arg3::Ptr{Cchar},
+                                             arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_read_sparse(f, Common)
-    @ccall libcholmod.cholmod_read_sparse(f::Ptr{Libc.FILE}, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_read_sparse(f::Ptr{Libc.FILE},
+                                          Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_read_sparse(arg1, arg2)
-    @ccall libcholmod.cholmod_l_read_sparse(arg1::Ptr{Libc.FILE}, arg2::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_read_sparse(arg1::Ptr{Libc.FILE},
+                                            arg2::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_read_triplet(f, Common)
-    @ccall libcholmod.cholmod_read_triplet(f::Ptr{Libc.FILE}, Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_read_triplet(f::Ptr{Libc.FILE},
+                                           Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_l_read_triplet(arg1, arg2)
-    @ccall libcholmod.cholmod_l_read_triplet(arg1::Ptr{Libc.FILE}, arg2::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_l_read_triplet(arg1::Ptr{Libc.FILE},
+                                             arg2::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_read_dense(f, Common)
-    @ccall libcholmod.cholmod_read_dense(f::Ptr{Libc.FILE}, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_read_dense(f::Ptr{Libc.FILE},
+                                         Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_read_dense(arg1, arg2)
-    @ccall libcholmod.cholmod_l_read_dense(arg1::Ptr{Libc.FILE}, arg2::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_read_dense(arg1::Ptr{Libc.FILE},
+                                           arg2::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_read_matrix(f, prefer, mtype, Common)
-    @ccall libcholmod.cholmod_read_matrix(f::Ptr{Libc.FILE}, prefer::Cint, mtype::Ptr{Cint}, Common::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_read_matrix(f::Ptr{Libc.FILE}, prefer::Cint, mtype::Ptr{Cint},
+                                          Common::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_l_read_matrix(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_read_matrix(arg1::Ptr{Libc.FILE}, arg2::Cint, arg3::Ptr{Cint}, arg4::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_l_read_matrix(arg1::Ptr{Libc.FILE}, arg2::Cint,
+                                            arg3::Ptr{Cint},
+                                            arg4::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_write_sparse(f, A, Z, comments, Common)
-    @ccall libcholmod.cholmod_write_sparse(f::Ptr{Libc.FILE}, A::Ptr{cholmod_sparse}, Z::Ptr{cholmod_sparse}, comments::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_write_sparse(f::Ptr{Libc.FILE}, A::Ptr{cholmod_sparse},
+                                           Z::Ptr{cholmod_sparse}, comments::Ptr{Cchar},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_write_sparse(arg1, arg2, arg3, c, arg5)
-    @ccall libcholmod.cholmod_l_write_sparse(arg1::Ptr{Libc.FILE}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_sparse}, c::Ptr{Cchar}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_write_sparse(arg1::Ptr{Libc.FILE},
+                                             arg2::Ptr{cholmod_sparse},
+                                             arg3::Ptr{cholmod_sparse}, c::Ptr{Cchar},
+                                             arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_write_dense(f, X, comments, Common)
-    @ccall libcholmod.cholmod_write_dense(f::Ptr{Libc.FILE}, X::Ptr{cholmod_dense}, comments::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_write_dense(f::Ptr{Libc.FILE}, X::Ptr{cholmod_dense},
+                                          comments::Ptr{Cchar},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_write_dense(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_write_dense(arg1::Ptr{Libc.FILE}, arg2::Ptr{cholmod_dense}, arg3::Ptr{Cchar}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_write_dense(arg1::Ptr{Libc.FILE}, arg2::Ptr{cholmod_dense},
+                                            arg3::Ptr{Cchar},
+                                            arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_analyze(A, Common)
-    @ccall libcholmod.cholmod_analyze(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_analyze(A::Ptr{cholmod_sparse},
+                                      Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_l_analyze(arg1, arg2)
-    @ccall libcholmod.cholmod_l_analyze(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_l_analyze(arg1::Ptr{cholmod_sparse},
+                                        arg2::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_analyze_p(A, UserPerm, fset, fsize, Common)
-    @ccall libcholmod.cholmod_analyze_p(A::Ptr{cholmod_sparse}, UserPerm::Ptr{Int32}, fset::Ptr{Int32}, fsize::Csize_t, Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_analyze_p(A::Ptr{cholmod_sparse}, UserPerm::Ptr{Int32},
+                                        fset::Ptr{Int32}, fsize::Csize_t,
+                                        Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_l_analyze_p(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_analyze_p(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Ptr{Int64}, arg4::Csize_t, arg5::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_l_analyze_p(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                          arg3::Ptr{Int64}, arg4::Csize_t,
+                                          arg5::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_analyze_p2(for_whom, A, UserPerm, fset, fsize, Common)
-    @ccall libcholmod.cholmod_analyze_p2(for_whom::Cint, A::Ptr{cholmod_sparse}, UserPerm::Ptr{Int32}, fset::Ptr{Int32}, fsize::Csize_t, Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_analyze_p2(for_whom::Cint, A::Ptr{cholmod_sparse},
+                                         UserPerm::Ptr{Int32}, fset::Ptr{Int32},
+                                         fsize::Csize_t,
+                                         Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_l_analyze_p2(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_analyze_p2(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Csize_t, arg6::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_l_analyze_p2(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                           arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                           arg5::Csize_t,
+                                           arg6::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_factorize(A, L, Common)
-    @ccall libcholmod.cholmod_factorize(A::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_factorize(A::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor},
+                                        Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_factorize(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_factorize(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_factorize(arg1::Ptr{cholmod_sparse},
+                                          arg2::Ptr{cholmod_factor},
+                                          arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_factorize_p(A, beta, fset, fsize, L, Common)
-    @ccall libcholmod.cholmod_factorize_p(A::Ptr{cholmod_sparse}, beta::Ptr{Cdouble}, fset::Ptr{Int32}, fsize::Csize_t, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_factorize_p(A::Ptr{cholmod_sparse}, beta::Ptr{Cdouble},
+                                          fset::Ptr{Int32}, fsize::Csize_t,
+                                          L::Ptr{cholmod_factor},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_factorize_p(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_factorize_p(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Cdouble}, arg3::Ptr{Int64}, arg4::Csize_t, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_factorize_p(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Cdouble},
+                                            arg3::Ptr{Int64}, arg4::Csize_t,
+                                            arg5::Ptr{cholmod_factor},
+                                            arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_solve(sys, L, B, Common)
-    @ccall libcholmod.cholmod_solve(sys::Cint, L::Ptr{cholmod_factor}, B::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_solve(sys::Cint, L::Ptr{cholmod_factor},
+                                    B::Ptr{cholmod_dense},
+                                    Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_solve(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_solve(arg1::Cint, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_dense}, arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_solve(arg1::Cint, arg2::Ptr{cholmod_factor},
+                                      arg3::Ptr{cholmod_dense},
+                                      arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_solve2(sys, L, B, Bset, X_Handle, Xset_Handle, Y_Handle, E_Handle, Common)
-    @ccall libcholmod.cholmod_solve2(sys::Cint, L::Ptr{cholmod_factor}, B::Ptr{cholmod_dense}, Bset::Ptr{cholmod_sparse}, X_Handle::Ptr{Ptr{cholmod_dense}}, Xset_Handle::Ptr{Ptr{cholmod_sparse}}, Y_Handle::Ptr{Ptr{cholmod_dense}}, E_Handle::Ptr{Ptr{cholmod_dense}}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_solve2(sys::Cint, L::Ptr{cholmod_factor},
+                                     B::Ptr{cholmod_dense}, Bset::Ptr{cholmod_sparse},
+                                     X_Handle::Ptr{Ptr{cholmod_dense}},
+                                     Xset_Handle::Ptr{Ptr{cholmod_sparse}},
+                                     Y_Handle::Ptr{Ptr{cholmod_dense}},
+                                     E_Handle::Ptr{Ptr{cholmod_dense}},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_solve2(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
-    @ccall libcholmod.cholmod_l_solve2(arg1::Cint, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_dense}, arg4::Ptr{cholmod_sparse}, arg5::Ptr{Ptr{cholmod_dense}}, arg6::Ptr{Ptr{cholmod_sparse}}, arg7::Ptr{Ptr{cholmod_dense}}, arg8::Ptr{Ptr{cholmod_dense}}, arg9::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_solve2(arg1::Cint, arg2::Ptr{cholmod_factor},
+                                       arg3::Ptr{cholmod_dense}, arg4::Ptr{cholmod_sparse},
+                                       arg5::Ptr{Ptr{cholmod_dense}},
+                                       arg6::Ptr{Ptr{cholmod_sparse}},
+                                       arg7::Ptr{Ptr{cholmod_dense}},
+                                       arg8::Ptr{Ptr{cholmod_dense}},
+                                       arg9::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_spsolve(sys, L, B, Common)
-    @ccall libcholmod.cholmod_spsolve(sys::Cint, L::Ptr{cholmod_factor}, B::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_spsolve(sys::Cint, L::Ptr{cholmod_factor},
+                                      B::Ptr{cholmod_sparse},
+                                      Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_spsolve(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_spsolve(arg1::Cint, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_sparse}, arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_spsolve(arg1::Cint, arg2::Ptr{cholmod_factor},
+                                        arg3::Ptr{cholmod_sparse},
+                                        arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_etree(A, Parent, Common)
-    @ccall libcholmod.cholmod_etree(A::Ptr{cholmod_sparse}, Parent::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_etree(A::Ptr{cholmod_sparse}, Parent::Ptr{Int32},
+                                    Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_etree(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_etree(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_etree(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                      arg3::Ptr{cholmod_common})::Cint
 end
 
-function cholmod_rowcolcounts(A, fset, fsize, Parent, Post, RowCount, ColCount, First, Level, Common)
-    @ccall libcholmod.cholmod_rowcolcounts(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, Parent::Ptr{Int32}, Post::Ptr{Int32}, RowCount::Ptr{Int32}, ColCount::Ptr{Int32}, First::Ptr{Int32}, Level::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+function cholmod_rowcolcounts(A, fset, fsize, Parent, Post, RowCount, ColCount, First,
+                              Level, Common)
+    @ccall libcholmod.cholmod_rowcolcounts(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                           fsize::Csize_t, Parent::Ptr{Int32},
+                                           Post::Ptr{Int32}, RowCount::Ptr{Int32},
+                                           ColCount::Ptr{Int32}, First::Ptr{Int32},
+                                           Level::Ptr{Int32},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowcolcounts(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)
-    @ccall libcholmod.cholmod_l_rowcolcounts(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{Int64}, arg6::Ptr{Int64}, arg7::Ptr{Int64}, arg8::Ptr{Int64}, arg9::Ptr{Int64}, arg10::Ptr{cholmod_common})::Cint
-end
-
-function cholmod_analyze_ordering(A, ordering, Perm, fset, fsize, Parent, Post, ColCount, First, Level, Common)
-    @ccall libcholmod.cholmod_analyze_ordering(A::Ptr{cholmod_sparse}, ordering::Cint, Perm::Ptr{Int32}, fset::Ptr{Int32}, fsize::Csize_t, Parent::Ptr{Int32}, Post::Ptr{Int32}, ColCount::Ptr{Int32}, First::Ptr{Int32}, Level::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
-end
-
-function cholmod_l_analyze_ordering(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11)
-    @ccall libcholmod.cholmod_l_analyze_ordering(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Csize_t, arg6::Ptr{Int64}, arg7::Ptr{Int64}, arg8::Ptr{Int64}, arg9::Ptr{Int64}, arg10::Ptr{Int64}, arg11::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowcolcounts(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                             arg3::Csize_t, arg4::Ptr{Int64},
+                                             arg5::Ptr{Int64}, arg6::Ptr{Int64},
+                                             arg7::Ptr{Int64}, arg8::Ptr{Int64},
+                                             arg9::Ptr{Int64},
+                                             arg10::Ptr{cholmod_common})::Cint
+end
+
+function cholmod_analyze_ordering(A, ordering, Perm, fset, fsize, Parent, Post, ColCount,
+                                  First, Level, Common)
+    @ccall libcholmod.cholmod_analyze_ordering(A::Ptr{cholmod_sparse}, ordering::Cint,
+                                               Perm::Ptr{Int32}, fset::Ptr{Int32},
+                                               fsize::Csize_t, Parent::Ptr{Int32},
+                                               Post::Ptr{Int32}, ColCount::Ptr{Int32},
+                                               First::Ptr{Int32}, Level::Ptr{Int32},
+                                               Common::Ptr{cholmod_common})::Cint
+end
+
+function cholmod_l_analyze_ordering(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9,
+                                    arg10, arg11)
+    @ccall libcholmod.cholmod_l_analyze_ordering(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                                 arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                                 arg5::Csize_t, arg6::Ptr{Int64},
+                                                 arg7::Ptr{Int64}, arg8::Ptr{Int64},
+                                                 arg9::Ptr{Int64}, arg10::Ptr{Int64},
+                                                 arg11::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_amd(A, fset, fsize, Perm, Common)
-    @ccall libcholmod.cholmod_amd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_amd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t,
+                                  Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_amd(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_amd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_amd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                    arg3::Csize_t, arg4::Ptr{Int64},
+                                    arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_colamd(A, fset, fsize, postorder, Perm, Common)
-    @ccall libcholmod.cholmod_colamd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, postorder::Cint, Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_colamd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                     fsize::Csize_t, postorder::Cint, Perm::Ptr{Int32},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_colamd(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_colamd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Cint, arg5::Ptr{Int64}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_colamd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                       arg3::Csize_t, arg4::Cint, arg5::Ptr{Int64},
+                                       arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowfac(A, F, beta, kstart, kend, L, Common)
-    @ccall libcholmod.cholmod_rowfac(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, beta::Ptr{Cdouble}, kstart::Csize_t, kend::Csize_t, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowfac(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse},
+                                     beta::Ptr{Cdouble}, kstart::Csize_t, kend::Csize_t,
+                                     L::Ptr{cholmod_factor},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowfac(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_rowfac(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Csize_t, arg5::Csize_t, arg6::Ptr{cholmod_factor}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowfac(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse},
+                                       arg3::Ptr{Cdouble}, arg4::Csize_t, arg5::Csize_t,
+                                       arg6::Ptr{cholmod_factor},
+                                       arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowfac_mask(A, F, beta, kstart, kend, mask, RLinkUp, L, Common)
-    @ccall libcholmod.cholmod_rowfac_mask(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, beta::Ptr{Cdouble}, kstart::Csize_t, kend::Csize_t, mask::Ptr{Int32}, RLinkUp::Ptr{Int32}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowfac_mask(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse},
+                                          beta::Ptr{Cdouble}, kstart::Csize_t,
+                                          kend::Csize_t, mask::Ptr{Int32},
+                                          RLinkUp::Ptr{Int32}, L::Ptr{cholmod_factor},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowfac_mask(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
-    @ccall libcholmod.cholmod_l_rowfac_mask(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Csize_t, arg5::Csize_t, arg6::Ptr{Int64}, arg7::Ptr{Int64}, arg8::Ptr{cholmod_factor}, arg9::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowfac_mask(arg1::Ptr{cholmod_sparse},
+                                            arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble},
+                                            arg4::Csize_t, arg5::Csize_t, arg6::Ptr{Int64},
+                                            arg7::Ptr{Int64}, arg8::Ptr{cholmod_factor},
+                                            arg9::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowfac_mask2(A, F, beta, kstart, kend, mask, maskmark, RLinkUp, L, Common)
-    @ccall libcholmod.cholmod_rowfac_mask2(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, beta::Ptr{Cdouble}, kstart::Csize_t, kend::Csize_t, mask::Ptr{Int32}, maskmark::Int32, RLinkUp::Ptr{Int32}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowfac_mask2(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse},
+                                           beta::Ptr{Cdouble}, kstart::Csize_t,
+                                           kend::Csize_t, mask::Ptr{Int32}, maskmark::Int32,
+                                           RLinkUp::Ptr{Int32}, L::Ptr{cholmod_factor},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowfac_mask2(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)
-    @ccall libcholmod.cholmod_l_rowfac_mask2(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Csize_t, arg5::Csize_t, arg6::Ptr{Int64}, arg7::Int64, arg8::Ptr{Int64}, arg9::Ptr{cholmod_factor}, arg10::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowfac_mask2(arg1::Ptr{cholmod_sparse},
+                                             arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble},
+                                             arg4::Csize_t, arg5::Csize_t, arg6::Ptr{Int64},
+                                             arg7::Int64, arg8::Ptr{Int64},
+                                             arg9::Ptr{cholmod_factor},
+                                             arg10::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_row_subtree(A, F, k, Parent, R, Common)
-    @ccall libcholmod.cholmod_row_subtree(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, k::Csize_t, Parent::Ptr{Int32}, R::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_row_subtree(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse},
+                                          k::Csize_t, Parent::Ptr{Int32},
+                                          R::Ptr{cholmod_sparse},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_row_subtree(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_row_subtree(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{cholmod_sparse}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_row_subtree(arg1::Ptr{cholmod_sparse},
+                                            arg2::Ptr{cholmod_sparse}, arg3::Csize_t,
+                                            arg4::Ptr{Int64}, arg5::Ptr{cholmod_sparse},
+                                            arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_lsolve_pattern(B, L, X, Common)
-    @ccall libcholmod.cholmod_lsolve_pattern(B::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_lsolve_pattern(B::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor},
+                                             X::Ptr{cholmod_sparse},
+                                             Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_lsolve_pattern(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_lsolve_pattern(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_sparse}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_lsolve_pattern(arg1::Ptr{cholmod_sparse},
+                                               arg2::Ptr{cholmod_factor},
+                                               arg3::Ptr{cholmod_sparse},
+                                               arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_row_lsubtree(A, Fi, fnz, k, L, R, Common)
-    @ccall libcholmod.cholmod_row_lsubtree(A::Ptr{cholmod_sparse}, Fi::Ptr{Int32}, fnz::Csize_t, k::Csize_t, L::Ptr{cholmod_factor}, R::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_row_lsubtree(A::Ptr{cholmod_sparse}, Fi::Ptr{Int32},
+                                           fnz::Csize_t, k::Csize_t, L::Ptr{cholmod_factor},
+                                           R::Ptr{cholmod_sparse},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_row_lsubtree(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_row_lsubtree(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Csize_t, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_sparse}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_row_lsubtree(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                             arg3::Csize_t, arg4::Csize_t,
+                                             arg5::Ptr{cholmod_factor},
+                                             arg6::Ptr{cholmod_sparse},
+                                             arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_resymbol(A, fset, fsize, pack, L, Common)
-    @ccall libcholmod.cholmod_resymbol(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, pack::Cint, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_resymbol(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                       fsize::Csize_t, pack::Cint, L::Ptr{cholmod_factor},
+                                       Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_resymbol(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_resymbol(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Cint, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_resymbol(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                         arg3::Csize_t, arg4::Cint,
+                                         arg5::Ptr{cholmod_factor},
+                                         arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_resymbol_noperm(A, fset, fsize, pack, L, Common)
-    @ccall libcholmod.cholmod_resymbol_noperm(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, pack::Cint, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_resymbol_noperm(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                              fsize::Csize_t, pack::Cint,
+                                              L::Ptr{cholmod_factor},
+                                              Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_resymbol_noperm(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_resymbol_noperm(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Cint, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_resymbol_noperm(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                                arg3::Csize_t, arg4::Cint,
+                                                arg5::Ptr{cholmod_factor},
+                                                arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rcond(L, Common)
-    @ccall libcholmod.cholmod_rcond(L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cdouble
+    @ccall libcholmod.cholmod_rcond(L::Ptr{cholmod_factor},
+                                    Common::Ptr{cholmod_common})::Cdouble
 end
 
 function cholmod_l_rcond(arg1, arg2)
-    @ccall libcholmod.cholmod_l_rcond(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_common})::Cdouble
+    @ccall libcholmod.cholmod_l_rcond(arg1::Ptr{cholmod_factor},
+                                      arg2::Ptr{cholmod_common})::Cdouble
 end
 
 function cholmod_postorder(Parent, n, Weight_p, Post, Common)
-    @ccall libcholmod.cholmod_postorder(Parent::Ptr{Int32}, n::Csize_t, Weight_p::Ptr{Int32}, Post::Ptr{Int32}, Common::Ptr{cholmod_common})::Int32
+    @ccall libcholmod.cholmod_postorder(Parent::Ptr{Int32}, n::Csize_t,
+                                        Weight_p::Ptr{Int32}, Post::Ptr{Int32},
+                                        Common::Ptr{cholmod_common})::Int32
 end
 
 function cholmod_l_postorder(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_postorder(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_l_postorder(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Ptr{Int64},
+                                          arg4::Ptr{Int64},
+                                          arg5::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_drop(tol, A, Common)
-    @ccall libcholmod.cholmod_drop(tol::Cdouble, A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_drop(tol::Cdouble, A::Ptr{cholmod_sparse},
+                                   Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_drop(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_drop(arg1::Cdouble, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_drop(arg1::Cdouble, arg2::Ptr{cholmod_sparse},
+                                     arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_norm_dense(X, norm, Common)
-    @ccall libcholmod.cholmod_norm_dense(X::Ptr{cholmod_dense}, norm::Cint, Common::Ptr{cholmod_common})::Cdouble
+    @ccall libcholmod.cholmod_norm_dense(X::Ptr{cholmod_dense}, norm::Cint,
+                                         Common::Ptr{cholmod_common})::Cdouble
 end
 
 function cholmod_l_norm_dense(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_norm_dense(arg1::Ptr{cholmod_dense}, arg2::Cint, arg3::Ptr{cholmod_common})::Cdouble
+    @ccall libcholmod.cholmod_l_norm_dense(arg1::Ptr{cholmod_dense}, arg2::Cint,
+                                           arg3::Ptr{cholmod_common})::Cdouble
 end
 
 function cholmod_norm_sparse(A, norm, Common)
-    @ccall libcholmod.cholmod_norm_sparse(A::Ptr{cholmod_sparse}, norm::Cint, Common::Ptr{cholmod_common})::Cdouble
+    @ccall libcholmod.cholmod_norm_sparse(A::Ptr{cholmod_sparse}, norm::Cint,
+                                          Common::Ptr{cholmod_common})::Cdouble
 end
 
 function cholmod_l_norm_sparse(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_norm_sparse(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{cholmod_common})::Cdouble
+    @ccall libcholmod.cholmod_l_norm_sparse(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                            arg3::Ptr{cholmod_common})::Cdouble
 end
 
 function cholmod_horzcat(A, B, values, Common)
-    @ccall libcholmod.cholmod_horzcat(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse}, values::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_horzcat(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse},
+                                      values::Cint,
+                                      Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_horzcat(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_horzcat(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_horzcat(arg1::Ptr{cholmod_sparse},
+                                        arg2::Ptr{cholmod_sparse}, arg3::Cint,
+                                        arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_scale(S, scale, A, Common)
-    @ccall libcholmod.cholmod_scale(S::Ptr{cholmod_dense}, scale::Cint, A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_scale(S::Ptr{cholmod_dense}, scale::Cint,
+                                    A::Ptr{cholmod_sparse},
+                                    Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_scale(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_scale(arg1::Ptr{cholmod_dense}, arg2::Cint, arg3::Ptr{cholmod_sparse}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_scale(arg1::Ptr{cholmod_dense}, arg2::Cint,
+                                      arg3::Ptr{cholmod_sparse},
+                                      arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_sdmult(A, transpose, alpha, beta, X, Y, Common)
-    @ccall libcholmod.cholmod_sdmult(A::Ptr{cholmod_sparse}, transpose::Cint, alpha::Ptr{Cdouble}, beta::Ptr{Cdouble}, X::Ptr{cholmod_dense}, Y::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_sdmult(A::Ptr{cholmod_sparse}, transpose::Cint,
+                                     alpha::Ptr{Cdouble}, beta::Ptr{Cdouble},
+                                     X::Ptr{cholmod_dense}, Y::Ptr{cholmod_dense},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_sdmult(arg1, arg2, arg3, arg4, arg5, Y, arg7)
-    @ccall libcholmod.cholmod_l_sdmult(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{Cdouble}, arg4::Ptr{Cdouble}, arg5::Ptr{cholmod_dense}, Y::Ptr{cholmod_dense}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_sdmult(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                       arg3::Ptr{Cdouble}, arg4::Ptr{Cdouble},
+                                       arg5::Ptr{cholmod_dense}, Y::Ptr{cholmod_dense},
+                                       arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_ssmult(A, B, stype, values, sorted, Common)
-    @ccall libcholmod.cholmod_ssmult(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse}, stype::Cint, values::Cint, sorted::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_ssmult(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse},
+                                     stype::Cint, values::Cint, sorted::Cint,
+                                     Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_ssmult(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_ssmult(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Cint, arg4::Cint, arg5::Cint, arg6::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_ssmult(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse},
+                                       arg3::Cint, arg4::Cint, arg5::Cint,
+                                       arg6::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_submatrix(A, rset, rsize, cset, csize, values, sorted, Common)
-    @ccall libcholmod.cholmod_submatrix(A::Ptr{cholmod_sparse}, rset::Ptr{Int32}, rsize::Int64, cset::Ptr{Int32}, csize::Int64, values::Cint, sorted::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_submatrix(A::Ptr{cholmod_sparse}, rset::Ptr{Int32},
+                                        rsize::Int64, cset::Ptr{Int32}, csize::Int64,
+                                        values::Cint, sorted::Cint,
+                                        Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_submatrix(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
-    @ccall libcholmod.cholmod_l_submatrix(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Int64, arg4::Ptr{Int64}, arg5::Int64, arg6::Cint, arg7::Cint, arg8::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_submatrix(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                          arg3::Int64, arg4::Ptr{Int64}, arg5::Int64,
+                                          arg6::Cint, arg7::Cint,
+                                          arg8::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_vertcat(A, B, values, Common)
-    @ccall libcholmod.cholmod_vertcat(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse}, values::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_vertcat(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse},
+                                      values::Cint,
+                                      Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_vertcat(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_vertcat(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_vertcat(arg1::Ptr{cholmod_sparse},
+                                        arg2::Ptr{cholmod_sparse}, arg3::Cint,
+                                        arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_symmetry(A, option, xmatched, pmatched, nzoffdiag, nzdiag, Common)
-    @ccall libcholmod.cholmod_symmetry(A::Ptr{cholmod_sparse}, option::Cint, xmatched::Ptr{Int32}, pmatched::Ptr{Int32}, nzoffdiag::Ptr{Int32}, nzdiag::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_symmetry(A::Ptr{cholmod_sparse}, option::Cint,
+                                       xmatched::Ptr{Int32}, pmatched::Ptr{Int32},
+                                       nzoffdiag::Ptr{Int32}, nzdiag::Ptr{Int32},
+                                       Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_symmetry(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_symmetry(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Ptr{Int64}, arg6::Ptr{Int64}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_symmetry(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                         arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                         arg5::Ptr{Int64}, arg6::Ptr{Int64},
+                                         arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_updown(update, C, L, Common)
-    @ccall libcholmod.cholmod_updown(update::Cint, C::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_updown(update::Cint, C::Ptr{cholmod_sparse},
+                                     L::Ptr{cholmod_factor},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_updown(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_updown(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_factor}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_updown(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                       arg3::Ptr{cholmod_factor},
+                                       arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_updown_solve(update, C, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_updown_solve(update::Cint, C::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_updown_solve(update::Cint, C::Ptr{cholmod_sparse},
+                                           L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense},
+                                           DeltaB::Ptr{cholmod_dense},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_updown_solve(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_updown_solve(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_factor}, arg4::Ptr{cholmod_dense}, arg5::Ptr{cholmod_dense}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_updown_solve(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                             arg3::Ptr{cholmod_factor},
+                                             arg4::Ptr{cholmod_dense},
+                                             arg5::Ptr{cholmod_dense},
+                                             arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_updown_mark(update, C, colmark, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_updown_mark(update::Cint, C::Ptr{cholmod_sparse}, colmark::Ptr{Int32}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_updown_mark(update::Cint, C::Ptr{cholmod_sparse},
+                                          colmark::Ptr{Int32}, L::Ptr{cholmod_factor},
+                                          X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_updown_mark(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_updown_mark(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Int64}, arg4::Ptr{cholmod_factor}, arg5::Ptr{cholmod_dense}, arg6::Ptr{cholmod_dense}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_updown_mark(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                            arg3::Ptr{Int64}, arg4::Ptr{cholmod_factor},
+                                            arg5::Ptr{cholmod_dense},
+                                            arg6::Ptr{cholmod_dense},
+                                            arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_updown_mask(update, C, colmark, mask, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_updown_mask(update::Cint, C::Ptr{cholmod_sparse}, colmark::Ptr{Int32}, mask::Ptr{Int32}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_updown_mask(update::Cint, C::Ptr{cholmod_sparse},
+                                          colmark::Ptr{Int32}, mask::Ptr{Int32},
+                                          L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense},
+                                          DeltaB::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_updown_mask(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
-    @ccall libcholmod.cholmod_l_updown_mask(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_dense}, arg7::Ptr{cholmod_dense}, arg8::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_updown_mask(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                            arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                            arg5::Ptr{cholmod_factor},
+                                            arg6::Ptr{cholmod_dense},
+                                            arg7::Ptr{cholmod_dense},
+                                            arg8::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_updown_mask2(update, C, colmark, mask, maskmark, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_updown_mask2(update::Cint, C::Ptr{cholmod_sparse}, colmark::Ptr{Int32}, mask::Ptr{Int32}, maskmark::Int32, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_updown_mask2(update::Cint, C::Ptr{cholmod_sparse},
+                                           colmark::Ptr{Int32}, mask::Ptr{Int32},
+                                           maskmark::Int32, L::Ptr{cholmod_factor},
+                                           X::Ptr{cholmod_dense},
+                                           DeltaB::Ptr{cholmod_dense},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_updown_mask2(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
-    @ccall libcholmod.cholmod_l_updown_mask2(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Int64, arg6::Ptr{cholmod_factor}, arg7::Ptr{cholmod_dense}, arg8::Ptr{cholmod_dense}, arg9::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_updown_mask2(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                             arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                             arg5::Int64, arg6::Ptr{cholmod_factor},
+                                             arg7::Ptr{cholmod_dense},
+                                             arg8::Ptr{cholmod_dense},
+                                             arg9::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowadd(k, R, L, Common)
-    @ccall libcholmod.cholmod_rowadd(k::Csize_t, R::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowadd(k::Csize_t, R::Ptr{cholmod_sparse},
+                                     L::Ptr{cholmod_factor},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowadd(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_rowadd(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_factor}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowadd(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                       arg3::Ptr{cholmod_factor},
+                                       arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowadd_solve(k, R, bk, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_rowadd_solve(k::Csize_t, R::Ptr{cholmod_sparse}, bk::Ptr{Cdouble}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowadd_solve(k::Csize_t, R::Ptr{cholmod_sparse},
+                                           bk::Ptr{Cdouble}, L::Ptr{cholmod_factor},
+                                           X::Ptr{cholmod_dense},
+                                           DeltaB::Ptr{cholmod_dense},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowadd_solve(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_rowadd_solve(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Ptr{cholmod_factor}, arg5::Ptr{cholmod_dense}, arg6::Ptr{cholmod_dense}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowadd_solve(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                             arg3::Ptr{Cdouble}, arg4::Ptr{cholmod_factor},
+                                             arg5::Ptr{cholmod_dense},
+                                             arg6::Ptr{cholmod_dense},
+                                             arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowadd_mark(k, R, bk, colmark, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_rowadd_mark(k::Csize_t, R::Ptr{cholmod_sparse}, bk::Ptr{Cdouble}, colmark::Ptr{Int32}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowadd_mark(k::Csize_t, R::Ptr{cholmod_sparse},
+                                          bk::Ptr{Cdouble}, colmark::Ptr{Int32},
+                                          L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense},
+                                          DeltaB::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowadd_mark(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
-    @ccall libcholmod.cholmod_l_rowadd_mark(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Ptr{Int64}, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_dense}, arg7::Ptr{cholmod_dense}, arg8::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowadd_mark(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                            arg3::Ptr{Cdouble}, arg4::Ptr{Int64},
+                                            arg5::Ptr{cholmod_factor},
+                                            arg6::Ptr{cholmod_dense},
+                                            arg7::Ptr{cholmod_dense},
+                                            arg8::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowdel(k, R, L, Common)
-    @ccall libcholmod.cholmod_rowdel(k::Csize_t, R::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowdel(k::Csize_t, R::Ptr{cholmod_sparse},
+                                     L::Ptr{cholmod_factor},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowdel(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_rowdel(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_factor}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowdel(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                       arg3::Ptr{cholmod_factor},
+                                       arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowdel_solve(k, R, yk, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_rowdel_solve(k::Csize_t, R::Ptr{cholmod_sparse}, yk::Ptr{Cdouble}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowdel_solve(k::Csize_t, R::Ptr{cholmod_sparse},
+                                           yk::Ptr{Cdouble}, L::Ptr{cholmod_factor},
+                                           X::Ptr{cholmod_dense},
+                                           DeltaB::Ptr{cholmod_dense},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowdel_solve(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_rowdel_solve(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Ptr{cholmod_factor}, arg5::Ptr{cholmod_dense}, arg6::Ptr{cholmod_dense}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowdel_solve(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                             arg3::Ptr{Cdouble}, arg4::Ptr{cholmod_factor},
+                                             arg5::Ptr{cholmod_dense},
+                                             arg6::Ptr{cholmod_dense},
+                                             arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowdel_mark(k, R, yk, colmark, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_rowdel_mark(k::Csize_t, R::Ptr{cholmod_sparse}, yk::Ptr{Cdouble}, colmark::Ptr{Int32}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowdel_mark(k::Csize_t, R::Ptr{cholmod_sparse},
+                                          yk::Ptr{Cdouble}, colmark::Ptr{Int32},
+                                          L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense},
+                                          DeltaB::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowdel_mark(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
-    @ccall libcholmod.cholmod_l_rowdel_mark(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Ptr{Int64}, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_dense}, arg7::Ptr{cholmod_dense}, arg8::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowdel_mark(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                            arg3::Ptr{Cdouble}, arg4::Ptr{Int64},
+                                            arg5::Ptr{cholmod_factor},
+                                            arg6::Ptr{cholmod_dense},
+                                            arg7::Ptr{cholmod_dense},
+                                            arg8::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_ccolamd(A, fset, fsize, Cmember, Perm, Common)
-    @ccall libcholmod.cholmod_ccolamd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, Cmember::Ptr{Int32}, Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_ccolamd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                      fsize::Csize_t, Cmember::Ptr{Int32}, Perm::Ptr{Int32},
+                                      Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_ccolamd(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_ccolamd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{Int64}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_ccolamd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                        arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{Int64},
+                                        arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_csymamd(A, Cmember, Perm, Common)
-    @ccall libcholmod.cholmod_csymamd(A::Ptr{cholmod_sparse}, Cmember::Ptr{Int32}, Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_csymamd(A::Ptr{cholmod_sparse}, Cmember::Ptr{Int32},
+                                      Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_csymamd(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_csymamd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Ptr{Int64}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_csymamd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                        arg3::Ptr{Int64}, arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_camd(A, fset, fsize, Cmember, Perm, Common)
-    @ccall libcholmod.cholmod_camd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, Cmember::Ptr{Int32}, Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_camd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t,
+                                   Cmember::Ptr{Int32}, Perm::Ptr{Int32},
+                                   Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_camd(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_camd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{Int64}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_camd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                     arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{Int64},
+                                     arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_nested_dissection(A, fset, fsize, Perm, CParent, Cmember, Common)
-    @ccall libcholmod.cholmod_nested_dissection(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, Perm::Ptr{Int32}, CParent::Ptr{Int32}, Cmember::Ptr{Int32}, Common::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_nested_dissection(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                                fsize::Csize_t, Perm::Ptr{Int32},
+                                                CParent::Ptr{Int32}, Cmember::Ptr{Int32},
+                                                Common::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_l_nested_dissection(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_nested_dissection(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{Int64}, arg6::Ptr{Int64}, arg7::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_l_nested_dissection(arg1::Ptr{cholmod_sparse},
+                                                  arg2::Ptr{Int64}, arg3::Csize_t,
+                                                  arg4::Ptr{Int64}, arg5::Ptr{Int64},
+                                                  arg6::Ptr{Int64},
+                                                  arg7::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_metis(A, fset, fsize, postorder, Perm, Common)
-    @ccall libcholmod.cholmod_metis(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, postorder::Cint, Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_metis(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                    fsize::Csize_t, postorder::Cint, Perm::Ptr{Int32},
+                                    Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_metis(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_metis(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Cint, arg5::Ptr{Int64}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_metis(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                      arg3::Csize_t, arg4::Cint, arg5::Ptr{Int64},
+                                      arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_bisect(A, fset, fsize, compress, Partition, Common)
-    @ccall libcholmod.cholmod_bisect(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, compress::Cint, Partition::Ptr{Int32}, Common::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_bisect(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                     fsize::Csize_t, compress::Cint, Partition::Ptr{Int32},
+                                     Common::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_l_bisect(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_bisect(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Cint, arg5::Ptr{Int64}, arg6::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_l_bisect(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                       arg3::Csize_t, arg4::Cint, arg5::Ptr{Int64},
+                                       arg6::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_metis_bisector(A, Anw, Aew, Partition, Common)
-    @ccall libcholmod.cholmod_metis_bisector(A::Ptr{cholmod_sparse}, Anw::Ptr{Int32}, Aew::Ptr{Int32}, Partition::Ptr{Int32}, Common::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_metis_bisector(A::Ptr{cholmod_sparse}, Anw::Ptr{Int32},
+                                             Aew::Ptr{Int32}, Partition::Ptr{Int32},
+                                             Common::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_l_metis_bisector(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_metis_bisector(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_l_metis_bisector(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                               arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                               arg5::Ptr{cholmod_common})::Int64
 end
 
-function cholmod_collapse_septree(n, ncomponents, nd_oksep, nd_small, CParent, Cmember, Common)
-    @ccall libcholmod.cholmod_collapse_septree(n::Csize_t, ncomponents::Csize_t, nd_oksep::Cdouble, nd_small::Csize_t, CParent::Ptr{Int32}, Cmember::Ptr{Int32}, Common::Ptr{cholmod_common})::Int64
+function cholmod_collapse_septree(n, ncomponents, nd_oksep, nd_small, CParent, Cmember,
+                                  Common)
+    @ccall libcholmod.cholmod_collapse_septree(n::Csize_t, ncomponents::Csize_t,
+                                               nd_oksep::Cdouble, nd_small::Csize_t,
+                                               CParent::Ptr{Int32}, Cmember::Ptr{Int32},
+                                               Common::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_l_collapse_septree(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_collapse_septree(arg1::Csize_t, arg2::Csize_t, arg3::Cdouble, arg4::Csize_t, arg5::Ptr{Int64}, arg6::Ptr{Int64}, arg7::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_l_collapse_septree(arg1::Csize_t, arg2::Csize_t,
+                                                 arg3::Cdouble, arg4::Csize_t,
+                                                 arg5::Ptr{Int64}, arg6::Ptr{Int64},
+                                                 arg7::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_super_symbolic(A, F, Parent, L, Common)
-    @ccall libcholmod.cholmod_super_symbolic(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, Parent::Ptr{Int32}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_super_symbolic(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse},
+                                             Parent::Ptr{Int32}, L::Ptr{cholmod_factor},
+                                             Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_super_symbolic(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_super_symbolic(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Int64}, arg4::Ptr{cholmod_factor}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_super_symbolic(arg1::Ptr{cholmod_sparse},
+                                               arg2::Ptr{cholmod_sparse}, arg3::Ptr{Int64},
+                                               arg4::Ptr{cholmod_factor},
+                                               arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_super_symbolic2(for_whom, A, F, Parent, L, Common)
-    @ccall libcholmod.cholmod_super_symbolic2(for_whom::Cint, A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, Parent::Ptr{Int32}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_super_symbolic2(for_whom::Cint, A::Ptr{cholmod_sparse},
+                                              F::Ptr{cholmod_sparse}, Parent::Ptr{Int32},
+                                              L::Ptr{cholmod_factor},
+                                              Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_super_symbolic2(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_super_symbolic2(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_sparse}, arg4::Ptr{Int64}, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_super_symbolic2(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                                arg3::Ptr{cholmod_sparse}, arg4::Ptr{Int64},
+                                                arg5::Ptr{cholmod_factor},
+                                                arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_super_numeric(A, F, beta, L, Common)
-    @ccall libcholmod.cholmod_super_numeric(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, beta::Ptr{Cdouble}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_super_numeric(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse},
+                                            beta::Ptr{Cdouble}, L::Ptr{cholmod_factor},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_super_numeric(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_super_numeric(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Ptr{cholmod_factor}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_super_numeric(arg1::Ptr{cholmod_sparse},
+                                              arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble},
+                                              arg4::Ptr{cholmod_factor},
+                                              arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_super_lsolve(L, X, E, Common)
-    @ccall libcholmod.cholmod_super_lsolve(L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, E::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_super_lsolve(L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense},
+                                           E::Ptr{cholmod_dense},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_super_lsolve(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_super_lsolve(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_dense}, arg3::Ptr{cholmod_dense}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_super_lsolve(arg1::Ptr{cholmod_factor},
+                                             arg2::Ptr{cholmod_dense},
+                                             arg3::Ptr{cholmod_dense},
+                                             arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_super_ltsolve(L, X, E, Common)
-    @ccall libcholmod.cholmod_super_ltsolve(L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, E::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_super_ltsolve(L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense},
+                                            E::Ptr{cholmod_dense},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_super_ltsolve(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_super_ltsolve(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_dense}, arg3::Ptr{cholmod_dense}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_super_ltsolve(arg1::Ptr{cholmod_factor},
+                                              arg2::Ptr{cholmod_dense},
+                                              arg3::Ptr{cholmod_dense},
+                                              arg4::Ptr{cholmod_common})::Cint
+end
+
+function SuiteSparseQR_C(ordering, tol, econ, getCTX, A, Bsparse, Bdense, Zsparse, Zdense,
+                         R, E, H, HPinv, HTau, cc)
+    @ccall libspqr.SuiteSparseQR_C(ordering::Cint, tol::Cdouble, econ::Int64, getCTX::Cint,
+                                   A::Ptr{cholmod_sparse}, Bsparse::Ptr{cholmod_sparse},
+                                   Bdense::Ptr{cholmod_dense},
+                                   Zsparse::Ptr{Ptr{cholmod_sparse}},
+                                   Zdense::Ptr{Ptr{cholmod_dense}},
+                                   R::Ptr{Ptr{cholmod_sparse}}, E::Ptr{Ptr{Int64}},
+                                   H::Ptr{Ptr{cholmod_sparse}}, HPinv::Ptr{Ptr{Int64}},
+                                   HTau::Ptr{Ptr{cholmod_dense}},
+                                   cc::Ptr{cholmod_common})::Int64
+end
+
+function SuiteSparseQR_i_C(ordering, tol, econ, getCTX, A, Bsparse, Bdense, Zsparse, Zdense,
+                           R, E, H, HPinv, HTau, cc)
+    @ccall libspqr.SuiteSparseQR_i_C(ordering::Cint, tol::Cdouble, econ::Int32,
+                                     getCTX::Cint, A::Ptr{cholmod_sparse},
+                                     Bsparse::Ptr{cholmod_sparse},
+                                     Bdense::Ptr{cholmod_dense},
+                                     Zsparse::Ptr{Ptr{cholmod_sparse}},
+                                     Zdense::Ptr{Ptr{cholmod_dense}},
+                                     R::Ptr{Ptr{cholmod_sparse}}, E::Ptr{Ptr{Int32}},
+                                     H::Ptr{Ptr{cholmod_sparse}}, HPinv::Ptr{Ptr{Int32}},
+                                     HTau::Ptr{Ptr{cholmod_dense}},
+                                     cc::Ptr{cholmod_common})::Int32
 end
 
-function SuiteSparseQR_C(ordering, tol, econ, getCTX, A, Bsparse, Bdense, Zsparse, Zdense, R, E, H, HPinv, HTau, cc)
-    @ccall libspqr.SuiteSparseQR_C(ordering::Cint, tol::Cdouble, econ::Int64, getCTX::Cint, A::Ptr{cholmod_sparse}, Bsparse::Ptr{cholmod_sparse}, Bdense::Ptr{cholmod_dense}, Zsparse::Ptr{Ptr{cholmod_sparse}}, Zdense::Ptr{Ptr{cholmod_dense}}, R::Ptr{Ptr{cholmod_sparse}}, E::Ptr{Ptr{Int64}}, H::Ptr{Ptr{cholmod_sparse}}, HPinv::Ptr{Ptr{Int64}}, HTau::Ptr{Ptr{cholmod_dense}}, cc::Ptr{cholmod_common})::Int64
+function SuiteSparseQR_C_QR(ordering, tol, econ, A, Q, R, E, cc)
+    @ccall libspqr.SuiteSparseQR_C_QR(ordering::Cint, tol::Cdouble, econ::Int64,
+                                      A::Ptr{cholmod_sparse}, Q::Ptr{Ptr{cholmod_sparse}},
+                                      R::Ptr{Ptr{cholmod_sparse}}, E::Ptr{Ptr{Int64}},
+                                      cc::Ptr{cholmod_common})::Int64
 end
 
-function SuiteSparseQR_C_QR(ordering, tol, econ, A, Q, R, E, cc)
-    @ccall libspqr.SuiteSparseQR_C_QR(ordering::Cint, tol::Cdouble, econ::Int64, A::Ptr{cholmod_sparse}, Q::Ptr{Ptr{cholmod_sparse}}, R::Ptr{Ptr{cholmod_sparse}}, E::Ptr{Ptr{Int64}}, cc::Ptr{cholmod_common})::Int64
+function SuiteSparseQR_i_C_QR(ordering, tol, econ, A, Q, R, E, cc)
+    @ccall libspqr.SuiteSparseQR_i_C_QR(ordering::Cint, tol::Cdouble, econ::Int32,
+                                        A::Ptr{cholmod_sparse}, Q::Ptr{Ptr{cholmod_sparse}},
+                                        R::Ptr{Ptr{cholmod_sparse}}, E::Ptr{Ptr{Int32}},
+                                        cc::Ptr{cholmod_common})::Int32
 end
 
 function SuiteSparseQR_C_backslash(ordering, tol, A, B, cc)
-    @ccall libspqr.SuiteSparseQR_C_backslash(ordering::Cint, tol::Cdouble, A::Ptr{cholmod_sparse}, B::Ptr{cholmod_dense}, cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libspqr.SuiteSparseQR_C_backslash(ordering::Cint, tol::Cdouble,
+                                             A::Ptr{cholmod_sparse}, B::Ptr{cholmod_dense},
+                                             cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function SuiteSparseQR_C_backslash_default(A, B, cc)
-    @ccall libspqr.SuiteSparseQR_C_backslash_default(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_dense}, cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libspqr.SuiteSparseQR_C_backslash_default(A::Ptr{cholmod_sparse},
+                                                     B::Ptr{cholmod_dense},
+                                                     cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function SuiteSparseQR_C_backslash_sparse(ordering, tol, A, B, cc)
-    @ccall libspqr.SuiteSparseQR_C_backslash_sparse(ordering::Cint, tol::Cdouble, A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse}, cc::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libspqr.SuiteSparseQR_C_backslash_sparse(ordering::Cint, tol::Cdouble,
+                                                    A::Ptr{cholmod_sparse},
+                                                    B::Ptr{cholmod_sparse},
+                                                    cc::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 mutable struct SuiteSparseQR_C_factorization_struct
     xtype::Cint
+    itype::Cint
     factors::Ptr{Cvoid}
     SuiteSparseQR_C_factorization_struct() = new()
 end
@@ -1536,51 +2115,78 @@ end
 const SuiteSparseQR_C_factorization = SuiteSparseQR_C_factorization_struct
 
 function SuiteSparseQR_C_factorize(ordering, tol, A, cc)
-    @ccall libspqr.SuiteSparseQR_C_factorize(ordering::Cint, tol::Cdouble, A::Ptr{cholmod_sparse}, cc::Ptr{cholmod_common})::Ptr{SuiteSparseQR_C_factorization}
+    @ccall libspqr.SuiteSparseQR_C_factorize(ordering::Cint, tol::Cdouble,
+                                             A::Ptr{cholmod_sparse},
+                                             cc::Ptr{cholmod_common})::Ptr{SuiteSparseQR_C_factorization}
 end
 
 function SuiteSparseQR_C_symbolic(ordering, allow_tol, A, cc)
-    @ccall libspqr.SuiteSparseQR_C_symbolic(ordering::Cint, allow_tol::Cint, A::Ptr{cholmod_sparse}, cc::Ptr{cholmod_common})::Ptr{SuiteSparseQR_C_factorization}
+    @ccall libspqr.SuiteSparseQR_C_symbolic(ordering::Cint, allow_tol::Cint,
+                                            A::Ptr{cholmod_sparse},
+                                            cc::Ptr{cholmod_common})::Ptr{SuiteSparseQR_C_factorization}
 end
 
 function SuiteSparseQR_C_numeric(tol, A, QR, cc)
-    @ccall libspqr.SuiteSparseQR_C_numeric(tol::Cdouble, A::Ptr{cholmod_sparse}, QR::Ptr{SuiteSparseQR_C_factorization}, cc::Ptr{cholmod_common})::Cint
+    @ccall libspqr.SuiteSparseQR_C_numeric(tol::Cdouble, A::Ptr{cholmod_sparse},
+                                           QR::Ptr{SuiteSparseQR_C_factorization},
+                                           cc::Ptr{cholmod_common})::Cint
 end
 
 function SuiteSparseQR_C_free(QR, cc)
-    @ccall libspqr.SuiteSparseQR_C_free(QR::Ptr{Ptr{SuiteSparseQR_C_factorization}}, cc::Ptr{cholmod_common})::Cint
+    @ccall libspqr.SuiteSparseQR_C_free(QR::Ptr{Ptr{SuiteSparseQR_C_factorization}},
+                                        cc::Ptr{cholmod_common})::Cint
 end
 
 function SuiteSparseQR_C_solve(system, QR, B, cc)
-    @ccall libspqr.SuiteSparseQR_C_solve(system::Cint, QR::Ptr{SuiteSparseQR_C_factorization}, B::Ptr{cholmod_dense}, cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libspqr.SuiteSparseQR_C_solve(system::Cint,
+                                         QR::Ptr{SuiteSparseQR_C_factorization},
+                                         B::Ptr{cholmod_dense},
+                                         cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function SuiteSparseQR_C_qmult(method, QR, X, cc)
-    @ccall libspqr.SuiteSparseQR_C_qmult(method::Cint, QR::Ptr{SuiteSparseQR_C_factorization}, X::Ptr{cholmod_dense}, cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libspqr.SuiteSparseQR_C_qmult(method::Cint,
+                                         QR::Ptr{SuiteSparseQR_C_factorization},
+                                         X::Ptr{cholmod_dense},
+                                         cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function amd_order(n, Ap, Ai, P, Control, Info)
-    @ccall libamd.amd_order(n::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, P::Ptr{Int32}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libamd.amd_order(n::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, P::Ptr{Int32},
+                            Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function amd_l_order(n, Ap, Ai, P, Control, Info)
-    @ccall libamd.amd_l_order(n::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, P::Ptr{Int64}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libamd.amd_l_order(n::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, P::Ptr{Int64},
+                              Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
-function amd_2(n, Pe, Iw, Len, iwlen, pfree, Nv, Next, Last, Head, Elen, Degree, W, Control, Info)
-    @ccall libamd.amd_2(n::Int32, Pe::Ptr{Int32}, Iw::Ptr{Int32}, Len::Ptr{Int32}, iwlen::Int32, pfree::Int32, Nv::Ptr{Int32}, Next::Ptr{Int32}, Last::Ptr{Int32}, Head::Ptr{Int32}, Elen::Ptr{Int32}, Degree::Ptr{Int32}, W::Ptr{Int32}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cvoid
+function amd_2(n, Pe, Iw, Len, iwlen, pfree, Nv, Next, Last, Head, Elen, Degree, W, Control,
+               Info)
+    @ccall libamd.amd_2(n::Int32, Pe::Ptr{Int32}, Iw::Ptr{Int32}, Len::Ptr{Int32},
+                        iwlen::Int32, pfree::Int32, Nv::Ptr{Int32}, Next::Ptr{Int32},
+                        Last::Ptr{Int32}, Head::Ptr{Int32}, Elen::Ptr{Int32},
+                        Degree::Ptr{Int32}, W::Ptr{Int32}, Control::Ptr{Cdouble},
+                        Info::Ptr{Cdouble})::Cvoid
 end
 
-function amd_l2(n, Pe, Iw, Len, iwlen, pfree, Nv, Next, Last, Head, Elen, Degree, W, Control, Info)
-    @ccall libamd.amd_l2(n::Int64, Pe::Ptr{Int64}, Iw::Ptr{Int64}, Len::Ptr{Int64}, iwlen::Int64, pfree::Int64, Nv::Ptr{Int64}, Next::Ptr{Int64}, Last::Ptr{Int64}, Head::Ptr{Int64}, Elen::Ptr{Int64}, Degree::Ptr{Int64}, W::Ptr{Int64}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cvoid
+function amd_l2(n, Pe, Iw, Len, iwlen, pfree, Nv, Next, Last, Head, Elen, Degree, W,
+                Control, Info)
+    @ccall libamd.amd_l2(n::Int64, Pe::Ptr{Int64}, Iw::Ptr{Int64}, Len::Ptr{Int64},
+                         iwlen::Int64, pfree::Int64, Nv::Ptr{Int64}, Next::Ptr{Int64},
+                         Last::Ptr{Int64}, Head::Ptr{Int64}, Elen::Ptr{Int64},
+                         Degree::Ptr{Int64}, W::Ptr{Int64}, Control::Ptr{Cdouble},
+                         Info::Ptr{Cdouble})::Cvoid
 end
 
 function amd_valid(n_row, n_col, Ap, Ai)
-    @ccall libamd.amd_valid(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32})::Cint
+    @ccall libamd.amd_valid(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                            Ai::Ptr{Int32})::Cint
 end
 
 function amd_l_valid(n_row, n_col, Ap, Ai)
-    @ccall libamd.amd_l_valid(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64})::Cint
+    @ccall libamd.amd_l_valid(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                              Ai::Ptr{Int64})::Cint
 end
 
 function amd_defaults(Control)
@@ -1607,188 +2213,88 @@ function amd_l_info(Info)
     @ccall libamd.amd_l_info(Info::Ptr{Cdouble})::Cvoid
 end
 
-function colamd_recommended(nnz, n_row, n_col)
-    @ccall libcolamd.colamd_recommended(nnz::Int32, n_row::Int32, n_col::Int32)::Csize_t
-end
-
-function colamd_l_recommended(nnz, n_row, n_col)
-    @ccall libcolamd.colamd_l_recommended(nnz::Int64, n_row::Int64, n_col::Int64)::Csize_t
-end
-
-function colamd_set_defaults(knobs)
-    @ccall libcolamd.colamd_set_defaults(knobs::Ptr{Cdouble})::Cvoid
-end
-
-function colamd_l_set_defaults(knobs)
-    @ccall libcolamd.colamd_l_set_defaults(knobs::Ptr{Cdouble})::Cvoid
-end
-
-function colamd(n_row, n_col, Alen, A, p, knobs, stats)
-    @ccall libcolamd.colamd(n_row::Int32, n_col::Int32, Alen::Int32, A::Ptr{Int32}, p::Ptr{Int32}, knobs::Ptr{Cdouble}, stats::Ptr{Int32})::Cint
-end
-
-function colamd_l(n_row, n_col, Alen, A, p, knobs, stats)
-    @ccall libcolamd.colamd_l(n_row::Int64, n_col::Int64, Alen::Int64, A::Ptr{Int64}, p::Ptr{Int64}, knobs::Ptr{Cdouble}, stats::Ptr{Int64})::Cint
-end
-
-function symamd(n, A, p, perm, knobs, stats, allocate, release)
-    @ccall libcolamd.symamd(n::Int32, A::Ptr{Int32}, p::Ptr{Int32}, perm::Ptr{Int32}, knobs::Ptr{Cdouble}, stats::Ptr{Int32}, allocate::Ptr{Cvoid}, release::Ptr{Cvoid})::Cint
-end
-
-function symamd_l(n, A, p, perm, knobs, stats, allocate, release)
-    @ccall libcolamd.symamd_l(n::Int64, A::Ptr{Int64}, p::Ptr{Int64}, perm::Ptr{Int64}, knobs::Ptr{Cdouble}, stats::Ptr{Int64}, allocate::Ptr{Cvoid}, release::Ptr{Cvoid})::Cint
-end
-
-function colamd_report(stats)
-    @ccall libcolamd.colamd_report(stats::Ptr{Int32})::Cvoid
-end
-
-function colamd_l_report(stats)
-    @ccall libcolamd.colamd_l_report(stats::Ptr{Int64})::Cvoid
-end
-
-function symamd_report(stats)
-    @ccall libcolamd.symamd_report(stats::Ptr{Int32})::Cvoid
-end
-
-function symamd_l_report(stats)
-    @ccall libcolamd.symamd_l_report(stats::Ptr{Int64})::Cvoid
-end
-
-function ccolamd_recommended(nnz, n_row, n_col)
-    @ccall libcolamd.ccolamd_recommended(nnz::Cint, n_row::Cint, n_col::Cint)::Csize_t
-end
-
-function ccolamd_l_recommended(nnz, n_row, n_col)
-    @ccall libcolamd.ccolamd_l_recommended(nnz::Int64, n_row::Int64, n_col::Int64)::Csize_t
-end
-
-function ccolamd_set_defaults(knobs)
-    @ccall libcolamd.ccolamd_set_defaults(knobs::Ptr{Cdouble})::Cvoid
-end
-
-function ccolamd_l_set_defaults(knobs)
-    @ccall libcolamd.ccolamd_l_set_defaults(knobs::Ptr{Cdouble})::Cvoid
-end
-
-function ccolamd(n_row, n_col, Alen, A, p, knobs, stats, cmember)
-    @ccall libcolamd.ccolamd(n_row::Cint, n_col::Cint, Alen::Cint, A::Ptr{Cint}, p::Ptr{Cint}, knobs::Ptr{Cdouble}, stats::Ptr{Cint}, cmember::Ptr{Cint})::Cint
-end
-
-function ccolamd_l(n_row, n_col, Alen, A, p, knobs, stats, cmember)
-    @ccall libcolamd.ccolamd_l(n_row::Int64, n_col::Int64, Alen::Int64, A::Ptr{Int64}, p::Ptr{Int64}, knobs::Ptr{Cdouble}, stats::Ptr{Int64}, cmember::Ptr{Int64})::Cint
-end
-
-function csymamd(n, A, p, perm, knobs, stats, allocate, release, cmember, stype)
-    @ccall libcolamd.csymamd(n::Cint, A::Ptr{Cint}, p::Ptr{Cint}, perm::Ptr{Cint}, knobs::Ptr{Cdouble}, stats::Ptr{Cint}, allocate::Ptr{Cvoid}, release::Ptr{Cvoid}, cmember::Ptr{Cint}, stype::Cint)::Cint
-end
-
-function csymamd_l(n, A, p, perm, knobs, stats, allocate, release, cmember, stype)
-    @ccall libcolamd.csymamd_l(n::Int64, A::Ptr{Int64}, p::Ptr{Int64}, perm::Ptr{Int64}, knobs::Ptr{Cdouble}, stats::Ptr{Int64}, allocate::Ptr{Cvoid}, release::Ptr{Cvoid}, cmember::Ptr{Int64}, stype::Int64)::Cint
-end
-
-function ccolamd_report(stats)
-    @ccall libcolamd.ccolamd_report(stats::Ptr{Cint})::Cvoid
-end
-
-function ccolamd_l_report(stats)
-    @ccall libcolamd.ccolamd_l_report(stats::Ptr{Int64})::Cvoid
-end
-
-function csymamd_report(stats)
-    @ccall libcolamd.csymamd_report(stats::Ptr{Cint})::Cvoid
-end
-
-function csymamd_l_report(stats)
-    @ccall libcolamd.csymamd_l_report(stats::Ptr{Int64})::Cvoid
-end
-
-function ccolamd2(n_row, n_col, Alen, A, p, knobs, stats, Front_npivcol, Front_nrows, Front_ncols, Front_parent, Front_cols, p_nfr, InFront, cmember)
-    @ccall libcolamd.ccolamd2(n_row::Cint, n_col::Cint, Alen::Cint, A::Ptr{Cint}, p::Ptr{Cint}, knobs::Ptr{Cdouble}, stats::Ptr{Cint}, Front_npivcol::Ptr{Cint}, Front_nrows::Ptr{Cint}, Front_ncols::Ptr{Cint}, Front_parent::Ptr{Cint}, Front_cols::Ptr{Cint}, p_nfr::Ptr{Cint}, InFront::Ptr{Cint}, cmember::Ptr{Cint})::Cint
-end
-
-function ccolamd2_l(n_row, n_col, Alen, A, p, knobs, stats, Front_npivcol, Front_nrows, Front_ncols, Front_parent, Front_cols, p_nfr, InFront, cmember)
-    @ccall libcolamd.ccolamd2_l(n_row::Int64, n_col::Int64, Alen::Int64, A::Ptr{Int64}, p::Ptr{Int64}, knobs::Ptr{Cdouble}, stats::Ptr{Int64}, Front_npivcol::Ptr{Int64}, Front_nrows::Ptr{Int64}, Front_ncols::Ptr{Int64}, Front_parent::Ptr{Int64}, Front_cols::Ptr{Int64}, p_nfr::Ptr{Int64}, InFront::Ptr{Int64}, cmember::Ptr{Int64})::Cint
-end
-
-function ccolamd_apply_order(Front, Order, Temp, nn, nfr)
-    @ccall libcolamd.ccolamd_apply_order(Front::Ptr{Cint}, Order::Ptr{Cint}, Temp::Ptr{Cint}, nn::Cint, nfr::Cint)::Cvoid
-end
-
-function ccolamd_l_apply_order(Front, Order, Temp, nn, nfr)
-    @ccall libcolamd.ccolamd_l_apply_order(Front::Ptr{Int64}, Order::Ptr{Int64}, Temp::Ptr{Int64}, nn::Int64, nfr::Int64)::Cvoid
-end
-
-function ccolamd_fsize(nn, MaxFsize, Fnrows, Fncols, Parent, Npiv)
-    @ccall libcolamd.ccolamd_fsize(nn::Cint, MaxFsize::Ptr{Cint}, Fnrows::Ptr{Cint}, Fncols::Ptr{Cint}, Parent::Ptr{Cint}, Npiv::Ptr{Cint})::Cvoid
-end
-
-function ccolamd_l_fsize(nn, MaxFsize, Fnrows, Fncols, Parent, Npiv)
-    @ccall libcolamd.ccolamd_l_fsize(nn::Int64, MaxFsize::Ptr{Int64}, Fnrows::Ptr{Int64}, Fncols::Ptr{Int64}, Parent::Ptr{Int64}, Npiv::Ptr{Int64})::Cvoid
-end
-
-function ccolamd_postorder(nn, Parent, Npiv, Fsize, Order, Child, Sibling, Stack, Front_cols, cmember)
-    @ccall libcolamd.ccolamd_postorder(nn::Cint, Parent::Ptr{Cint}, Npiv::Ptr{Cint}, Fsize::Ptr{Cint}, Order::Ptr{Cint}, Child::Ptr{Cint}, Sibling::Ptr{Cint}, Stack::Ptr{Cint}, Front_cols::Ptr{Cint}, cmember::Ptr{Cint})::Cvoid
-end
-
-function ccolamd_l_postorder(nn, Parent, Npiv, Fsize, Order, Child, Sibling, Stack, Front_cols, cmember)
-    @ccall libcolamd.ccolamd_l_postorder(nn::Int64, Parent::Ptr{Int64}, Npiv::Ptr{Int64}, Fsize::Ptr{Int64}, Order::Ptr{Int64}, Child::Ptr{Int64}, Sibling::Ptr{Int64}, Stack::Ptr{Int64}, Front_cols::Ptr{Int64}, cmember::Ptr{Int64})::Cvoid
-end
-
-function ccolamd_post_tree(root, k, Child, Sibling, Order, Stack)
-    @ccall libcolamd.ccolamd_post_tree(root::Cint, k::Cint, Child::Ptr{Cint}, Sibling::Ptr{Cint}, Order::Ptr{Cint}, Stack::Ptr{Cint})::Cint
-end
-
-function ccolamd_l_post_tree(root, k, Child, Sibling, Order, Stack)
-    @ccall libcolamd.ccolamd_l_post_tree(root::Int64, k::Int64, Child::Ptr{Int64}, Sibling::Ptr{Int64}, Order::Ptr{Int64}, Stack::Ptr{Int64})::Int64
-end
-
 function umfpack_di_symbolic(n_row, n_col, Ap, Ai, Ax, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_di_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                          Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                          Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                          Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_symbolic(n_row, n_col, Ap, Ai, Ax, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_dl_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                          Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                          Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                          Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_symbolic(n_row, n_col, Ap, Ai, Ax, Az, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_zi_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                          Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                          Az::Ptr{Cdouble}, Symbolic::Ptr{Ptr{Cvoid}},
+                                          Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_symbolic(n_row, n_col, Ap, Ai, Ax, Az, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_zl_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                          Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                          Az::Ptr{Cdouble}, Symbolic::Ptr{Ptr{Cvoid}},
+                                          Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_numeric(Ap, Ai, Ax, Symbolic, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_di_numeric(Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Symbolic::Ptr{Cvoid}, Numeric::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_numeric(Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                         Symbolic::Ptr{Cvoid}, Numeric::Ptr{Ptr{Cvoid}},
+                                         Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_numeric(Ap, Ai, Ax, Symbolic, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_dl_numeric(Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Symbolic::Ptr{Cvoid}, Numeric::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_numeric(Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                         Symbolic::Ptr{Cvoid}, Numeric::Ptr{Ptr{Cvoid}},
+                                         Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_numeric(Ap, Ai, Ax, Az, Symbolic, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_zi_numeric(Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Symbolic::Ptr{Cvoid}, Numeric::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_numeric(Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                         Az::Ptr{Cdouble}, Symbolic::Ptr{Cvoid},
+                                         Numeric::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                         Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_numeric(Ap, Ai, Ax, Az, Symbolic, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_zl_numeric(Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Symbolic::Ptr{Cvoid}, Numeric::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_numeric(Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                         Az::Ptr{Cdouble}, Symbolic::Ptr{Cvoid},
+                                         Numeric::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                         Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_solve(sys, Ap, Ai, Ax, X, B, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_di_solve(sys::Cint, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_solve(sys::Cint, Ap::Ptr{Int32}, Ai::Ptr{Int32},
+                                       Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble},
+                                       Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                       Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_solve(sys, Ap, Ai, Ax, X, B, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_dl_solve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_solve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64},
+                                       Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble},
+                                       Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                       Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_solve(sys, Ap, Ai, Ax, Az, Xx, Xz, Bx, Bz, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_zi_solve(sys::Cint, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_solve(sys::Cint, Ap::Ptr{Int32}, Ai::Ptr{Int32},
+                                       Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Xx::Ptr{Cdouble},
+                                       Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble},
+                                       Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                       Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_solve(sys, Ap, Ai, Ax, Az, Xx, Xz, Bx, Bz, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_zl_solve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_solve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64},
+                                       Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Xx::Ptr{Cdouble},
+                                       Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble},
+                                       Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                       Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_free_symbolic(Symbolic)
@@ -1840,51 +2346,119 @@ function umfpack_zl_defaults(Control)
 end
 
 function umfpack_di_qsymbolic(n_row, n_col, Ap, Ai, Ax, Qinit, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_di_qsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Qinit::Ptr{Int32}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_qsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                           Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                           Qinit::Ptr{Int32}, Symbolic::Ptr{Ptr{Cvoid}},
+                                           Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_qsymbolic(n_row, n_col, Ap, Ai, Ax, Qinit, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_dl_qsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Qinit::Ptr{Int64}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_qsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                           Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                           Qinit::Ptr{Int64}, Symbolic::Ptr{Ptr{Cvoid}},
+                                           Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_qsymbolic(n_row, n_col, Ap, Ai, Ax, Az, Qinit, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_zi_qsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Qinit::Ptr{Int32}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_qsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                           Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                           Az::Ptr{Cdouble}, Qinit::Ptr{Int32},
+                                           Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                           Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_qsymbolic(n_row, n_col, Ap, Ai, Ax, Az, Qinit, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_zl_qsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Qinit::Ptr{Int64}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_di_fsymbolic(n_row, n_col, Ap, Ai, Ax, user_ordering, user_params, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_di_fsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_dl_fsymbolic(n_row, n_col, Ap, Ai, Ax, user_ordering, user_params, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_dl_fsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_zi_fsymbolic(n_row, n_col, Ap, Ai, Ax, Az, user_ordering, user_params, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_zi_fsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_zl_fsymbolic(n_row, n_col, Ap, Ai, Ax, Az, user_ordering, user_params, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_zl_fsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_di_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Qinit, user_ordering, user_params, Symbolic, SW, Control, Info)
-    @ccall libumfpack.umfpack_di_paru_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Qinit::Ptr{Int32}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_dl_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Qinit, user_ordering, user_params, Symbolic, SW, Control, Info)
-    @ccall libumfpack.umfpack_dl_paru_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Qinit::Ptr{Int64}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_zi_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Az, Qinit, user_ordering, user_params, Symbolic, SW, Control, Info)
-    @ccall libumfpack.umfpack_zi_paru_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Qinit::Ptr{Int32}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_zl_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Az, Qinit, user_ordering, user_params, Symbolic, SW, Control, Info)
-    @ccall libumfpack.umfpack_zl_paru_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Qinit::Ptr{Int64}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_qsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                           Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                           Az::Ptr{Cdouble}, Qinit::Ptr{Int64},
+                                           Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                           Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_di_fsymbolic(n_row, n_col, Ap, Ai, Ax, user_ordering, user_params,
+                              Symbolic, Control, Info)
+    @ccall libumfpack.umfpack_di_fsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                           Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                           user_ordering::Ptr{Cvoid},
+                                           user_params::Ptr{Cvoid},
+                                           Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                           Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_dl_fsymbolic(n_row, n_col, Ap, Ai, Ax, user_ordering, user_params,
+                              Symbolic, Control, Info)
+    @ccall libumfpack.umfpack_dl_fsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                           Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                           user_ordering::Ptr{Cvoid},
+                                           user_params::Ptr{Cvoid},
+                                           Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                           Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_zi_fsymbolic(n_row, n_col, Ap, Ai, Ax, Az, user_ordering, user_params,
+                              Symbolic, Control, Info)
+    @ccall libumfpack.umfpack_zi_fsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                           Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                           Az::Ptr{Cdouble}, user_ordering::Ptr{Cvoid},
+                                           user_params::Ptr{Cvoid},
+                                           Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                           Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_zl_fsymbolic(n_row, n_col, Ap, Ai, Ax, Az, user_ordering, user_params,
+                              Symbolic, Control, Info)
+    @ccall libumfpack.umfpack_zl_fsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                           Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                           Az::Ptr{Cdouble}, user_ordering::Ptr{Cvoid},
+                                           user_params::Ptr{Cvoid},
+                                           Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                           Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_di_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Qinit, user_ordering,
+                                  user_params, Symbolic, SW, Control, Info)
+    @ccall libumfpack.umfpack_di_paru_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                               Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                               Qinit::Ptr{Int32}, user_ordering::Ptr{Cvoid},
+                                               user_params::Ptr{Cvoid},
+                                               Symbolic::Ptr{Ptr{Cvoid}},
+                                               SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                               Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_dl_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Qinit, user_ordering,
+                                  user_params, Symbolic, SW, Control, Info)
+    @ccall libumfpack.umfpack_dl_paru_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                               Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                               Qinit::Ptr{Int64}, user_ordering::Ptr{Cvoid},
+                                               user_params::Ptr{Cvoid},
+                                               Symbolic::Ptr{Ptr{Cvoid}},
+                                               SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                               Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_zi_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Az, Qinit, user_ordering,
+                                  user_params, Symbolic, SW, Control, Info)
+    @ccall libumfpack.umfpack_zi_paru_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                               Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                               Az::Ptr{Cdouble}, Qinit::Ptr{Int32},
+                                               user_ordering::Ptr{Cvoid},
+                                               user_params::Ptr{Cvoid},
+                                               Symbolic::Ptr{Ptr{Cvoid}},
+                                               SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                               Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_zl_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Az, Qinit, user_ordering,
+                                  user_params, Symbolic, SW, Control, Info)
+    @ccall libumfpack.umfpack_zl_paru_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                               Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                               Az::Ptr{Cdouble}, Qinit::Ptr{Int64},
+                                               user_ordering::Ptr{Cvoid},
+                                               user_params::Ptr{Cvoid},
+                                               Symbolic::Ptr{Ptr{Cvoid}},
+                                               SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                               Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_paru_free_sw(SW)
@@ -1904,339 +2478,547 @@ function umfpack_zl_paru_free_sw(SW)
 end
 
 function umfpack_di_wsolve(sys, Ap, Ai, Ax, X, B, Numeric, Control, Info, Wi, W)
-    @ccall libumfpack.umfpack_di_wsolve(sys::Cint, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble}, Wi::Ptr{Int32}, W::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_wsolve(sys::Cint, Ap::Ptr{Int32}, Ai::Ptr{Int32},
+                                        Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble},
+                                        Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                        Info::Ptr{Cdouble}, Wi::Ptr{Int32},
+                                        W::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_wsolve(sys, Ap, Ai, Ax, X, B, Numeric, Control, Info, Wi, W)
-    @ccall libumfpack.umfpack_dl_wsolve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble}, Wi::Ptr{Int64}, W::Ptr{Cdouble})::Cint
-end
-
-function umfpack_zi_wsolve(sys, Ap, Ai, Ax, Az, Xx, Xz, Bx, Bz, Numeric, Control, Info, Wi, W)
-    @ccall libumfpack.umfpack_zi_wsolve(sys::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble}, Wi::Ptr{Int32}, W::Ptr{Cdouble})::Cint
-end
-
-function umfpack_zl_wsolve(sys, Ap, Ai, Ax, Az, Xx, Xz, Bx, Bz, Numeric, Control, Info, Wi, W)
-    @ccall libumfpack.umfpack_zl_wsolve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble}, Wi::Ptr{Int64}, W::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_wsolve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64},
+                                        Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble},
+                                        Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                        Info::Ptr{Cdouble}, Wi::Ptr{Int64},
+                                        W::Ptr{Cdouble})::Cint
+end
+
+function umfpack_zi_wsolve(sys, Ap, Ai, Ax, Az, Xx, Xz, Bx, Bz, Numeric, Control, Info, Wi,
+                           W)
+    @ccall libumfpack.umfpack_zi_wsolve(sys::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32},
+                                        Ax::Ptr{Cdouble}, Az::Ptr{Cdouble},
+                                        Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble},
+                                        Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble},
+                                        Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                        Info::Ptr{Cdouble}, Wi::Ptr{Int32},
+                                        W::Ptr{Cdouble})::Cint
+end
+
+function umfpack_zl_wsolve(sys, Ap, Ai, Ax, Az, Xx, Xz, Bx, Bz, Numeric, Control, Info, Wi,
+                           W)
+    @ccall libumfpack.umfpack_zl_wsolve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64},
+                                        Ax::Ptr{Cdouble}, Az::Ptr{Cdouble},
+                                        Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble},
+                                        Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble},
+                                        Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                        Info::Ptr{Cdouble}, Wi::Ptr{Int64},
+                                        W::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_triplet_to_col(n_row, n_col, nz, Ti, Tj, Tx, Ap, Ai, Ax, Map)
-    @ccall libumfpack.umfpack_di_triplet_to_col(n_row::Int32, n_col::Int32, nz::Int32, Ti::Ptr{Int32}, Tj::Ptr{Int32}, Tx::Ptr{Cdouble}, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Map::Ptr{Int32})::Cint
+    @ccall libumfpack.umfpack_di_triplet_to_col(n_row::Int32, n_col::Int32, nz::Int32,
+                                                Ti::Ptr{Int32}, Tj::Ptr{Int32},
+                                                Tx::Ptr{Cdouble}, Ap::Ptr{Int32},
+                                                Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                                Map::Ptr{Int32})::Cint
 end
 
 function umfpack_dl_triplet_to_col(n_row, n_col, nz, Ti, Tj, Tx, Ap, Ai, Ax, Map)
-    @ccall libumfpack.umfpack_dl_triplet_to_col(n_row::Int64, n_col::Int64, nz::Int64, Ti::Ptr{Int64}, Tj::Ptr{Int64}, Tx::Ptr{Cdouble}, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Map::Ptr{Int64})::Cint
+    @ccall libumfpack.umfpack_dl_triplet_to_col(n_row::Int64, n_col::Int64, nz::Int64,
+                                                Ti::Ptr{Int64}, Tj::Ptr{Int64},
+                                                Tx::Ptr{Cdouble}, Ap::Ptr{Int64},
+                                                Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                                Map::Ptr{Int64})::Cint
 end
 
 function umfpack_zi_triplet_to_col(n_row, n_col, nz, Ti, Tj, Tx, Tz, Ap, Ai, Ax, Az, Map)
-    @ccall libumfpack.umfpack_zi_triplet_to_col(n_row::Int32, n_col::Int32, nz::Int32, Ti::Ptr{Int32}, Tj::Ptr{Int32}, Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble}, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Map::Ptr{Int32})::Cint
+    @ccall libumfpack.umfpack_zi_triplet_to_col(n_row::Int32, n_col::Int32, nz::Int32,
+                                                Ti::Ptr{Int32}, Tj::Ptr{Int32},
+                                                Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble},
+                                                Ap::Ptr{Int32}, Ai::Ptr{Int32},
+                                                Ax::Ptr{Cdouble}, Az::Ptr{Cdouble},
+                                                Map::Ptr{Int32})::Cint
 end
 
 function umfpack_zl_triplet_to_col(n_row, n_col, nz, Ti, Tj, Tx, Tz, Ap, Ai, Ax, Az, Map)
-    @ccall libumfpack.umfpack_zl_triplet_to_col(n_row::Int64, n_col::Int64, nz::Int64, Ti::Ptr{Int64}, Tj::Ptr{Int64}, Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble}, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Map::Ptr{Int64})::Cint
+    @ccall libumfpack.umfpack_zl_triplet_to_col(n_row::Int64, n_col::Int64, nz::Int64,
+                                                Ti::Ptr{Int64}, Tj::Ptr{Int64},
+                                                Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble},
+                                                Ap::Ptr{Int64}, Ai::Ptr{Int64},
+                                                Ax::Ptr{Cdouble}, Az::Ptr{Cdouble},
+                                                Map::Ptr{Int64})::Cint
 end
 
 function umfpack_di_col_to_triplet(n_col, Ap, Tj)
-    @ccall libumfpack.umfpack_di_col_to_triplet(n_col::Int32, Ap::Ptr{Int32}, Tj::Ptr{Int32})::Cint
+    @ccall libumfpack.umfpack_di_col_to_triplet(n_col::Int32, Ap::Ptr{Int32},
+                                                Tj::Ptr{Int32})::Cint
 end
 
 function umfpack_dl_col_to_triplet(n_col, Ap, Tj)
-    @ccall libumfpack.umfpack_dl_col_to_triplet(n_col::Int64, Ap::Ptr{Int64}, Tj::Ptr{Int64})::Cint
+    @ccall libumfpack.umfpack_dl_col_to_triplet(n_col::Int64, Ap::Ptr{Int64},
+                                                Tj::Ptr{Int64})::Cint
 end
 
 function umfpack_zi_col_to_triplet(n_col, Ap, Tj)
-    @ccall libumfpack.umfpack_zi_col_to_triplet(n_col::Int32, Ap::Ptr{Int32}, Tj::Ptr{Int32})::Cint
+    @ccall libumfpack.umfpack_zi_col_to_triplet(n_col::Int32, Ap::Ptr{Int32},
+                                                Tj::Ptr{Int32})::Cint
 end
 
 function umfpack_zl_col_to_triplet(n_col, Ap, Tj)
-    @ccall libumfpack.umfpack_zl_col_to_triplet(n_col::Int64, Ap::Ptr{Int64}, Tj::Ptr{Int64})::Cint
+    @ccall libumfpack.umfpack_zl_col_to_triplet(n_col::Int64, Ap::Ptr{Int64},
+                                                Tj::Ptr{Int64})::Cint
 end
 
 function umfpack_di_transpose(n_row, n_col, Ap, Ai, Ax, P, Q, Rp, Ri, Rx)
-    @ccall libumfpack.umfpack_di_transpose(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, P::Ptr{Int32}, Q::Ptr{Int32}, Rp::Ptr{Int32}, Ri::Ptr{Int32}, Rx::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_transpose(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                           Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, P::Ptr{Int32},
+                                           Q::Ptr{Int32}, Rp::Ptr{Int32}, Ri::Ptr{Int32},
+                                           Rx::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_transpose(n_row, n_col, Ap, Ai, Ax, P, Q, Rp, Ri, Rx)
-    @ccall libumfpack.umfpack_dl_transpose(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, P::Ptr{Int64}, Q::Ptr{Int64}, Rp::Ptr{Int64}, Ri::Ptr{Int64}, Rx::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_transpose(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                           Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, P::Ptr{Int64},
+                                           Q::Ptr{Int64}, Rp::Ptr{Int64}, Ri::Ptr{Int64},
+                                           Rx::Ptr{Cdouble})::Cint
 end
 
-function umfpack_zi_transpose(n_row, n_col, Ap, Ai, Ax, Az, P, Q, Rp, Ri, Rx, Rz, do_conjugate)
-    @ccall libumfpack.umfpack_zi_transpose(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, P::Ptr{Int32}, Q::Ptr{Int32}, Rp::Ptr{Int32}, Ri::Ptr{Int32}, Rx::Ptr{Cdouble}, Rz::Ptr{Cdouble}, do_conjugate::Cint)::Cint
+function umfpack_zi_transpose(n_row, n_col, Ap, Ai, Ax, Az, P, Q, Rp, Ri, Rx, Rz,
+                              do_conjugate)
+    @ccall libumfpack.umfpack_zi_transpose(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                           Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                           Az::Ptr{Cdouble}, P::Ptr{Int32}, Q::Ptr{Int32},
+                                           Rp::Ptr{Int32}, Ri::Ptr{Int32}, Rx::Ptr{Cdouble},
+                                           Rz::Ptr{Cdouble}, do_conjugate::Cint)::Cint
 end
 
-function umfpack_zl_transpose(n_row, n_col, Ap, Ai, Ax, Az, P, Q, Rp, Ri, Rx, Rz, do_conjugate)
-    @ccall libumfpack.umfpack_zl_transpose(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, P::Ptr{Int64}, Q::Ptr{Int64}, Rp::Ptr{Int64}, Ri::Ptr{Int64}, Rx::Ptr{Cdouble}, Rz::Ptr{Cdouble}, do_conjugate::Cint)::Cint
+function umfpack_zl_transpose(n_row, n_col, Ap, Ai, Ax, Az, P, Q, Rp, Ri, Rx, Rz,
+                              do_conjugate)
+    @ccall libumfpack.umfpack_zl_transpose(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                           Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                           Az::Ptr{Cdouble}, P::Ptr{Int64}, Q::Ptr{Int64},
+                                           Rp::Ptr{Int64}, Ri::Ptr{Int64}, Rx::Ptr{Cdouble},
+                                           Rz::Ptr{Cdouble}, do_conjugate::Cint)::Cint
 end
 
 function umfpack_di_scale(X, B, Numeric)
-    @ccall libumfpack.umfpack_di_scale(X::Ptr{Cdouble}, B::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_scale(X::Ptr{Cdouble}, B::Ptr{Cdouble},
+                                       Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_scale(X, B, Numeric)
-    @ccall libumfpack.umfpack_dl_scale(X::Ptr{Cdouble}, B::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_scale(X::Ptr{Cdouble}, B::Ptr{Cdouble},
+                                       Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_scale(Xx, Xz, Bx, Bz, Numeric)
-    @ccall libumfpack.umfpack_zi_scale(Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_scale(Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble},
+                                       Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_scale(Xx, Xz, Bx, Bz, Numeric)
-    @ccall libumfpack.umfpack_zl_scale(Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_scale(Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble},
+                                       Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_get_lunz(lnz, unz, n_row, n_col, nz_udiag, Numeric)
-    @ccall libumfpack.umfpack_di_get_lunz(lnz::Ptr{Int32}, unz::Ptr{Int32}, n_row::Ptr{Int32}, n_col::Ptr{Int32}, nz_udiag::Ptr{Int32}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_get_lunz(lnz::Ptr{Int32}, unz::Ptr{Int32},
+                                          n_row::Ptr{Int32}, n_col::Ptr{Int32},
+                                          nz_udiag::Ptr{Int32}, Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_get_lunz(lnz, unz, n_row, n_col, nz_udiag, Numeric)
-    @ccall libumfpack.umfpack_dl_get_lunz(lnz::Ptr{Int64}, unz::Ptr{Int64}, n_row::Ptr{Int64}, n_col::Ptr{Int64}, nz_udiag::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_get_lunz(lnz::Ptr{Int64}, unz::Ptr{Int64},
+                                          n_row::Ptr{Int64}, n_col::Ptr{Int64},
+                                          nz_udiag::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_get_lunz(lnz, unz, n_row, n_col, nz_udiag, Numeric)
-    @ccall libumfpack.umfpack_zi_get_lunz(lnz::Ptr{Int32}, unz::Ptr{Int32}, n_row::Ptr{Int32}, n_col::Ptr{Int32}, nz_udiag::Ptr{Int32}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_get_lunz(lnz::Ptr{Int32}, unz::Ptr{Int32},
+                                          n_row::Ptr{Int32}, n_col::Ptr{Int32},
+                                          nz_udiag::Ptr{Int32}, Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_get_lunz(lnz, unz, n_row, n_col, nz_udiag, Numeric)
-    @ccall libumfpack.umfpack_zl_get_lunz(lnz::Ptr{Int64}, unz::Ptr{Int64}, n_row::Ptr{Int64}, n_col::Ptr{Int64}, nz_udiag::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_get_lunz(lnz::Ptr{Int64}, unz::Ptr{Int64},
+                                          n_row::Ptr{Int64}, n_col::Ptr{Int64},
+                                          nz_udiag::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_get_numeric(Lp, Lj, Lx, Up, Ui, Ux, P, Q, Dx, do_recip, Rs, Numeric)
-    @ccall libumfpack.umfpack_di_get_numeric(Lp::Ptr{Int32}, Lj::Ptr{Int32}, Lx::Ptr{Cdouble}, Up::Ptr{Int32}, Ui::Ptr{Int32}, Ux::Ptr{Cdouble}, P::Ptr{Int32}, Q::Ptr{Int32}, Dx::Ptr{Cdouble}, do_recip::Ptr{Int32}, Rs::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_get_numeric(Lp::Ptr{Int32}, Lj::Ptr{Int32},
+                                             Lx::Ptr{Cdouble}, Up::Ptr{Int32},
+                                             Ui::Ptr{Int32}, Ux::Ptr{Cdouble},
+                                             P::Ptr{Int32}, Q::Ptr{Int32}, Dx::Ptr{Cdouble},
+                                             do_recip::Ptr{Int32}, Rs::Ptr{Cdouble},
+                                             Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_get_numeric(Lp, Lj, Lx, Up, Ui, Ux, P, Q, Dx, do_recip, Rs, Numeric)
-    @ccall libumfpack.umfpack_dl_get_numeric(Lp::Ptr{Int64}, Lj::Ptr{Int64}, Lx::Ptr{Cdouble}, Up::Ptr{Int64}, Ui::Ptr{Int64}, Ux::Ptr{Cdouble}, P::Ptr{Int64}, Q::Ptr{Int64}, Dx::Ptr{Cdouble}, do_recip::Ptr{Int64}, Rs::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
-end
-
-function umfpack_zi_get_numeric(Lp, Lj, Lx, Lz, Up, Ui, Ux, Uz, P, Q, Dx, Dz, do_recip, Rs, Numeric)
-    @ccall libumfpack.umfpack_zi_get_numeric(Lp::Ptr{Int32}, Lj::Ptr{Int32}, Lx::Ptr{Cdouble}, Lz::Ptr{Cdouble}, Up::Ptr{Int32}, Ui::Ptr{Int32}, Ux::Ptr{Cdouble}, Uz::Ptr{Cdouble}, P::Ptr{Int32}, Q::Ptr{Int32}, Dx::Ptr{Cdouble}, Dz::Ptr{Cdouble}, do_recip::Ptr{Int32}, Rs::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
-end
-
-function umfpack_zl_get_numeric(Lp, Lj, Lx, Lz, Up, Ui, Ux, Uz, P, Q, Dx, Dz, do_recip, Rs, Numeric)
-    @ccall libumfpack.umfpack_zl_get_numeric(Lp::Ptr{Int64}, Lj::Ptr{Int64}, Lx::Ptr{Cdouble}, Lz::Ptr{Cdouble}, Up::Ptr{Int64}, Ui::Ptr{Int64}, Ux::Ptr{Cdouble}, Uz::Ptr{Cdouble}, P::Ptr{Int64}, Q::Ptr{Int64}, Dx::Ptr{Cdouble}, Dz::Ptr{Cdouble}, do_recip::Ptr{Int64}, Rs::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
-end
-
-function umfpack_di_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol, Front_parent, Front_1strow, Front_leftmostdesc, Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
-    @ccall libumfpack.umfpack_di_get_symbolic(n_row::Ptr{Int32}, n_col::Ptr{Int32}, n1::Ptr{Int32}, nz::Ptr{Int32}, nfr::Ptr{Int32}, nchains::Ptr{Int32}, P::Ptr{Int32}, Q::Ptr{Int32}, Front_npivcol::Ptr{Int32}, Front_parent::Ptr{Int32}, Front_1strow::Ptr{Int32}, Front_leftmostdesc::Ptr{Int32}, Chain_start::Ptr{Int32}, Chain_maxrows::Ptr{Int32}, Chain_maxcols::Ptr{Int32}, Dmap::Ptr{Int32}, Symbolic::Ptr{Cvoid})::Cint
-end
-
-function umfpack_dl_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol, Front_parent, Front_1strow, Front_leftmostdesc, Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
-    @ccall libumfpack.umfpack_dl_get_symbolic(n_row::Ptr{Int64}, n_col::Ptr{Int64}, n1::Ptr{Int64}, nz::Ptr{Int64}, nfr::Ptr{Int64}, nchains::Ptr{Int64}, P::Ptr{Int64}, Q::Ptr{Int64}, Front_npivcol::Ptr{Int64}, Front_parent::Ptr{Int64}, Front_1strow::Ptr{Int64}, Front_leftmostdesc::Ptr{Int64}, Chain_start::Ptr{Int64}, Chain_maxrows::Ptr{Int64}, Chain_maxcols::Ptr{Int64}, Dmap::Ptr{Int64}, Symbolic::Ptr{Cvoid})::Cint
-end
-
-function umfpack_zi_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol, Front_parent, Front_1strow, Front_leftmostdesc, Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
-    @ccall libumfpack.umfpack_zi_get_symbolic(n_row::Ptr{Int32}, n_col::Ptr{Int32}, n1::Ptr{Int32}, nz::Ptr{Int32}, nfr::Ptr{Int32}, nchains::Ptr{Int32}, P::Ptr{Int32}, Q::Ptr{Int32}, Front_npivcol::Ptr{Int32}, Front_parent::Ptr{Int32}, Front_1strow::Ptr{Int32}, Front_leftmostdesc::Ptr{Int32}, Chain_start::Ptr{Int32}, Chain_maxrows::Ptr{Int32}, Chain_maxcols::Ptr{Int32}, Dmap::Ptr{Int32}, Symbolic::Ptr{Cvoid})::Cint
-end
-
-function umfpack_zl_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol, Front_parent, Front_1strow, Front_leftmostdesc, Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
-    @ccall libumfpack.umfpack_zl_get_symbolic(n_row::Ptr{Int64}, n_col::Ptr{Int64}, n1::Ptr{Int64}, nz::Ptr{Int64}, nfr::Ptr{Int64}, nchains::Ptr{Int64}, P::Ptr{Int64}, Q::Ptr{Int64}, Front_npivcol::Ptr{Int64}, Front_parent::Ptr{Int64}, Front_1strow::Ptr{Int64}, Front_leftmostdesc::Ptr{Int64}, Chain_start::Ptr{Int64}, Chain_maxrows::Ptr{Int64}, Chain_maxcols::Ptr{Int64}, Dmap::Ptr{Int64}, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_get_numeric(Lp::Ptr{Int64}, Lj::Ptr{Int64},
+                                             Lx::Ptr{Cdouble}, Up::Ptr{Int64},
+                                             Ui::Ptr{Int64}, Ux::Ptr{Cdouble},
+                                             P::Ptr{Int64}, Q::Ptr{Int64}, Dx::Ptr{Cdouble},
+                                             do_recip::Ptr{Int64}, Rs::Ptr{Cdouble},
+                                             Numeric::Ptr{Cvoid})::Cint
+end
+
+function umfpack_zi_get_numeric(Lp, Lj, Lx, Lz, Up, Ui, Ux, Uz, P, Q, Dx, Dz, do_recip, Rs,
+                                Numeric)
+    @ccall libumfpack.umfpack_zi_get_numeric(Lp::Ptr{Int32}, Lj::Ptr{Int32},
+                                             Lx::Ptr{Cdouble}, Lz::Ptr{Cdouble},
+                                             Up::Ptr{Int32}, Ui::Ptr{Int32},
+                                             Ux::Ptr{Cdouble}, Uz::Ptr{Cdouble},
+                                             P::Ptr{Int32}, Q::Ptr{Int32}, Dx::Ptr{Cdouble},
+                                             Dz::Ptr{Cdouble}, do_recip::Ptr{Int32},
+                                             Rs::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+end
+
+function umfpack_zl_get_numeric(Lp, Lj, Lx, Lz, Up, Ui, Ux, Uz, P, Q, Dx, Dz, do_recip, Rs,
+                                Numeric)
+    @ccall libumfpack.umfpack_zl_get_numeric(Lp::Ptr{Int64}, Lj::Ptr{Int64},
+                                             Lx::Ptr{Cdouble}, Lz::Ptr{Cdouble},
+                                             Up::Ptr{Int64}, Ui::Ptr{Int64},
+                                             Ux::Ptr{Cdouble}, Uz::Ptr{Cdouble},
+                                             P::Ptr{Int64}, Q::Ptr{Int64}, Dx::Ptr{Cdouble},
+                                             Dz::Ptr{Cdouble}, do_recip::Ptr{Int64},
+                                             Rs::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+end
+
+function umfpack_di_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol,
+                                 Front_parent, Front_1strow, Front_leftmostdesc,
+                                 Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
+    @ccall libumfpack.umfpack_di_get_symbolic(n_row::Ptr{Int32}, n_col::Ptr{Int32},
+                                              n1::Ptr{Int32}, nz::Ptr{Int32},
+                                              nfr::Ptr{Int32}, nchains::Ptr{Int32},
+                                              P::Ptr{Int32}, Q::Ptr{Int32},
+                                              Front_npivcol::Ptr{Int32},
+                                              Front_parent::Ptr{Int32},
+                                              Front_1strow::Ptr{Int32},
+                                              Front_leftmostdesc::Ptr{Int32},
+                                              Chain_start::Ptr{Int32},
+                                              Chain_maxrows::Ptr{Int32},
+                                              Chain_maxcols::Ptr{Int32}, Dmap::Ptr{Int32},
+                                              Symbolic::Ptr{Cvoid})::Cint
+end
+
+function umfpack_dl_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol,
+                                 Front_parent, Front_1strow, Front_leftmostdesc,
+                                 Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
+    @ccall libumfpack.umfpack_dl_get_symbolic(n_row::Ptr{Int64}, n_col::Ptr{Int64},
+                                              n1::Ptr{Int64}, nz::Ptr{Int64},
+                                              nfr::Ptr{Int64}, nchains::Ptr{Int64},
+                                              P::Ptr{Int64}, Q::Ptr{Int64},
+                                              Front_npivcol::Ptr{Int64},
+                                              Front_parent::Ptr{Int64},
+                                              Front_1strow::Ptr{Int64},
+                                              Front_leftmostdesc::Ptr{Int64},
+                                              Chain_start::Ptr{Int64},
+                                              Chain_maxrows::Ptr{Int64},
+                                              Chain_maxcols::Ptr{Int64}, Dmap::Ptr{Int64},
+                                              Symbolic::Ptr{Cvoid})::Cint
+end
+
+function umfpack_zi_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol,
+                                 Front_parent, Front_1strow, Front_leftmostdesc,
+                                 Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
+    @ccall libumfpack.umfpack_zi_get_symbolic(n_row::Ptr{Int32}, n_col::Ptr{Int32},
+                                              n1::Ptr{Int32}, nz::Ptr{Int32},
+                                              nfr::Ptr{Int32}, nchains::Ptr{Int32},
+                                              P::Ptr{Int32}, Q::Ptr{Int32},
+                                              Front_npivcol::Ptr{Int32},
+                                              Front_parent::Ptr{Int32},
+                                              Front_1strow::Ptr{Int32},
+                                              Front_leftmostdesc::Ptr{Int32},
+                                              Chain_start::Ptr{Int32},
+                                              Chain_maxrows::Ptr{Int32},
+                                              Chain_maxcols::Ptr{Int32}, Dmap::Ptr{Int32},
+                                              Symbolic::Ptr{Cvoid})::Cint
+end
+
+function umfpack_zl_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol,
+                                 Front_parent, Front_1strow, Front_leftmostdesc,
+                                 Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
+    @ccall libumfpack.umfpack_zl_get_symbolic(n_row::Ptr{Int64}, n_col::Ptr{Int64},
+                                              n1::Ptr{Int64}, nz::Ptr{Int64},
+                                              nfr::Ptr{Int64}, nchains::Ptr{Int64},
+                                              P::Ptr{Int64}, Q::Ptr{Int64},
+                                              Front_npivcol::Ptr{Int64},
+                                              Front_parent::Ptr{Int64},
+                                              Front_1strow::Ptr{Int64},
+                                              Front_leftmostdesc::Ptr{Int64},
+                                              Chain_start::Ptr{Int64},
+                                              Chain_maxrows::Ptr{Int64},
+                                              Chain_maxcols::Ptr{Int64}, Dmap::Ptr{Int64},
+                                              Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_save_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_di_save_numeric(Numeric::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_di_save_numeric(Numeric::Ptr{Cvoid},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_dl_save_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_dl_save_numeric(Numeric::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_dl_save_numeric(Numeric::Ptr{Cvoid},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zi_save_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_zi_save_numeric(Numeric::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zi_save_numeric(Numeric::Ptr{Cvoid},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zl_save_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_zl_save_numeric(Numeric::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zl_save_numeric(Numeric::Ptr{Cvoid},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_di_load_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_di_load_numeric(Numeric::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_di_load_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_dl_load_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_dl_load_numeric(Numeric::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_dl_load_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zi_load_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_zi_load_numeric(Numeric::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zi_load_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zl_load_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_zl_load_numeric(Numeric::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zl_load_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_di_copy_numeric(Numeric, Original)
-    @ccall libumfpack.umfpack_di_copy_numeric(Numeric::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_copy_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_copy_numeric(Numeric, Original)
-    @ccall libumfpack.umfpack_dl_copy_numeric(Numeric::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_copy_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_copy_numeric(Numeric, Original)
-    @ccall libumfpack.umfpack_zi_copy_numeric(Numeric::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_copy_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_copy_numeric(Numeric, Original)
-    @ccall libumfpack.umfpack_zl_copy_numeric(Numeric::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_copy_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_serialize_numeric_size(blobsize, Numeric)
-    @ccall libumfpack.umfpack_di_serialize_numeric_size(blobsize::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_serialize_numeric_size(blobsize::Ptr{Int64},
+                                                        Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_serialize_numeric_size(blobsize, Numeric)
-    @ccall libumfpack.umfpack_dl_serialize_numeric_size(blobsize::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_serialize_numeric_size(blobsize::Ptr{Int64},
+                                                        Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_serialize_numeric_size(blobsize, Numeric)
-    @ccall libumfpack.umfpack_zi_serialize_numeric_size(blobsize::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_serialize_numeric_size(blobsize::Ptr{Int64},
+                                                        Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_serialize_numeric_size(blobsize, Numeric)
-    @ccall libumfpack.umfpack_zl_serialize_numeric_size(blobsize::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_serialize_numeric_size(blobsize::Ptr{Int64},
+                                                        Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_serialize_numeric(blob, blobsize, Numeric)
-    @ccall libumfpack.umfpack_di_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64,
+                                                   Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_serialize_numeric(blob, blobsize, Numeric)
-    @ccall libumfpack.umfpack_dl_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64,
+                                                   Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_serialize_numeric(blob, blobsize, Numeric)
-    @ccall libumfpack.umfpack_zi_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64,
+                                                   Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_serialize_numeric(blob, blobsize, Numeric)
-    @ccall libumfpack.umfpack_zl_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64,
+                                                   Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_deserialize_numeric(Numeric, blob, blobsize)
-    @ccall libumfpack.umfpack_di_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_di_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                                     blob::Ptr{Int8}, blobsize::Int64)::Cint
 end
 
 function umfpack_dl_deserialize_numeric(Numeric, blob, blobsize)
-    @ccall libumfpack.umfpack_dl_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_dl_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                                     blob::Ptr{Int8}, blobsize::Int64)::Cint
 end
 
 function umfpack_zi_deserialize_numeric(Numeric, blob, blobsize)
-    @ccall libumfpack.umfpack_zi_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_zi_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                                     blob::Ptr{Int8}, blobsize::Int64)::Cint
 end
 
 function umfpack_zl_deserialize_numeric(Numeric, blob, blobsize)
-    @ccall libumfpack.umfpack_zl_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_zl_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                                     blob::Ptr{Int8}, blobsize::Int64)::Cint
 end
 
 function umfpack_di_save_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_di_save_symbolic(Symbolic::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_di_save_symbolic(Symbolic::Ptr{Cvoid},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_dl_save_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_dl_save_symbolic(Symbolic::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_dl_save_symbolic(Symbolic::Ptr{Cvoid},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zi_save_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_zi_save_symbolic(Symbolic::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zi_save_symbolic(Symbolic::Ptr{Cvoid},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zl_save_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_zl_save_symbolic(Symbolic::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zl_save_symbolic(Symbolic::Ptr{Cvoid},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_di_load_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_di_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_di_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_dl_load_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_dl_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_dl_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zi_load_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_zi_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zi_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zl_load_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_zl_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zl_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_di_copy_symbolic(Symbolic, Original)
-    @ccall libumfpack.umfpack_di_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_copy_symbolic(Symbolic, Original)
-    @ccall libumfpack.umfpack_dl_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_copy_symbolic(Symbolic, Original)
-    @ccall libumfpack.umfpack_zi_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_copy_symbolic(Symbolic, Original)
-    @ccall libumfpack.umfpack_zl_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_serialize_symbolic_size(blobsize, Symbolic)
-    @ccall libumfpack.umfpack_di_serialize_symbolic_size(blobsize::Ptr{Int64}, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_serialize_symbolic_size(blobsize::Ptr{Int64},
+                                                         Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_serialize_symbolic_size(blobsize, Symbolic)
-    @ccall libumfpack.umfpack_dl_serialize_symbolic_size(blobsize::Ptr{Int64}, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_serialize_symbolic_size(blobsize::Ptr{Int64},
+                                                         Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_serialize_symbolic_size(blobsize, Symbolic)
-    @ccall libumfpack.umfpack_zi_serialize_symbolic_size(blobsize::Ptr{Int64}, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_serialize_symbolic_size(blobsize::Ptr{Int64},
+                                                         Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_serialize_symbolic_size(blobsize, Symbolic)
-    @ccall libumfpack.umfpack_zl_serialize_symbolic_size(blobsize::Ptr{Int64}, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_serialize_symbolic_size(blobsize::Ptr{Int64},
+                                                         Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_serialize_symbolic(blob, blobsize, Symbolic)
-    @ccall libumfpack.umfpack_di_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64,
+                                                    Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_serialize_symbolic(blob, blobsize, Symbolic)
-    @ccall libumfpack.umfpack_dl_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64,
+                                                    Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_serialize_symbolic(blob, blobsize, Symbolic)
-    @ccall libumfpack.umfpack_zi_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64,
+                                                    Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_serialize_symbolic(blob, blobsize, Symbolic)
-    @ccall libumfpack.umfpack_zl_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64,
+                                                    Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_deserialize_symbolic(Symbolic, blob, blobsize)
-    @ccall libumfpack.umfpack_di_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_di_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                                      blob::Ptr{Int8},
+                                                      blobsize::Int64)::Cint
 end
 
 function umfpack_dl_deserialize_symbolic(Symbolic, blob, blobsize)
-    @ccall libumfpack.umfpack_dl_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_dl_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                                      blob::Ptr{Int8},
+                                                      blobsize::Int64)::Cint
 end
 
 function umfpack_zi_deserialize_symbolic(Symbolic, blob, blobsize)
-    @ccall libumfpack.umfpack_zi_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_zi_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                                      blob::Ptr{Int8},
+                                                      blobsize::Int64)::Cint
 end
 
 function umfpack_zl_deserialize_symbolic(Symbolic, blob, blobsize)
-    @ccall libumfpack.umfpack_zl_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_zl_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                                      blob::Ptr{Int8},
+                                                      blobsize::Int64)::Cint
 end
 
 function umfpack_di_get_determinant(Mx, Ex, Numeric, User_Info)
-    @ccall libumfpack.umfpack_di_get_determinant(Mx::Ptr{Cdouble}, Ex::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, User_Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_get_determinant(Mx::Ptr{Cdouble}, Ex::Ptr{Cdouble},
+                                                 Numeric::Ptr{Cvoid},
+                                                 User_Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_get_determinant(Mx, Ex, Numeric, User_Info)
-    @ccall libumfpack.umfpack_dl_get_determinant(Mx::Ptr{Cdouble}, Ex::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, User_Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_get_determinant(Mx::Ptr{Cdouble}, Ex::Ptr{Cdouble},
+                                                 Numeric::Ptr{Cvoid},
+                                                 User_Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_get_determinant(Mx, Mz, Ex, Numeric, User_Info)
-    @ccall libumfpack.umfpack_zi_get_determinant(Mx::Ptr{Cdouble}, Mz::Ptr{Cdouble}, Ex::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, User_Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_get_determinant(Mx::Ptr{Cdouble}, Mz::Ptr{Cdouble},
+                                                 Ex::Ptr{Cdouble}, Numeric::Ptr{Cvoid},
+                                                 User_Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_get_determinant(Mx, Mz, Ex, Numeric, User_Info)
-    @ccall libumfpack.umfpack_zl_get_determinant(Mx::Ptr{Cdouble}, Mz::Ptr{Cdouble}, Ex::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, User_Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_get_determinant(Mx::Ptr{Cdouble}, Mz::Ptr{Cdouble},
+                                                 Ex::Ptr{Cdouble}, Numeric::Ptr{Cvoid},
+                                                 User_Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_report_status(Control, status)
@@ -2256,19 +3038,23 @@ function umfpack_zl_report_status(Control, status)
 end
 
 function umfpack_di_report_info(Control, Info)
-    @ccall libumfpack.umfpack_di_report_info(Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cvoid
+    @ccall libumfpack.umfpack_di_report_info(Control::Ptr{Cdouble},
+                                             Info::Ptr{Cdouble})::Cvoid
 end
 
 function umfpack_dl_report_info(Control, Info)
-    @ccall libumfpack.umfpack_dl_report_info(Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cvoid
+    @ccall libumfpack.umfpack_dl_report_info(Control::Ptr{Cdouble},
+                                             Info::Ptr{Cdouble})::Cvoid
 end
 
 function umfpack_zi_report_info(Control, Info)
-    @ccall libumfpack.umfpack_zi_report_info(Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cvoid
+    @ccall libumfpack.umfpack_zi_report_info(Control::Ptr{Cdouble},
+                                             Info::Ptr{Cdouble})::Cvoid
 end
 
 function umfpack_zl_report_info(Control, Info)
-    @ccall libumfpack.umfpack_zl_report_info(Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cvoid
+    @ccall libumfpack.umfpack_zl_report_info(Control::Ptr{Cdouble},
+                                             Info::Ptr{Cdouble})::Cvoid
 end
 
 function umfpack_di_report_control(Control)
@@ -2288,99 +3074,137 @@ function umfpack_zl_report_control(Control)
 end
 
 function umfpack_di_report_matrix(n_row, n_col, Ap, Ai, Ax, col_form, Control)
-    @ccall libumfpack.umfpack_di_report_matrix(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, col_form::Cint, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_report_matrix(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                               Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                               col_form::Cint, Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_report_matrix(n_row, n_col, Ap, Ai, Ax, col_form, Control)
-    @ccall libumfpack.umfpack_dl_report_matrix(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, col_form::Cint, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_report_matrix(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                               Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                               col_form::Cint, Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_report_matrix(n_row, n_col, Ap, Ai, Ax, Az, col_form, Control)
-    @ccall libumfpack.umfpack_zi_report_matrix(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, col_form::Cint, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_report_matrix(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                               Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                               Az::Ptr{Cdouble}, col_form::Cint,
+                                               Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_report_matrix(n_row, n_col, Ap, Ai, Ax, Az, col_form, Control)
-    @ccall libumfpack.umfpack_zl_report_matrix(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, col_form::Cint, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_report_matrix(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                               Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                               Az::Ptr{Cdouble}, col_form::Cint,
+                                               Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_report_triplet(n_row, n_col, nz, Ti, Tj, Tx, Control)
-    @ccall libumfpack.umfpack_di_report_triplet(n_row::Int32, n_col::Int32, nz::Int32, Ti::Ptr{Int32}, Tj::Ptr{Int32}, Tx::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_report_triplet(n_row::Int32, n_col::Int32, nz::Int32,
+                                                Ti::Ptr{Int32}, Tj::Ptr{Int32},
+                                                Tx::Ptr{Cdouble},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_report_triplet(n_row, n_col, nz, Ti, Tj, Tx, Control)
-    @ccall libumfpack.umfpack_dl_report_triplet(n_row::Int64, n_col::Int64, nz::Int64, Ti::Ptr{Int64}, Tj::Ptr{Int64}, Tx::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_report_triplet(n_row::Int64, n_col::Int64, nz::Int64,
+                                                Ti::Ptr{Int64}, Tj::Ptr{Int64},
+                                                Tx::Ptr{Cdouble},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_report_triplet(n_row, n_col, nz, Ti, Tj, Tx, Tz, Control)
-    @ccall libumfpack.umfpack_zi_report_triplet(n_row::Int32, n_col::Int32, nz::Int32, Ti::Ptr{Int32}, Tj::Ptr{Int32}, Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_report_triplet(n_row::Int32, n_col::Int32, nz::Int32,
+                                                Ti::Ptr{Int32}, Tj::Ptr{Int32},
+                                                Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_report_triplet(n_row, n_col, nz, Ti, Tj, Tx, Tz, Control)
-    @ccall libumfpack.umfpack_zl_report_triplet(n_row::Int64, n_col::Int64, nz::Int64, Ti::Ptr{Int64}, Tj::Ptr{Int64}, Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_report_triplet(n_row::Int64, n_col::Int64, nz::Int64,
+                                                Ti::Ptr{Int64}, Tj::Ptr{Int64},
+                                                Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_report_vector(n, X, Control)
-    @ccall libumfpack.umfpack_di_report_vector(n::Int32, X::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_report_vector(n::Int32, X::Ptr{Cdouble},
+                                               Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_report_vector(n, X, Control)
-    @ccall libumfpack.umfpack_dl_report_vector(n::Int64, X::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_report_vector(n::Int64, X::Ptr{Cdouble},
+                                               Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_report_vector(n, Xx, Xz, Control)
-    @ccall libumfpack.umfpack_zi_report_vector(n::Int32, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_report_vector(n::Int32, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble},
+                                               Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_report_vector(n, Xx, Xz, Control)
-    @ccall libumfpack.umfpack_zl_report_vector(n::Int64, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_report_vector(n::Int64, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble},
+                                               Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_report_symbolic(Symbolic, Control)
-    @ccall libumfpack.umfpack_di_report_symbolic(Symbolic::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_report_symbolic(Symbolic::Ptr{Cvoid},
+                                                 Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_report_symbolic(Symbolic, Control)
-    @ccall libumfpack.umfpack_dl_report_symbolic(Symbolic::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_report_symbolic(Symbolic::Ptr{Cvoid},
+                                                 Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_report_symbolic(Symbolic, Control)
-    @ccall libumfpack.umfpack_zi_report_symbolic(Symbolic::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_report_symbolic(Symbolic::Ptr{Cvoid},
+                                                 Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_report_symbolic(Symbolic, Control)
-    @ccall libumfpack.umfpack_zl_report_symbolic(Symbolic::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_report_symbolic(Symbolic::Ptr{Cvoid},
+                                                 Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_report_numeric(Numeric, Control)
-    @ccall libumfpack.umfpack_di_report_numeric(Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_report_numeric(Numeric::Ptr{Cvoid},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_report_numeric(Numeric, Control)
-    @ccall libumfpack.umfpack_dl_report_numeric(Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_report_numeric(Numeric::Ptr{Cvoid},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_report_numeric(Numeric, Control)
-    @ccall libumfpack.umfpack_zi_report_numeric(Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_report_numeric(Numeric::Ptr{Cvoid},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_report_numeric(Numeric, Control)
-    @ccall libumfpack.umfpack_zl_report_numeric(Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_report_numeric(Numeric::Ptr{Cvoid},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_report_perm(np, Perm, Control)
-    @ccall libumfpack.umfpack_di_report_perm(np::Int32, Perm::Ptr{Int32}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_report_perm(np::Int32, Perm::Ptr{Int32},
+                                             Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_report_perm(np, Perm, Control)
-    @ccall libumfpack.umfpack_dl_report_perm(np::Int64, Perm::Ptr{Int64}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_report_perm(np::Int64, Perm::Ptr{Int64},
+                                             Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_report_perm(np, Perm, Control)
-    @ccall libumfpack.umfpack_zi_report_perm(np::Int32, Perm::Ptr{Int32}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_report_perm(np::Int32, Perm::Ptr{Int32},
+                                             Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_report_perm(np, Perm, Control)
-    @ccall libumfpack.umfpack_zl_report_perm(np::Int64, Perm::Ptr{Int64}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_report_perm(np::Int64, Perm::Ptr{Int64},
+                                             Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_timer()
@@ -2395,13 +3219,13 @@ function umfpack_toc(stats)
     @ccall libumfpack.umfpack_toc(stats::Ptr{Cdouble})::Cvoid
 end
 
-const CHOLMOD_DATE = "Jan 17, 2023"
+const CHOLMOD_DATE = "June 16, 2023"
 
 const CHOLMOD_MAIN_VERSION = 4
 
 const CHOLMOD_SUB_VERSION = 0
 
-const CHOLMOD_SUBSUB_VERSION = 3
+const CHOLMOD_SUBSUB_VERSION = 4
 
 const _FILE_OFFSET_BITS = 64
 
@@ -2427,17 +3251,18 @@ const SUITESPARSE_COMPILER_MSC = 0
 
 const SUITESPARSE_COMPILER_XLC = 0
 
-const SUITESPARSE_DATE = "Jan 20, 2023"
+const SUITESPARSE_DATE = "June 29, 2023"
 
 const SUITESPARSE_MAIN_VERSION = 7
 
-const SUITESPARSE_SUB_VERSION = 0
+const SUITESPARSE_SUB_VERSION = 1
 
-const SUITESPARSE_SUBSUB_VERSION = 1
+const SUITESPARSE_SUBSUB_VERSION = 0
 
 SUITESPARSE_VER_CODE(main, sub) = main * 1000 + sub
 
-const SUITESPARSE_VERSION = SUITESPARSE_VER_CODE(SUITESPARSE_MAIN_VERSION, SUITESPARSE_SUB_VERSION)
+const SUITESPARSE_VERSION = SUITESPARSE_VER_CODE(SUITESPARSE_MAIN_VERSION,
+                                                 SUITESPARSE_SUB_VERSION)
 
 CHOLMOD_VER_CODE(main, sub) = main * 1000 + sub
 
@@ -2601,20 +3426,18 @@ const SPQR_RTX_EQUALS_B = 2
 
 const SPQR_RTX_EQUALS_ETB = 3
 
-const SPQR_DATE = "Jan 17, 2023"
+const SPQR_DATE = "July FIXME, 2023"
 
-const SPQR_MAIN_VERSION = 3
+const SPQR_MAIN_VERSION = 4
 
 const SPQR_SUB_VERSION = 0
 
-const SPQR_SUBSUB_VERSION = 3
+const SPQR_SUBSUB_VERSION = 0
 
 SPQR_VER_CODE(main, sub) = main * 1000 + sub
 
 const SPQR_VERSION = SPQR_VER_CODE(SPQR_MAIN_VERSION, SPQR_SUB_VERSION)
 
-const Complex = Float64
-
 const AMD_CONTROL = 5
 
 const AMD_INFO = 20
@@ -2663,172 +3486,29 @@ const AMD_INVALID = -2
 
 const AMD_OK_BUT_JUMBLED = 1
 
-const AMD_DATE = "Jan 17, 2023"
+const AMD_DATE = "June 16, 2023"
 
 const AMD_MAIN_VERSION = 3
 
 const AMD_SUB_VERSION = 0
 
-const AMD_SUBSUB_VERSION = 3
+const AMD_SUBSUB_VERSION = 4
 
 AMD_VERSION_CODE(main, sub) = main * 1000 + sub
 
 const AMD_VERSION = AMD_VERSION_CODE(AMD_MAIN_VERSION, AMD_SUB_VERSION)
 
-const COLAMD_DATE = "Jan 17, 2023"
-
-const COLAMD_MAIN_VERSION = 3
-
-const COLAMD_SUB_VERSION = 0
-
-const COLAMD_SUBSUB_VERSION = 3
-
-COLAMD_VERSION_CODE(main, sub) = main * 1000 + sub
-
-const COLAMD_VERSION = COLAMD_VERSION_CODE(COLAMD_MAIN_VERSION, COLAMD_SUB_VERSION)
-
-const COLAMD_KNOBS = 20
-
-const COLAMD_STATS = 20
-
-const COLAMD_DENSE_ROW = 0
-
-const COLAMD_DENSE_COL = 1
-
-const COLAMD_AGGRESSIVE = 2
-
-const COLAMD_DEFRAG_COUNT = 2
-
-const COLAMD_STATUS = 3
-
-const COLAMD_INFO1 = 4
-
-const COLAMD_INFO2 = 5
-
-const COLAMD_INFO3 = 6
-
-const COLAMD_OK = 0
-
-const COLAMD_OK_BUT_JUMBLED = 1
-
-const COLAMD_ERROR_A_not_present = -1
-
-const COLAMD_ERROR_p_not_present = -2
-
-const COLAMD_ERROR_nrow_negative = -3
-
-const COLAMD_ERROR_ncol_negative = -4
-
-const COLAMD_ERROR_nnz_negative = -5
-
-const COLAMD_ERROR_p0_nonzero = -6
-
-const COLAMD_ERROR_A_too_small = -7
-
-const COLAMD_ERROR_col_length_negative = -8
-
-const COLAMD_ERROR_row_index_out_of_bounds = -9
-
-const COLAMD_ERROR_out_of_memory = -10
-
-const COLAMD_ERROR_internal_error = -999
-
-const CCOLAMD_DATE = "Jan 17, 2023"
-
-const CCOLAMD_MAIN_VERSION = 3
-
-const CCOLAMD_SUB_VERSION = 0
-
-const CCOLAMD_SUBSUB_VERSION = 3
-
-CCOLAMD_VERSION_CODE(main, sub) = main * 1000 + sub
-
-const CCOLAMD_VERSION = CCOLAMD_VERSION_CODE(CCOLAMD_MAIN_VERSION, CCOLAMD_SUB_VERSION)
-
-const CCOLAMD_KNOBS = 20
-
-const CCOLAMD_STATS = 20
-
-const CCOLAMD_DENSE_ROW = 0
-
-const CCOLAMD_DENSE_COL = 1
-
-const CCOLAMD_AGGRESSIVE = 2
-
-const CCOLAMD_LU = 3
-
-const CCOLAMD_DEFRAG_COUNT = 2
-
-const CCOLAMD_STATUS = 3
-
-const CCOLAMD_INFO1 = 4
-
-const CCOLAMD_INFO2 = 5
-
-const CCOLAMD_INFO3 = 6
-
-const CCOLAMD_EMPTY_ROW = 7
-
-const CCOLAMD_EMPTY_COL = 8
-
-const CCOLAMD_NEWLY_EMPTY_ROW = 9
-
-const CCOLAMD_NEWLY_EMPTY_COL = 10
-
-const CCOLAMD_OK = 0
-
-const CCOLAMD_OK_BUT_JUMBLED = 1
-
-const CCOLAMD_ERROR_A_not_present = -1
-
-const CCOLAMD_ERROR_p_not_present = -2
-
-const CCOLAMD_ERROR_nrow_negative = -3
-
-const CCOLAMD_ERROR_ncol_negative = -4
-
-const CCOLAMD_ERROR_nnz_negative = -5
-
-const CCOLAMD_ERROR_p0_nonzero = -6
-
-const CCOLAMD_ERROR_A_too_small = -7
-
-const CCOLAMD_ERROR_col_length_negative = -8
-
-const CCOLAMD_ERROR_row_index_out_of_bounds = -9
-
-const CCOLAMD_ERROR_out_of_memory = -10
-
-const CCOLAMD_ERROR_invalid_cmember = -11
-
-const CCOLAMD_ERROR_internal_error = -999
-
 const UMFPACK_INFO = 90
 
 const UMFPACK_CONTROL = 20
 
-# Skipping MacroDefinition: UMFPACK_COPYRIGHT \
-#"UMFPACK:  Copyright (c) 2005-2023 by Timothy A. Davis.  All Rights Reserved.\n"
-
-# Skipping MacroDefinition: UMFPACK_LICENSE_PART1 \
-#"\nUMFPACK License: SPDX-License-Identifier: GPL-2.0+\n" \
-#"   UMFPACK is available under alternate licenses,\n" \
-#"   contact T. Davis for details.\n"
-
-const UMFPACK_LICENSE_PART2 = "\n"
-
-# Skipping MacroDefinition: UMFPACK_LICENSE_PART3 \
-#"\n" \
-#"Availability: http://www.suitesparse.com" \
-#"\n"
-
-const UMFPACK_DATE = "Jan 17, 2023"
+const UMFPACK_DATE = "June 16, 2023"
 
 const UMFPACK_MAIN_VERSION = 6
 
 const UMFPACK_SUB_VERSION = 1
 
-const UMFPACK_SUBSUB_VERSION = 0
+const UMFPACK_SUBSUB_VERSION = 1
 
 UMFPACK_VER_CODE(main, sub) = main * 1000 + sub
 
@@ -3169,4 +3849,3 @@ const UMFPACK_Q_Uat = 12
 const UMFPACK_Ut = 13
 
 const UMFPACK_Uat = 14
-
diff --git a/src/solvers/lib/armv7l-linux-gnueabihf.jl b/src/solvers/lib/armv7l-linux-gnueabihf.jl
index fcf756d2..a5aa4e44 100644
--- a/src/solvers/lib/armv7l-linux-gnueabihf.jl
+++ b/src/solvers/lib/armv7l-linux-gnueabihf.jl
@@ -1,137 +1,150 @@
 function SuiteSparse_config_printf_func_get()
-    @ccall libcholmod.SuiteSparse_config_printf_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_printf_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_malloc_func_get()
-    @ccall libcholmod.SuiteSparse_config_malloc_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_malloc_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_calloc_func_get()
-    @ccall libcholmod.SuiteSparse_config_calloc_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_calloc_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_realloc_func_get()
-    @ccall libcholmod.SuiteSparse_config_realloc_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_realloc_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_free_func_get()
-    @ccall libcholmod.SuiteSparse_config_free_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_free_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_hypot_func_get()
-    @ccall libcholmod.SuiteSparse_config_hypot_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_hypot_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_divcomplex_func_get()
-    @ccall libcholmod.SuiteSparse_config_divcomplex_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_divcomplex_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_malloc_func_set(malloc_func)
-    @ccall libcholmod.SuiteSparse_config_malloc_func_set(malloc_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_malloc_func_set(malloc_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_calloc_func_set(calloc_func)
-    @ccall libcholmod.SuiteSparse_config_calloc_func_set(calloc_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_calloc_func_set(calloc_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_realloc_func_set(realloc_func)
-    @ccall libcholmod.SuiteSparse_config_realloc_func_set(realloc_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_realloc_func_set(realloc_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_free_func_set(free_func)
-    @ccall libcholmod.SuiteSparse_config_free_func_set(free_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_free_func_set(free_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_printf_func_set(printf_func)
-    @ccall libcholmod.SuiteSparse_config_printf_func_set(printf_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_printf_func_set(printf_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_hypot_func_set(hypot_func)
-    @ccall libcholmod.SuiteSparse_config_hypot_func_set(hypot_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_hypot_func_set(hypot_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_divcomplex_func_set(divcomplex_func)
-    @ccall libcholmod.SuiteSparse_config_divcomplex_func_set(divcomplex_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_divcomplex_func_set(divcomplex_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_malloc(s)
-    @ccall libcholmod.SuiteSparse_config_malloc(s::Csize_t)::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_malloc(s::Csize_t)::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_calloc(n, s)
-    @ccall libcholmod.SuiteSparse_config_calloc(n::Csize_t, s::Csize_t)::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_calloc(n::Csize_t,
+                                                          s::Csize_t)::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_realloc(arg1, s)
-    @ccall libcholmod.SuiteSparse_config_realloc(arg1::Ptr{Cvoid}, s::Csize_t)::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_realloc(arg1::Ptr{Cvoid},
+                                                           s::Csize_t)::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_free(arg1)
-    @ccall libcholmod.SuiteSparse_config_free(arg1::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_free(arg1::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_hypot(x, y)
-    @ccall libcholmod.SuiteSparse_config_hypot(x::Cdouble, y::Cdouble)::Cdouble
+    @ccall libsuitesparseconfig.SuiteSparse_config_hypot(x::Cdouble, y::Cdouble)::Cdouble
 end
 
 function SuiteSparse_config_divcomplex(xr, xi, yr, yi, zr, zi)
-    @ccall libcholmod.SuiteSparse_config_divcomplex(xr::Cdouble, xi::Cdouble, yr::Cdouble, yi::Cdouble, zr::Ptr{Cdouble}, zi::Ptr{Cdouble})::Cint
+    @ccall libsuitesparseconfig.SuiteSparse_config_divcomplex(xr::Cdouble, xi::Cdouble,
+                                                              yr::Cdouble, yi::Cdouble,
+                                                              zr::Ptr{Cdouble},
+                                                              zi::Ptr{Cdouble})::Cint
 end
 
 function SuiteSparse_start()
-    @ccall libcholmod.SuiteSparse_start()::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_start()::Cvoid
 end
 
 function SuiteSparse_finish()
-    @ccall libcholmod.SuiteSparse_finish()::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_finish()::Cvoid
 end
 
 function SuiteSparse_malloc(nitems, size_of_item)
-    @ccall libcholmod.SuiteSparse_malloc(nitems::Csize_t, size_of_item::Csize_t)::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_malloc(nitems::Csize_t,
+                                                   size_of_item::Csize_t)::Ptr{Cvoid}
 end
 
 function SuiteSparse_calloc(nitems, size_of_item)
-    @ccall libcholmod.SuiteSparse_calloc(nitems::Csize_t, size_of_item::Csize_t)::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_calloc(nitems::Csize_t,
+                                                   size_of_item::Csize_t)::Ptr{Cvoid}
 end
 
 function SuiteSparse_realloc(nitems_new, nitems_old, size_of_item, p, ok)
-    @ccall libcholmod.SuiteSparse_realloc(nitems_new::Csize_t, nitems_old::Csize_t, size_of_item::Csize_t, p::Ptr{Cvoid}, ok::Ptr{Cint})::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_realloc(nitems_new::Csize_t,
+                                                    nitems_old::Csize_t,
+                                                    size_of_item::Csize_t, p::Ptr{Cvoid},
+                                                    ok::Ptr{Cint})::Ptr{Cvoid}
 end
 
 function SuiteSparse_free(p)
-    @ccall libcholmod.SuiteSparse_free(p::Ptr{Cvoid})::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_free(p::Ptr{Cvoid})::Ptr{Cvoid}
 end
 
 function SuiteSparse_tic(tic)
-    @ccall libcholmod.SuiteSparse_tic(tic::Ptr{Cdouble})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_tic(tic::Ptr{Cdouble})::Cvoid
 end
 
 function SuiteSparse_toc(tic)
-    @ccall libcholmod.SuiteSparse_toc(tic::Ptr{Cdouble})::Cdouble
+    @ccall libsuitesparseconfig.SuiteSparse_toc(tic::Ptr{Cdouble})::Cdouble
 end
 
 function SuiteSparse_time()
-    @ccall libcholmod.SuiteSparse_time()::Cdouble
+    @ccall libsuitesparseconfig.SuiteSparse_time()::Cdouble
 end
 
 function SuiteSparse_hypot(x, y)
-    @ccall libcholmod.SuiteSparse_hypot(x::Cdouble, y::Cdouble)::Cdouble
+    @ccall libsuitesparseconfig.SuiteSparse_hypot(x::Cdouble, y::Cdouble)::Cdouble
 end
 
 function SuiteSparse_divcomplex(ar, ai, br, bi, cr, ci)
-    @ccall libcholmod.SuiteSparse_divcomplex(ar::Cdouble, ai::Cdouble, br::Cdouble, bi::Cdouble, cr::Ptr{Cdouble}, ci::Ptr{Cdouble})::Cint
+    @ccall libsuitesparseconfig.SuiteSparse_divcomplex(ar::Cdouble, ai::Cdouble,
+                                                       br::Cdouble, bi::Cdouble,
+                                                       cr::Ptr{Cdouble},
+                                                       ci::Ptr{Cdouble})::Cint
 end
 
 function SuiteSparse_version(version)
-    @ccall libcholmod.SuiteSparse_version(version::Ptr{Cint})::Cint
+    @ccall libsuitesparseconfig.SuiteSparse_version(version::Ptr{Cint})::Cint
 end
 
 function SuiteSparse_BLAS_library()
-    @ccall libcholmod.SuiteSparse_BLAS_library()::Ptr{Cchar}
+    @ccall libsuitesparseconfig.SuiteSparse_BLAS_library()::Ptr{Cchar}
 end
 
 function SuiteSparse_BLAS_integer_size()
-    @ccall libcholmod.SuiteSparse_BLAS_integer_size()::Csize_t
+    @ccall libsuitesparseconfig.SuiteSparse_BLAS_integer_size()::Csize_t
 end
 
 struct cholmod_method_struct
@@ -140,16 +153,16 @@ struct cholmod_method_struct
     prune_dense::Cdouble
     prune_dense2::Cdouble
     nd_oksep::Cdouble
-    other_1::NTuple{4, Cdouble}
+    other_1::NTuple{4,Cdouble}
     nd_small::Csize_t
-    other_2::NTuple{4, Csize_t}
+    other_2::NTuple{4,Csize_t}
     aggressive::Cint
     order_for_lu::Cint
     nd_compress::Cint
     nd_camd::Cint
     nd_components::Cint
     ordering::Cint
-    other_3::NTuple{4, Csize_t}
+    other_3::NTuple{4,Csize_t}
 end
 
 mutable struct cholmod_common_struct
@@ -166,8 +179,8 @@ mutable struct cholmod_common_struct
     final_pack::Cint
     final_monotonic::Cint
     final_resymbol::Cint
-    zrelax::NTuple{3, Cdouble}
-    nrelax::NTuple{3, Csize_t}
+    zrelax::NTuple{3,Cdouble}
+    nrelax::NTuple{3,Csize_t}
     prefer_zomplex::Cint
     prefer_upper::Cint
     quick_return_if_not_posdef::Cint
@@ -179,7 +192,7 @@ mutable struct cholmod_common_struct
     nmethods::Cint
     current::Cint
     selected::Cint
-    method::NTuple{10, cholmod_method_struct}
+    method::NTuple{10,cholmod_method_struct}
     postorder::Cint
     default_nesdis::Cint
     metis_memory::Cdouble
@@ -222,7 +235,7 @@ mutable struct cholmod_common_struct
     SPQR_flopcount_bound::Cdouble
     SPQR_tol_used::Cdouble
     SPQR_norm_E_fro::Cdouble
-    SPQR_istat::NTuple{10, Int64}
+    SPQR_istat::NTuple{10,Int64}
     useGPU::Cint
     maxGpuMemBytes::Csize_t
     maxGpuMemFraction::Cdouble
@@ -231,10 +244,10 @@ mutable struct cholmod_common_struct
     gpuFlops::Int64
     gpuNumKernelLaunches::Cint
     cublasHandle::Ptr{Cvoid}
-    gpuStream::NTuple{8, Ptr{Cvoid}}
-    cublasEventPotrf::NTuple{3, Ptr{Cvoid}}
+    gpuStream::NTuple{8,Ptr{Cvoid}}
+    cublasEventPotrf::NTuple{3,Ptr{Cvoid}}
     updateCKernelsComplete::Ptr{Cvoid}
-    updateCBuffersFree::NTuple{8, Ptr{Cvoid}}
+    updateCBuffersFree::NTuple{8,Ptr{Cvoid}}
     dev_mempool::Ptr{Cvoid}
     dev_mempool_size::Csize_t
     host_pinned_mempool::Ptr{Cvoid}
@@ -300,11 +313,14 @@ function cholmod_l_maxrank(arg1, arg2)
 end
 
 function cholmod_allocate_work(nrow, iworksize, xworksize, Common)
-    @ccall libcholmod.cholmod_allocate_work(nrow::Csize_t, iworksize::Csize_t, xworksize::Csize_t, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_allocate_work(nrow::Csize_t, iworksize::Csize_t,
+                                            xworksize::Csize_t,
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_allocate_work(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_allocate_work(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_allocate_work(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t,
+                                              arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_free_work(Common)
@@ -324,11 +340,13 @@ function cholmod_l_clear_flag(arg1)
 end
 
 function cholmod_error(status, file, line, message, Common)
-    @ccall libcholmod.cholmod_error(status::Cint, file::Ptr{Cchar}, line::Cint, message::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_error(status::Cint, file::Ptr{Cchar}, line::Cint,
+                                    message::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_error(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_error(arg1::Cint, arg2::Ptr{Cchar}, arg3::Cint, arg4::Ptr{Cchar}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_error(arg1::Cint, arg2::Ptr{Cchar}, arg3::Cint,
+                                      arg4::Ptr{Cchar}, arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_dbound(dj, Common)
@@ -348,11 +366,14 @@ function cholmod_l_hypot(arg1, arg2)
 end
 
 function cholmod_divcomplex(ar, ai, br, bi, cr, ci)
-    @ccall libcholmod.cholmod_divcomplex(ar::Cdouble, ai::Cdouble, br::Cdouble, bi::Cdouble, cr::Ptr{Cdouble}, ci::Ptr{Cdouble})::Cint
+    @ccall libcholmod.cholmod_divcomplex(ar::Cdouble, ai::Cdouble, br::Cdouble, bi::Cdouble,
+                                         cr::Ptr{Cdouble}, ci::Ptr{Cdouble})::Cint
 end
 
 function cholmod_l_divcomplex(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_divcomplex(arg1::Cdouble, arg2::Cdouble, arg3::Cdouble, arg4::Cdouble, arg5::Ptr{Cdouble}, arg6::Ptr{Cdouble})::Cint
+    @ccall libcholmod.cholmod_l_divcomplex(arg1::Cdouble, arg2::Cdouble, arg3::Cdouble,
+                                           arg4::Cdouble, arg5::Ptr{Cdouble},
+                                           arg6::Ptr{Cdouble})::Cint
 end
 
 mutable struct cholmod_sparse_struct
@@ -384,155 +405,217 @@ end
 const descendantScore = cholmod_descendant_score_t
 
 function cholmod_score_comp(i, j)
-    @ccall libcholmod.cholmod_score_comp(i::Ptr{cholmod_descendant_score_t}, j::Ptr{cholmod_descendant_score_t})::Cint
+    @ccall libcholmod.cholmod_score_comp(i::Ptr{cholmod_descendant_score_t},
+                                         j::Ptr{cholmod_descendant_score_t})::Cint
 end
 
 function cholmod_l_score_comp(i, j)
-    @ccall libcholmod.cholmod_l_score_comp(i::Ptr{cholmod_descendant_score_t}, j::Ptr{cholmod_descendant_score_t})::Cint
+    @ccall libcholmod.cholmod_l_score_comp(i::Ptr{cholmod_descendant_score_t},
+                                           j::Ptr{cholmod_descendant_score_t})::Cint
 end
 
 function cholmod_allocate_sparse(nrow, ncol, nzmax, sorted, packed, stype, xtype, Common)
-    @ccall libcholmod.cholmod_allocate_sparse(nrow::Csize_t, ncol::Csize_t, nzmax::Csize_t, sorted::Cint, packed::Cint, stype::Cint, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_allocate_sparse(nrow::Csize_t, ncol::Csize_t, nzmax::Csize_t,
+                                              sorted::Cint, packed::Cint, stype::Cint,
+                                              xtype::Cint,
+                                              Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_allocate_sparse(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
-    @ccall libcholmod.cholmod_l_allocate_sparse(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t, arg4::Cint, arg5::Cint, arg6::Cint, arg7::Cint, arg8::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_allocate_sparse(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t,
+                                                arg4::Cint, arg5::Cint, arg6::Cint,
+                                                arg7::Cint,
+                                                arg8::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_free_sparse(A, Common)
-    @ccall libcholmod.cholmod_free_sparse(A::Ptr{Ptr{cholmod_sparse}}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_free_sparse(A::Ptr{Ptr{cholmod_sparse}},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_free_sparse(arg1, arg2)
-    @ccall libcholmod.cholmod_l_free_sparse(arg1::Ptr{Ptr{cholmod_sparse}}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_free_sparse(arg1::Ptr{Ptr{cholmod_sparse}},
+                                            arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_reallocate_sparse(nznew, A, Common)
-    @ccall libcholmod.cholmod_reallocate_sparse(nznew::Csize_t, A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_reallocate_sparse(nznew::Csize_t, A::Ptr{cholmod_sparse},
+                                                Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_reallocate_sparse(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_reallocate_sparse(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_reallocate_sparse(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                                  arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_nnz(A, Common)
-    @ccall libcholmod.cholmod_nnz(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_nnz(A::Ptr{cholmod_sparse},
+                                  Common::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_l_nnz(arg1, arg2)
-    @ccall libcholmod.cholmod_l_nnz(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_l_nnz(arg1::Ptr{cholmod_sparse},
+                                    arg2::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_speye(nrow, ncol, xtype, Common)
-    @ccall libcholmod.cholmod_speye(nrow::Csize_t, ncol::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_speye(nrow::Csize_t, ncol::Csize_t, xtype::Cint,
+                                    Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_speye(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_speye(arg1::Csize_t, arg2::Csize_t, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_speye(arg1::Csize_t, arg2::Csize_t, arg3::Cint,
+                                      arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_spzeros(nrow, ncol, nzmax, xtype, Common)
-    @ccall libcholmod.cholmod_spzeros(nrow::Csize_t, ncol::Csize_t, nzmax::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_spzeros(nrow::Csize_t, ncol::Csize_t, nzmax::Csize_t,
+                                      xtype::Cint,
+                                      Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_spzeros(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_spzeros(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t, arg4::Cint, arg5::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_spzeros(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t,
+                                        arg4::Cint,
+                                        arg5::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_transpose(A, values, Common)
-    @ccall libcholmod.cholmod_transpose(A::Ptr{cholmod_sparse}, values::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_transpose(A::Ptr{cholmod_sparse}, values::Cint,
+                                        Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_transpose(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_transpose(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_transpose(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                          arg3::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_transpose_unsym(A, values, Perm, fset, fsize, F, Common)
-    @ccall libcholmod.cholmod_transpose_unsym(A::Ptr{cholmod_sparse}, values::Cint, Perm::Ptr{Int32}, fset::Ptr{Int32}, fsize::Csize_t, F::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_transpose_unsym(A::Ptr{cholmod_sparse}, values::Cint,
+                                              Perm::Ptr{Int32}, fset::Ptr{Int32},
+                                              fsize::Csize_t, F::Ptr{cholmod_sparse},
+                                              Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_transpose_unsym(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_transpose_unsym(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Csize_t, arg6::Ptr{cholmod_sparse}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_transpose_unsym(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                                arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                                arg5::Csize_t, arg6::Ptr{cholmod_sparse},
+                                                arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_transpose_sym(A, values, Perm, F, Common)
-    @ccall libcholmod.cholmod_transpose_sym(A::Ptr{cholmod_sparse}, values::Cint, Perm::Ptr{Int32}, F::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_transpose_sym(A::Ptr{cholmod_sparse}, values::Cint,
+                                            Perm::Ptr{Int32}, F::Ptr{cholmod_sparse},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_transpose_sym(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_transpose_sym(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{Int64}, arg4::Ptr{cholmod_sparse}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_transpose_sym(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                              arg3::Ptr{Int64}, arg4::Ptr{cholmod_sparse},
+                                              arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_ptranspose(A, values, Perm, fset, fsize, Common)
-    @ccall libcholmod.cholmod_ptranspose(A::Ptr{cholmod_sparse}, values::Cint, Perm::Ptr{Int32}, fset::Ptr{Int32}, fsize::Csize_t, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_ptranspose(A::Ptr{cholmod_sparse}, values::Cint,
+                                         Perm::Ptr{Int32}, fset::Ptr{Int32}, fsize::Csize_t,
+                                         Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_ptranspose(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_ptranspose(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Csize_t, arg6::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_ptranspose(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                           arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                           arg5::Csize_t,
+                                           arg6::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_sort(A, Common)
-    @ccall libcholmod.cholmod_sort(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_sort(A::Ptr{cholmod_sparse},
+                                   Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_sort(arg1, arg2)
-    @ccall libcholmod.cholmod_l_sort(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_sort(arg1::Ptr{cholmod_sparse},
+                                     arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_band(A, k1, k2, mode, Common)
-    @ccall libcholmod.cholmod_band(A::Ptr{cholmod_sparse}, k1::Int64, k2::Int64, mode::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_band(A::Ptr{cholmod_sparse}, k1::Int64, k2::Int64, mode::Cint,
+                                   Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_band(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_band(arg1::Ptr{cholmod_sparse}, arg2::Int64, arg3::Int64, arg4::Cint, arg5::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_band(arg1::Ptr{cholmod_sparse}, arg2::Int64, arg3::Int64,
+                                     arg4::Cint,
+                                     arg5::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_band_inplace(k1, k2, mode, A, Common)
-    @ccall libcholmod.cholmod_band_inplace(k1::Int64, k2::Int64, mode::Cint, A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_band_inplace(k1::Int64, k2::Int64, mode::Cint,
+                                           A::Ptr{cholmod_sparse},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_band_inplace(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_band_inplace(arg1::Int64, arg2::Int64, arg3::Cint, arg4::Ptr{cholmod_sparse}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_band_inplace(arg1::Int64, arg2::Int64, arg3::Cint,
+                                             arg4::Ptr{cholmod_sparse},
+                                             arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_aat(A, fset, fsize, mode, Common)
-    @ccall libcholmod.cholmod_aat(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, mode::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_aat(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t,
+                                  mode::Cint,
+                                  Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_aat(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_aat(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Cint, arg5::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_aat(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                    arg3::Csize_t, arg4::Cint,
+                                    arg5::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_copy_sparse(A, Common)
-    @ccall libcholmod.cholmod_copy_sparse(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_copy_sparse(A::Ptr{cholmod_sparse},
+                                          Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_copy_sparse(arg1, arg2)
-    @ccall libcholmod.cholmod_l_copy_sparse(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_copy_sparse(arg1::Ptr{cholmod_sparse},
+                                            arg2::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_copy(A, stype, mode, Common)
-    @ccall libcholmod.cholmod_copy(A::Ptr{cholmod_sparse}, stype::Cint, mode::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_copy(A::Ptr{cholmod_sparse}, stype::Cint, mode::Cint,
+                                   Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_copy(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_copy(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_copy(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Cint,
+                                     arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_add(A, B, alpha, beta, values, sorted, Common)
-    @ccall libcholmod.cholmod_add(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse}, alpha::Ptr{Cdouble}, beta::Ptr{Cdouble}, values::Cint, sorted::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_add(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse},
+                                  alpha::Ptr{Cdouble}, beta::Ptr{Cdouble}, values::Cint,
+                                  sorted::Cint,
+                                  Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_add(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_add(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Ptr{Cdouble}, arg5::Cint, arg6::Cint, arg7::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_add(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse},
+                                    arg3::Ptr{Cdouble}, arg4::Ptr{Cdouble}, arg5::Cint,
+                                    arg6::Cint,
+                                    arg7::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_sparse_xtype(to_xtype, A, Common)
-    @ccall libcholmod.cholmod_sparse_xtype(to_xtype::Cint, A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_sparse_xtype(to_xtype::Cint, A::Ptr{cholmod_sparse},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_sparse_xtype(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_sparse_xtype(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_sparse_xtype(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                             arg3::Ptr{cholmod_common})::Cint
 end
 
 mutable struct cholmod_factor_struct
@@ -572,75 +655,100 @@ end
 const cholmod_factor = cholmod_factor_struct
 
 function cholmod_allocate_factor(n, Common)
-    @ccall libcholmod.cholmod_allocate_factor(n::Csize_t, Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_allocate_factor(n::Csize_t,
+                                              Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_l_allocate_factor(arg1, arg2)
-    @ccall libcholmod.cholmod_l_allocate_factor(arg1::Csize_t, arg2::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_l_allocate_factor(arg1::Csize_t,
+                                                arg2::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_free_factor(L, Common)
-    @ccall libcholmod.cholmod_free_factor(L::Ptr{Ptr{cholmod_factor}}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_free_factor(L::Ptr{Ptr{cholmod_factor}},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_free_factor(arg1, arg2)
-    @ccall libcholmod.cholmod_l_free_factor(arg1::Ptr{Ptr{cholmod_factor}}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_free_factor(arg1::Ptr{Ptr{cholmod_factor}},
+                                            arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_reallocate_factor(nznew, L, Common)
-    @ccall libcholmod.cholmod_reallocate_factor(nznew::Csize_t, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_reallocate_factor(nznew::Csize_t, L::Ptr{cholmod_factor},
+                                                Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_reallocate_factor(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_reallocate_factor(arg1::Csize_t, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_reallocate_factor(arg1::Csize_t, arg2::Ptr{cholmod_factor},
+                                                  arg3::Ptr{cholmod_common})::Cint
 end
 
-function cholmod_change_factor(to_xtype, to_ll, to_super, to_packed, to_monotonic, L, Common)
-    @ccall libcholmod.cholmod_change_factor(to_xtype::Cint, to_ll::Cint, to_super::Cint, to_packed::Cint, to_monotonic::Cint, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+function cholmod_change_factor(to_xtype, to_ll, to_super, to_packed, to_monotonic, L,
+                               Common)
+    @ccall libcholmod.cholmod_change_factor(to_xtype::Cint, to_ll::Cint, to_super::Cint,
+                                            to_packed::Cint, to_monotonic::Cint,
+                                            L::Ptr{cholmod_factor},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_change_factor(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_change_factor(arg1::Cint, arg2::Cint, arg3::Cint, arg4::Cint, arg5::Cint, arg6::Ptr{cholmod_factor}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_change_factor(arg1::Cint, arg2::Cint, arg3::Cint,
+                                              arg4::Cint, arg5::Cint,
+                                              arg6::Ptr{cholmod_factor},
+                                              arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_pack_factor(L, Common)
-    @ccall libcholmod.cholmod_pack_factor(L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_pack_factor(L::Ptr{cholmod_factor},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_pack_factor(arg1, arg2)
-    @ccall libcholmod.cholmod_l_pack_factor(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_pack_factor(arg1::Ptr{cholmod_factor},
+                                            arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_reallocate_column(j, need, L, Common)
-    @ccall libcholmod.cholmod_reallocate_column(j::Csize_t, need::Csize_t, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_reallocate_column(j::Csize_t, need::Csize_t,
+                                                L::Ptr{cholmod_factor},
+                                                Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_reallocate_column(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_reallocate_column(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{cholmod_factor}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_reallocate_column(arg1::Csize_t, arg2::Csize_t,
+                                                  arg3::Ptr{cholmod_factor},
+                                                  arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_factor_to_sparse(L, Common)
-    @ccall libcholmod.cholmod_factor_to_sparse(L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_factor_to_sparse(L::Ptr{cholmod_factor},
+                                               Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_factor_to_sparse(arg1, arg2)
-    @ccall libcholmod.cholmod_l_factor_to_sparse(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_factor_to_sparse(arg1::Ptr{cholmod_factor},
+                                                 arg2::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_copy_factor(L, Common)
-    @ccall libcholmod.cholmod_copy_factor(L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_copy_factor(L::Ptr{cholmod_factor},
+                                          Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_l_copy_factor(arg1, arg2)
-    @ccall libcholmod.cholmod_l_copy_factor(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_l_copy_factor(arg1::Ptr{cholmod_factor},
+                                            arg2::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_factor_xtype(to_xtype, L, Common)
-    @ccall libcholmod.cholmod_factor_xtype(to_xtype::Cint, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_factor_xtype(to_xtype::Cint, L::Ptr{cholmod_factor},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_factor_xtype(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_factor_xtype(arg1::Cint, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_factor_xtype(arg1::Cint, arg2::Ptr{cholmod_factor},
+                                             arg3::Ptr{cholmod_common})::Cint
 end
 
 mutable struct cholmod_dense_struct
@@ -658,91 +766,118 @@ end
 const cholmod_dense = cholmod_dense_struct
 
 function cholmod_allocate_dense(nrow, ncol, d, xtype, Common)
-    @ccall libcholmod.cholmod_allocate_dense(nrow::Csize_t, ncol::Csize_t, d::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_allocate_dense(nrow::Csize_t, ncol::Csize_t, d::Csize_t,
+                                             xtype::Cint,
+                                             Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_allocate_dense(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_allocate_dense(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t, arg4::Cint, arg5::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_allocate_dense(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t,
+                                               arg4::Cint,
+                                               arg5::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_zeros(nrow, ncol, xtype, Common)
-    @ccall libcholmod.cholmod_zeros(nrow::Csize_t, ncol::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_zeros(nrow::Csize_t, ncol::Csize_t, xtype::Cint,
+                                    Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_zeros(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_zeros(arg1::Csize_t, arg2::Csize_t, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_zeros(arg1::Csize_t, arg2::Csize_t, arg3::Cint,
+                                      arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_ones(nrow, ncol, xtype, Common)
-    @ccall libcholmod.cholmod_ones(nrow::Csize_t, ncol::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_ones(nrow::Csize_t, ncol::Csize_t, xtype::Cint,
+                                   Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_ones(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_ones(arg1::Csize_t, arg2::Csize_t, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_ones(arg1::Csize_t, arg2::Csize_t, arg3::Cint,
+                                     arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_eye(nrow, ncol, xtype, Common)
-    @ccall libcholmod.cholmod_eye(nrow::Csize_t, ncol::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_eye(nrow::Csize_t, ncol::Csize_t, xtype::Cint,
+                                  Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_eye(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_eye(arg1::Csize_t, arg2::Csize_t, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_eye(arg1::Csize_t, arg2::Csize_t, arg3::Cint,
+                                    arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_free_dense(X, Common)
-    @ccall libcholmod.cholmod_free_dense(X::Ptr{Ptr{cholmod_dense}}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_free_dense(X::Ptr{Ptr{cholmod_dense}},
+                                         Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_free_dense(arg1, arg2)
-    @ccall libcholmod.cholmod_l_free_dense(arg1::Ptr{Ptr{cholmod_dense}}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_free_dense(arg1::Ptr{Ptr{cholmod_dense}},
+                                           arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_ensure_dense(XHandle, nrow, ncol, d, xtype, Common)
-    @ccall libcholmod.cholmod_ensure_dense(XHandle::Ptr{Ptr{cholmod_dense}}, nrow::Csize_t, ncol::Csize_t, d::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_ensure_dense(XHandle::Ptr{Ptr{cholmod_dense}}, nrow::Csize_t,
+                                           ncol::Csize_t, d::Csize_t, xtype::Cint,
+                                           Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_ensure_dense(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_ensure_dense(arg1::Ptr{Ptr{cholmod_dense}}, arg2::Csize_t, arg3::Csize_t, arg4::Csize_t, arg5::Cint, arg6::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_ensure_dense(arg1::Ptr{Ptr{cholmod_dense}}, arg2::Csize_t,
+                                             arg3::Csize_t, arg4::Csize_t, arg5::Cint,
+                                             arg6::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_sparse_to_dense(A, Common)
-    @ccall libcholmod.cholmod_sparse_to_dense(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_sparse_to_dense(A::Ptr{cholmod_sparse},
+                                              Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_sparse_to_dense(arg1, arg2)
-    @ccall libcholmod.cholmod_l_sparse_to_dense(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_sparse_to_dense(arg1::Ptr{cholmod_sparse},
+                                                arg2::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_dense_to_sparse(X, values, Common)
-    @ccall libcholmod.cholmod_dense_to_sparse(X::Ptr{cholmod_dense}, values::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_dense_to_sparse(X::Ptr{cholmod_dense}, values::Cint,
+                                              Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_dense_to_sparse(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_dense_to_sparse(arg1::Ptr{cholmod_dense}, arg2::Cint, arg3::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_dense_to_sparse(arg1::Ptr{cholmod_dense}, arg2::Cint,
+                                                arg3::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_copy_dense(X, Common)
-    @ccall libcholmod.cholmod_copy_dense(X::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_copy_dense(X::Ptr{cholmod_dense},
+                                         Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_copy_dense(arg1, arg2)
-    @ccall libcholmod.cholmod_l_copy_dense(arg1::Ptr{cholmod_dense}, arg2::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_copy_dense(arg1::Ptr{cholmod_dense},
+                                           arg2::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_copy_dense2(X, Y, Common)
-    @ccall libcholmod.cholmod_copy_dense2(X::Ptr{cholmod_dense}, Y::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_copy_dense2(X::Ptr{cholmod_dense}, Y::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_copy_dense2(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_copy_dense2(arg1::Ptr{cholmod_dense}, arg2::Ptr{cholmod_dense}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_copy_dense2(arg1::Ptr{cholmod_dense},
+                                            arg2::Ptr{cholmod_dense},
+                                            arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_dense_xtype(to_xtype, X, Common)
-    @ccall libcholmod.cholmod_dense_xtype(to_xtype::Cint, X::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_dense_xtype(to_xtype::Cint, X::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_dense_xtype(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_dense_xtype(arg1::Cint, arg2::Ptr{cholmod_dense}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_dense_xtype(arg1::Cint, arg2::Ptr{cholmod_dense},
+                                            arg3::Ptr{cholmod_common})::Cint
 end
 
 mutable struct cholmod_triplet_struct
@@ -764,99 +899,137 @@ end
 const cholmod_triplet = cholmod_triplet_struct
 
 function cholmod_allocate_triplet(nrow, ncol, nzmax, stype, xtype, Common)
-    @ccall libcholmod.cholmod_allocate_triplet(nrow::Csize_t, ncol::Csize_t, nzmax::Csize_t, stype::Cint, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_allocate_triplet(nrow::Csize_t, ncol::Csize_t, nzmax::Csize_t,
+                                               stype::Cint, xtype::Cint,
+                                               Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_l_allocate_triplet(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_allocate_triplet(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t, arg4::Cint, arg5::Cint, arg6::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_l_allocate_triplet(arg1::Csize_t, arg2::Csize_t,
+                                                 arg3::Csize_t, arg4::Cint, arg5::Cint,
+                                                 arg6::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_free_triplet(T, Common)
-    @ccall libcholmod.cholmod_free_triplet(T::Ptr{Ptr{cholmod_triplet}}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_free_triplet(T::Ptr{Ptr{cholmod_triplet}},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_free_triplet(arg1, arg2)
-    @ccall libcholmod.cholmod_l_free_triplet(arg1::Ptr{Ptr{cholmod_triplet}}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_free_triplet(arg1::Ptr{Ptr{cholmod_triplet}},
+                                             arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_reallocate_triplet(nznew, T, Common)
-    @ccall libcholmod.cholmod_reallocate_triplet(nznew::Csize_t, T::Ptr{cholmod_triplet}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_reallocate_triplet(nznew::Csize_t, T::Ptr{cholmod_triplet},
+                                                 Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_reallocate_triplet(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_reallocate_triplet(arg1::Csize_t, arg2::Ptr{cholmod_triplet}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_reallocate_triplet(arg1::Csize_t,
+                                                   arg2::Ptr{cholmod_triplet},
+                                                   arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_sparse_to_triplet(A, Common)
-    @ccall libcholmod.cholmod_sparse_to_triplet(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_sparse_to_triplet(A::Ptr{cholmod_sparse},
+                                                Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_l_sparse_to_triplet(arg1, arg2)
-    @ccall libcholmod.cholmod_l_sparse_to_triplet(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_l_sparse_to_triplet(arg1::Ptr{cholmod_sparse},
+                                                  arg2::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_triplet_to_sparse(T, nzmax, Common)
-    @ccall libcholmod.cholmod_triplet_to_sparse(T::Ptr{cholmod_triplet}, nzmax::Csize_t, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_triplet_to_sparse(T::Ptr{cholmod_triplet}, nzmax::Csize_t,
+                                                Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_triplet_to_sparse(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_triplet_to_sparse(arg1::Ptr{cholmod_triplet}, arg2::Csize_t, arg3::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_triplet_to_sparse(arg1::Ptr{cholmod_triplet}, arg2::Csize_t,
+                                                  arg3::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_copy_triplet(T, Common)
-    @ccall libcholmod.cholmod_copy_triplet(T::Ptr{cholmod_triplet}, Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_copy_triplet(T::Ptr{cholmod_triplet},
+                                           Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_l_copy_triplet(arg1, arg2)
-    @ccall libcholmod.cholmod_l_copy_triplet(arg1::Ptr{cholmod_triplet}, arg2::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_l_copy_triplet(arg1::Ptr{cholmod_triplet},
+                                             arg2::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_triplet_xtype(to_xtype, T, Common)
-    @ccall libcholmod.cholmod_triplet_xtype(to_xtype::Cint, T::Ptr{cholmod_triplet}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_triplet_xtype(to_xtype::Cint, T::Ptr{cholmod_triplet},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_triplet_xtype(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_triplet_xtype(arg1::Cint, arg2::Ptr{cholmod_triplet}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_triplet_xtype(arg1::Cint, arg2::Ptr{cholmod_triplet},
+                                              arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_malloc(n, size, Common)
-    @ccall libcholmod.cholmod_malloc(n::Csize_t, size::Csize_t, Common::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_malloc(n::Csize_t, size::Csize_t,
+                                     Common::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_l_malloc(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_malloc(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_l_malloc(arg1::Csize_t, arg2::Csize_t,
+                                       arg3::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_calloc(n, size, Common)
-    @ccall libcholmod.cholmod_calloc(n::Csize_t, size::Csize_t, Common::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_calloc(n::Csize_t, size::Csize_t,
+                                     Common::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_l_calloc(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_calloc(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_l_calloc(arg1::Csize_t, arg2::Csize_t,
+                                       arg3::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_free(n, size, p, Common)
-    @ccall libcholmod.cholmod_free(n::Csize_t, size::Csize_t, p::Ptr{Cvoid}, Common::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_free(n::Csize_t, size::Csize_t, p::Ptr{Cvoid},
+                                   Common::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_l_free(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_free(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{Cvoid}, arg4::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_l_free(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{Cvoid},
+                                     arg4::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_realloc(nnew, size, p, n, Common)
-    @ccall libcholmod.cholmod_realloc(nnew::Csize_t, size::Csize_t, p::Ptr{Cvoid}, n::Ptr{Csize_t}, Common::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_realloc(nnew::Csize_t, size::Csize_t, p::Ptr{Cvoid},
+                                      n::Ptr{Csize_t},
+                                      Common::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_l_realloc(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_realloc(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{Cvoid}, arg4::Ptr{Csize_t}, arg5::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_l_realloc(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{Cvoid},
+                                        arg4::Ptr{Csize_t},
+                                        arg5::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
-function cholmod_realloc_multiple(nnew, nint, xtype, Iblock, Jblock, Xblock, Zblock, n, Common)
-    @ccall libcholmod.cholmod_realloc_multiple(nnew::Csize_t, nint::Cint, xtype::Cint, Iblock::Ptr{Ptr{Cvoid}}, Jblock::Ptr{Ptr{Cvoid}}, Xblock::Ptr{Ptr{Cvoid}}, Zblock::Ptr{Ptr{Cvoid}}, n::Ptr{Csize_t}, Common::Ptr{cholmod_common})::Cint
+function cholmod_realloc_multiple(nnew, nint, xtype, Iblock, Jblock, Xblock, Zblock, n,
+                                  Common)
+    @ccall libcholmod.cholmod_realloc_multiple(nnew::Csize_t, nint::Cint, xtype::Cint,
+                                               Iblock::Ptr{Ptr{Cvoid}},
+                                               Jblock::Ptr{Ptr{Cvoid}},
+                                               Xblock::Ptr{Ptr{Cvoid}},
+                                               Zblock::Ptr{Ptr{Cvoid}}, n::Ptr{Csize_t},
+                                               Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_realloc_multiple(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
-    @ccall libcholmod.cholmod_l_realloc_multiple(arg1::Csize_t, arg2::Cint, arg3::Cint, arg4::Ptr{Ptr{Cvoid}}, arg5::Ptr{Ptr{Cvoid}}, arg6::Ptr{Ptr{Cvoid}}, arg7::Ptr{Ptr{Cvoid}}, arg8::Ptr{Csize_t}, arg9::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_realloc_multiple(arg1::Csize_t, arg2::Cint, arg3::Cint,
+                                                 arg4::Ptr{Ptr{Cvoid}},
+                                                 arg5::Ptr{Ptr{Cvoid}},
+                                                 arg6::Ptr{Ptr{Cvoid}},
+                                                 arg7::Ptr{Ptr{Cvoid}}, arg8::Ptr{Csize_t},
+                                                 arg9::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_version(version)
@@ -876,11 +1049,13 @@ function cholmod_l_check_common(arg1)
 end
 
 function cholmod_print_common(name, Common)
-    @ccall libcholmod.cholmod_print_common(name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_common(name::Ptr{Cchar},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_common(arg1, arg2)
-    @ccall libcholmod.cholmod_l_print_common(arg1::Ptr{Cchar}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_common(arg1::Ptr{Cchar},
+                                             arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_gpu_stats(arg1)
@@ -892,643 +1067,1047 @@ function cholmod_l_gpu_stats(arg1)
 end
 
 function cholmod_check_sparse(A, Common)
-    @ccall libcholmod.cholmod_check_sparse(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_sparse(A::Ptr{cholmod_sparse},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_sparse(arg1, arg2)
-    @ccall libcholmod.cholmod_l_check_sparse(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_sparse(arg1::Ptr{cholmod_sparse},
+                                             arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_sparse(A, name, Common)
-    @ccall libcholmod.cholmod_print_sparse(A::Ptr{cholmod_sparse}, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_sparse(A::Ptr{cholmod_sparse}, name::Ptr{Cchar},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_sparse(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_print_sparse(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Cchar}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_sparse(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Cchar},
+                                             arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_check_dense(X, Common)
-    @ccall libcholmod.cholmod_check_dense(X::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_dense(X::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_dense(arg1, arg2)
-    @ccall libcholmod.cholmod_l_check_dense(arg1::Ptr{cholmod_dense}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_dense(arg1::Ptr{cholmod_dense},
+                                            arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_dense(X, name, Common)
-    @ccall libcholmod.cholmod_print_dense(X::Ptr{cholmod_dense}, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_dense(X::Ptr{cholmod_dense}, name::Ptr{Cchar},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_dense(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_print_dense(arg1::Ptr{cholmod_dense}, arg2::Ptr{Cchar}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_dense(arg1::Ptr{cholmod_dense}, arg2::Ptr{Cchar},
+                                            arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_check_factor(L, Common)
-    @ccall libcholmod.cholmod_check_factor(L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_factor(L::Ptr{cholmod_factor},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_factor(arg1, arg2)
-    @ccall libcholmod.cholmod_l_check_factor(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_factor(arg1::Ptr{cholmod_factor},
+                                             arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_factor(L, name, Common)
-    @ccall libcholmod.cholmod_print_factor(L::Ptr{cholmod_factor}, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_factor(L::Ptr{cholmod_factor}, name::Ptr{Cchar},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_factor(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_print_factor(arg1::Ptr{cholmod_factor}, arg2::Ptr{Cchar}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_factor(arg1::Ptr{cholmod_factor}, arg2::Ptr{Cchar},
+                                             arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_check_triplet(T, Common)
-    @ccall libcholmod.cholmod_check_triplet(T::Ptr{cholmod_triplet}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_triplet(T::Ptr{cholmod_triplet},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_triplet(arg1, arg2)
-    @ccall libcholmod.cholmod_l_check_triplet(arg1::Ptr{cholmod_triplet}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_triplet(arg1::Ptr{cholmod_triplet},
+                                              arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_triplet(T, name, Common)
-    @ccall libcholmod.cholmod_print_triplet(T::Ptr{cholmod_triplet}, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_triplet(T::Ptr{cholmod_triplet}, name::Ptr{Cchar},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_triplet(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_print_triplet(arg1::Ptr{cholmod_triplet}, arg2::Ptr{Cchar}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_triplet(arg1::Ptr{cholmod_triplet}, arg2::Ptr{Cchar},
+                                              arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_check_subset(Set, len, n, Common)
-    @ccall libcholmod.cholmod_check_subset(Set::Ptr{Int32}, len::Int64, n::Csize_t, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_subset(Set::Ptr{Int32}, len::Int64, n::Csize_t,
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_subset(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_check_subset(arg1::Ptr{Int64}, arg2::Int64, arg3::Csize_t, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_subset(arg1::Ptr{Int64}, arg2::Int64, arg3::Csize_t,
+                                             arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_subset(Set, len, n, name, Common)
-    @ccall libcholmod.cholmod_print_subset(Set::Ptr{Int32}, len::Int64, n::Csize_t, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_subset(Set::Ptr{Int32}, len::Int64, n::Csize_t,
+                                           name::Ptr{Cchar},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_subset(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_print_subset(arg1::Ptr{Int64}, arg2::Int64, arg3::Csize_t, arg4::Ptr{Cchar}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_subset(arg1::Ptr{Int64}, arg2::Int64, arg3::Csize_t,
+                                             arg4::Ptr{Cchar},
+                                             arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_check_perm(Perm, len, n, Common)
-    @ccall libcholmod.cholmod_check_perm(Perm::Ptr{Int32}, len::Csize_t, n::Csize_t, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_perm(Perm::Ptr{Int32}, len::Csize_t, n::Csize_t,
+                                         Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_perm(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_check_perm(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Csize_t, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_perm(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Csize_t,
+                                           arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_perm(Perm, len, n, name, Common)
-    @ccall libcholmod.cholmod_print_perm(Perm::Ptr{Int32}, len::Csize_t, n::Csize_t, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_perm(Perm::Ptr{Int32}, len::Csize_t, n::Csize_t,
+                                         name::Ptr{Cchar},
+                                         Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_perm(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_print_perm(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Csize_t, arg4::Ptr{Cchar}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_perm(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Csize_t,
+                                           arg4::Ptr{Cchar},
+                                           arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_check_parent(Parent, n, Common)
-    @ccall libcholmod.cholmod_check_parent(Parent::Ptr{Int32}, n::Csize_t, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_parent(Parent::Ptr{Int32}, n::Csize_t,
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_parent(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_check_parent(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_parent(arg1::Ptr{Int64}, arg2::Csize_t,
+                                             arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_parent(Parent, n, name, Common)
-    @ccall libcholmod.cholmod_print_parent(Parent::Ptr{Int32}, n::Csize_t, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_parent(Parent::Ptr{Int32}, n::Csize_t, name::Ptr{Cchar},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_parent(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_print_parent(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Ptr{Cchar}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_parent(arg1::Ptr{Int64}, arg2::Csize_t,
+                                             arg3::Ptr{Cchar},
+                                             arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_read_sparse(f, Common)
-    @ccall libcholmod.cholmod_read_sparse(f::Ptr{Libc.FILE}, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_read_sparse(f::Ptr{Libc.FILE},
+                                          Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_read_sparse(arg1, arg2)
-    @ccall libcholmod.cholmod_l_read_sparse(arg1::Ptr{Libc.FILE}, arg2::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_read_sparse(arg1::Ptr{Libc.FILE},
+                                            arg2::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_read_triplet(f, Common)
-    @ccall libcholmod.cholmod_read_triplet(f::Ptr{Libc.FILE}, Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_read_triplet(f::Ptr{Libc.FILE},
+                                           Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_l_read_triplet(arg1, arg2)
-    @ccall libcholmod.cholmod_l_read_triplet(arg1::Ptr{Libc.FILE}, arg2::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_l_read_triplet(arg1::Ptr{Libc.FILE},
+                                             arg2::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_read_dense(f, Common)
-    @ccall libcholmod.cholmod_read_dense(f::Ptr{Libc.FILE}, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_read_dense(f::Ptr{Libc.FILE},
+                                         Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_read_dense(arg1, arg2)
-    @ccall libcholmod.cholmod_l_read_dense(arg1::Ptr{Libc.FILE}, arg2::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_read_dense(arg1::Ptr{Libc.FILE},
+                                           arg2::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_read_matrix(f, prefer, mtype, Common)
-    @ccall libcholmod.cholmod_read_matrix(f::Ptr{Libc.FILE}, prefer::Cint, mtype::Ptr{Cint}, Common::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_read_matrix(f::Ptr{Libc.FILE}, prefer::Cint, mtype::Ptr{Cint},
+                                          Common::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_l_read_matrix(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_read_matrix(arg1::Ptr{Libc.FILE}, arg2::Cint, arg3::Ptr{Cint}, arg4::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_l_read_matrix(arg1::Ptr{Libc.FILE}, arg2::Cint,
+                                            arg3::Ptr{Cint},
+                                            arg4::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_write_sparse(f, A, Z, comments, Common)
-    @ccall libcholmod.cholmod_write_sparse(f::Ptr{Libc.FILE}, A::Ptr{cholmod_sparse}, Z::Ptr{cholmod_sparse}, comments::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_write_sparse(f::Ptr{Libc.FILE}, A::Ptr{cholmod_sparse},
+                                           Z::Ptr{cholmod_sparse}, comments::Ptr{Cchar},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_write_sparse(arg1, arg2, arg3, c, arg5)
-    @ccall libcholmod.cholmod_l_write_sparse(arg1::Ptr{Libc.FILE}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_sparse}, c::Ptr{Cchar}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_write_sparse(arg1::Ptr{Libc.FILE},
+                                             arg2::Ptr{cholmod_sparse},
+                                             arg3::Ptr{cholmod_sparse}, c::Ptr{Cchar},
+                                             arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_write_dense(f, X, comments, Common)
-    @ccall libcholmod.cholmod_write_dense(f::Ptr{Libc.FILE}, X::Ptr{cholmod_dense}, comments::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_write_dense(f::Ptr{Libc.FILE}, X::Ptr{cholmod_dense},
+                                          comments::Ptr{Cchar},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_write_dense(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_write_dense(arg1::Ptr{Libc.FILE}, arg2::Ptr{cholmod_dense}, arg3::Ptr{Cchar}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_write_dense(arg1::Ptr{Libc.FILE}, arg2::Ptr{cholmod_dense},
+                                            arg3::Ptr{Cchar},
+                                            arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_analyze(A, Common)
-    @ccall libcholmod.cholmod_analyze(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_analyze(A::Ptr{cholmod_sparse},
+                                      Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_l_analyze(arg1, arg2)
-    @ccall libcholmod.cholmod_l_analyze(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_l_analyze(arg1::Ptr{cholmod_sparse},
+                                        arg2::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_analyze_p(A, UserPerm, fset, fsize, Common)
-    @ccall libcholmod.cholmod_analyze_p(A::Ptr{cholmod_sparse}, UserPerm::Ptr{Int32}, fset::Ptr{Int32}, fsize::Csize_t, Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_analyze_p(A::Ptr{cholmod_sparse}, UserPerm::Ptr{Int32},
+                                        fset::Ptr{Int32}, fsize::Csize_t,
+                                        Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_l_analyze_p(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_analyze_p(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Ptr{Int64}, arg4::Csize_t, arg5::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_l_analyze_p(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                          arg3::Ptr{Int64}, arg4::Csize_t,
+                                          arg5::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_analyze_p2(for_whom, A, UserPerm, fset, fsize, Common)
-    @ccall libcholmod.cholmod_analyze_p2(for_whom::Cint, A::Ptr{cholmod_sparse}, UserPerm::Ptr{Int32}, fset::Ptr{Int32}, fsize::Csize_t, Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_analyze_p2(for_whom::Cint, A::Ptr{cholmod_sparse},
+                                         UserPerm::Ptr{Int32}, fset::Ptr{Int32},
+                                         fsize::Csize_t,
+                                         Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_l_analyze_p2(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_analyze_p2(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Csize_t, arg6::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_l_analyze_p2(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                           arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                           arg5::Csize_t,
+                                           arg6::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_factorize(A, L, Common)
-    @ccall libcholmod.cholmod_factorize(A::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_factorize(A::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor},
+                                        Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_factorize(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_factorize(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_factorize(arg1::Ptr{cholmod_sparse},
+                                          arg2::Ptr{cholmod_factor},
+                                          arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_factorize_p(A, beta, fset, fsize, L, Common)
-    @ccall libcholmod.cholmod_factorize_p(A::Ptr{cholmod_sparse}, beta::Ptr{Cdouble}, fset::Ptr{Int32}, fsize::Csize_t, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_factorize_p(A::Ptr{cholmod_sparse}, beta::Ptr{Cdouble},
+                                          fset::Ptr{Int32}, fsize::Csize_t,
+                                          L::Ptr{cholmod_factor},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_factorize_p(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_factorize_p(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Cdouble}, arg3::Ptr{Int64}, arg4::Csize_t, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_factorize_p(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Cdouble},
+                                            arg3::Ptr{Int64}, arg4::Csize_t,
+                                            arg5::Ptr{cholmod_factor},
+                                            arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_solve(sys, L, B, Common)
-    @ccall libcholmod.cholmod_solve(sys::Cint, L::Ptr{cholmod_factor}, B::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_solve(sys::Cint, L::Ptr{cholmod_factor},
+                                    B::Ptr{cholmod_dense},
+                                    Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_solve(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_solve(arg1::Cint, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_dense}, arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_solve(arg1::Cint, arg2::Ptr{cholmod_factor},
+                                      arg3::Ptr{cholmod_dense},
+                                      arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_solve2(sys, L, B, Bset, X_Handle, Xset_Handle, Y_Handle, E_Handle, Common)
-    @ccall libcholmod.cholmod_solve2(sys::Cint, L::Ptr{cholmod_factor}, B::Ptr{cholmod_dense}, Bset::Ptr{cholmod_sparse}, X_Handle::Ptr{Ptr{cholmod_dense}}, Xset_Handle::Ptr{Ptr{cholmod_sparse}}, Y_Handle::Ptr{Ptr{cholmod_dense}}, E_Handle::Ptr{Ptr{cholmod_dense}}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_solve2(sys::Cint, L::Ptr{cholmod_factor},
+                                     B::Ptr{cholmod_dense}, Bset::Ptr{cholmod_sparse},
+                                     X_Handle::Ptr{Ptr{cholmod_dense}},
+                                     Xset_Handle::Ptr{Ptr{cholmod_sparse}},
+                                     Y_Handle::Ptr{Ptr{cholmod_dense}},
+                                     E_Handle::Ptr{Ptr{cholmod_dense}},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_solve2(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
-    @ccall libcholmod.cholmod_l_solve2(arg1::Cint, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_dense}, arg4::Ptr{cholmod_sparse}, arg5::Ptr{Ptr{cholmod_dense}}, arg6::Ptr{Ptr{cholmod_sparse}}, arg7::Ptr{Ptr{cholmod_dense}}, arg8::Ptr{Ptr{cholmod_dense}}, arg9::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_solve2(arg1::Cint, arg2::Ptr{cholmod_factor},
+                                       arg3::Ptr{cholmod_dense}, arg4::Ptr{cholmod_sparse},
+                                       arg5::Ptr{Ptr{cholmod_dense}},
+                                       arg6::Ptr{Ptr{cholmod_sparse}},
+                                       arg7::Ptr{Ptr{cholmod_dense}},
+                                       arg8::Ptr{Ptr{cholmod_dense}},
+                                       arg9::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_spsolve(sys, L, B, Common)
-    @ccall libcholmod.cholmod_spsolve(sys::Cint, L::Ptr{cholmod_factor}, B::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_spsolve(sys::Cint, L::Ptr{cholmod_factor},
+                                      B::Ptr{cholmod_sparse},
+                                      Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_spsolve(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_spsolve(arg1::Cint, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_sparse}, arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_spsolve(arg1::Cint, arg2::Ptr{cholmod_factor},
+                                        arg3::Ptr{cholmod_sparse},
+                                        arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_etree(A, Parent, Common)
-    @ccall libcholmod.cholmod_etree(A::Ptr{cholmod_sparse}, Parent::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_etree(A::Ptr{cholmod_sparse}, Parent::Ptr{Int32},
+                                    Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_etree(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_etree(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_etree(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                      arg3::Ptr{cholmod_common})::Cint
 end
 
-function cholmod_rowcolcounts(A, fset, fsize, Parent, Post, RowCount, ColCount, First, Level, Common)
-    @ccall libcholmod.cholmod_rowcolcounts(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, Parent::Ptr{Int32}, Post::Ptr{Int32}, RowCount::Ptr{Int32}, ColCount::Ptr{Int32}, First::Ptr{Int32}, Level::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+function cholmod_rowcolcounts(A, fset, fsize, Parent, Post, RowCount, ColCount, First,
+                              Level, Common)
+    @ccall libcholmod.cholmod_rowcolcounts(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                           fsize::Csize_t, Parent::Ptr{Int32},
+                                           Post::Ptr{Int32}, RowCount::Ptr{Int32},
+                                           ColCount::Ptr{Int32}, First::Ptr{Int32},
+                                           Level::Ptr{Int32},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowcolcounts(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)
-    @ccall libcholmod.cholmod_l_rowcolcounts(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{Int64}, arg6::Ptr{Int64}, arg7::Ptr{Int64}, arg8::Ptr{Int64}, arg9::Ptr{Int64}, arg10::Ptr{cholmod_common})::Cint
-end
-
-function cholmod_analyze_ordering(A, ordering, Perm, fset, fsize, Parent, Post, ColCount, First, Level, Common)
-    @ccall libcholmod.cholmod_analyze_ordering(A::Ptr{cholmod_sparse}, ordering::Cint, Perm::Ptr{Int32}, fset::Ptr{Int32}, fsize::Csize_t, Parent::Ptr{Int32}, Post::Ptr{Int32}, ColCount::Ptr{Int32}, First::Ptr{Int32}, Level::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
-end
-
-function cholmod_l_analyze_ordering(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11)
-    @ccall libcholmod.cholmod_l_analyze_ordering(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Csize_t, arg6::Ptr{Int64}, arg7::Ptr{Int64}, arg8::Ptr{Int64}, arg9::Ptr{Int64}, arg10::Ptr{Int64}, arg11::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowcolcounts(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                             arg3::Csize_t, arg4::Ptr{Int64},
+                                             arg5::Ptr{Int64}, arg6::Ptr{Int64},
+                                             arg7::Ptr{Int64}, arg8::Ptr{Int64},
+                                             arg9::Ptr{Int64},
+                                             arg10::Ptr{cholmod_common})::Cint
+end
+
+function cholmod_analyze_ordering(A, ordering, Perm, fset, fsize, Parent, Post, ColCount,
+                                  First, Level, Common)
+    @ccall libcholmod.cholmod_analyze_ordering(A::Ptr{cholmod_sparse}, ordering::Cint,
+                                               Perm::Ptr{Int32}, fset::Ptr{Int32},
+                                               fsize::Csize_t, Parent::Ptr{Int32},
+                                               Post::Ptr{Int32}, ColCount::Ptr{Int32},
+                                               First::Ptr{Int32}, Level::Ptr{Int32},
+                                               Common::Ptr{cholmod_common})::Cint
+end
+
+function cholmod_l_analyze_ordering(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9,
+                                    arg10, arg11)
+    @ccall libcholmod.cholmod_l_analyze_ordering(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                                 arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                                 arg5::Csize_t, arg6::Ptr{Int64},
+                                                 arg7::Ptr{Int64}, arg8::Ptr{Int64},
+                                                 arg9::Ptr{Int64}, arg10::Ptr{Int64},
+                                                 arg11::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_amd(A, fset, fsize, Perm, Common)
-    @ccall libcholmod.cholmod_amd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_amd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t,
+                                  Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_amd(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_amd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_amd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                    arg3::Csize_t, arg4::Ptr{Int64},
+                                    arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_colamd(A, fset, fsize, postorder, Perm, Common)
-    @ccall libcholmod.cholmod_colamd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, postorder::Cint, Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_colamd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                     fsize::Csize_t, postorder::Cint, Perm::Ptr{Int32},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_colamd(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_colamd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Cint, arg5::Ptr{Int64}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_colamd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                       arg3::Csize_t, arg4::Cint, arg5::Ptr{Int64},
+                                       arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowfac(A, F, beta, kstart, kend, L, Common)
-    @ccall libcholmod.cholmod_rowfac(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, beta::Ptr{Cdouble}, kstart::Csize_t, kend::Csize_t, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowfac(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse},
+                                     beta::Ptr{Cdouble}, kstart::Csize_t, kend::Csize_t,
+                                     L::Ptr{cholmod_factor},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowfac(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_rowfac(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Csize_t, arg5::Csize_t, arg6::Ptr{cholmod_factor}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowfac(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse},
+                                       arg3::Ptr{Cdouble}, arg4::Csize_t, arg5::Csize_t,
+                                       arg6::Ptr{cholmod_factor},
+                                       arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowfac_mask(A, F, beta, kstart, kend, mask, RLinkUp, L, Common)
-    @ccall libcholmod.cholmod_rowfac_mask(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, beta::Ptr{Cdouble}, kstart::Csize_t, kend::Csize_t, mask::Ptr{Int32}, RLinkUp::Ptr{Int32}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowfac_mask(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse},
+                                          beta::Ptr{Cdouble}, kstart::Csize_t,
+                                          kend::Csize_t, mask::Ptr{Int32},
+                                          RLinkUp::Ptr{Int32}, L::Ptr{cholmod_factor},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowfac_mask(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
-    @ccall libcholmod.cholmod_l_rowfac_mask(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Csize_t, arg5::Csize_t, arg6::Ptr{Int64}, arg7::Ptr{Int64}, arg8::Ptr{cholmod_factor}, arg9::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowfac_mask(arg1::Ptr{cholmod_sparse},
+                                            arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble},
+                                            arg4::Csize_t, arg5::Csize_t, arg6::Ptr{Int64},
+                                            arg7::Ptr{Int64}, arg8::Ptr{cholmod_factor},
+                                            arg9::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowfac_mask2(A, F, beta, kstart, kend, mask, maskmark, RLinkUp, L, Common)
-    @ccall libcholmod.cholmod_rowfac_mask2(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, beta::Ptr{Cdouble}, kstart::Csize_t, kend::Csize_t, mask::Ptr{Int32}, maskmark::Int32, RLinkUp::Ptr{Int32}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowfac_mask2(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse},
+                                           beta::Ptr{Cdouble}, kstart::Csize_t,
+                                           kend::Csize_t, mask::Ptr{Int32}, maskmark::Int32,
+                                           RLinkUp::Ptr{Int32}, L::Ptr{cholmod_factor},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowfac_mask2(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)
-    @ccall libcholmod.cholmod_l_rowfac_mask2(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Csize_t, arg5::Csize_t, arg6::Ptr{Int64}, arg7::Int64, arg8::Ptr{Int64}, arg9::Ptr{cholmod_factor}, arg10::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowfac_mask2(arg1::Ptr{cholmod_sparse},
+                                             arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble},
+                                             arg4::Csize_t, arg5::Csize_t, arg6::Ptr{Int64},
+                                             arg7::Int64, arg8::Ptr{Int64},
+                                             arg9::Ptr{cholmod_factor},
+                                             arg10::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_row_subtree(A, F, k, Parent, R, Common)
-    @ccall libcholmod.cholmod_row_subtree(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, k::Csize_t, Parent::Ptr{Int32}, R::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_row_subtree(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse},
+                                          k::Csize_t, Parent::Ptr{Int32},
+                                          R::Ptr{cholmod_sparse},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_row_subtree(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_row_subtree(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{cholmod_sparse}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_row_subtree(arg1::Ptr{cholmod_sparse},
+                                            arg2::Ptr{cholmod_sparse}, arg3::Csize_t,
+                                            arg4::Ptr{Int64}, arg5::Ptr{cholmod_sparse},
+                                            arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_lsolve_pattern(B, L, X, Common)
-    @ccall libcholmod.cholmod_lsolve_pattern(B::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_lsolve_pattern(B::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor},
+                                             X::Ptr{cholmod_sparse},
+                                             Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_lsolve_pattern(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_lsolve_pattern(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_sparse}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_lsolve_pattern(arg1::Ptr{cholmod_sparse},
+                                               arg2::Ptr{cholmod_factor},
+                                               arg3::Ptr{cholmod_sparse},
+                                               arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_row_lsubtree(A, Fi, fnz, k, L, R, Common)
-    @ccall libcholmod.cholmod_row_lsubtree(A::Ptr{cholmod_sparse}, Fi::Ptr{Int32}, fnz::Csize_t, k::Csize_t, L::Ptr{cholmod_factor}, R::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_row_lsubtree(A::Ptr{cholmod_sparse}, Fi::Ptr{Int32},
+                                           fnz::Csize_t, k::Csize_t, L::Ptr{cholmod_factor},
+                                           R::Ptr{cholmod_sparse},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_row_lsubtree(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_row_lsubtree(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Csize_t, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_sparse}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_row_lsubtree(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                             arg3::Csize_t, arg4::Csize_t,
+                                             arg5::Ptr{cholmod_factor},
+                                             arg6::Ptr{cholmod_sparse},
+                                             arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_resymbol(A, fset, fsize, pack, L, Common)
-    @ccall libcholmod.cholmod_resymbol(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, pack::Cint, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_resymbol(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                       fsize::Csize_t, pack::Cint, L::Ptr{cholmod_factor},
+                                       Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_resymbol(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_resymbol(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Cint, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_resymbol(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                         arg3::Csize_t, arg4::Cint,
+                                         arg5::Ptr{cholmod_factor},
+                                         arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_resymbol_noperm(A, fset, fsize, pack, L, Common)
-    @ccall libcholmod.cholmod_resymbol_noperm(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, pack::Cint, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_resymbol_noperm(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                              fsize::Csize_t, pack::Cint,
+                                              L::Ptr{cholmod_factor},
+                                              Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_resymbol_noperm(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_resymbol_noperm(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Cint, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_resymbol_noperm(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                                arg3::Csize_t, arg4::Cint,
+                                                arg5::Ptr{cholmod_factor},
+                                                arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rcond(L, Common)
-    @ccall libcholmod.cholmod_rcond(L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cdouble
+    @ccall libcholmod.cholmod_rcond(L::Ptr{cholmod_factor},
+                                    Common::Ptr{cholmod_common})::Cdouble
 end
 
 function cholmod_l_rcond(arg1, arg2)
-    @ccall libcholmod.cholmod_l_rcond(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_common})::Cdouble
+    @ccall libcholmod.cholmod_l_rcond(arg1::Ptr{cholmod_factor},
+                                      arg2::Ptr{cholmod_common})::Cdouble
 end
 
 function cholmod_postorder(Parent, n, Weight_p, Post, Common)
-    @ccall libcholmod.cholmod_postorder(Parent::Ptr{Int32}, n::Csize_t, Weight_p::Ptr{Int32}, Post::Ptr{Int32}, Common::Ptr{cholmod_common})::Int32
+    @ccall libcholmod.cholmod_postorder(Parent::Ptr{Int32}, n::Csize_t,
+                                        Weight_p::Ptr{Int32}, Post::Ptr{Int32},
+                                        Common::Ptr{cholmod_common})::Int32
 end
 
 function cholmod_l_postorder(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_postorder(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_l_postorder(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Ptr{Int64},
+                                          arg4::Ptr{Int64},
+                                          arg5::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_drop(tol, A, Common)
-    @ccall libcholmod.cholmod_drop(tol::Cdouble, A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_drop(tol::Cdouble, A::Ptr{cholmod_sparse},
+                                   Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_drop(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_drop(arg1::Cdouble, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_drop(arg1::Cdouble, arg2::Ptr{cholmod_sparse},
+                                     arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_norm_dense(X, norm, Common)
-    @ccall libcholmod.cholmod_norm_dense(X::Ptr{cholmod_dense}, norm::Cint, Common::Ptr{cholmod_common})::Cdouble
+    @ccall libcholmod.cholmod_norm_dense(X::Ptr{cholmod_dense}, norm::Cint,
+                                         Common::Ptr{cholmod_common})::Cdouble
 end
 
 function cholmod_l_norm_dense(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_norm_dense(arg1::Ptr{cholmod_dense}, arg2::Cint, arg3::Ptr{cholmod_common})::Cdouble
+    @ccall libcholmod.cholmod_l_norm_dense(arg1::Ptr{cholmod_dense}, arg2::Cint,
+                                           arg3::Ptr{cholmod_common})::Cdouble
 end
 
 function cholmod_norm_sparse(A, norm, Common)
-    @ccall libcholmod.cholmod_norm_sparse(A::Ptr{cholmod_sparse}, norm::Cint, Common::Ptr{cholmod_common})::Cdouble
+    @ccall libcholmod.cholmod_norm_sparse(A::Ptr{cholmod_sparse}, norm::Cint,
+                                          Common::Ptr{cholmod_common})::Cdouble
 end
 
 function cholmod_l_norm_sparse(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_norm_sparse(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{cholmod_common})::Cdouble
+    @ccall libcholmod.cholmod_l_norm_sparse(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                            arg3::Ptr{cholmod_common})::Cdouble
 end
 
 function cholmod_horzcat(A, B, values, Common)
-    @ccall libcholmod.cholmod_horzcat(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse}, values::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_horzcat(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse},
+                                      values::Cint,
+                                      Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_horzcat(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_horzcat(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_horzcat(arg1::Ptr{cholmod_sparse},
+                                        arg2::Ptr{cholmod_sparse}, arg3::Cint,
+                                        arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_scale(S, scale, A, Common)
-    @ccall libcholmod.cholmod_scale(S::Ptr{cholmod_dense}, scale::Cint, A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_scale(S::Ptr{cholmod_dense}, scale::Cint,
+                                    A::Ptr{cholmod_sparse},
+                                    Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_scale(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_scale(arg1::Ptr{cholmod_dense}, arg2::Cint, arg3::Ptr{cholmod_sparse}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_scale(arg1::Ptr{cholmod_dense}, arg2::Cint,
+                                      arg3::Ptr{cholmod_sparse},
+                                      arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_sdmult(A, transpose, alpha, beta, X, Y, Common)
-    @ccall libcholmod.cholmod_sdmult(A::Ptr{cholmod_sparse}, transpose::Cint, alpha::Ptr{Cdouble}, beta::Ptr{Cdouble}, X::Ptr{cholmod_dense}, Y::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_sdmult(A::Ptr{cholmod_sparse}, transpose::Cint,
+                                     alpha::Ptr{Cdouble}, beta::Ptr{Cdouble},
+                                     X::Ptr{cholmod_dense}, Y::Ptr{cholmod_dense},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_sdmult(arg1, arg2, arg3, arg4, arg5, Y, arg7)
-    @ccall libcholmod.cholmod_l_sdmult(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{Cdouble}, arg4::Ptr{Cdouble}, arg5::Ptr{cholmod_dense}, Y::Ptr{cholmod_dense}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_sdmult(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                       arg3::Ptr{Cdouble}, arg4::Ptr{Cdouble},
+                                       arg5::Ptr{cholmod_dense}, Y::Ptr{cholmod_dense},
+                                       arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_ssmult(A, B, stype, values, sorted, Common)
-    @ccall libcholmod.cholmod_ssmult(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse}, stype::Cint, values::Cint, sorted::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_ssmult(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse},
+                                     stype::Cint, values::Cint, sorted::Cint,
+                                     Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_ssmult(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_ssmult(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Cint, arg4::Cint, arg5::Cint, arg6::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_ssmult(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse},
+                                       arg3::Cint, arg4::Cint, arg5::Cint,
+                                       arg6::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_submatrix(A, rset, rsize, cset, csize, values, sorted, Common)
-    @ccall libcholmod.cholmod_submatrix(A::Ptr{cholmod_sparse}, rset::Ptr{Int32}, rsize::Int64, cset::Ptr{Int32}, csize::Int64, values::Cint, sorted::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_submatrix(A::Ptr{cholmod_sparse}, rset::Ptr{Int32},
+                                        rsize::Int64, cset::Ptr{Int32}, csize::Int64,
+                                        values::Cint, sorted::Cint,
+                                        Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_submatrix(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
-    @ccall libcholmod.cholmod_l_submatrix(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Int64, arg4::Ptr{Int64}, arg5::Int64, arg6::Cint, arg7::Cint, arg8::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_submatrix(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                          arg3::Int64, arg4::Ptr{Int64}, arg5::Int64,
+                                          arg6::Cint, arg7::Cint,
+                                          arg8::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_vertcat(A, B, values, Common)
-    @ccall libcholmod.cholmod_vertcat(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse}, values::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_vertcat(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse},
+                                      values::Cint,
+                                      Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_vertcat(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_vertcat(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_vertcat(arg1::Ptr{cholmod_sparse},
+                                        arg2::Ptr{cholmod_sparse}, arg3::Cint,
+                                        arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_symmetry(A, option, xmatched, pmatched, nzoffdiag, nzdiag, Common)
-    @ccall libcholmod.cholmod_symmetry(A::Ptr{cholmod_sparse}, option::Cint, xmatched::Ptr{Int32}, pmatched::Ptr{Int32}, nzoffdiag::Ptr{Int32}, nzdiag::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_symmetry(A::Ptr{cholmod_sparse}, option::Cint,
+                                       xmatched::Ptr{Int32}, pmatched::Ptr{Int32},
+                                       nzoffdiag::Ptr{Int32}, nzdiag::Ptr{Int32},
+                                       Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_symmetry(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_symmetry(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Ptr{Int64}, arg6::Ptr{Int64}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_symmetry(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                         arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                         arg5::Ptr{Int64}, arg6::Ptr{Int64},
+                                         arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_updown(update, C, L, Common)
-    @ccall libcholmod.cholmod_updown(update::Cint, C::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_updown(update::Cint, C::Ptr{cholmod_sparse},
+                                     L::Ptr{cholmod_factor},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_updown(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_updown(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_factor}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_updown(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                       arg3::Ptr{cholmod_factor},
+                                       arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_updown_solve(update, C, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_updown_solve(update::Cint, C::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_updown_solve(update::Cint, C::Ptr{cholmod_sparse},
+                                           L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense},
+                                           DeltaB::Ptr{cholmod_dense},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_updown_solve(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_updown_solve(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_factor}, arg4::Ptr{cholmod_dense}, arg5::Ptr{cholmod_dense}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_updown_solve(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                             arg3::Ptr{cholmod_factor},
+                                             arg4::Ptr{cholmod_dense},
+                                             arg5::Ptr{cholmod_dense},
+                                             arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_updown_mark(update, C, colmark, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_updown_mark(update::Cint, C::Ptr{cholmod_sparse}, colmark::Ptr{Int32}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_updown_mark(update::Cint, C::Ptr{cholmod_sparse},
+                                          colmark::Ptr{Int32}, L::Ptr{cholmod_factor},
+                                          X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_updown_mark(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_updown_mark(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Int64}, arg4::Ptr{cholmod_factor}, arg5::Ptr{cholmod_dense}, arg6::Ptr{cholmod_dense}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_updown_mark(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                            arg3::Ptr{Int64}, arg4::Ptr{cholmod_factor},
+                                            arg5::Ptr{cholmod_dense},
+                                            arg6::Ptr{cholmod_dense},
+                                            arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_updown_mask(update, C, colmark, mask, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_updown_mask(update::Cint, C::Ptr{cholmod_sparse}, colmark::Ptr{Int32}, mask::Ptr{Int32}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_updown_mask(update::Cint, C::Ptr{cholmod_sparse},
+                                          colmark::Ptr{Int32}, mask::Ptr{Int32},
+                                          L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense},
+                                          DeltaB::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_updown_mask(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
-    @ccall libcholmod.cholmod_l_updown_mask(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_dense}, arg7::Ptr{cholmod_dense}, arg8::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_updown_mask(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                            arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                            arg5::Ptr{cholmod_factor},
+                                            arg6::Ptr{cholmod_dense},
+                                            arg7::Ptr{cholmod_dense},
+                                            arg8::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_updown_mask2(update, C, colmark, mask, maskmark, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_updown_mask2(update::Cint, C::Ptr{cholmod_sparse}, colmark::Ptr{Int32}, mask::Ptr{Int32}, maskmark::Int32, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_updown_mask2(update::Cint, C::Ptr{cholmod_sparse},
+                                           colmark::Ptr{Int32}, mask::Ptr{Int32},
+                                           maskmark::Int32, L::Ptr{cholmod_factor},
+                                           X::Ptr{cholmod_dense},
+                                           DeltaB::Ptr{cholmod_dense},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_updown_mask2(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
-    @ccall libcholmod.cholmod_l_updown_mask2(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Int64, arg6::Ptr{cholmod_factor}, arg7::Ptr{cholmod_dense}, arg8::Ptr{cholmod_dense}, arg9::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_updown_mask2(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                             arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                             arg5::Int64, arg6::Ptr{cholmod_factor},
+                                             arg7::Ptr{cholmod_dense},
+                                             arg8::Ptr{cholmod_dense},
+                                             arg9::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowadd(k, R, L, Common)
-    @ccall libcholmod.cholmod_rowadd(k::Csize_t, R::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowadd(k::Csize_t, R::Ptr{cholmod_sparse},
+                                     L::Ptr{cholmod_factor},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowadd(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_rowadd(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_factor}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowadd(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                       arg3::Ptr{cholmod_factor},
+                                       arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowadd_solve(k, R, bk, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_rowadd_solve(k::Csize_t, R::Ptr{cholmod_sparse}, bk::Ptr{Cdouble}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowadd_solve(k::Csize_t, R::Ptr{cholmod_sparse},
+                                           bk::Ptr{Cdouble}, L::Ptr{cholmod_factor},
+                                           X::Ptr{cholmod_dense},
+                                           DeltaB::Ptr{cholmod_dense},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowadd_solve(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_rowadd_solve(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Ptr{cholmod_factor}, arg5::Ptr{cholmod_dense}, arg6::Ptr{cholmod_dense}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowadd_solve(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                             arg3::Ptr{Cdouble}, arg4::Ptr{cholmod_factor},
+                                             arg5::Ptr{cholmod_dense},
+                                             arg6::Ptr{cholmod_dense},
+                                             arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowadd_mark(k, R, bk, colmark, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_rowadd_mark(k::Csize_t, R::Ptr{cholmod_sparse}, bk::Ptr{Cdouble}, colmark::Ptr{Int32}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowadd_mark(k::Csize_t, R::Ptr{cholmod_sparse},
+                                          bk::Ptr{Cdouble}, colmark::Ptr{Int32},
+                                          L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense},
+                                          DeltaB::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowadd_mark(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
-    @ccall libcholmod.cholmod_l_rowadd_mark(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Ptr{Int64}, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_dense}, arg7::Ptr{cholmod_dense}, arg8::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowadd_mark(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                            arg3::Ptr{Cdouble}, arg4::Ptr{Int64},
+                                            arg5::Ptr{cholmod_factor},
+                                            arg6::Ptr{cholmod_dense},
+                                            arg7::Ptr{cholmod_dense},
+                                            arg8::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowdel(k, R, L, Common)
-    @ccall libcholmod.cholmod_rowdel(k::Csize_t, R::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowdel(k::Csize_t, R::Ptr{cholmod_sparse},
+                                     L::Ptr{cholmod_factor},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowdel(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_rowdel(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_factor}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowdel(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                       arg3::Ptr{cholmod_factor},
+                                       arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowdel_solve(k, R, yk, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_rowdel_solve(k::Csize_t, R::Ptr{cholmod_sparse}, yk::Ptr{Cdouble}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowdel_solve(k::Csize_t, R::Ptr{cholmod_sparse},
+                                           yk::Ptr{Cdouble}, L::Ptr{cholmod_factor},
+                                           X::Ptr{cholmod_dense},
+                                           DeltaB::Ptr{cholmod_dense},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowdel_solve(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_rowdel_solve(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Ptr{cholmod_factor}, arg5::Ptr{cholmod_dense}, arg6::Ptr{cholmod_dense}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowdel_solve(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                             arg3::Ptr{Cdouble}, arg4::Ptr{cholmod_factor},
+                                             arg5::Ptr{cholmod_dense},
+                                             arg6::Ptr{cholmod_dense},
+                                             arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowdel_mark(k, R, yk, colmark, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_rowdel_mark(k::Csize_t, R::Ptr{cholmod_sparse}, yk::Ptr{Cdouble}, colmark::Ptr{Int32}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowdel_mark(k::Csize_t, R::Ptr{cholmod_sparse},
+                                          yk::Ptr{Cdouble}, colmark::Ptr{Int32},
+                                          L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense},
+                                          DeltaB::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowdel_mark(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
-    @ccall libcholmod.cholmod_l_rowdel_mark(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Ptr{Int64}, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_dense}, arg7::Ptr{cholmod_dense}, arg8::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowdel_mark(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                            arg3::Ptr{Cdouble}, arg4::Ptr{Int64},
+                                            arg5::Ptr{cholmod_factor},
+                                            arg6::Ptr{cholmod_dense},
+                                            arg7::Ptr{cholmod_dense},
+                                            arg8::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_ccolamd(A, fset, fsize, Cmember, Perm, Common)
-    @ccall libcholmod.cholmod_ccolamd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, Cmember::Ptr{Int32}, Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_ccolamd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                      fsize::Csize_t, Cmember::Ptr{Int32}, Perm::Ptr{Int32},
+                                      Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_ccolamd(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_ccolamd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{Int64}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_ccolamd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                        arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{Int64},
+                                        arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_csymamd(A, Cmember, Perm, Common)
-    @ccall libcholmod.cholmod_csymamd(A::Ptr{cholmod_sparse}, Cmember::Ptr{Int32}, Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_csymamd(A::Ptr{cholmod_sparse}, Cmember::Ptr{Int32},
+                                      Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_csymamd(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_csymamd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Ptr{Int64}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_csymamd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                        arg3::Ptr{Int64}, arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_camd(A, fset, fsize, Cmember, Perm, Common)
-    @ccall libcholmod.cholmod_camd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, Cmember::Ptr{Int32}, Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_camd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t,
+                                   Cmember::Ptr{Int32}, Perm::Ptr{Int32},
+                                   Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_camd(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_camd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{Int64}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_camd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                     arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{Int64},
+                                     arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_nested_dissection(A, fset, fsize, Perm, CParent, Cmember, Common)
-    @ccall libcholmod.cholmod_nested_dissection(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, Perm::Ptr{Int32}, CParent::Ptr{Int32}, Cmember::Ptr{Int32}, Common::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_nested_dissection(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                                fsize::Csize_t, Perm::Ptr{Int32},
+                                                CParent::Ptr{Int32}, Cmember::Ptr{Int32},
+                                                Common::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_l_nested_dissection(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_nested_dissection(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{Int64}, arg6::Ptr{Int64}, arg7::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_l_nested_dissection(arg1::Ptr{cholmod_sparse},
+                                                  arg2::Ptr{Int64}, arg3::Csize_t,
+                                                  arg4::Ptr{Int64}, arg5::Ptr{Int64},
+                                                  arg6::Ptr{Int64},
+                                                  arg7::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_metis(A, fset, fsize, postorder, Perm, Common)
-    @ccall libcholmod.cholmod_metis(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, postorder::Cint, Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_metis(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                    fsize::Csize_t, postorder::Cint, Perm::Ptr{Int32},
+                                    Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_metis(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_metis(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Cint, arg5::Ptr{Int64}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_metis(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                      arg3::Csize_t, arg4::Cint, arg5::Ptr{Int64},
+                                      arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_bisect(A, fset, fsize, compress, Partition, Common)
-    @ccall libcholmod.cholmod_bisect(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, compress::Cint, Partition::Ptr{Int32}, Common::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_bisect(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                     fsize::Csize_t, compress::Cint, Partition::Ptr{Int32},
+                                     Common::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_l_bisect(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_bisect(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Cint, arg5::Ptr{Int64}, arg6::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_l_bisect(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                       arg3::Csize_t, arg4::Cint, arg5::Ptr{Int64},
+                                       arg6::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_metis_bisector(A, Anw, Aew, Partition, Common)
-    @ccall libcholmod.cholmod_metis_bisector(A::Ptr{cholmod_sparse}, Anw::Ptr{Int32}, Aew::Ptr{Int32}, Partition::Ptr{Int32}, Common::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_metis_bisector(A::Ptr{cholmod_sparse}, Anw::Ptr{Int32},
+                                             Aew::Ptr{Int32}, Partition::Ptr{Int32},
+                                             Common::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_l_metis_bisector(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_metis_bisector(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_l_metis_bisector(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                               arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                               arg5::Ptr{cholmod_common})::Int64
 end
 
-function cholmod_collapse_septree(n, ncomponents, nd_oksep, nd_small, CParent, Cmember, Common)
-    @ccall libcholmod.cholmod_collapse_septree(n::Csize_t, ncomponents::Csize_t, nd_oksep::Cdouble, nd_small::Csize_t, CParent::Ptr{Int32}, Cmember::Ptr{Int32}, Common::Ptr{cholmod_common})::Int64
+function cholmod_collapse_septree(n, ncomponents, nd_oksep, nd_small, CParent, Cmember,
+                                  Common)
+    @ccall libcholmod.cholmod_collapse_septree(n::Csize_t, ncomponents::Csize_t,
+                                               nd_oksep::Cdouble, nd_small::Csize_t,
+                                               CParent::Ptr{Int32}, Cmember::Ptr{Int32},
+                                               Common::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_l_collapse_septree(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_collapse_septree(arg1::Csize_t, arg2::Csize_t, arg3::Cdouble, arg4::Csize_t, arg5::Ptr{Int64}, arg6::Ptr{Int64}, arg7::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_l_collapse_septree(arg1::Csize_t, arg2::Csize_t,
+                                                 arg3::Cdouble, arg4::Csize_t,
+                                                 arg5::Ptr{Int64}, arg6::Ptr{Int64},
+                                                 arg7::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_super_symbolic(A, F, Parent, L, Common)
-    @ccall libcholmod.cholmod_super_symbolic(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, Parent::Ptr{Int32}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_super_symbolic(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse},
+                                             Parent::Ptr{Int32}, L::Ptr{cholmod_factor},
+                                             Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_super_symbolic(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_super_symbolic(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Int64}, arg4::Ptr{cholmod_factor}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_super_symbolic(arg1::Ptr{cholmod_sparse},
+                                               arg2::Ptr{cholmod_sparse}, arg3::Ptr{Int64},
+                                               arg4::Ptr{cholmod_factor},
+                                               arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_super_symbolic2(for_whom, A, F, Parent, L, Common)
-    @ccall libcholmod.cholmod_super_symbolic2(for_whom::Cint, A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, Parent::Ptr{Int32}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_super_symbolic2(for_whom::Cint, A::Ptr{cholmod_sparse},
+                                              F::Ptr{cholmod_sparse}, Parent::Ptr{Int32},
+                                              L::Ptr{cholmod_factor},
+                                              Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_super_symbolic2(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_super_symbolic2(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_sparse}, arg4::Ptr{Int64}, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_super_symbolic2(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                                arg3::Ptr{cholmod_sparse}, arg4::Ptr{Int64},
+                                                arg5::Ptr{cholmod_factor},
+                                                arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_super_numeric(A, F, beta, L, Common)
-    @ccall libcholmod.cholmod_super_numeric(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, beta::Ptr{Cdouble}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_super_numeric(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse},
+                                            beta::Ptr{Cdouble}, L::Ptr{cholmod_factor},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_super_numeric(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_super_numeric(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Ptr{cholmod_factor}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_super_numeric(arg1::Ptr{cholmod_sparse},
+                                              arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble},
+                                              arg4::Ptr{cholmod_factor},
+                                              arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_super_lsolve(L, X, E, Common)
-    @ccall libcholmod.cholmod_super_lsolve(L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, E::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_super_lsolve(L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense},
+                                           E::Ptr{cholmod_dense},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_super_lsolve(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_super_lsolve(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_dense}, arg3::Ptr{cholmod_dense}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_super_lsolve(arg1::Ptr{cholmod_factor},
+                                             arg2::Ptr{cholmod_dense},
+                                             arg3::Ptr{cholmod_dense},
+                                             arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_super_ltsolve(L, X, E, Common)
-    @ccall libcholmod.cholmod_super_ltsolve(L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, E::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_super_ltsolve(L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense},
+                                            E::Ptr{cholmod_dense},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_super_ltsolve(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_super_ltsolve(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_dense}, arg3::Ptr{cholmod_dense}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_super_ltsolve(arg1::Ptr{cholmod_factor},
+                                              arg2::Ptr{cholmod_dense},
+                                              arg3::Ptr{cholmod_dense},
+                                              arg4::Ptr{cholmod_common})::Cint
+end
+
+function SuiteSparseQR_C(ordering, tol, econ, getCTX, A, Bsparse, Bdense, Zsparse, Zdense,
+                         R, E, H, HPinv, HTau, cc)
+    @ccall libspqr.SuiteSparseQR_C(ordering::Cint, tol::Cdouble, econ::Int64, getCTX::Cint,
+                                   A::Ptr{cholmod_sparse}, Bsparse::Ptr{cholmod_sparse},
+                                   Bdense::Ptr{cholmod_dense},
+                                   Zsparse::Ptr{Ptr{cholmod_sparse}},
+                                   Zdense::Ptr{Ptr{cholmod_dense}},
+                                   R::Ptr{Ptr{cholmod_sparse}}, E::Ptr{Ptr{Int64}},
+                                   H::Ptr{Ptr{cholmod_sparse}}, HPinv::Ptr{Ptr{Int64}},
+                                   HTau::Ptr{Ptr{cholmod_dense}},
+                                   cc::Ptr{cholmod_common})::Int64
+end
+
+function SuiteSparseQR_i_C(ordering, tol, econ, getCTX, A, Bsparse, Bdense, Zsparse, Zdense,
+                           R, E, H, HPinv, HTau, cc)
+    @ccall libspqr.SuiteSparseQR_i_C(ordering::Cint, tol::Cdouble, econ::Int32,
+                                     getCTX::Cint, A::Ptr{cholmod_sparse},
+                                     Bsparse::Ptr{cholmod_sparse},
+                                     Bdense::Ptr{cholmod_dense},
+                                     Zsparse::Ptr{Ptr{cholmod_sparse}},
+                                     Zdense::Ptr{Ptr{cholmod_dense}},
+                                     R::Ptr{Ptr{cholmod_sparse}}, E::Ptr{Ptr{Int32}},
+                                     H::Ptr{Ptr{cholmod_sparse}}, HPinv::Ptr{Ptr{Int32}},
+                                     HTau::Ptr{Ptr{cholmod_dense}},
+                                     cc::Ptr{cholmod_common})::Int32
 end
 
-function SuiteSparseQR_C(ordering, tol, econ, getCTX, A, Bsparse, Bdense, Zsparse, Zdense, R, E, H, HPinv, HTau, cc)
-    @ccall libspqr.SuiteSparseQR_C(ordering::Cint, tol::Cdouble, econ::Int64, getCTX::Cint, A::Ptr{cholmod_sparse}, Bsparse::Ptr{cholmod_sparse}, Bdense::Ptr{cholmod_dense}, Zsparse::Ptr{Ptr{cholmod_sparse}}, Zdense::Ptr{Ptr{cholmod_dense}}, R::Ptr{Ptr{cholmod_sparse}}, E::Ptr{Ptr{Int64}}, H::Ptr{Ptr{cholmod_sparse}}, HPinv::Ptr{Ptr{Int64}}, HTau::Ptr{Ptr{cholmod_dense}}, cc::Ptr{cholmod_common})::Int64
+function SuiteSparseQR_C_QR(ordering, tol, econ, A, Q, R, E, cc)
+    @ccall libspqr.SuiteSparseQR_C_QR(ordering::Cint, tol::Cdouble, econ::Int64,
+                                      A::Ptr{cholmod_sparse}, Q::Ptr{Ptr{cholmod_sparse}},
+                                      R::Ptr{Ptr{cholmod_sparse}}, E::Ptr{Ptr{Int64}},
+                                      cc::Ptr{cholmod_common})::Int64
 end
 
-function SuiteSparseQR_C_QR(ordering, tol, econ, A, Q, R, E, cc)
-    @ccall libspqr.SuiteSparseQR_C_QR(ordering::Cint, tol::Cdouble, econ::Int64, A::Ptr{cholmod_sparse}, Q::Ptr{Ptr{cholmod_sparse}}, R::Ptr{Ptr{cholmod_sparse}}, E::Ptr{Ptr{Int64}}, cc::Ptr{cholmod_common})::Int64
+function SuiteSparseQR_i_C_QR(ordering, tol, econ, A, Q, R, E, cc)
+    @ccall libspqr.SuiteSparseQR_i_C_QR(ordering::Cint, tol::Cdouble, econ::Int32,
+                                        A::Ptr{cholmod_sparse}, Q::Ptr{Ptr{cholmod_sparse}},
+                                        R::Ptr{Ptr{cholmod_sparse}}, E::Ptr{Ptr{Int32}},
+                                        cc::Ptr{cholmod_common})::Int32
 end
 
 function SuiteSparseQR_C_backslash(ordering, tol, A, B, cc)
-    @ccall libspqr.SuiteSparseQR_C_backslash(ordering::Cint, tol::Cdouble, A::Ptr{cholmod_sparse}, B::Ptr{cholmod_dense}, cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libspqr.SuiteSparseQR_C_backslash(ordering::Cint, tol::Cdouble,
+                                             A::Ptr{cholmod_sparse}, B::Ptr{cholmod_dense},
+                                             cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function SuiteSparseQR_C_backslash_default(A, B, cc)
-    @ccall libspqr.SuiteSparseQR_C_backslash_default(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_dense}, cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libspqr.SuiteSparseQR_C_backslash_default(A::Ptr{cholmod_sparse},
+                                                     B::Ptr{cholmod_dense},
+                                                     cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function SuiteSparseQR_C_backslash_sparse(ordering, tol, A, B, cc)
-    @ccall libspqr.SuiteSparseQR_C_backslash_sparse(ordering::Cint, tol::Cdouble, A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse}, cc::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libspqr.SuiteSparseQR_C_backslash_sparse(ordering::Cint, tol::Cdouble,
+                                                    A::Ptr{cholmod_sparse},
+                                                    B::Ptr{cholmod_sparse},
+                                                    cc::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 mutable struct SuiteSparseQR_C_factorization_struct
     xtype::Cint
+    itype::Cint
     factors::Ptr{Cvoid}
     SuiteSparseQR_C_factorization_struct() = new()
 end
@@ -1536,51 +2115,78 @@ end
 const SuiteSparseQR_C_factorization = SuiteSparseQR_C_factorization_struct
 
 function SuiteSparseQR_C_factorize(ordering, tol, A, cc)
-    @ccall libspqr.SuiteSparseQR_C_factorize(ordering::Cint, tol::Cdouble, A::Ptr{cholmod_sparse}, cc::Ptr{cholmod_common})::Ptr{SuiteSparseQR_C_factorization}
+    @ccall libspqr.SuiteSparseQR_C_factorize(ordering::Cint, tol::Cdouble,
+                                             A::Ptr{cholmod_sparse},
+                                             cc::Ptr{cholmod_common})::Ptr{SuiteSparseQR_C_factorization}
 end
 
 function SuiteSparseQR_C_symbolic(ordering, allow_tol, A, cc)
-    @ccall libspqr.SuiteSparseQR_C_symbolic(ordering::Cint, allow_tol::Cint, A::Ptr{cholmod_sparse}, cc::Ptr{cholmod_common})::Ptr{SuiteSparseQR_C_factorization}
+    @ccall libspqr.SuiteSparseQR_C_symbolic(ordering::Cint, allow_tol::Cint,
+                                            A::Ptr{cholmod_sparse},
+                                            cc::Ptr{cholmod_common})::Ptr{SuiteSparseQR_C_factorization}
 end
 
 function SuiteSparseQR_C_numeric(tol, A, QR, cc)
-    @ccall libspqr.SuiteSparseQR_C_numeric(tol::Cdouble, A::Ptr{cholmod_sparse}, QR::Ptr{SuiteSparseQR_C_factorization}, cc::Ptr{cholmod_common})::Cint
+    @ccall libspqr.SuiteSparseQR_C_numeric(tol::Cdouble, A::Ptr{cholmod_sparse},
+                                           QR::Ptr{SuiteSparseQR_C_factorization},
+                                           cc::Ptr{cholmod_common})::Cint
 end
 
 function SuiteSparseQR_C_free(QR, cc)
-    @ccall libspqr.SuiteSparseQR_C_free(QR::Ptr{Ptr{SuiteSparseQR_C_factorization}}, cc::Ptr{cholmod_common})::Cint
+    @ccall libspqr.SuiteSparseQR_C_free(QR::Ptr{Ptr{SuiteSparseQR_C_factorization}},
+                                        cc::Ptr{cholmod_common})::Cint
 end
 
 function SuiteSparseQR_C_solve(system, QR, B, cc)
-    @ccall libspqr.SuiteSparseQR_C_solve(system::Cint, QR::Ptr{SuiteSparseQR_C_factorization}, B::Ptr{cholmod_dense}, cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libspqr.SuiteSparseQR_C_solve(system::Cint,
+                                         QR::Ptr{SuiteSparseQR_C_factorization},
+                                         B::Ptr{cholmod_dense},
+                                         cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function SuiteSparseQR_C_qmult(method, QR, X, cc)
-    @ccall libspqr.SuiteSparseQR_C_qmult(method::Cint, QR::Ptr{SuiteSparseQR_C_factorization}, X::Ptr{cholmod_dense}, cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libspqr.SuiteSparseQR_C_qmult(method::Cint,
+                                         QR::Ptr{SuiteSparseQR_C_factorization},
+                                         X::Ptr{cholmod_dense},
+                                         cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function amd_order(n, Ap, Ai, P, Control, Info)
-    @ccall libamd.amd_order(n::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, P::Ptr{Int32}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libamd.amd_order(n::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, P::Ptr{Int32},
+                            Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function amd_l_order(n, Ap, Ai, P, Control, Info)
-    @ccall libamd.amd_l_order(n::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, P::Ptr{Int64}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libamd.amd_l_order(n::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, P::Ptr{Int64},
+                              Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
-function amd_2(n, Pe, Iw, Len, iwlen, pfree, Nv, Next, Last, Head, Elen, Degree, W, Control, Info)
-    @ccall libamd.amd_2(n::Int32, Pe::Ptr{Int32}, Iw::Ptr{Int32}, Len::Ptr{Int32}, iwlen::Int32, pfree::Int32, Nv::Ptr{Int32}, Next::Ptr{Int32}, Last::Ptr{Int32}, Head::Ptr{Int32}, Elen::Ptr{Int32}, Degree::Ptr{Int32}, W::Ptr{Int32}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cvoid
+function amd_2(n, Pe, Iw, Len, iwlen, pfree, Nv, Next, Last, Head, Elen, Degree, W, Control,
+               Info)
+    @ccall libamd.amd_2(n::Int32, Pe::Ptr{Int32}, Iw::Ptr{Int32}, Len::Ptr{Int32},
+                        iwlen::Int32, pfree::Int32, Nv::Ptr{Int32}, Next::Ptr{Int32},
+                        Last::Ptr{Int32}, Head::Ptr{Int32}, Elen::Ptr{Int32},
+                        Degree::Ptr{Int32}, W::Ptr{Int32}, Control::Ptr{Cdouble},
+                        Info::Ptr{Cdouble})::Cvoid
 end
 
-function amd_l2(n, Pe, Iw, Len, iwlen, pfree, Nv, Next, Last, Head, Elen, Degree, W, Control, Info)
-    @ccall libamd.amd_l2(n::Int64, Pe::Ptr{Int64}, Iw::Ptr{Int64}, Len::Ptr{Int64}, iwlen::Int64, pfree::Int64, Nv::Ptr{Int64}, Next::Ptr{Int64}, Last::Ptr{Int64}, Head::Ptr{Int64}, Elen::Ptr{Int64}, Degree::Ptr{Int64}, W::Ptr{Int64}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cvoid
+function amd_l2(n, Pe, Iw, Len, iwlen, pfree, Nv, Next, Last, Head, Elen, Degree, W,
+                Control, Info)
+    @ccall libamd.amd_l2(n::Int64, Pe::Ptr{Int64}, Iw::Ptr{Int64}, Len::Ptr{Int64},
+                         iwlen::Int64, pfree::Int64, Nv::Ptr{Int64}, Next::Ptr{Int64},
+                         Last::Ptr{Int64}, Head::Ptr{Int64}, Elen::Ptr{Int64},
+                         Degree::Ptr{Int64}, W::Ptr{Int64}, Control::Ptr{Cdouble},
+                         Info::Ptr{Cdouble})::Cvoid
 end
 
 function amd_valid(n_row, n_col, Ap, Ai)
-    @ccall libamd.amd_valid(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32})::Cint
+    @ccall libamd.amd_valid(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                            Ai::Ptr{Int32})::Cint
 end
 
 function amd_l_valid(n_row, n_col, Ap, Ai)
-    @ccall libamd.amd_l_valid(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64})::Cint
+    @ccall libamd.amd_l_valid(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                              Ai::Ptr{Int64})::Cint
 end
 
 function amd_defaults(Control)
@@ -1607,188 +2213,88 @@ function amd_l_info(Info)
     @ccall libamd.amd_l_info(Info::Ptr{Cdouble})::Cvoid
 end
 
-function colamd_recommended(nnz, n_row, n_col)
-    @ccall libcolamd.colamd_recommended(nnz::Int32, n_row::Int32, n_col::Int32)::Csize_t
-end
-
-function colamd_l_recommended(nnz, n_row, n_col)
-    @ccall libcolamd.colamd_l_recommended(nnz::Int64, n_row::Int64, n_col::Int64)::Csize_t
-end
-
-function colamd_set_defaults(knobs)
-    @ccall libcolamd.colamd_set_defaults(knobs::Ptr{Cdouble})::Cvoid
-end
-
-function colamd_l_set_defaults(knobs)
-    @ccall libcolamd.colamd_l_set_defaults(knobs::Ptr{Cdouble})::Cvoid
-end
-
-function colamd(n_row, n_col, Alen, A, p, knobs, stats)
-    @ccall libcolamd.colamd(n_row::Int32, n_col::Int32, Alen::Int32, A::Ptr{Int32}, p::Ptr{Int32}, knobs::Ptr{Cdouble}, stats::Ptr{Int32})::Cint
-end
-
-function colamd_l(n_row, n_col, Alen, A, p, knobs, stats)
-    @ccall libcolamd.colamd_l(n_row::Int64, n_col::Int64, Alen::Int64, A::Ptr{Int64}, p::Ptr{Int64}, knobs::Ptr{Cdouble}, stats::Ptr{Int64})::Cint
-end
-
-function symamd(n, A, p, perm, knobs, stats, allocate, release)
-    @ccall libcolamd.symamd(n::Int32, A::Ptr{Int32}, p::Ptr{Int32}, perm::Ptr{Int32}, knobs::Ptr{Cdouble}, stats::Ptr{Int32}, allocate::Ptr{Cvoid}, release::Ptr{Cvoid})::Cint
-end
-
-function symamd_l(n, A, p, perm, knobs, stats, allocate, release)
-    @ccall libcolamd.symamd_l(n::Int64, A::Ptr{Int64}, p::Ptr{Int64}, perm::Ptr{Int64}, knobs::Ptr{Cdouble}, stats::Ptr{Int64}, allocate::Ptr{Cvoid}, release::Ptr{Cvoid})::Cint
-end
-
-function colamd_report(stats)
-    @ccall libcolamd.colamd_report(stats::Ptr{Int32})::Cvoid
-end
-
-function colamd_l_report(stats)
-    @ccall libcolamd.colamd_l_report(stats::Ptr{Int64})::Cvoid
-end
-
-function symamd_report(stats)
-    @ccall libcolamd.symamd_report(stats::Ptr{Int32})::Cvoid
-end
-
-function symamd_l_report(stats)
-    @ccall libcolamd.symamd_l_report(stats::Ptr{Int64})::Cvoid
-end
-
-function ccolamd_recommended(nnz, n_row, n_col)
-    @ccall libcolamd.ccolamd_recommended(nnz::Cint, n_row::Cint, n_col::Cint)::Csize_t
-end
-
-function ccolamd_l_recommended(nnz, n_row, n_col)
-    @ccall libcolamd.ccolamd_l_recommended(nnz::Int64, n_row::Int64, n_col::Int64)::Csize_t
-end
-
-function ccolamd_set_defaults(knobs)
-    @ccall libcolamd.ccolamd_set_defaults(knobs::Ptr{Cdouble})::Cvoid
-end
-
-function ccolamd_l_set_defaults(knobs)
-    @ccall libcolamd.ccolamd_l_set_defaults(knobs::Ptr{Cdouble})::Cvoid
-end
-
-function ccolamd(n_row, n_col, Alen, A, p, knobs, stats, cmember)
-    @ccall libcolamd.ccolamd(n_row::Cint, n_col::Cint, Alen::Cint, A::Ptr{Cint}, p::Ptr{Cint}, knobs::Ptr{Cdouble}, stats::Ptr{Cint}, cmember::Ptr{Cint})::Cint
-end
-
-function ccolamd_l(n_row, n_col, Alen, A, p, knobs, stats, cmember)
-    @ccall libcolamd.ccolamd_l(n_row::Int64, n_col::Int64, Alen::Int64, A::Ptr{Int64}, p::Ptr{Int64}, knobs::Ptr{Cdouble}, stats::Ptr{Int64}, cmember::Ptr{Int64})::Cint
-end
-
-function csymamd(n, A, p, perm, knobs, stats, allocate, release, cmember, stype)
-    @ccall libcolamd.csymamd(n::Cint, A::Ptr{Cint}, p::Ptr{Cint}, perm::Ptr{Cint}, knobs::Ptr{Cdouble}, stats::Ptr{Cint}, allocate::Ptr{Cvoid}, release::Ptr{Cvoid}, cmember::Ptr{Cint}, stype::Cint)::Cint
-end
-
-function csymamd_l(n, A, p, perm, knobs, stats, allocate, release, cmember, stype)
-    @ccall libcolamd.csymamd_l(n::Int64, A::Ptr{Int64}, p::Ptr{Int64}, perm::Ptr{Int64}, knobs::Ptr{Cdouble}, stats::Ptr{Int64}, allocate::Ptr{Cvoid}, release::Ptr{Cvoid}, cmember::Ptr{Int64}, stype::Int64)::Cint
-end
-
-function ccolamd_report(stats)
-    @ccall libcolamd.ccolamd_report(stats::Ptr{Cint})::Cvoid
-end
-
-function ccolamd_l_report(stats)
-    @ccall libcolamd.ccolamd_l_report(stats::Ptr{Int64})::Cvoid
-end
-
-function csymamd_report(stats)
-    @ccall libcolamd.csymamd_report(stats::Ptr{Cint})::Cvoid
-end
-
-function csymamd_l_report(stats)
-    @ccall libcolamd.csymamd_l_report(stats::Ptr{Int64})::Cvoid
-end
-
-function ccolamd2(n_row, n_col, Alen, A, p, knobs, stats, Front_npivcol, Front_nrows, Front_ncols, Front_parent, Front_cols, p_nfr, InFront, cmember)
-    @ccall libcolamd.ccolamd2(n_row::Cint, n_col::Cint, Alen::Cint, A::Ptr{Cint}, p::Ptr{Cint}, knobs::Ptr{Cdouble}, stats::Ptr{Cint}, Front_npivcol::Ptr{Cint}, Front_nrows::Ptr{Cint}, Front_ncols::Ptr{Cint}, Front_parent::Ptr{Cint}, Front_cols::Ptr{Cint}, p_nfr::Ptr{Cint}, InFront::Ptr{Cint}, cmember::Ptr{Cint})::Cint
-end
-
-function ccolamd2_l(n_row, n_col, Alen, A, p, knobs, stats, Front_npivcol, Front_nrows, Front_ncols, Front_parent, Front_cols, p_nfr, InFront, cmember)
-    @ccall libcolamd.ccolamd2_l(n_row::Int64, n_col::Int64, Alen::Int64, A::Ptr{Int64}, p::Ptr{Int64}, knobs::Ptr{Cdouble}, stats::Ptr{Int64}, Front_npivcol::Ptr{Int64}, Front_nrows::Ptr{Int64}, Front_ncols::Ptr{Int64}, Front_parent::Ptr{Int64}, Front_cols::Ptr{Int64}, p_nfr::Ptr{Int64}, InFront::Ptr{Int64}, cmember::Ptr{Int64})::Cint
-end
-
-function ccolamd_apply_order(Front, Order, Temp, nn, nfr)
-    @ccall libcolamd.ccolamd_apply_order(Front::Ptr{Cint}, Order::Ptr{Cint}, Temp::Ptr{Cint}, nn::Cint, nfr::Cint)::Cvoid
-end
-
-function ccolamd_l_apply_order(Front, Order, Temp, nn, nfr)
-    @ccall libcolamd.ccolamd_l_apply_order(Front::Ptr{Int64}, Order::Ptr{Int64}, Temp::Ptr{Int64}, nn::Int64, nfr::Int64)::Cvoid
-end
-
-function ccolamd_fsize(nn, MaxFsize, Fnrows, Fncols, Parent, Npiv)
-    @ccall libcolamd.ccolamd_fsize(nn::Cint, MaxFsize::Ptr{Cint}, Fnrows::Ptr{Cint}, Fncols::Ptr{Cint}, Parent::Ptr{Cint}, Npiv::Ptr{Cint})::Cvoid
-end
-
-function ccolamd_l_fsize(nn, MaxFsize, Fnrows, Fncols, Parent, Npiv)
-    @ccall libcolamd.ccolamd_l_fsize(nn::Int64, MaxFsize::Ptr{Int64}, Fnrows::Ptr{Int64}, Fncols::Ptr{Int64}, Parent::Ptr{Int64}, Npiv::Ptr{Int64})::Cvoid
-end
-
-function ccolamd_postorder(nn, Parent, Npiv, Fsize, Order, Child, Sibling, Stack, Front_cols, cmember)
-    @ccall libcolamd.ccolamd_postorder(nn::Cint, Parent::Ptr{Cint}, Npiv::Ptr{Cint}, Fsize::Ptr{Cint}, Order::Ptr{Cint}, Child::Ptr{Cint}, Sibling::Ptr{Cint}, Stack::Ptr{Cint}, Front_cols::Ptr{Cint}, cmember::Ptr{Cint})::Cvoid
-end
-
-function ccolamd_l_postorder(nn, Parent, Npiv, Fsize, Order, Child, Sibling, Stack, Front_cols, cmember)
-    @ccall libcolamd.ccolamd_l_postorder(nn::Int64, Parent::Ptr{Int64}, Npiv::Ptr{Int64}, Fsize::Ptr{Int64}, Order::Ptr{Int64}, Child::Ptr{Int64}, Sibling::Ptr{Int64}, Stack::Ptr{Int64}, Front_cols::Ptr{Int64}, cmember::Ptr{Int64})::Cvoid
-end
-
-function ccolamd_post_tree(root, k, Child, Sibling, Order, Stack)
-    @ccall libcolamd.ccolamd_post_tree(root::Cint, k::Cint, Child::Ptr{Cint}, Sibling::Ptr{Cint}, Order::Ptr{Cint}, Stack::Ptr{Cint})::Cint
-end
-
-function ccolamd_l_post_tree(root, k, Child, Sibling, Order, Stack)
-    @ccall libcolamd.ccolamd_l_post_tree(root::Int64, k::Int64, Child::Ptr{Int64}, Sibling::Ptr{Int64}, Order::Ptr{Int64}, Stack::Ptr{Int64})::Int64
-end
-
 function umfpack_di_symbolic(n_row, n_col, Ap, Ai, Ax, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_di_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                          Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                          Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                          Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_symbolic(n_row, n_col, Ap, Ai, Ax, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_dl_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                          Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                          Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                          Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_symbolic(n_row, n_col, Ap, Ai, Ax, Az, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_zi_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                          Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                          Az::Ptr{Cdouble}, Symbolic::Ptr{Ptr{Cvoid}},
+                                          Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_symbolic(n_row, n_col, Ap, Ai, Ax, Az, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_zl_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                          Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                          Az::Ptr{Cdouble}, Symbolic::Ptr{Ptr{Cvoid}},
+                                          Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_numeric(Ap, Ai, Ax, Symbolic, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_di_numeric(Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Symbolic::Ptr{Cvoid}, Numeric::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_numeric(Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                         Symbolic::Ptr{Cvoid}, Numeric::Ptr{Ptr{Cvoid}},
+                                         Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_numeric(Ap, Ai, Ax, Symbolic, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_dl_numeric(Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Symbolic::Ptr{Cvoid}, Numeric::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_numeric(Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                         Symbolic::Ptr{Cvoid}, Numeric::Ptr{Ptr{Cvoid}},
+                                         Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_numeric(Ap, Ai, Ax, Az, Symbolic, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_zi_numeric(Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Symbolic::Ptr{Cvoid}, Numeric::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_numeric(Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                         Az::Ptr{Cdouble}, Symbolic::Ptr{Cvoid},
+                                         Numeric::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                         Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_numeric(Ap, Ai, Ax, Az, Symbolic, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_zl_numeric(Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Symbolic::Ptr{Cvoid}, Numeric::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_numeric(Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                         Az::Ptr{Cdouble}, Symbolic::Ptr{Cvoid},
+                                         Numeric::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                         Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_solve(sys, Ap, Ai, Ax, X, B, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_di_solve(sys::Cint, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_solve(sys::Cint, Ap::Ptr{Int32}, Ai::Ptr{Int32},
+                                       Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble},
+                                       Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                       Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_solve(sys, Ap, Ai, Ax, X, B, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_dl_solve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_solve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64},
+                                       Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble},
+                                       Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                       Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_solve(sys, Ap, Ai, Ax, Az, Xx, Xz, Bx, Bz, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_zi_solve(sys::Cint, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_solve(sys::Cint, Ap::Ptr{Int32}, Ai::Ptr{Int32},
+                                       Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Xx::Ptr{Cdouble},
+                                       Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble},
+                                       Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                       Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_solve(sys, Ap, Ai, Ax, Az, Xx, Xz, Bx, Bz, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_zl_solve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_solve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64},
+                                       Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Xx::Ptr{Cdouble},
+                                       Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble},
+                                       Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                       Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_free_symbolic(Symbolic)
@@ -1840,51 +2346,119 @@ function umfpack_zl_defaults(Control)
 end
 
 function umfpack_di_qsymbolic(n_row, n_col, Ap, Ai, Ax, Qinit, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_di_qsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Qinit::Ptr{Int32}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_qsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                           Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                           Qinit::Ptr{Int32}, Symbolic::Ptr{Ptr{Cvoid}},
+                                           Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_qsymbolic(n_row, n_col, Ap, Ai, Ax, Qinit, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_dl_qsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Qinit::Ptr{Int64}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_qsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                           Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                           Qinit::Ptr{Int64}, Symbolic::Ptr{Ptr{Cvoid}},
+                                           Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_qsymbolic(n_row, n_col, Ap, Ai, Ax, Az, Qinit, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_zi_qsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Qinit::Ptr{Int32}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_qsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                           Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                           Az::Ptr{Cdouble}, Qinit::Ptr{Int32},
+                                           Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                           Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_qsymbolic(n_row, n_col, Ap, Ai, Ax, Az, Qinit, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_zl_qsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Qinit::Ptr{Int64}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_di_fsymbolic(n_row, n_col, Ap, Ai, Ax, user_ordering, user_params, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_di_fsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_dl_fsymbolic(n_row, n_col, Ap, Ai, Ax, user_ordering, user_params, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_dl_fsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_zi_fsymbolic(n_row, n_col, Ap, Ai, Ax, Az, user_ordering, user_params, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_zi_fsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_zl_fsymbolic(n_row, n_col, Ap, Ai, Ax, Az, user_ordering, user_params, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_zl_fsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_di_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Qinit, user_ordering, user_params, Symbolic, SW, Control, Info)
-    @ccall libumfpack.umfpack_di_paru_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Qinit::Ptr{Int32}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_dl_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Qinit, user_ordering, user_params, Symbolic, SW, Control, Info)
-    @ccall libumfpack.umfpack_dl_paru_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Qinit::Ptr{Int64}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_zi_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Az, Qinit, user_ordering, user_params, Symbolic, SW, Control, Info)
-    @ccall libumfpack.umfpack_zi_paru_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Qinit::Ptr{Int32}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_zl_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Az, Qinit, user_ordering, user_params, Symbolic, SW, Control, Info)
-    @ccall libumfpack.umfpack_zl_paru_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Qinit::Ptr{Int64}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_qsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                           Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                           Az::Ptr{Cdouble}, Qinit::Ptr{Int64},
+                                           Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                           Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_di_fsymbolic(n_row, n_col, Ap, Ai, Ax, user_ordering, user_params,
+                              Symbolic, Control, Info)
+    @ccall libumfpack.umfpack_di_fsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                           Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                           user_ordering::Ptr{Cvoid},
+                                           user_params::Ptr{Cvoid},
+                                           Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                           Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_dl_fsymbolic(n_row, n_col, Ap, Ai, Ax, user_ordering, user_params,
+                              Symbolic, Control, Info)
+    @ccall libumfpack.umfpack_dl_fsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                           Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                           user_ordering::Ptr{Cvoid},
+                                           user_params::Ptr{Cvoid},
+                                           Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                           Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_zi_fsymbolic(n_row, n_col, Ap, Ai, Ax, Az, user_ordering, user_params,
+                              Symbolic, Control, Info)
+    @ccall libumfpack.umfpack_zi_fsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                           Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                           Az::Ptr{Cdouble}, user_ordering::Ptr{Cvoid},
+                                           user_params::Ptr{Cvoid},
+                                           Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                           Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_zl_fsymbolic(n_row, n_col, Ap, Ai, Ax, Az, user_ordering, user_params,
+                              Symbolic, Control, Info)
+    @ccall libumfpack.umfpack_zl_fsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                           Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                           Az::Ptr{Cdouble}, user_ordering::Ptr{Cvoid},
+                                           user_params::Ptr{Cvoid},
+                                           Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                           Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_di_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Qinit, user_ordering,
+                                  user_params, Symbolic, SW, Control, Info)
+    @ccall libumfpack.umfpack_di_paru_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                               Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                               Qinit::Ptr{Int32}, user_ordering::Ptr{Cvoid},
+                                               user_params::Ptr{Cvoid},
+                                               Symbolic::Ptr{Ptr{Cvoid}},
+                                               SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                               Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_dl_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Qinit, user_ordering,
+                                  user_params, Symbolic, SW, Control, Info)
+    @ccall libumfpack.umfpack_dl_paru_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                               Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                               Qinit::Ptr{Int64}, user_ordering::Ptr{Cvoid},
+                                               user_params::Ptr{Cvoid},
+                                               Symbolic::Ptr{Ptr{Cvoid}},
+                                               SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                               Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_zi_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Az, Qinit, user_ordering,
+                                  user_params, Symbolic, SW, Control, Info)
+    @ccall libumfpack.umfpack_zi_paru_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                               Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                               Az::Ptr{Cdouble}, Qinit::Ptr{Int32},
+                                               user_ordering::Ptr{Cvoid},
+                                               user_params::Ptr{Cvoid},
+                                               Symbolic::Ptr{Ptr{Cvoid}},
+                                               SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                               Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_zl_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Az, Qinit, user_ordering,
+                                  user_params, Symbolic, SW, Control, Info)
+    @ccall libumfpack.umfpack_zl_paru_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                               Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                               Az::Ptr{Cdouble}, Qinit::Ptr{Int64},
+                                               user_ordering::Ptr{Cvoid},
+                                               user_params::Ptr{Cvoid},
+                                               Symbolic::Ptr{Ptr{Cvoid}},
+                                               SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                               Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_paru_free_sw(SW)
@@ -1904,339 +2478,547 @@ function umfpack_zl_paru_free_sw(SW)
 end
 
 function umfpack_di_wsolve(sys, Ap, Ai, Ax, X, B, Numeric, Control, Info, Wi, W)
-    @ccall libumfpack.umfpack_di_wsolve(sys::Cint, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble}, Wi::Ptr{Int32}, W::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_wsolve(sys::Cint, Ap::Ptr{Int32}, Ai::Ptr{Int32},
+                                        Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble},
+                                        Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                        Info::Ptr{Cdouble}, Wi::Ptr{Int32},
+                                        W::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_wsolve(sys, Ap, Ai, Ax, X, B, Numeric, Control, Info, Wi, W)
-    @ccall libumfpack.umfpack_dl_wsolve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble}, Wi::Ptr{Int64}, W::Ptr{Cdouble})::Cint
-end
-
-function umfpack_zi_wsolve(sys, Ap, Ai, Ax, Az, Xx, Xz, Bx, Bz, Numeric, Control, Info, Wi, W)
-    @ccall libumfpack.umfpack_zi_wsolve(sys::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble}, Wi::Ptr{Int32}, W::Ptr{Cdouble})::Cint
-end
-
-function umfpack_zl_wsolve(sys, Ap, Ai, Ax, Az, Xx, Xz, Bx, Bz, Numeric, Control, Info, Wi, W)
-    @ccall libumfpack.umfpack_zl_wsolve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble}, Wi::Ptr{Int64}, W::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_wsolve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64},
+                                        Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble},
+                                        Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                        Info::Ptr{Cdouble}, Wi::Ptr{Int64},
+                                        W::Ptr{Cdouble})::Cint
+end
+
+function umfpack_zi_wsolve(sys, Ap, Ai, Ax, Az, Xx, Xz, Bx, Bz, Numeric, Control, Info, Wi,
+                           W)
+    @ccall libumfpack.umfpack_zi_wsolve(sys::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32},
+                                        Ax::Ptr{Cdouble}, Az::Ptr{Cdouble},
+                                        Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble},
+                                        Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble},
+                                        Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                        Info::Ptr{Cdouble}, Wi::Ptr{Int32},
+                                        W::Ptr{Cdouble})::Cint
+end
+
+function umfpack_zl_wsolve(sys, Ap, Ai, Ax, Az, Xx, Xz, Bx, Bz, Numeric, Control, Info, Wi,
+                           W)
+    @ccall libumfpack.umfpack_zl_wsolve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64},
+                                        Ax::Ptr{Cdouble}, Az::Ptr{Cdouble},
+                                        Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble},
+                                        Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble},
+                                        Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                        Info::Ptr{Cdouble}, Wi::Ptr{Int64},
+                                        W::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_triplet_to_col(n_row, n_col, nz, Ti, Tj, Tx, Ap, Ai, Ax, Map)
-    @ccall libumfpack.umfpack_di_triplet_to_col(n_row::Int32, n_col::Int32, nz::Int32, Ti::Ptr{Int32}, Tj::Ptr{Int32}, Tx::Ptr{Cdouble}, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Map::Ptr{Int32})::Cint
+    @ccall libumfpack.umfpack_di_triplet_to_col(n_row::Int32, n_col::Int32, nz::Int32,
+                                                Ti::Ptr{Int32}, Tj::Ptr{Int32},
+                                                Tx::Ptr{Cdouble}, Ap::Ptr{Int32},
+                                                Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                                Map::Ptr{Int32})::Cint
 end
 
 function umfpack_dl_triplet_to_col(n_row, n_col, nz, Ti, Tj, Tx, Ap, Ai, Ax, Map)
-    @ccall libumfpack.umfpack_dl_triplet_to_col(n_row::Int64, n_col::Int64, nz::Int64, Ti::Ptr{Int64}, Tj::Ptr{Int64}, Tx::Ptr{Cdouble}, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Map::Ptr{Int64})::Cint
+    @ccall libumfpack.umfpack_dl_triplet_to_col(n_row::Int64, n_col::Int64, nz::Int64,
+                                                Ti::Ptr{Int64}, Tj::Ptr{Int64},
+                                                Tx::Ptr{Cdouble}, Ap::Ptr{Int64},
+                                                Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                                Map::Ptr{Int64})::Cint
 end
 
 function umfpack_zi_triplet_to_col(n_row, n_col, nz, Ti, Tj, Tx, Tz, Ap, Ai, Ax, Az, Map)
-    @ccall libumfpack.umfpack_zi_triplet_to_col(n_row::Int32, n_col::Int32, nz::Int32, Ti::Ptr{Int32}, Tj::Ptr{Int32}, Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble}, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Map::Ptr{Int32})::Cint
+    @ccall libumfpack.umfpack_zi_triplet_to_col(n_row::Int32, n_col::Int32, nz::Int32,
+                                                Ti::Ptr{Int32}, Tj::Ptr{Int32},
+                                                Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble},
+                                                Ap::Ptr{Int32}, Ai::Ptr{Int32},
+                                                Ax::Ptr{Cdouble}, Az::Ptr{Cdouble},
+                                                Map::Ptr{Int32})::Cint
 end
 
 function umfpack_zl_triplet_to_col(n_row, n_col, nz, Ti, Tj, Tx, Tz, Ap, Ai, Ax, Az, Map)
-    @ccall libumfpack.umfpack_zl_triplet_to_col(n_row::Int64, n_col::Int64, nz::Int64, Ti::Ptr{Int64}, Tj::Ptr{Int64}, Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble}, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Map::Ptr{Int64})::Cint
+    @ccall libumfpack.umfpack_zl_triplet_to_col(n_row::Int64, n_col::Int64, nz::Int64,
+                                                Ti::Ptr{Int64}, Tj::Ptr{Int64},
+                                                Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble},
+                                                Ap::Ptr{Int64}, Ai::Ptr{Int64},
+                                                Ax::Ptr{Cdouble}, Az::Ptr{Cdouble},
+                                                Map::Ptr{Int64})::Cint
 end
 
 function umfpack_di_col_to_triplet(n_col, Ap, Tj)
-    @ccall libumfpack.umfpack_di_col_to_triplet(n_col::Int32, Ap::Ptr{Int32}, Tj::Ptr{Int32})::Cint
+    @ccall libumfpack.umfpack_di_col_to_triplet(n_col::Int32, Ap::Ptr{Int32},
+                                                Tj::Ptr{Int32})::Cint
 end
 
 function umfpack_dl_col_to_triplet(n_col, Ap, Tj)
-    @ccall libumfpack.umfpack_dl_col_to_triplet(n_col::Int64, Ap::Ptr{Int64}, Tj::Ptr{Int64})::Cint
+    @ccall libumfpack.umfpack_dl_col_to_triplet(n_col::Int64, Ap::Ptr{Int64},
+                                                Tj::Ptr{Int64})::Cint
 end
 
 function umfpack_zi_col_to_triplet(n_col, Ap, Tj)
-    @ccall libumfpack.umfpack_zi_col_to_triplet(n_col::Int32, Ap::Ptr{Int32}, Tj::Ptr{Int32})::Cint
+    @ccall libumfpack.umfpack_zi_col_to_triplet(n_col::Int32, Ap::Ptr{Int32},
+                                                Tj::Ptr{Int32})::Cint
 end
 
 function umfpack_zl_col_to_triplet(n_col, Ap, Tj)
-    @ccall libumfpack.umfpack_zl_col_to_triplet(n_col::Int64, Ap::Ptr{Int64}, Tj::Ptr{Int64})::Cint
+    @ccall libumfpack.umfpack_zl_col_to_triplet(n_col::Int64, Ap::Ptr{Int64},
+                                                Tj::Ptr{Int64})::Cint
 end
 
 function umfpack_di_transpose(n_row, n_col, Ap, Ai, Ax, P, Q, Rp, Ri, Rx)
-    @ccall libumfpack.umfpack_di_transpose(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, P::Ptr{Int32}, Q::Ptr{Int32}, Rp::Ptr{Int32}, Ri::Ptr{Int32}, Rx::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_transpose(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                           Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, P::Ptr{Int32},
+                                           Q::Ptr{Int32}, Rp::Ptr{Int32}, Ri::Ptr{Int32},
+                                           Rx::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_transpose(n_row, n_col, Ap, Ai, Ax, P, Q, Rp, Ri, Rx)
-    @ccall libumfpack.umfpack_dl_transpose(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, P::Ptr{Int64}, Q::Ptr{Int64}, Rp::Ptr{Int64}, Ri::Ptr{Int64}, Rx::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_transpose(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                           Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, P::Ptr{Int64},
+                                           Q::Ptr{Int64}, Rp::Ptr{Int64}, Ri::Ptr{Int64},
+                                           Rx::Ptr{Cdouble})::Cint
 end
 
-function umfpack_zi_transpose(n_row, n_col, Ap, Ai, Ax, Az, P, Q, Rp, Ri, Rx, Rz, do_conjugate)
-    @ccall libumfpack.umfpack_zi_transpose(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, P::Ptr{Int32}, Q::Ptr{Int32}, Rp::Ptr{Int32}, Ri::Ptr{Int32}, Rx::Ptr{Cdouble}, Rz::Ptr{Cdouble}, do_conjugate::Cint)::Cint
+function umfpack_zi_transpose(n_row, n_col, Ap, Ai, Ax, Az, P, Q, Rp, Ri, Rx, Rz,
+                              do_conjugate)
+    @ccall libumfpack.umfpack_zi_transpose(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                           Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                           Az::Ptr{Cdouble}, P::Ptr{Int32}, Q::Ptr{Int32},
+                                           Rp::Ptr{Int32}, Ri::Ptr{Int32}, Rx::Ptr{Cdouble},
+                                           Rz::Ptr{Cdouble}, do_conjugate::Cint)::Cint
 end
 
-function umfpack_zl_transpose(n_row, n_col, Ap, Ai, Ax, Az, P, Q, Rp, Ri, Rx, Rz, do_conjugate)
-    @ccall libumfpack.umfpack_zl_transpose(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, P::Ptr{Int64}, Q::Ptr{Int64}, Rp::Ptr{Int64}, Ri::Ptr{Int64}, Rx::Ptr{Cdouble}, Rz::Ptr{Cdouble}, do_conjugate::Cint)::Cint
+function umfpack_zl_transpose(n_row, n_col, Ap, Ai, Ax, Az, P, Q, Rp, Ri, Rx, Rz,
+                              do_conjugate)
+    @ccall libumfpack.umfpack_zl_transpose(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                           Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                           Az::Ptr{Cdouble}, P::Ptr{Int64}, Q::Ptr{Int64},
+                                           Rp::Ptr{Int64}, Ri::Ptr{Int64}, Rx::Ptr{Cdouble},
+                                           Rz::Ptr{Cdouble}, do_conjugate::Cint)::Cint
 end
 
 function umfpack_di_scale(X, B, Numeric)
-    @ccall libumfpack.umfpack_di_scale(X::Ptr{Cdouble}, B::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_scale(X::Ptr{Cdouble}, B::Ptr{Cdouble},
+                                       Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_scale(X, B, Numeric)
-    @ccall libumfpack.umfpack_dl_scale(X::Ptr{Cdouble}, B::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_scale(X::Ptr{Cdouble}, B::Ptr{Cdouble},
+                                       Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_scale(Xx, Xz, Bx, Bz, Numeric)
-    @ccall libumfpack.umfpack_zi_scale(Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_scale(Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble},
+                                       Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_scale(Xx, Xz, Bx, Bz, Numeric)
-    @ccall libumfpack.umfpack_zl_scale(Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_scale(Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble},
+                                       Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_get_lunz(lnz, unz, n_row, n_col, nz_udiag, Numeric)
-    @ccall libumfpack.umfpack_di_get_lunz(lnz::Ptr{Int32}, unz::Ptr{Int32}, n_row::Ptr{Int32}, n_col::Ptr{Int32}, nz_udiag::Ptr{Int32}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_get_lunz(lnz::Ptr{Int32}, unz::Ptr{Int32},
+                                          n_row::Ptr{Int32}, n_col::Ptr{Int32},
+                                          nz_udiag::Ptr{Int32}, Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_get_lunz(lnz, unz, n_row, n_col, nz_udiag, Numeric)
-    @ccall libumfpack.umfpack_dl_get_lunz(lnz::Ptr{Int64}, unz::Ptr{Int64}, n_row::Ptr{Int64}, n_col::Ptr{Int64}, nz_udiag::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_get_lunz(lnz::Ptr{Int64}, unz::Ptr{Int64},
+                                          n_row::Ptr{Int64}, n_col::Ptr{Int64},
+                                          nz_udiag::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_get_lunz(lnz, unz, n_row, n_col, nz_udiag, Numeric)
-    @ccall libumfpack.umfpack_zi_get_lunz(lnz::Ptr{Int32}, unz::Ptr{Int32}, n_row::Ptr{Int32}, n_col::Ptr{Int32}, nz_udiag::Ptr{Int32}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_get_lunz(lnz::Ptr{Int32}, unz::Ptr{Int32},
+                                          n_row::Ptr{Int32}, n_col::Ptr{Int32},
+                                          nz_udiag::Ptr{Int32}, Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_get_lunz(lnz, unz, n_row, n_col, nz_udiag, Numeric)
-    @ccall libumfpack.umfpack_zl_get_lunz(lnz::Ptr{Int64}, unz::Ptr{Int64}, n_row::Ptr{Int64}, n_col::Ptr{Int64}, nz_udiag::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_get_lunz(lnz::Ptr{Int64}, unz::Ptr{Int64},
+                                          n_row::Ptr{Int64}, n_col::Ptr{Int64},
+                                          nz_udiag::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_get_numeric(Lp, Lj, Lx, Up, Ui, Ux, P, Q, Dx, do_recip, Rs, Numeric)
-    @ccall libumfpack.umfpack_di_get_numeric(Lp::Ptr{Int32}, Lj::Ptr{Int32}, Lx::Ptr{Cdouble}, Up::Ptr{Int32}, Ui::Ptr{Int32}, Ux::Ptr{Cdouble}, P::Ptr{Int32}, Q::Ptr{Int32}, Dx::Ptr{Cdouble}, do_recip::Ptr{Int32}, Rs::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_get_numeric(Lp::Ptr{Int32}, Lj::Ptr{Int32},
+                                             Lx::Ptr{Cdouble}, Up::Ptr{Int32},
+                                             Ui::Ptr{Int32}, Ux::Ptr{Cdouble},
+                                             P::Ptr{Int32}, Q::Ptr{Int32}, Dx::Ptr{Cdouble},
+                                             do_recip::Ptr{Int32}, Rs::Ptr{Cdouble},
+                                             Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_get_numeric(Lp, Lj, Lx, Up, Ui, Ux, P, Q, Dx, do_recip, Rs, Numeric)
-    @ccall libumfpack.umfpack_dl_get_numeric(Lp::Ptr{Int64}, Lj::Ptr{Int64}, Lx::Ptr{Cdouble}, Up::Ptr{Int64}, Ui::Ptr{Int64}, Ux::Ptr{Cdouble}, P::Ptr{Int64}, Q::Ptr{Int64}, Dx::Ptr{Cdouble}, do_recip::Ptr{Int64}, Rs::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
-end
-
-function umfpack_zi_get_numeric(Lp, Lj, Lx, Lz, Up, Ui, Ux, Uz, P, Q, Dx, Dz, do_recip, Rs, Numeric)
-    @ccall libumfpack.umfpack_zi_get_numeric(Lp::Ptr{Int32}, Lj::Ptr{Int32}, Lx::Ptr{Cdouble}, Lz::Ptr{Cdouble}, Up::Ptr{Int32}, Ui::Ptr{Int32}, Ux::Ptr{Cdouble}, Uz::Ptr{Cdouble}, P::Ptr{Int32}, Q::Ptr{Int32}, Dx::Ptr{Cdouble}, Dz::Ptr{Cdouble}, do_recip::Ptr{Int32}, Rs::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
-end
-
-function umfpack_zl_get_numeric(Lp, Lj, Lx, Lz, Up, Ui, Ux, Uz, P, Q, Dx, Dz, do_recip, Rs, Numeric)
-    @ccall libumfpack.umfpack_zl_get_numeric(Lp::Ptr{Int64}, Lj::Ptr{Int64}, Lx::Ptr{Cdouble}, Lz::Ptr{Cdouble}, Up::Ptr{Int64}, Ui::Ptr{Int64}, Ux::Ptr{Cdouble}, Uz::Ptr{Cdouble}, P::Ptr{Int64}, Q::Ptr{Int64}, Dx::Ptr{Cdouble}, Dz::Ptr{Cdouble}, do_recip::Ptr{Int64}, Rs::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
-end
-
-function umfpack_di_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol, Front_parent, Front_1strow, Front_leftmostdesc, Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
-    @ccall libumfpack.umfpack_di_get_symbolic(n_row::Ptr{Int32}, n_col::Ptr{Int32}, n1::Ptr{Int32}, nz::Ptr{Int32}, nfr::Ptr{Int32}, nchains::Ptr{Int32}, P::Ptr{Int32}, Q::Ptr{Int32}, Front_npivcol::Ptr{Int32}, Front_parent::Ptr{Int32}, Front_1strow::Ptr{Int32}, Front_leftmostdesc::Ptr{Int32}, Chain_start::Ptr{Int32}, Chain_maxrows::Ptr{Int32}, Chain_maxcols::Ptr{Int32}, Dmap::Ptr{Int32}, Symbolic::Ptr{Cvoid})::Cint
-end
-
-function umfpack_dl_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol, Front_parent, Front_1strow, Front_leftmostdesc, Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
-    @ccall libumfpack.umfpack_dl_get_symbolic(n_row::Ptr{Int64}, n_col::Ptr{Int64}, n1::Ptr{Int64}, nz::Ptr{Int64}, nfr::Ptr{Int64}, nchains::Ptr{Int64}, P::Ptr{Int64}, Q::Ptr{Int64}, Front_npivcol::Ptr{Int64}, Front_parent::Ptr{Int64}, Front_1strow::Ptr{Int64}, Front_leftmostdesc::Ptr{Int64}, Chain_start::Ptr{Int64}, Chain_maxrows::Ptr{Int64}, Chain_maxcols::Ptr{Int64}, Dmap::Ptr{Int64}, Symbolic::Ptr{Cvoid})::Cint
-end
-
-function umfpack_zi_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol, Front_parent, Front_1strow, Front_leftmostdesc, Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
-    @ccall libumfpack.umfpack_zi_get_symbolic(n_row::Ptr{Int32}, n_col::Ptr{Int32}, n1::Ptr{Int32}, nz::Ptr{Int32}, nfr::Ptr{Int32}, nchains::Ptr{Int32}, P::Ptr{Int32}, Q::Ptr{Int32}, Front_npivcol::Ptr{Int32}, Front_parent::Ptr{Int32}, Front_1strow::Ptr{Int32}, Front_leftmostdesc::Ptr{Int32}, Chain_start::Ptr{Int32}, Chain_maxrows::Ptr{Int32}, Chain_maxcols::Ptr{Int32}, Dmap::Ptr{Int32}, Symbolic::Ptr{Cvoid})::Cint
-end
-
-function umfpack_zl_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol, Front_parent, Front_1strow, Front_leftmostdesc, Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
-    @ccall libumfpack.umfpack_zl_get_symbolic(n_row::Ptr{Int64}, n_col::Ptr{Int64}, n1::Ptr{Int64}, nz::Ptr{Int64}, nfr::Ptr{Int64}, nchains::Ptr{Int64}, P::Ptr{Int64}, Q::Ptr{Int64}, Front_npivcol::Ptr{Int64}, Front_parent::Ptr{Int64}, Front_1strow::Ptr{Int64}, Front_leftmostdesc::Ptr{Int64}, Chain_start::Ptr{Int64}, Chain_maxrows::Ptr{Int64}, Chain_maxcols::Ptr{Int64}, Dmap::Ptr{Int64}, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_get_numeric(Lp::Ptr{Int64}, Lj::Ptr{Int64},
+                                             Lx::Ptr{Cdouble}, Up::Ptr{Int64},
+                                             Ui::Ptr{Int64}, Ux::Ptr{Cdouble},
+                                             P::Ptr{Int64}, Q::Ptr{Int64}, Dx::Ptr{Cdouble},
+                                             do_recip::Ptr{Int64}, Rs::Ptr{Cdouble},
+                                             Numeric::Ptr{Cvoid})::Cint
+end
+
+function umfpack_zi_get_numeric(Lp, Lj, Lx, Lz, Up, Ui, Ux, Uz, P, Q, Dx, Dz, do_recip, Rs,
+                                Numeric)
+    @ccall libumfpack.umfpack_zi_get_numeric(Lp::Ptr{Int32}, Lj::Ptr{Int32},
+                                             Lx::Ptr{Cdouble}, Lz::Ptr{Cdouble},
+                                             Up::Ptr{Int32}, Ui::Ptr{Int32},
+                                             Ux::Ptr{Cdouble}, Uz::Ptr{Cdouble},
+                                             P::Ptr{Int32}, Q::Ptr{Int32}, Dx::Ptr{Cdouble},
+                                             Dz::Ptr{Cdouble}, do_recip::Ptr{Int32},
+                                             Rs::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+end
+
+function umfpack_zl_get_numeric(Lp, Lj, Lx, Lz, Up, Ui, Ux, Uz, P, Q, Dx, Dz, do_recip, Rs,
+                                Numeric)
+    @ccall libumfpack.umfpack_zl_get_numeric(Lp::Ptr{Int64}, Lj::Ptr{Int64},
+                                             Lx::Ptr{Cdouble}, Lz::Ptr{Cdouble},
+                                             Up::Ptr{Int64}, Ui::Ptr{Int64},
+                                             Ux::Ptr{Cdouble}, Uz::Ptr{Cdouble},
+                                             P::Ptr{Int64}, Q::Ptr{Int64}, Dx::Ptr{Cdouble},
+                                             Dz::Ptr{Cdouble}, do_recip::Ptr{Int64},
+                                             Rs::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+end
+
+function umfpack_di_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol,
+                                 Front_parent, Front_1strow, Front_leftmostdesc,
+                                 Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
+    @ccall libumfpack.umfpack_di_get_symbolic(n_row::Ptr{Int32}, n_col::Ptr{Int32},
+                                              n1::Ptr{Int32}, nz::Ptr{Int32},
+                                              nfr::Ptr{Int32}, nchains::Ptr{Int32},
+                                              P::Ptr{Int32}, Q::Ptr{Int32},
+                                              Front_npivcol::Ptr{Int32},
+                                              Front_parent::Ptr{Int32},
+                                              Front_1strow::Ptr{Int32},
+                                              Front_leftmostdesc::Ptr{Int32},
+                                              Chain_start::Ptr{Int32},
+                                              Chain_maxrows::Ptr{Int32},
+                                              Chain_maxcols::Ptr{Int32}, Dmap::Ptr{Int32},
+                                              Symbolic::Ptr{Cvoid})::Cint
+end
+
+function umfpack_dl_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol,
+                                 Front_parent, Front_1strow, Front_leftmostdesc,
+                                 Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
+    @ccall libumfpack.umfpack_dl_get_symbolic(n_row::Ptr{Int64}, n_col::Ptr{Int64},
+                                              n1::Ptr{Int64}, nz::Ptr{Int64},
+                                              nfr::Ptr{Int64}, nchains::Ptr{Int64},
+                                              P::Ptr{Int64}, Q::Ptr{Int64},
+                                              Front_npivcol::Ptr{Int64},
+                                              Front_parent::Ptr{Int64},
+                                              Front_1strow::Ptr{Int64},
+                                              Front_leftmostdesc::Ptr{Int64},
+                                              Chain_start::Ptr{Int64},
+                                              Chain_maxrows::Ptr{Int64},
+                                              Chain_maxcols::Ptr{Int64}, Dmap::Ptr{Int64},
+                                              Symbolic::Ptr{Cvoid})::Cint
+end
+
+function umfpack_zi_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol,
+                                 Front_parent, Front_1strow, Front_leftmostdesc,
+                                 Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
+    @ccall libumfpack.umfpack_zi_get_symbolic(n_row::Ptr{Int32}, n_col::Ptr{Int32},
+                                              n1::Ptr{Int32}, nz::Ptr{Int32},
+                                              nfr::Ptr{Int32}, nchains::Ptr{Int32},
+                                              P::Ptr{Int32}, Q::Ptr{Int32},
+                                              Front_npivcol::Ptr{Int32},
+                                              Front_parent::Ptr{Int32},
+                                              Front_1strow::Ptr{Int32},
+                                              Front_leftmostdesc::Ptr{Int32},
+                                              Chain_start::Ptr{Int32},
+                                              Chain_maxrows::Ptr{Int32},
+                                              Chain_maxcols::Ptr{Int32}, Dmap::Ptr{Int32},
+                                              Symbolic::Ptr{Cvoid})::Cint
+end
+
+function umfpack_zl_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol,
+                                 Front_parent, Front_1strow, Front_leftmostdesc,
+                                 Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
+    @ccall libumfpack.umfpack_zl_get_symbolic(n_row::Ptr{Int64}, n_col::Ptr{Int64},
+                                              n1::Ptr{Int64}, nz::Ptr{Int64},
+                                              nfr::Ptr{Int64}, nchains::Ptr{Int64},
+                                              P::Ptr{Int64}, Q::Ptr{Int64},
+                                              Front_npivcol::Ptr{Int64},
+                                              Front_parent::Ptr{Int64},
+                                              Front_1strow::Ptr{Int64},
+                                              Front_leftmostdesc::Ptr{Int64},
+                                              Chain_start::Ptr{Int64},
+                                              Chain_maxrows::Ptr{Int64},
+                                              Chain_maxcols::Ptr{Int64}, Dmap::Ptr{Int64},
+                                              Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_save_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_di_save_numeric(Numeric::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_di_save_numeric(Numeric::Ptr{Cvoid},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_dl_save_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_dl_save_numeric(Numeric::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_dl_save_numeric(Numeric::Ptr{Cvoid},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zi_save_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_zi_save_numeric(Numeric::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zi_save_numeric(Numeric::Ptr{Cvoid},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zl_save_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_zl_save_numeric(Numeric::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zl_save_numeric(Numeric::Ptr{Cvoid},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_di_load_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_di_load_numeric(Numeric::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_di_load_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_dl_load_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_dl_load_numeric(Numeric::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_dl_load_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zi_load_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_zi_load_numeric(Numeric::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zi_load_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zl_load_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_zl_load_numeric(Numeric::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zl_load_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_di_copy_numeric(Numeric, Original)
-    @ccall libumfpack.umfpack_di_copy_numeric(Numeric::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_copy_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_copy_numeric(Numeric, Original)
-    @ccall libumfpack.umfpack_dl_copy_numeric(Numeric::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_copy_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_copy_numeric(Numeric, Original)
-    @ccall libumfpack.umfpack_zi_copy_numeric(Numeric::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_copy_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_copy_numeric(Numeric, Original)
-    @ccall libumfpack.umfpack_zl_copy_numeric(Numeric::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_copy_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_serialize_numeric_size(blobsize, Numeric)
-    @ccall libumfpack.umfpack_di_serialize_numeric_size(blobsize::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_serialize_numeric_size(blobsize::Ptr{Int64},
+                                                        Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_serialize_numeric_size(blobsize, Numeric)
-    @ccall libumfpack.umfpack_dl_serialize_numeric_size(blobsize::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_serialize_numeric_size(blobsize::Ptr{Int64},
+                                                        Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_serialize_numeric_size(blobsize, Numeric)
-    @ccall libumfpack.umfpack_zi_serialize_numeric_size(blobsize::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_serialize_numeric_size(blobsize::Ptr{Int64},
+                                                        Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_serialize_numeric_size(blobsize, Numeric)
-    @ccall libumfpack.umfpack_zl_serialize_numeric_size(blobsize::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_serialize_numeric_size(blobsize::Ptr{Int64},
+                                                        Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_serialize_numeric(blob, blobsize, Numeric)
-    @ccall libumfpack.umfpack_di_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64,
+                                                   Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_serialize_numeric(blob, blobsize, Numeric)
-    @ccall libumfpack.umfpack_dl_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64,
+                                                   Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_serialize_numeric(blob, blobsize, Numeric)
-    @ccall libumfpack.umfpack_zi_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64,
+                                                   Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_serialize_numeric(blob, blobsize, Numeric)
-    @ccall libumfpack.umfpack_zl_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64,
+                                                   Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_deserialize_numeric(Numeric, blob, blobsize)
-    @ccall libumfpack.umfpack_di_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_di_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                                     blob::Ptr{Int8}, blobsize::Int64)::Cint
 end
 
 function umfpack_dl_deserialize_numeric(Numeric, blob, blobsize)
-    @ccall libumfpack.umfpack_dl_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_dl_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                                     blob::Ptr{Int8}, blobsize::Int64)::Cint
 end
 
 function umfpack_zi_deserialize_numeric(Numeric, blob, blobsize)
-    @ccall libumfpack.umfpack_zi_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_zi_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                                     blob::Ptr{Int8}, blobsize::Int64)::Cint
 end
 
 function umfpack_zl_deserialize_numeric(Numeric, blob, blobsize)
-    @ccall libumfpack.umfpack_zl_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_zl_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                                     blob::Ptr{Int8}, blobsize::Int64)::Cint
 end
 
 function umfpack_di_save_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_di_save_symbolic(Symbolic::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_di_save_symbolic(Symbolic::Ptr{Cvoid},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_dl_save_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_dl_save_symbolic(Symbolic::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_dl_save_symbolic(Symbolic::Ptr{Cvoid},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zi_save_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_zi_save_symbolic(Symbolic::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zi_save_symbolic(Symbolic::Ptr{Cvoid},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zl_save_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_zl_save_symbolic(Symbolic::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zl_save_symbolic(Symbolic::Ptr{Cvoid},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_di_load_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_di_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_di_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_dl_load_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_dl_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_dl_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zi_load_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_zi_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zi_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zl_load_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_zl_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zl_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_di_copy_symbolic(Symbolic, Original)
-    @ccall libumfpack.umfpack_di_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_copy_symbolic(Symbolic, Original)
-    @ccall libumfpack.umfpack_dl_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_copy_symbolic(Symbolic, Original)
-    @ccall libumfpack.umfpack_zi_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_copy_symbolic(Symbolic, Original)
-    @ccall libumfpack.umfpack_zl_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_serialize_symbolic_size(blobsize, Symbolic)
-    @ccall libumfpack.umfpack_di_serialize_symbolic_size(blobsize::Ptr{Int64}, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_serialize_symbolic_size(blobsize::Ptr{Int64},
+                                                         Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_serialize_symbolic_size(blobsize, Symbolic)
-    @ccall libumfpack.umfpack_dl_serialize_symbolic_size(blobsize::Ptr{Int64}, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_serialize_symbolic_size(blobsize::Ptr{Int64},
+                                                         Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_serialize_symbolic_size(blobsize, Symbolic)
-    @ccall libumfpack.umfpack_zi_serialize_symbolic_size(blobsize::Ptr{Int64}, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_serialize_symbolic_size(blobsize::Ptr{Int64},
+                                                         Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_serialize_symbolic_size(blobsize, Symbolic)
-    @ccall libumfpack.umfpack_zl_serialize_symbolic_size(blobsize::Ptr{Int64}, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_serialize_symbolic_size(blobsize::Ptr{Int64},
+                                                         Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_serialize_symbolic(blob, blobsize, Symbolic)
-    @ccall libumfpack.umfpack_di_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64,
+                                                    Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_serialize_symbolic(blob, blobsize, Symbolic)
-    @ccall libumfpack.umfpack_dl_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64,
+                                                    Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_serialize_symbolic(blob, blobsize, Symbolic)
-    @ccall libumfpack.umfpack_zi_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64,
+                                                    Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_serialize_symbolic(blob, blobsize, Symbolic)
-    @ccall libumfpack.umfpack_zl_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64,
+                                                    Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_deserialize_symbolic(Symbolic, blob, blobsize)
-    @ccall libumfpack.umfpack_di_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_di_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                                      blob::Ptr{Int8},
+                                                      blobsize::Int64)::Cint
 end
 
 function umfpack_dl_deserialize_symbolic(Symbolic, blob, blobsize)
-    @ccall libumfpack.umfpack_dl_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_dl_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                                      blob::Ptr{Int8},
+                                                      blobsize::Int64)::Cint
 end
 
 function umfpack_zi_deserialize_symbolic(Symbolic, blob, blobsize)
-    @ccall libumfpack.umfpack_zi_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_zi_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                                      blob::Ptr{Int8},
+                                                      blobsize::Int64)::Cint
 end
 
 function umfpack_zl_deserialize_symbolic(Symbolic, blob, blobsize)
-    @ccall libumfpack.umfpack_zl_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_zl_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                                      blob::Ptr{Int8},
+                                                      blobsize::Int64)::Cint
 end
 
 function umfpack_di_get_determinant(Mx, Ex, Numeric, User_Info)
-    @ccall libumfpack.umfpack_di_get_determinant(Mx::Ptr{Cdouble}, Ex::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, User_Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_get_determinant(Mx::Ptr{Cdouble}, Ex::Ptr{Cdouble},
+                                                 Numeric::Ptr{Cvoid},
+                                                 User_Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_get_determinant(Mx, Ex, Numeric, User_Info)
-    @ccall libumfpack.umfpack_dl_get_determinant(Mx::Ptr{Cdouble}, Ex::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, User_Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_get_determinant(Mx::Ptr{Cdouble}, Ex::Ptr{Cdouble},
+                                                 Numeric::Ptr{Cvoid},
+                                                 User_Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_get_determinant(Mx, Mz, Ex, Numeric, User_Info)
-    @ccall libumfpack.umfpack_zi_get_determinant(Mx::Ptr{Cdouble}, Mz::Ptr{Cdouble}, Ex::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, User_Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_get_determinant(Mx::Ptr{Cdouble}, Mz::Ptr{Cdouble},
+                                                 Ex::Ptr{Cdouble}, Numeric::Ptr{Cvoid},
+                                                 User_Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_get_determinant(Mx, Mz, Ex, Numeric, User_Info)
-    @ccall libumfpack.umfpack_zl_get_determinant(Mx::Ptr{Cdouble}, Mz::Ptr{Cdouble}, Ex::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, User_Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_get_determinant(Mx::Ptr{Cdouble}, Mz::Ptr{Cdouble},
+                                                 Ex::Ptr{Cdouble}, Numeric::Ptr{Cvoid},
+                                                 User_Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_report_status(Control, status)
@@ -2256,19 +3038,23 @@ function umfpack_zl_report_status(Control, status)
 end
 
 function umfpack_di_report_info(Control, Info)
-    @ccall libumfpack.umfpack_di_report_info(Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cvoid
+    @ccall libumfpack.umfpack_di_report_info(Control::Ptr{Cdouble},
+                                             Info::Ptr{Cdouble})::Cvoid
 end
 
 function umfpack_dl_report_info(Control, Info)
-    @ccall libumfpack.umfpack_dl_report_info(Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cvoid
+    @ccall libumfpack.umfpack_dl_report_info(Control::Ptr{Cdouble},
+                                             Info::Ptr{Cdouble})::Cvoid
 end
 
 function umfpack_zi_report_info(Control, Info)
-    @ccall libumfpack.umfpack_zi_report_info(Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cvoid
+    @ccall libumfpack.umfpack_zi_report_info(Control::Ptr{Cdouble},
+                                             Info::Ptr{Cdouble})::Cvoid
 end
 
 function umfpack_zl_report_info(Control, Info)
-    @ccall libumfpack.umfpack_zl_report_info(Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cvoid
+    @ccall libumfpack.umfpack_zl_report_info(Control::Ptr{Cdouble},
+                                             Info::Ptr{Cdouble})::Cvoid
 end
 
 function umfpack_di_report_control(Control)
@@ -2288,99 +3074,137 @@ function umfpack_zl_report_control(Control)
 end
 
 function umfpack_di_report_matrix(n_row, n_col, Ap, Ai, Ax, col_form, Control)
-    @ccall libumfpack.umfpack_di_report_matrix(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, col_form::Cint, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_report_matrix(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                               Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                               col_form::Cint, Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_report_matrix(n_row, n_col, Ap, Ai, Ax, col_form, Control)
-    @ccall libumfpack.umfpack_dl_report_matrix(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, col_form::Cint, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_report_matrix(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                               Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                               col_form::Cint, Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_report_matrix(n_row, n_col, Ap, Ai, Ax, Az, col_form, Control)
-    @ccall libumfpack.umfpack_zi_report_matrix(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, col_form::Cint, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_report_matrix(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                               Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                               Az::Ptr{Cdouble}, col_form::Cint,
+                                               Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_report_matrix(n_row, n_col, Ap, Ai, Ax, Az, col_form, Control)
-    @ccall libumfpack.umfpack_zl_report_matrix(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, col_form::Cint, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_report_matrix(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                               Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                               Az::Ptr{Cdouble}, col_form::Cint,
+                                               Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_report_triplet(n_row, n_col, nz, Ti, Tj, Tx, Control)
-    @ccall libumfpack.umfpack_di_report_triplet(n_row::Int32, n_col::Int32, nz::Int32, Ti::Ptr{Int32}, Tj::Ptr{Int32}, Tx::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_report_triplet(n_row::Int32, n_col::Int32, nz::Int32,
+                                                Ti::Ptr{Int32}, Tj::Ptr{Int32},
+                                                Tx::Ptr{Cdouble},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_report_triplet(n_row, n_col, nz, Ti, Tj, Tx, Control)
-    @ccall libumfpack.umfpack_dl_report_triplet(n_row::Int64, n_col::Int64, nz::Int64, Ti::Ptr{Int64}, Tj::Ptr{Int64}, Tx::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_report_triplet(n_row::Int64, n_col::Int64, nz::Int64,
+                                                Ti::Ptr{Int64}, Tj::Ptr{Int64},
+                                                Tx::Ptr{Cdouble},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_report_triplet(n_row, n_col, nz, Ti, Tj, Tx, Tz, Control)
-    @ccall libumfpack.umfpack_zi_report_triplet(n_row::Int32, n_col::Int32, nz::Int32, Ti::Ptr{Int32}, Tj::Ptr{Int32}, Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_report_triplet(n_row::Int32, n_col::Int32, nz::Int32,
+                                                Ti::Ptr{Int32}, Tj::Ptr{Int32},
+                                                Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_report_triplet(n_row, n_col, nz, Ti, Tj, Tx, Tz, Control)
-    @ccall libumfpack.umfpack_zl_report_triplet(n_row::Int64, n_col::Int64, nz::Int64, Ti::Ptr{Int64}, Tj::Ptr{Int64}, Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_report_triplet(n_row::Int64, n_col::Int64, nz::Int64,
+                                                Ti::Ptr{Int64}, Tj::Ptr{Int64},
+                                                Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_report_vector(n, X, Control)
-    @ccall libumfpack.umfpack_di_report_vector(n::Int32, X::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_report_vector(n::Int32, X::Ptr{Cdouble},
+                                               Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_report_vector(n, X, Control)
-    @ccall libumfpack.umfpack_dl_report_vector(n::Int64, X::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_report_vector(n::Int64, X::Ptr{Cdouble},
+                                               Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_report_vector(n, Xx, Xz, Control)
-    @ccall libumfpack.umfpack_zi_report_vector(n::Int32, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_report_vector(n::Int32, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble},
+                                               Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_report_vector(n, Xx, Xz, Control)
-    @ccall libumfpack.umfpack_zl_report_vector(n::Int64, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_report_vector(n::Int64, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble},
+                                               Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_report_symbolic(Symbolic, Control)
-    @ccall libumfpack.umfpack_di_report_symbolic(Symbolic::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_report_symbolic(Symbolic::Ptr{Cvoid},
+                                                 Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_report_symbolic(Symbolic, Control)
-    @ccall libumfpack.umfpack_dl_report_symbolic(Symbolic::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_report_symbolic(Symbolic::Ptr{Cvoid},
+                                                 Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_report_symbolic(Symbolic, Control)
-    @ccall libumfpack.umfpack_zi_report_symbolic(Symbolic::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_report_symbolic(Symbolic::Ptr{Cvoid},
+                                                 Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_report_symbolic(Symbolic, Control)
-    @ccall libumfpack.umfpack_zl_report_symbolic(Symbolic::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_report_symbolic(Symbolic::Ptr{Cvoid},
+                                                 Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_report_numeric(Numeric, Control)
-    @ccall libumfpack.umfpack_di_report_numeric(Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_report_numeric(Numeric::Ptr{Cvoid},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_report_numeric(Numeric, Control)
-    @ccall libumfpack.umfpack_dl_report_numeric(Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_report_numeric(Numeric::Ptr{Cvoid},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_report_numeric(Numeric, Control)
-    @ccall libumfpack.umfpack_zi_report_numeric(Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_report_numeric(Numeric::Ptr{Cvoid},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_report_numeric(Numeric, Control)
-    @ccall libumfpack.umfpack_zl_report_numeric(Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_report_numeric(Numeric::Ptr{Cvoid},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_report_perm(np, Perm, Control)
-    @ccall libumfpack.umfpack_di_report_perm(np::Int32, Perm::Ptr{Int32}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_report_perm(np::Int32, Perm::Ptr{Int32},
+                                             Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_report_perm(np, Perm, Control)
-    @ccall libumfpack.umfpack_dl_report_perm(np::Int64, Perm::Ptr{Int64}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_report_perm(np::Int64, Perm::Ptr{Int64},
+                                             Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_report_perm(np, Perm, Control)
-    @ccall libumfpack.umfpack_zi_report_perm(np::Int32, Perm::Ptr{Int32}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_report_perm(np::Int32, Perm::Ptr{Int32},
+                                             Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_report_perm(np, Perm, Control)
-    @ccall libumfpack.umfpack_zl_report_perm(np::Int64, Perm::Ptr{Int64}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_report_perm(np::Int64, Perm::Ptr{Int64},
+                                             Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_timer()
@@ -2395,13 +3219,13 @@ function umfpack_toc(stats)
     @ccall libumfpack.umfpack_toc(stats::Ptr{Cdouble})::Cvoid
 end
 
-const CHOLMOD_DATE = "Jan 17, 2023"
+const CHOLMOD_DATE = "June 16, 2023"
 
 const CHOLMOD_MAIN_VERSION = 4
 
 const CHOLMOD_SUB_VERSION = 0
 
-const CHOLMOD_SUBSUB_VERSION = 3
+const CHOLMOD_SUBSUB_VERSION = 4
 
 const _FILE_OFFSET_BITS = 64
 
@@ -2427,17 +3251,18 @@ const SUITESPARSE_COMPILER_MSC = 0
 
 const SUITESPARSE_COMPILER_XLC = 0
 
-const SUITESPARSE_DATE = "Jan 20, 2023"
+const SUITESPARSE_DATE = "June 29, 2023"
 
 const SUITESPARSE_MAIN_VERSION = 7
 
-const SUITESPARSE_SUB_VERSION = 0
+const SUITESPARSE_SUB_VERSION = 1
 
-const SUITESPARSE_SUBSUB_VERSION = 1
+const SUITESPARSE_SUBSUB_VERSION = 0
 
 SUITESPARSE_VER_CODE(main, sub) = main * 1000 + sub
 
-const SUITESPARSE_VERSION = SUITESPARSE_VER_CODE(SUITESPARSE_MAIN_VERSION, SUITESPARSE_SUB_VERSION)
+const SUITESPARSE_VERSION = SUITESPARSE_VER_CODE(SUITESPARSE_MAIN_VERSION,
+                                                 SUITESPARSE_SUB_VERSION)
 
 CHOLMOD_VER_CODE(main, sub) = main * 1000 + sub
 
@@ -2601,20 +3426,18 @@ const SPQR_RTX_EQUALS_B = 2
 
 const SPQR_RTX_EQUALS_ETB = 3
 
-const SPQR_DATE = "Jan 17, 2023"
+const SPQR_DATE = "July FIXME, 2023"
 
-const SPQR_MAIN_VERSION = 3
+const SPQR_MAIN_VERSION = 4
 
 const SPQR_SUB_VERSION = 0
 
-const SPQR_SUBSUB_VERSION = 3
+const SPQR_SUBSUB_VERSION = 0
 
 SPQR_VER_CODE(main, sub) = main * 1000 + sub
 
 const SPQR_VERSION = SPQR_VER_CODE(SPQR_MAIN_VERSION, SPQR_SUB_VERSION)
 
-const Complex = Float64
-
 const AMD_CONTROL = 5
 
 const AMD_INFO = 20
@@ -2663,172 +3486,29 @@ const AMD_INVALID = -2
 
 const AMD_OK_BUT_JUMBLED = 1
 
-const AMD_DATE = "Jan 17, 2023"
+const AMD_DATE = "June 16, 2023"
 
 const AMD_MAIN_VERSION = 3
 
 const AMD_SUB_VERSION = 0
 
-const AMD_SUBSUB_VERSION = 3
+const AMD_SUBSUB_VERSION = 4
 
 AMD_VERSION_CODE(main, sub) = main * 1000 + sub
 
 const AMD_VERSION = AMD_VERSION_CODE(AMD_MAIN_VERSION, AMD_SUB_VERSION)
 
-const COLAMD_DATE = "Jan 17, 2023"
-
-const COLAMD_MAIN_VERSION = 3
-
-const COLAMD_SUB_VERSION = 0
-
-const COLAMD_SUBSUB_VERSION = 3
-
-COLAMD_VERSION_CODE(main, sub) = main * 1000 + sub
-
-const COLAMD_VERSION = COLAMD_VERSION_CODE(COLAMD_MAIN_VERSION, COLAMD_SUB_VERSION)
-
-const COLAMD_KNOBS = 20
-
-const COLAMD_STATS = 20
-
-const COLAMD_DENSE_ROW = 0
-
-const COLAMD_DENSE_COL = 1
-
-const COLAMD_AGGRESSIVE = 2
-
-const COLAMD_DEFRAG_COUNT = 2
-
-const COLAMD_STATUS = 3
-
-const COLAMD_INFO1 = 4
-
-const COLAMD_INFO2 = 5
-
-const COLAMD_INFO3 = 6
-
-const COLAMD_OK = 0
-
-const COLAMD_OK_BUT_JUMBLED = 1
-
-const COLAMD_ERROR_A_not_present = -1
-
-const COLAMD_ERROR_p_not_present = -2
-
-const COLAMD_ERROR_nrow_negative = -3
-
-const COLAMD_ERROR_ncol_negative = -4
-
-const COLAMD_ERROR_nnz_negative = -5
-
-const COLAMD_ERROR_p0_nonzero = -6
-
-const COLAMD_ERROR_A_too_small = -7
-
-const COLAMD_ERROR_col_length_negative = -8
-
-const COLAMD_ERROR_row_index_out_of_bounds = -9
-
-const COLAMD_ERROR_out_of_memory = -10
-
-const COLAMD_ERROR_internal_error = -999
-
-const CCOLAMD_DATE = "Jan 17, 2023"
-
-const CCOLAMD_MAIN_VERSION = 3
-
-const CCOLAMD_SUB_VERSION = 0
-
-const CCOLAMD_SUBSUB_VERSION = 3
-
-CCOLAMD_VERSION_CODE(main, sub) = main * 1000 + sub
-
-const CCOLAMD_VERSION = CCOLAMD_VERSION_CODE(CCOLAMD_MAIN_VERSION, CCOLAMD_SUB_VERSION)
-
-const CCOLAMD_KNOBS = 20
-
-const CCOLAMD_STATS = 20
-
-const CCOLAMD_DENSE_ROW = 0
-
-const CCOLAMD_DENSE_COL = 1
-
-const CCOLAMD_AGGRESSIVE = 2
-
-const CCOLAMD_LU = 3
-
-const CCOLAMD_DEFRAG_COUNT = 2
-
-const CCOLAMD_STATUS = 3
-
-const CCOLAMD_INFO1 = 4
-
-const CCOLAMD_INFO2 = 5
-
-const CCOLAMD_INFO3 = 6
-
-const CCOLAMD_EMPTY_ROW = 7
-
-const CCOLAMD_EMPTY_COL = 8
-
-const CCOLAMD_NEWLY_EMPTY_ROW = 9
-
-const CCOLAMD_NEWLY_EMPTY_COL = 10
-
-const CCOLAMD_OK = 0
-
-const CCOLAMD_OK_BUT_JUMBLED = 1
-
-const CCOLAMD_ERROR_A_not_present = -1
-
-const CCOLAMD_ERROR_p_not_present = -2
-
-const CCOLAMD_ERROR_nrow_negative = -3
-
-const CCOLAMD_ERROR_ncol_negative = -4
-
-const CCOLAMD_ERROR_nnz_negative = -5
-
-const CCOLAMD_ERROR_p0_nonzero = -6
-
-const CCOLAMD_ERROR_A_too_small = -7
-
-const CCOLAMD_ERROR_col_length_negative = -8
-
-const CCOLAMD_ERROR_row_index_out_of_bounds = -9
-
-const CCOLAMD_ERROR_out_of_memory = -10
-
-const CCOLAMD_ERROR_invalid_cmember = -11
-
-const CCOLAMD_ERROR_internal_error = -999
-
 const UMFPACK_INFO = 90
 
 const UMFPACK_CONTROL = 20
 
-# Skipping MacroDefinition: UMFPACK_COPYRIGHT \
-#"UMFPACK:  Copyright (c) 2005-2023 by Timothy A. Davis.  All Rights Reserved.\n"
-
-# Skipping MacroDefinition: UMFPACK_LICENSE_PART1 \
-#"\nUMFPACK License: SPDX-License-Identifier: GPL-2.0+\n" \
-#"   UMFPACK is available under alternate licenses,\n" \
-#"   contact T. Davis for details.\n"
-
-const UMFPACK_LICENSE_PART2 = "\n"
-
-# Skipping MacroDefinition: UMFPACK_LICENSE_PART3 \
-#"\n" \
-#"Availability: http://www.suitesparse.com" \
-#"\n"
-
-const UMFPACK_DATE = "Jan 17, 2023"
+const UMFPACK_DATE = "June 16, 2023"
 
 const UMFPACK_MAIN_VERSION = 6
 
 const UMFPACK_SUB_VERSION = 1
 
-const UMFPACK_SUBSUB_VERSION = 0
+const UMFPACK_SUBSUB_VERSION = 1
 
 UMFPACK_VER_CODE(main, sub) = main * 1000 + sub
 
@@ -3169,4 +3849,3 @@ const UMFPACK_Q_Uat = 12
 const UMFPACK_Ut = 13
 
 const UMFPACK_Uat = 14
-
diff --git a/src/solvers/lib/armv7l-linux-musleabihf.jl b/src/solvers/lib/armv7l-linux-musleabihf.jl
index fcf756d2..a5aa4e44 100644
--- a/src/solvers/lib/armv7l-linux-musleabihf.jl
+++ b/src/solvers/lib/armv7l-linux-musleabihf.jl
@@ -1,137 +1,150 @@
 function SuiteSparse_config_printf_func_get()
-    @ccall libcholmod.SuiteSparse_config_printf_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_printf_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_malloc_func_get()
-    @ccall libcholmod.SuiteSparse_config_malloc_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_malloc_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_calloc_func_get()
-    @ccall libcholmod.SuiteSparse_config_calloc_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_calloc_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_realloc_func_get()
-    @ccall libcholmod.SuiteSparse_config_realloc_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_realloc_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_free_func_get()
-    @ccall libcholmod.SuiteSparse_config_free_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_free_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_hypot_func_get()
-    @ccall libcholmod.SuiteSparse_config_hypot_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_hypot_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_divcomplex_func_get()
-    @ccall libcholmod.SuiteSparse_config_divcomplex_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_divcomplex_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_malloc_func_set(malloc_func)
-    @ccall libcholmod.SuiteSparse_config_malloc_func_set(malloc_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_malloc_func_set(malloc_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_calloc_func_set(calloc_func)
-    @ccall libcholmod.SuiteSparse_config_calloc_func_set(calloc_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_calloc_func_set(calloc_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_realloc_func_set(realloc_func)
-    @ccall libcholmod.SuiteSparse_config_realloc_func_set(realloc_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_realloc_func_set(realloc_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_free_func_set(free_func)
-    @ccall libcholmod.SuiteSparse_config_free_func_set(free_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_free_func_set(free_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_printf_func_set(printf_func)
-    @ccall libcholmod.SuiteSparse_config_printf_func_set(printf_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_printf_func_set(printf_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_hypot_func_set(hypot_func)
-    @ccall libcholmod.SuiteSparse_config_hypot_func_set(hypot_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_hypot_func_set(hypot_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_divcomplex_func_set(divcomplex_func)
-    @ccall libcholmod.SuiteSparse_config_divcomplex_func_set(divcomplex_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_divcomplex_func_set(divcomplex_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_malloc(s)
-    @ccall libcholmod.SuiteSparse_config_malloc(s::Csize_t)::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_malloc(s::Csize_t)::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_calloc(n, s)
-    @ccall libcholmod.SuiteSparse_config_calloc(n::Csize_t, s::Csize_t)::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_calloc(n::Csize_t,
+                                                          s::Csize_t)::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_realloc(arg1, s)
-    @ccall libcholmod.SuiteSparse_config_realloc(arg1::Ptr{Cvoid}, s::Csize_t)::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_realloc(arg1::Ptr{Cvoid},
+                                                           s::Csize_t)::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_free(arg1)
-    @ccall libcholmod.SuiteSparse_config_free(arg1::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_free(arg1::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_hypot(x, y)
-    @ccall libcholmod.SuiteSparse_config_hypot(x::Cdouble, y::Cdouble)::Cdouble
+    @ccall libsuitesparseconfig.SuiteSparse_config_hypot(x::Cdouble, y::Cdouble)::Cdouble
 end
 
 function SuiteSparse_config_divcomplex(xr, xi, yr, yi, zr, zi)
-    @ccall libcholmod.SuiteSparse_config_divcomplex(xr::Cdouble, xi::Cdouble, yr::Cdouble, yi::Cdouble, zr::Ptr{Cdouble}, zi::Ptr{Cdouble})::Cint
+    @ccall libsuitesparseconfig.SuiteSparse_config_divcomplex(xr::Cdouble, xi::Cdouble,
+                                                              yr::Cdouble, yi::Cdouble,
+                                                              zr::Ptr{Cdouble},
+                                                              zi::Ptr{Cdouble})::Cint
 end
 
 function SuiteSparse_start()
-    @ccall libcholmod.SuiteSparse_start()::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_start()::Cvoid
 end
 
 function SuiteSparse_finish()
-    @ccall libcholmod.SuiteSparse_finish()::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_finish()::Cvoid
 end
 
 function SuiteSparse_malloc(nitems, size_of_item)
-    @ccall libcholmod.SuiteSparse_malloc(nitems::Csize_t, size_of_item::Csize_t)::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_malloc(nitems::Csize_t,
+                                                   size_of_item::Csize_t)::Ptr{Cvoid}
 end
 
 function SuiteSparse_calloc(nitems, size_of_item)
-    @ccall libcholmod.SuiteSparse_calloc(nitems::Csize_t, size_of_item::Csize_t)::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_calloc(nitems::Csize_t,
+                                                   size_of_item::Csize_t)::Ptr{Cvoid}
 end
 
 function SuiteSparse_realloc(nitems_new, nitems_old, size_of_item, p, ok)
-    @ccall libcholmod.SuiteSparse_realloc(nitems_new::Csize_t, nitems_old::Csize_t, size_of_item::Csize_t, p::Ptr{Cvoid}, ok::Ptr{Cint})::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_realloc(nitems_new::Csize_t,
+                                                    nitems_old::Csize_t,
+                                                    size_of_item::Csize_t, p::Ptr{Cvoid},
+                                                    ok::Ptr{Cint})::Ptr{Cvoid}
 end
 
 function SuiteSparse_free(p)
-    @ccall libcholmod.SuiteSparse_free(p::Ptr{Cvoid})::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_free(p::Ptr{Cvoid})::Ptr{Cvoid}
 end
 
 function SuiteSparse_tic(tic)
-    @ccall libcholmod.SuiteSparse_tic(tic::Ptr{Cdouble})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_tic(tic::Ptr{Cdouble})::Cvoid
 end
 
 function SuiteSparse_toc(tic)
-    @ccall libcholmod.SuiteSparse_toc(tic::Ptr{Cdouble})::Cdouble
+    @ccall libsuitesparseconfig.SuiteSparse_toc(tic::Ptr{Cdouble})::Cdouble
 end
 
 function SuiteSparse_time()
-    @ccall libcholmod.SuiteSparse_time()::Cdouble
+    @ccall libsuitesparseconfig.SuiteSparse_time()::Cdouble
 end
 
 function SuiteSparse_hypot(x, y)
-    @ccall libcholmod.SuiteSparse_hypot(x::Cdouble, y::Cdouble)::Cdouble
+    @ccall libsuitesparseconfig.SuiteSparse_hypot(x::Cdouble, y::Cdouble)::Cdouble
 end
 
 function SuiteSparse_divcomplex(ar, ai, br, bi, cr, ci)
-    @ccall libcholmod.SuiteSparse_divcomplex(ar::Cdouble, ai::Cdouble, br::Cdouble, bi::Cdouble, cr::Ptr{Cdouble}, ci::Ptr{Cdouble})::Cint
+    @ccall libsuitesparseconfig.SuiteSparse_divcomplex(ar::Cdouble, ai::Cdouble,
+                                                       br::Cdouble, bi::Cdouble,
+                                                       cr::Ptr{Cdouble},
+                                                       ci::Ptr{Cdouble})::Cint
 end
 
 function SuiteSparse_version(version)
-    @ccall libcholmod.SuiteSparse_version(version::Ptr{Cint})::Cint
+    @ccall libsuitesparseconfig.SuiteSparse_version(version::Ptr{Cint})::Cint
 end
 
 function SuiteSparse_BLAS_library()
-    @ccall libcholmod.SuiteSparse_BLAS_library()::Ptr{Cchar}
+    @ccall libsuitesparseconfig.SuiteSparse_BLAS_library()::Ptr{Cchar}
 end
 
 function SuiteSparse_BLAS_integer_size()
-    @ccall libcholmod.SuiteSparse_BLAS_integer_size()::Csize_t
+    @ccall libsuitesparseconfig.SuiteSparse_BLAS_integer_size()::Csize_t
 end
 
 struct cholmod_method_struct
@@ -140,16 +153,16 @@ struct cholmod_method_struct
     prune_dense::Cdouble
     prune_dense2::Cdouble
     nd_oksep::Cdouble
-    other_1::NTuple{4, Cdouble}
+    other_1::NTuple{4,Cdouble}
     nd_small::Csize_t
-    other_2::NTuple{4, Csize_t}
+    other_2::NTuple{4,Csize_t}
     aggressive::Cint
     order_for_lu::Cint
     nd_compress::Cint
     nd_camd::Cint
     nd_components::Cint
     ordering::Cint
-    other_3::NTuple{4, Csize_t}
+    other_3::NTuple{4,Csize_t}
 end
 
 mutable struct cholmod_common_struct
@@ -166,8 +179,8 @@ mutable struct cholmod_common_struct
     final_pack::Cint
     final_monotonic::Cint
     final_resymbol::Cint
-    zrelax::NTuple{3, Cdouble}
-    nrelax::NTuple{3, Csize_t}
+    zrelax::NTuple{3,Cdouble}
+    nrelax::NTuple{3,Csize_t}
     prefer_zomplex::Cint
     prefer_upper::Cint
     quick_return_if_not_posdef::Cint
@@ -179,7 +192,7 @@ mutable struct cholmod_common_struct
     nmethods::Cint
     current::Cint
     selected::Cint
-    method::NTuple{10, cholmod_method_struct}
+    method::NTuple{10,cholmod_method_struct}
     postorder::Cint
     default_nesdis::Cint
     metis_memory::Cdouble
@@ -222,7 +235,7 @@ mutable struct cholmod_common_struct
     SPQR_flopcount_bound::Cdouble
     SPQR_tol_used::Cdouble
     SPQR_norm_E_fro::Cdouble
-    SPQR_istat::NTuple{10, Int64}
+    SPQR_istat::NTuple{10,Int64}
     useGPU::Cint
     maxGpuMemBytes::Csize_t
     maxGpuMemFraction::Cdouble
@@ -231,10 +244,10 @@ mutable struct cholmod_common_struct
     gpuFlops::Int64
     gpuNumKernelLaunches::Cint
     cublasHandle::Ptr{Cvoid}
-    gpuStream::NTuple{8, Ptr{Cvoid}}
-    cublasEventPotrf::NTuple{3, Ptr{Cvoid}}
+    gpuStream::NTuple{8,Ptr{Cvoid}}
+    cublasEventPotrf::NTuple{3,Ptr{Cvoid}}
     updateCKernelsComplete::Ptr{Cvoid}
-    updateCBuffersFree::NTuple{8, Ptr{Cvoid}}
+    updateCBuffersFree::NTuple{8,Ptr{Cvoid}}
     dev_mempool::Ptr{Cvoid}
     dev_mempool_size::Csize_t
     host_pinned_mempool::Ptr{Cvoid}
@@ -300,11 +313,14 @@ function cholmod_l_maxrank(arg1, arg2)
 end
 
 function cholmod_allocate_work(nrow, iworksize, xworksize, Common)
-    @ccall libcholmod.cholmod_allocate_work(nrow::Csize_t, iworksize::Csize_t, xworksize::Csize_t, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_allocate_work(nrow::Csize_t, iworksize::Csize_t,
+                                            xworksize::Csize_t,
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_allocate_work(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_allocate_work(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_allocate_work(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t,
+                                              arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_free_work(Common)
@@ -324,11 +340,13 @@ function cholmod_l_clear_flag(arg1)
 end
 
 function cholmod_error(status, file, line, message, Common)
-    @ccall libcholmod.cholmod_error(status::Cint, file::Ptr{Cchar}, line::Cint, message::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_error(status::Cint, file::Ptr{Cchar}, line::Cint,
+                                    message::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_error(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_error(arg1::Cint, arg2::Ptr{Cchar}, arg3::Cint, arg4::Ptr{Cchar}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_error(arg1::Cint, arg2::Ptr{Cchar}, arg3::Cint,
+                                      arg4::Ptr{Cchar}, arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_dbound(dj, Common)
@@ -348,11 +366,14 @@ function cholmod_l_hypot(arg1, arg2)
 end
 
 function cholmod_divcomplex(ar, ai, br, bi, cr, ci)
-    @ccall libcholmod.cholmod_divcomplex(ar::Cdouble, ai::Cdouble, br::Cdouble, bi::Cdouble, cr::Ptr{Cdouble}, ci::Ptr{Cdouble})::Cint
+    @ccall libcholmod.cholmod_divcomplex(ar::Cdouble, ai::Cdouble, br::Cdouble, bi::Cdouble,
+                                         cr::Ptr{Cdouble}, ci::Ptr{Cdouble})::Cint
 end
 
 function cholmod_l_divcomplex(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_divcomplex(arg1::Cdouble, arg2::Cdouble, arg3::Cdouble, arg4::Cdouble, arg5::Ptr{Cdouble}, arg6::Ptr{Cdouble})::Cint
+    @ccall libcholmod.cholmod_l_divcomplex(arg1::Cdouble, arg2::Cdouble, arg3::Cdouble,
+                                           arg4::Cdouble, arg5::Ptr{Cdouble},
+                                           arg6::Ptr{Cdouble})::Cint
 end
 
 mutable struct cholmod_sparse_struct
@@ -384,155 +405,217 @@ end
 const descendantScore = cholmod_descendant_score_t
 
 function cholmod_score_comp(i, j)
-    @ccall libcholmod.cholmod_score_comp(i::Ptr{cholmod_descendant_score_t}, j::Ptr{cholmod_descendant_score_t})::Cint
+    @ccall libcholmod.cholmod_score_comp(i::Ptr{cholmod_descendant_score_t},
+                                         j::Ptr{cholmod_descendant_score_t})::Cint
 end
 
 function cholmod_l_score_comp(i, j)
-    @ccall libcholmod.cholmod_l_score_comp(i::Ptr{cholmod_descendant_score_t}, j::Ptr{cholmod_descendant_score_t})::Cint
+    @ccall libcholmod.cholmod_l_score_comp(i::Ptr{cholmod_descendant_score_t},
+                                           j::Ptr{cholmod_descendant_score_t})::Cint
 end
 
 function cholmod_allocate_sparse(nrow, ncol, nzmax, sorted, packed, stype, xtype, Common)
-    @ccall libcholmod.cholmod_allocate_sparse(nrow::Csize_t, ncol::Csize_t, nzmax::Csize_t, sorted::Cint, packed::Cint, stype::Cint, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_allocate_sparse(nrow::Csize_t, ncol::Csize_t, nzmax::Csize_t,
+                                              sorted::Cint, packed::Cint, stype::Cint,
+                                              xtype::Cint,
+                                              Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_allocate_sparse(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
-    @ccall libcholmod.cholmod_l_allocate_sparse(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t, arg4::Cint, arg5::Cint, arg6::Cint, arg7::Cint, arg8::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_allocate_sparse(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t,
+                                                arg4::Cint, arg5::Cint, arg6::Cint,
+                                                arg7::Cint,
+                                                arg8::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_free_sparse(A, Common)
-    @ccall libcholmod.cholmod_free_sparse(A::Ptr{Ptr{cholmod_sparse}}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_free_sparse(A::Ptr{Ptr{cholmod_sparse}},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_free_sparse(arg1, arg2)
-    @ccall libcholmod.cholmod_l_free_sparse(arg1::Ptr{Ptr{cholmod_sparse}}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_free_sparse(arg1::Ptr{Ptr{cholmod_sparse}},
+                                            arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_reallocate_sparse(nznew, A, Common)
-    @ccall libcholmod.cholmod_reallocate_sparse(nznew::Csize_t, A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_reallocate_sparse(nznew::Csize_t, A::Ptr{cholmod_sparse},
+                                                Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_reallocate_sparse(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_reallocate_sparse(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_reallocate_sparse(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                                  arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_nnz(A, Common)
-    @ccall libcholmod.cholmod_nnz(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_nnz(A::Ptr{cholmod_sparse},
+                                  Common::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_l_nnz(arg1, arg2)
-    @ccall libcholmod.cholmod_l_nnz(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_l_nnz(arg1::Ptr{cholmod_sparse},
+                                    arg2::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_speye(nrow, ncol, xtype, Common)
-    @ccall libcholmod.cholmod_speye(nrow::Csize_t, ncol::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_speye(nrow::Csize_t, ncol::Csize_t, xtype::Cint,
+                                    Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_speye(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_speye(arg1::Csize_t, arg2::Csize_t, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_speye(arg1::Csize_t, arg2::Csize_t, arg3::Cint,
+                                      arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_spzeros(nrow, ncol, nzmax, xtype, Common)
-    @ccall libcholmod.cholmod_spzeros(nrow::Csize_t, ncol::Csize_t, nzmax::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_spzeros(nrow::Csize_t, ncol::Csize_t, nzmax::Csize_t,
+                                      xtype::Cint,
+                                      Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_spzeros(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_spzeros(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t, arg4::Cint, arg5::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_spzeros(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t,
+                                        arg4::Cint,
+                                        arg5::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_transpose(A, values, Common)
-    @ccall libcholmod.cholmod_transpose(A::Ptr{cholmod_sparse}, values::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_transpose(A::Ptr{cholmod_sparse}, values::Cint,
+                                        Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_transpose(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_transpose(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_transpose(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                          arg3::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_transpose_unsym(A, values, Perm, fset, fsize, F, Common)
-    @ccall libcholmod.cholmod_transpose_unsym(A::Ptr{cholmod_sparse}, values::Cint, Perm::Ptr{Int32}, fset::Ptr{Int32}, fsize::Csize_t, F::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_transpose_unsym(A::Ptr{cholmod_sparse}, values::Cint,
+                                              Perm::Ptr{Int32}, fset::Ptr{Int32},
+                                              fsize::Csize_t, F::Ptr{cholmod_sparse},
+                                              Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_transpose_unsym(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_transpose_unsym(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Csize_t, arg6::Ptr{cholmod_sparse}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_transpose_unsym(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                                arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                                arg5::Csize_t, arg6::Ptr{cholmod_sparse},
+                                                arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_transpose_sym(A, values, Perm, F, Common)
-    @ccall libcholmod.cholmod_transpose_sym(A::Ptr{cholmod_sparse}, values::Cint, Perm::Ptr{Int32}, F::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_transpose_sym(A::Ptr{cholmod_sparse}, values::Cint,
+                                            Perm::Ptr{Int32}, F::Ptr{cholmod_sparse},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_transpose_sym(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_transpose_sym(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{Int64}, arg4::Ptr{cholmod_sparse}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_transpose_sym(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                              arg3::Ptr{Int64}, arg4::Ptr{cholmod_sparse},
+                                              arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_ptranspose(A, values, Perm, fset, fsize, Common)
-    @ccall libcholmod.cholmod_ptranspose(A::Ptr{cholmod_sparse}, values::Cint, Perm::Ptr{Int32}, fset::Ptr{Int32}, fsize::Csize_t, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_ptranspose(A::Ptr{cholmod_sparse}, values::Cint,
+                                         Perm::Ptr{Int32}, fset::Ptr{Int32}, fsize::Csize_t,
+                                         Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_ptranspose(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_ptranspose(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Csize_t, arg6::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_ptranspose(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                           arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                           arg5::Csize_t,
+                                           arg6::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_sort(A, Common)
-    @ccall libcholmod.cholmod_sort(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_sort(A::Ptr{cholmod_sparse},
+                                   Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_sort(arg1, arg2)
-    @ccall libcholmod.cholmod_l_sort(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_sort(arg1::Ptr{cholmod_sparse},
+                                     arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_band(A, k1, k2, mode, Common)
-    @ccall libcholmod.cholmod_band(A::Ptr{cholmod_sparse}, k1::Int64, k2::Int64, mode::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_band(A::Ptr{cholmod_sparse}, k1::Int64, k2::Int64, mode::Cint,
+                                   Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_band(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_band(arg1::Ptr{cholmod_sparse}, arg2::Int64, arg3::Int64, arg4::Cint, arg5::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_band(arg1::Ptr{cholmod_sparse}, arg2::Int64, arg3::Int64,
+                                     arg4::Cint,
+                                     arg5::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_band_inplace(k1, k2, mode, A, Common)
-    @ccall libcholmod.cholmod_band_inplace(k1::Int64, k2::Int64, mode::Cint, A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_band_inplace(k1::Int64, k2::Int64, mode::Cint,
+                                           A::Ptr{cholmod_sparse},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_band_inplace(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_band_inplace(arg1::Int64, arg2::Int64, arg3::Cint, arg4::Ptr{cholmod_sparse}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_band_inplace(arg1::Int64, arg2::Int64, arg3::Cint,
+                                             arg4::Ptr{cholmod_sparse},
+                                             arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_aat(A, fset, fsize, mode, Common)
-    @ccall libcholmod.cholmod_aat(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, mode::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_aat(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t,
+                                  mode::Cint,
+                                  Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_aat(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_aat(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Cint, arg5::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_aat(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                    arg3::Csize_t, arg4::Cint,
+                                    arg5::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_copy_sparse(A, Common)
-    @ccall libcholmod.cholmod_copy_sparse(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_copy_sparse(A::Ptr{cholmod_sparse},
+                                          Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_copy_sparse(arg1, arg2)
-    @ccall libcholmod.cholmod_l_copy_sparse(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_copy_sparse(arg1::Ptr{cholmod_sparse},
+                                            arg2::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_copy(A, stype, mode, Common)
-    @ccall libcholmod.cholmod_copy(A::Ptr{cholmod_sparse}, stype::Cint, mode::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_copy(A::Ptr{cholmod_sparse}, stype::Cint, mode::Cint,
+                                   Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_copy(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_copy(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_copy(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Cint,
+                                     arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_add(A, B, alpha, beta, values, sorted, Common)
-    @ccall libcholmod.cholmod_add(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse}, alpha::Ptr{Cdouble}, beta::Ptr{Cdouble}, values::Cint, sorted::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_add(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse},
+                                  alpha::Ptr{Cdouble}, beta::Ptr{Cdouble}, values::Cint,
+                                  sorted::Cint,
+                                  Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_add(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_add(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Ptr{Cdouble}, arg5::Cint, arg6::Cint, arg7::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_add(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse},
+                                    arg3::Ptr{Cdouble}, arg4::Ptr{Cdouble}, arg5::Cint,
+                                    arg6::Cint,
+                                    arg7::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_sparse_xtype(to_xtype, A, Common)
-    @ccall libcholmod.cholmod_sparse_xtype(to_xtype::Cint, A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_sparse_xtype(to_xtype::Cint, A::Ptr{cholmod_sparse},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_sparse_xtype(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_sparse_xtype(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_sparse_xtype(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                             arg3::Ptr{cholmod_common})::Cint
 end
 
 mutable struct cholmod_factor_struct
@@ -572,75 +655,100 @@ end
 const cholmod_factor = cholmod_factor_struct
 
 function cholmod_allocate_factor(n, Common)
-    @ccall libcholmod.cholmod_allocate_factor(n::Csize_t, Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_allocate_factor(n::Csize_t,
+                                              Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_l_allocate_factor(arg1, arg2)
-    @ccall libcholmod.cholmod_l_allocate_factor(arg1::Csize_t, arg2::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_l_allocate_factor(arg1::Csize_t,
+                                                arg2::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_free_factor(L, Common)
-    @ccall libcholmod.cholmod_free_factor(L::Ptr{Ptr{cholmod_factor}}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_free_factor(L::Ptr{Ptr{cholmod_factor}},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_free_factor(arg1, arg2)
-    @ccall libcholmod.cholmod_l_free_factor(arg1::Ptr{Ptr{cholmod_factor}}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_free_factor(arg1::Ptr{Ptr{cholmod_factor}},
+                                            arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_reallocate_factor(nznew, L, Common)
-    @ccall libcholmod.cholmod_reallocate_factor(nznew::Csize_t, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_reallocate_factor(nznew::Csize_t, L::Ptr{cholmod_factor},
+                                                Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_reallocate_factor(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_reallocate_factor(arg1::Csize_t, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_reallocate_factor(arg1::Csize_t, arg2::Ptr{cholmod_factor},
+                                                  arg3::Ptr{cholmod_common})::Cint
 end
 
-function cholmod_change_factor(to_xtype, to_ll, to_super, to_packed, to_monotonic, L, Common)
-    @ccall libcholmod.cholmod_change_factor(to_xtype::Cint, to_ll::Cint, to_super::Cint, to_packed::Cint, to_monotonic::Cint, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+function cholmod_change_factor(to_xtype, to_ll, to_super, to_packed, to_monotonic, L,
+                               Common)
+    @ccall libcholmod.cholmod_change_factor(to_xtype::Cint, to_ll::Cint, to_super::Cint,
+                                            to_packed::Cint, to_monotonic::Cint,
+                                            L::Ptr{cholmod_factor},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_change_factor(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_change_factor(arg1::Cint, arg2::Cint, arg3::Cint, arg4::Cint, arg5::Cint, arg6::Ptr{cholmod_factor}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_change_factor(arg1::Cint, arg2::Cint, arg3::Cint,
+                                              arg4::Cint, arg5::Cint,
+                                              arg6::Ptr{cholmod_factor},
+                                              arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_pack_factor(L, Common)
-    @ccall libcholmod.cholmod_pack_factor(L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_pack_factor(L::Ptr{cholmod_factor},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_pack_factor(arg1, arg2)
-    @ccall libcholmod.cholmod_l_pack_factor(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_pack_factor(arg1::Ptr{cholmod_factor},
+                                            arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_reallocate_column(j, need, L, Common)
-    @ccall libcholmod.cholmod_reallocate_column(j::Csize_t, need::Csize_t, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_reallocate_column(j::Csize_t, need::Csize_t,
+                                                L::Ptr{cholmod_factor},
+                                                Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_reallocate_column(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_reallocate_column(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{cholmod_factor}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_reallocate_column(arg1::Csize_t, arg2::Csize_t,
+                                                  arg3::Ptr{cholmod_factor},
+                                                  arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_factor_to_sparse(L, Common)
-    @ccall libcholmod.cholmod_factor_to_sparse(L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_factor_to_sparse(L::Ptr{cholmod_factor},
+                                               Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_factor_to_sparse(arg1, arg2)
-    @ccall libcholmod.cholmod_l_factor_to_sparse(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_factor_to_sparse(arg1::Ptr{cholmod_factor},
+                                                 arg2::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_copy_factor(L, Common)
-    @ccall libcholmod.cholmod_copy_factor(L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_copy_factor(L::Ptr{cholmod_factor},
+                                          Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_l_copy_factor(arg1, arg2)
-    @ccall libcholmod.cholmod_l_copy_factor(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_l_copy_factor(arg1::Ptr{cholmod_factor},
+                                            arg2::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_factor_xtype(to_xtype, L, Common)
-    @ccall libcholmod.cholmod_factor_xtype(to_xtype::Cint, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_factor_xtype(to_xtype::Cint, L::Ptr{cholmod_factor},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_factor_xtype(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_factor_xtype(arg1::Cint, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_factor_xtype(arg1::Cint, arg2::Ptr{cholmod_factor},
+                                             arg3::Ptr{cholmod_common})::Cint
 end
 
 mutable struct cholmod_dense_struct
@@ -658,91 +766,118 @@ end
 const cholmod_dense = cholmod_dense_struct
 
 function cholmod_allocate_dense(nrow, ncol, d, xtype, Common)
-    @ccall libcholmod.cholmod_allocate_dense(nrow::Csize_t, ncol::Csize_t, d::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_allocate_dense(nrow::Csize_t, ncol::Csize_t, d::Csize_t,
+                                             xtype::Cint,
+                                             Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_allocate_dense(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_allocate_dense(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t, arg4::Cint, arg5::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_allocate_dense(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t,
+                                               arg4::Cint,
+                                               arg5::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_zeros(nrow, ncol, xtype, Common)
-    @ccall libcholmod.cholmod_zeros(nrow::Csize_t, ncol::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_zeros(nrow::Csize_t, ncol::Csize_t, xtype::Cint,
+                                    Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_zeros(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_zeros(arg1::Csize_t, arg2::Csize_t, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_zeros(arg1::Csize_t, arg2::Csize_t, arg3::Cint,
+                                      arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_ones(nrow, ncol, xtype, Common)
-    @ccall libcholmod.cholmod_ones(nrow::Csize_t, ncol::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_ones(nrow::Csize_t, ncol::Csize_t, xtype::Cint,
+                                   Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_ones(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_ones(arg1::Csize_t, arg2::Csize_t, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_ones(arg1::Csize_t, arg2::Csize_t, arg3::Cint,
+                                     arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_eye(nrow, ncol, xtype, Common)
-    @ccall libcholmod.cholmod_eye(nrow::Csize_t, ncol::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_eye(nrow::Csize_t, ncol::Csize_t, xtype::Cint,
+                                  Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_eye(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_eye(arg1::Csize_t, arg2::Csize_t, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_eye(arg1::Csize_t, arg2::Csize_t, arg3::Cint,
+                                    arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_free_dense(X, Common)
-    @ccall libcholmod.cholmod_free_dense(X::Ptr{Ptr{cholmod_dense}}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_free_dense(X::Ptr{Ptr{cholmod_dense}},
+                                         Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_free_dense(arg1, arg2)
-    @ccall libcholmod.cholmod_l_free_dense(arg1::Ptr{Ptr{cholmod_dense}}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_free_dense(arg1::Ptr{Ptr{cholmod_dense}},
+                                           arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_ensure_dense(XHandle, nrow, ncol, d, xtype, Common)
-    @ccall libcholmod.cholmod_ensure_dense(XHandle::Ptr{Ptr{cholmod_dense}}, nrow::Csize_t, ncol::Csize_t, d::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_ensure_dense(XHandle::Ptr{Ptr{cholmod_dense}}, nrow::Csize_t,
+                                           ncol::Csize_t, d::Csize_t, xtype::Cint,
+                                           Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_ensure_dense(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_ensure_dense(arg1::Ptr{Ptr{cholmod_dense}}, arg2::Csize_t, arg3::Csize_t, arg4::Csize_t, arg5::Cint, arg6::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_ensure_dense(arg1::Ptr{Ptr{cholmod_dense}}, arg2::Csize_t,
+                                             arg3::Csize_t, arg4::Csize_t, arg5::Cint,
+                                             arg6::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_sparse_to_dense(A, Common)
-    @ccall libcholmod.cholmod_sparse_to_dense(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_sparse_to_dense(A::Ptr{cholmod_sparse},
+                                              Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_sparse_to_dense(arg1, arg2)
-    @ccall libcholmod.cholmod_l_sparse_to_dense(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_sparse_to_dense(arg1::Ptr{cholmod_sparse},
+                                                arg2::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_dense_to_sparse(X, values, Common)
-    @ccall libcholmod.cholmod_dense_to_sparse(X::Ptr{cholmod_dense}, values::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_dense_to_sparse(X::Ptr{cholmod_dense}, values::Cint,
+                                              Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_dense_to_sparse(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_dense_to_sparse(arg1::Ptr{cholmod_dense}, arg2::Cint, arg3::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_dense_to_sparse(arg1::Ptr{cholmod_dense}, arg2::Cint,
+                                                arg3::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_copy_dense(X, Common)
-    @ccall libcholmod.cholmod_copy_dense(X::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_copy_dense(X::Ptr{cholmod_dense},
+                                         Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_copy_dense(arg1, arg2)
-    @ccall libcholmod.cholmod_l_copy_dense(arg1::Ptr{cholmod_dense}, arg2::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_copy_dense(arg1::Ptr{cholmod_dense},
+                                           arg2::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_copy_dense2(X, Y, Common)
-    @ccall libcholmod.cholmod_copy_dense2(X::Ptr{cholmod_dense}, Y::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_copy_dense2(X::Ptr{cholmod_dense}, Y::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_copy_dense2(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_copy_dense2(arg1::Ptr{cholmod_dense}, arg2::Ptr{cholmod_dense}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_copy_dense2(arg1::Ptr{cholmod_dense},
+                                            arg2::Ptr{cholmod_dense},
+                                            arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_dense_xtype(to_xtype, X, Common)
-    @ccall libcholmod.cholmod_dense_xtype(to_xtype::Cint, X::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_dense_xtype(to_xtype::Cint, X::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_dense_xtype(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_dense_xtype(arg1::Cint, arg2::Ptr{cholmod_dense}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_dense_xtype(arg1::Cint, arg2::Ptr{cholmod_dense},
+                                            arg3::Ptr{cholmod_common})::Cint
 end
 
 mutable struct cholmod_triplet_struct
@@ -764,99 +899,137 @@ end
 const cholmod_triplet = cholmod_triplet_struct
 
 function cholmod_allocate_triplet(nrow, ncol, nzmax, stype, xtype, Common)
-    @ccall libcholmod.cholmod_allocate_triplet(nrow::Csize_t, ncol::Csize_t, nzmax::Csize_t, stype::Cint, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_allocate_triplet(nrow::Csize_t, ncol::Csize_t, nzmax::Csize_t,
+                                               stype::Cint, xtype::Cint,
+                                               Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_l_allocate_triplet(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_allocate_triplet(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t, arg4::Cint, arg5::Cint, arg6::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_l_allocate_triplet(arg1::Csize_t, arg2::Csize_t,
+                                                 arg3::Csize_t, arg4::Cint, arg5::Cint,
+                                                 arg6::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_free_triplet(T, Common)
-    @ccall libcholmod.cholmod_free_triplet(T::Ptr{Ptr{cholmod_triplet}}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_free_triplet(T::Ptr{Ptr{cholmod_triplet}},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_free_triplet(arg1, arg2)
-    @ccall libcholmod.cholmod_l_free_triplet(arg1::Ptr{Ptr{cholmod_triplet}}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_free_triplet(arg1::Ptr{Ptr{cholmod_triplet}},
+                                             arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_reallocate_triplet(nznew, T, Common)
-    @ccall libcholmod.cholmod_reallocate_triplet(nznew::Csize_t, T::Ptr{cholmod_triplet}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_reallocate_triplet(nznew::Csize_t, T::Ptr{cholmod_triplet},
+                                                 Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_reallocate_triplet(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_reallocate_triplet(arg1::Csize_t, arg2::Ptr{cholmod_triplet}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_reallocate_triplet(arg1::Csize_t,
+                                                   arg2::Ptr{cholmod_triplet},
+                                                   arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_sparse_to_triplet(A, Common)
-    @ccall libcholmod.cholmod_sparse_to_triplet(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_sparse_to_triplet(A::Ptr{cholmod_sparse},
+                                                Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_l_sparse_to_triplet(arg1, arg2)
-    @ccall libcholmod.cholmod_l_sparse_to_triplet(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_l_sparse_to_triplet(arg1::Ptr{cholmod_sparse},
+                                                  arg2::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_triplet_to_sparse(T, nzmax, Common)
-    @ccall libcholmod.cholmod_triplet_to_sparse(T::Ptr{cholmod_triplet}, nzmax::Csize_t, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_triplet_to_sparse(T::Ptr{cholmod_triplet}, nzmax::Csize_t,
+                                                Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_triplet_to_sparse(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_triplet_to_sparse(arg1::Ptr{cholmod_triplet}, arg2::Csize_t, arg3::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_triplet_to_sparse(arg1::Ptr{cholmod_triplet}, arg2::Csize_t,
+                                                  arg3::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_copy_triplet(T, Common)
-    @ccall libcholmod.cholmod_copy_triplet(T::Ptr{cholmod_triplet}, Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_copy_triplet(T::Ptr{cholmod_triplet},
+                                           Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_l_copy_triplet(arg1, arg2)
-    @ccall libcholmod.cholmod_l_copy_triplet(arg1::Ptr{cholmod_triplet}, arg2::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_l_copy_triplet(arg1::Ptr{cholmod_triplet},
+                                             arg2::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_triplet_xtype(to_xtype, T, Common)
-    @ccall libcholmod.cholmod_triplet_xtype(to_xtype::Cint, T::Ptr{cholmod_triplet}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_triplet_xtype(to_xtype::Cint, T::Ptr{cholmod_triplet},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_triplet_xtype(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_triplet_xtype(arg1::Cint, arg2::Ptr{cholmod_triplet}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_triplet_xtype(arg1::Cint, arg2::Ptr{cholmod_triplet},
+                                              arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_malloc(n, size, Common)
-    @ccall libcholmod.cholmod_malloc(n::Csize_t, size::Csize_t, Common::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_malloc(n::Csize_t, size::Csize_t,
+                                     Common::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_l_malloc(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_malloc(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_l_malloc(arg1::Csize_t, arg2::Csize_t,
+                                       arg3::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_calloc(n, size, Common)
-    @ccall libcholmod.cholmod_calloc(n::Csize_t, size::Csize_t, Common::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_calloc(n::Csize_t, size::Csize_t,
+                                     Common::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_l_calloc(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_calloc(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_l_calloc(arg1::Csize_t, arg2::Csize_t,
+                                       arg3::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_free(n, size, p, Common)
-    @ccall libcholmod.cholmod_free(n::Csize_t, size::Csize_t, p::Ptr{Cvoid}, Common::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_free(n::Csize_t, size::Csize_t, p::Ptr{Cvoid},
+                                   Common::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_l_free(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_free(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{Cvoid}, arg4::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_l_free(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{Cvoid},
+                                     arg4::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_realloc(nnew, size, p, n, Common)
-    @ccall libcholmod.cholmod_realloc(nnew::Csize_t, size::Csize_t, p::Ptr{Cvoid}, n::Ptr{Csize_t}, Common::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_realloc(nnew::Csize_t, size::Csize_t, p::Ptr{Cvoid},
+                                      n::Ptr{Csize_t},
+                                      Common::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_l_realloc(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_realloc(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{Cvoid}, arg4::Ptr{Csize_t}, arg5::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_l_realloc(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{Cvoid},
+                                        arg4::Ptr{Csize_t},
+                                        arg5::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
-function cholmod_realloc_multiple(nnew, nint, xtype, Iblock, Jblock, Xblock, Zblock, n, Common)
-    @ccall libcholmod.cholmod_realloc_multiple(nnew::Csize_t, nint::Cint, xtype::Cint, Iblock::Ptr{Ptr{Cvoid}}, Jblock::Ptr{Ptr{Cvoid}}, Xblock::Ptr{Ptr{Cvoid}}, Zblock::Ptr{Ptr{Cvoid}}, n::Ptr{Csize_t}, Common::Ptr{cholmod_common})::Cint
+function cholmod_realloc_multiple(nnew, nint, xtype, Iblock, Jblock, Xblock, Zblock, n,
+                                  Common)
+    @ccall libcholmod.cholmod_realloc_multiple(nnew::Csize_t, nint::Cint, xtype::Cint,
+                                               Iblock::Ptr{Ptr{Cvoid}},
+                                               Jblock::Ptr{Ptr{Cvoid}},
+                                               Xblock::Ptr{Ptr{Cvoid}},
+                                               Zblock::Ptr{Ptr{Cvoid}}, n::Ptr{Csize_t},
+                                               Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_realloc_multiple(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
-    @ccall libcholmod.cholmod_l_realloc_multiple(arg1::Csize_t, arg2::Cint, arg3::Cint, arg4::Ptr{Ptr{Cvoid}}, arg5::Ptr{Ptr{Cvoid}}, arg6::Ptr{Ptr{Cvoid}}, arg7::Ptr{Ptr{Cvoid}}, arg8::Ptr{Csize_t}, arg9::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_realloc_multiple(arg1::Csize_t, arg2::Cint, arg3::Cint,
+                                                 arg4::Ptr{Ptr{Cvoid}},
+                                                 arg5::Ptr{Ptr{Cvoid}},
+                                                 arg6::Ptr{Ptr{Cvoid}},
+                                                 arg7::Ptr{Ptr{Cvoid}}, arg8::Ptr{Csize_t},
+                                                 arg9::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_version(version)
@@ -876,11 +1049,13 @@ function cholmod_l_check_common(arg1)
 end
 
 function cholmod_print_common(name, Common)
-    @ccall libcholmod.cholmod_print_common(name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_common(name::Ptr{Cchar},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_common(arg1, arg2)
-    @ccall libcholmod.cholmod_l_print_common(arg1::Ptr{Cchar}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_common(arg1::Ptr{Cchar},
+                                             arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_gpu_stats(arg1)
@@ -892,643 +1067,1047 @@ function cholmod_l_gpu_stats(arg1)
 end
 
 function cholmod_check_sparse(A, Common)
-    @ccall libcholmod.cholmod_check_sparse(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_sparse(A::Ptr{cholmod_sparse},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_sparse(arg1, arg2)
-    @ccall libcholmod.cholmod_l_check_sparse(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_sparse(arg1::Ptr{cholmod_sparse},
+                                             arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_sparse(A, name, Common)
-    @ccall libcholmod.cholmod_print_sparse(A::Ptr{cholmod_sparse}, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_sparse(A::Ptr{cholmod_sparse}, name::Ptr{Cchar},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_sparse(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_print_sparse(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Cchar}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_sparse(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Cchar},
+                                             arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_check_dense(X, Common)
-    @ccall libcholmod.cholmod_check_dense(X::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_dense(X::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_dense(arg1, arg2)
-    @ccall libcholmod.cholmod_l_check_dense(arg1::Ptr{cholmod_dense}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_dense(arg1::Ptr{cholmod_dense},
+                                            arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_dense(X, name, Common)
-    @ccall libcholmod.cholmod_print_dense(X::Ptr{cholmod_dense}, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_dense(X::Ptr{cholmod_dense}, name::Ptr{Cchar},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_dense(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_print_dense(arg1::Ptr{cholmod_dense}, arg2::Ptr{Cchar}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_dense(arg1::Ptr{cholmod_dense}, arg2::Ptr{Cchar},
+                                            arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_check_factor(L, Common)
-    @ccall libcholmod.cholmod_check_factor(L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_factor(L::Ptr{cholmod_factor},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_factor(arg1, arg2)
-    @ccall libcholmod.cholmod_l_check_factor(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_factor(arg1::Ptr{cholmod_factor},
+                                             arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_factor(L, name, Common)
-    @ccall libcholmod.cholmod_print_factor(L::Ptr{cholmod_factor}, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_factor(L::Ptr{cholmod_factor}, name::Ptr{Cchar},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_factor(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_print_factor(arg1::Ptr{cholmod_factor}, arg2::Ptr{Cchar}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_factor(arg1::Ptr{cholmod_factor}, arg2::Ptr{Cchar},
+                                             arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_check_triplet(T, Common)
-    @ccall libcholmod.cholmod_check_triplet(T::Ptr{cholmod_triplet}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_triplet(T::Ptr{cholmod_triplet},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_triplet(arg1, arg2)
-    @ccall libcholmod.cholmod_l_check_triplet(arg1::Ptr{cholmod_triplet}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_triplet(arg1::Ptr{cholmod_triplet},
+                                              arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_triplet(T, name, Common)
-    @ccall libcholmod.cholmod_print_triplet(T::Ptr{cholmod_triplet}, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_triplet(T::Ptr{cholmod_triplet}, name::Ptr{Cchar},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_triplet(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_print_triplet(arg1::Ptr{cholmod_triplet}, arg2::Ptr{Cchar}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_triplet(arg1::Ptr{cholmod_triplet}, arg2::Ptr{Cchar},
+                                              arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_check_subset(Set, len, n, Common)
-    @ccall libcholmod.cholmod_check_subset(Set::Ptr{Int32}, len::Int64, n::Csize_t, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_subset(Set::Ptr{Int32}, len::Int64, n::Csize_t,
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_subset(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_check_subset(arg1::Ptr{Int64}, arg2::Int64, arg3::Csize_t, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_subset(arg1::Ptr{Int64}, arg2::Int64, arg3::Csize_t,
+                                             arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_subset(Set, len, n, name, Common)
-    @ccall libcholmod.cholmod_print_subset(Set::Ptr{Int32}, len::Int64, n::Csize_t, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_subset(Set::Ptr{Int32}, len::Int64, n::Csize_t,
+                                           name::Ptr{Cchar},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_subset(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_print_subset(arg1::Ptr{Int64}, arg2::Int64, arg3::Csize_t, arg4::Ptr{Cchar}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_subset(arg1::Ptr{Int64}, arg2::Int64, arg3::Csize_t,
+                                             arg4::Ptr{Cchar},
+                                             arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_check_perm(Perm, len, n, Common)
-    @ccall libcholmod.cholmod_check_perm(Perm::Ptr{Int32}, len::Csize_t, n::Csize_t, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_perm(Perm::Ptr{Int32}, len::Csize_t, n::Csize_t,
+                                         Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_perm(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_check_perm(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Csize_t, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_perm(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Csize_t,
+                                           arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_perm(Perm, len, n, name, Common)
-    @ccall libcholmod.cholmod_print_perm(Perm::Ptr{Int32}, len::Csize_t, n::Csize_t, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_perm(Perm::Ptr{Int32}, len::Csize_t, n::Csize_t,
+                                         name::Ptr{Cchar},
+                                         Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_perm(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_print_perm(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Csize_t, arg4::Ptr{Cchar}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_perm(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Csize_t,
+                                           arg4::Ptr{Cchar},
+                                           arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_check_parent(Parent, n, Common)
-    @ccall libcholmod.cholmod_check_parent(Parent::Ptr{Int32}, n::Csize_t, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_parent(Parent::Ptr{Int32}, n::Csize_t,
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_parent(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_check_parent(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_parent(arg1::Ptr{Int64}, arg2::Csize_t,
+                                             arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_parent(Parent, n, name, Common)
-    @ccall libcholmod.cholmod_print_parent(Parent::Ptr{Int32}, n::Csize_t, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_parent(Parent::Ptr{Int32}, n::Csize_t, name::Ptr{Cchar},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_parent(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_print_parent(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Ptr{Cchar}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_parent(arg1::Ptr{Int64}, arg2::Csize_t,
+                                             arg3::Ptr{Cchar},
+                                             arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_read_sparse(f, Common)
-    @ccall libcholmod.cholmod_read_sparse(f::Ptr{Libc.FILE}, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_read_sparse(f::Ptr{Libc.FILE},
+                                          Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_read_sparse(arg1, arg2)
-    @ccall libcholmod.cholmod_l_read_sparse(arg1::Ptr{Libc.FILE}, arg2::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_read_sparse(arg1::Ptr{Libc.FILE},
+                                            arg2::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_read_triplet(f, Common)
-    @ccall libcholmod.cholmod_read_triplet(f::Ptr{Libc.FILE}, Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_read_triplet(f::Ptr{Libc.FILE},
+                                           Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_l_read_triplet(arg1, arg2)
-    @ccall libcholmod.cholmod_l_read_triplet(arg1::Ptr{Libc.FILE}, arg2::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_l_read_triplet(arg1::Ptr{Libc.FILE},
+                                             arg2::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_read_dense(f, Common)
-    @ccall libcholmod.cholmod_read_dense(f::Ptr{Libc.FILE}, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_read_dense(f::Ptr{Libc.FILE},
+                                         Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_read_dense(arg1, arg2)
-    @ccall libcholmod.cholmod_l_read_dense(arg1::Ptr{Libc.FILE}, arg2::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_read_dense(arg1::Ptr{Libc.FILE},
+                                           arg2::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_read_matrix(f, prefer, mtype, Common)
-    @ccall libcholmod.cholmod_read_matrix(f::Ptr{Libc.FILE}, prefer::Cint, mtype::Ptr{Cint}, Common::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_read_matrix(f::Ptr{Libc.FILE}, prefer::Cint, mtype::Ptr{Cint},
+                                          Common::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_l_read_matrix(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_read_matrix(arg1::Ptr{Libc.FILE}, arg2::Cint, arg3::Ptr{Cint}, arg4::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_l_read_matrix(arg1::Ptr{Libc.FILE}, arg2::Cint,
+                                            arg3::Ptr{Cint},
+                                            arg4::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_write_sparse(f, A, Z, comments, Common)
-    @ccall libcholmod.cholmod_write_sparse(f::Ptr{Libc.FILE}, A::Ptr{cholmod_sparse}, Z::Ptr{cholmod_sparse}, comments::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_write_sparse(f::Ptr{Libc.FILE}, A::Ptr{cholmod_sparse},
+                                           Z::Ptr{cholmod_sparse}, comments::Ptr{Cchar},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_write_sparse(arg1, arg2, arg3, c, arg5)
-    @ccall libcholmod.cholmod_l_write_sparse(arg1::Ptr{Libc.FILE}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_sparse}, c::Ptr{Cchar}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_write_sparse(arg1::Ptr{Libc.FILE},
+                                             arg2::Ptr{cholmod_sparse},
+                                             arg3::Ptr{cholmod_sparse}, c::Ptr{Cchar},
+                                             arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_write_dense(f, X, comments, Common)
-    @ccall libcholmod.cholmod_write_dense(f::Ptr{Libc.FILE}, X::Ptr{cholmod_dense}, comments::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_write_dense(f::Ptr{Libc.FILE}, X::Ptr{cholmod_dense},
+                                          comments::Ptr{Cchar},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_write_dense(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_write_dense(arg1::Ptr{Libc.FILE}, arg2::Ptr{cholmod_dense}, arg3::Ptr{Cchar}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_write_dense(arg1::Ptr{Libc.FILE}, arg2::Ptr{cholmod_dense},
+                                            arg3::Ptr{Cchar},
+                                            arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_analyze(A, Common)
-    @ccall libcholmod.cholmod_analyze(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_analyze(A::Ptr{cholmod_sparse},
+                                      Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_l_analyze(arg1, arg2)
-    @ccall libcholmod.cholmod_l_analyze(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_l_analyze(arg1::Ptr{cholmod_sparse},
+                                        arg2::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_analyze_p(A, UserPerm, fset, fsize, Common)
-    @ccall libcholmod.cholmod_analyze_p(A::Ptr{cholmod_sparse}, UserPerm::Ptr{Int32}, fset::Ptr{Int32}, fsize::Csize_t, Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_analyze_p(A::Ptr{cholmod_sparse}, UserPerm::Ptr{Int32},
+                                        fset::Ptr{Int32}, fsize::Csize_t,
+                                        Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_l_analyze_p(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_analyze_p(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Ptr{Int64}, arg4::Csize_t, arg5::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_l_analyze_p(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                          arg3::Ptr{Int64}, arg4::Csize_t,
+                                          arg5::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_analyze_p2(for_whom, A, UserPerm, fset, fsize, Common)
-    @ccall libcholmod.cholmod_analyze_p2(for_whom::Cint, A::Ptr{cholmod_sparse}, UserPerm::Ptr{Int32}, fset::Ptr{Int32}, fsize::Csize_t, Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_analyze_p2(for_whom::Cint, A::Ptr{cholmod_sparse},
+                                         UserPerm::Ptr{Int32}, fset::Ptr{Int32},
+                                         fsize::Csize_t,
+                                         Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_l_analyze_p2(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_analyze_p2(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Csize_t, arg6::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_l_analyze_p2(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                           arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                           arg5::Csize_t,
+                                           arg6::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_factorize(A, L, Common)
-    @ccall libcholmod.cholmod_factorize(A::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_factorize(A::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor},
+                                        Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_factorize(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_factorize(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_factorize(arg1::Ptr{cholmod_sparse},
+                                          arg2::Ptr{cholmod_factor},
+                                          arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_factorize_p(A, beta, fset, fsize, L, Common)
-    @ccall libcholmod.cholmod_factorize_p(A::Ptr{cholmod_sparse}, beta::Ptr{Cdouble}, fset::Ptr{Int32}, fsize::Csize_t, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_factorize_p(A::Ptr{cholmod_sparse}, beta::Ptr{Cdouble},
+                                          fset::Ptr{Int32}, fsize::Csize_t,
+                                          L::Ptr{cholmod_factor},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_factorize_p(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_factorize_p(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Cdouble}, arg3::Ptr{Int64}, arg4::Csize_t, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_factorize_p(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Cdouble},
+                                            arg3::Ptr{Int64}, arg4::Csize_t,
+                                            arg5::Ptr{cholmod_factor},
+                                            arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_solve(sys, L, B, Common)
-    @ccall libcholmod.cholmod_solve(sys::Cint, L::Ptr{cholmod_factor}, B::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_solve(sys::Cint, L::Ptr{cholmod_factor},
+                                    B::Ptr{cholmod_dense},
+                                    Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_solve(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_solve(arg1::Cint, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_dense}, arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_solve(arg1::Cint, arg2::Ptr{cholmod_factor},
+                                      arg3::Ptr{cholmod_dense},
+                                      arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_solve2(sys, L, B, Bset, X_Handle, Xset_Handle, Y_Handle, E_Handle, Common)
-    @ccall libcholmod.cholmod_solve2(sys::Cint, L::Ptr{cholmod_factor}, B::Ptr{cholmod_dense}, Bset::Ptr{cholmod_sparse}, X_Handle::Ptr{Ptr{cholmod_dense}}, Xset_Handle::Ptr{Ptr{cholmod_sparse}}, Y_Handle::Ptr{Ptr{cholmod_dense}}, E_Handle::Ptr{Ptr{cholmod_dense}}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_solve2(sys::Cint, L::Ptr{cholmod_factor},
+                                     B::Ptr{cholmod_dense}, Bset::Ptr{cholmod_sparse},
+                                     X_Handle::Ptr{Ptr{cholmod_dense}},
+                                     Xset_Handle::Ptr{Ptr{cholmod_sparse}},
+                                     Y_Handle::Ptr{Ptr{cholmod_dense}},
+                                     E_Handle::Ptr{Ptr{cholmod_dense}},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_solve2(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
-    @ccall libcholmod.cholmod_l_solve2(arg1::Cint, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_dense}, arg4::Ptr{cholmod_sparse}, arg5::Ptr{Ptr{cholmod_dense}}, arg6::Ptr{Ptr{cholmod_sparse}}, arg7::Ptr{Ptr{cholmod_dense}}, arg8::Ptr{Ptr{cholmod_dense}}, arg9::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_solve2(arg1::Cint, arg2::Ptr{cholmod_factor},
+                                       arg3::Ptr{cholmod_dense}, arg4::Ptr{cholmod_sparse},
+                                       arg5::Ptr{Ptr{cholmod_dense}},
+                                       arg6::Ptr{Ptr{cholmod_sparse}},
+                                       arg7::Ptr{Ptr{cholmod_dense}},
+                                       arg8::Ptr{Ptr{cholmod_dense}},
+                                       arg9::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_spsolve(sys, L, B, Common)
-    @ccall libcholmod.cholmod_spsolve(sys::Cint, L::Ptr{cholmod_factor}, B::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_spsolve(sys::Cint, L::Ptr{cholmod_factor},
+                                      B::Ptr{cholmod_sparse},
+                                      Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_spsolve(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_spsolve(arg1::Cint, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_sparse}, arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_spsolve(arg1::Cint, arg2::Ptr{cholmod_factor},
+                                        arg3::Ptr{cholmod_sparse},
+                                        arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_etree(A, Parent, Common)
-    @ccall libcholmod.cholmod_etree(A::Ptr{cholmod_sparse}, Parent::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_etree(A::Ptr{cholmod_sparse}, Parent::Ptr{Int32},
+                                    Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_etree(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_etree(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_etree(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                      arg3::Ptr{cholmod_common})::Cint
 end
 
-function cholmod_rowcolcounts(A, fset, fsize, Parent, Post, RowCount, ColCount, First, Level, Common)
-    @ccall libcholmod.cholmod_rowcolcounts(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, Parent::Ptr{Int32}, Post::Ptr{Int32}, RowCount::Ptr{Int32}, ColCount::Ptr{Int32}, First::Ptr{Int32}, Level::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+function cholmod_rowcolcounts(A, fset, fsize, Parent, Post, RowCount, ColCount, First,
+                              Level, Common)
+    @ccall libcholmod.cholmod_rowcolcounts(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                           fsize::Csize_t, Parent::Ptr{Int32},
+                                           Post::Ptr{Int32}, RowCount::Ptr{Int32},
+                                           ColCount::Ptr{Int32}, First::Ptr{Int32},
+                                           Level::Ptr{Int32},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowcolcounts(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)
-    @ccall libcholmod.cholmod_l_rowcolcounts(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{Int64}, arg6::Ptr{Int64}, arg7::Ptr{Int64}, arg8::Ptr{Int64}, arg9::Ptr{Int64}, arg10::Ptr{cholmod_common})::Cint
-end
-
-function cholmod_analyze_ordering(A, ordering, Perm, fset, fsize, Parent, Post, ColCount, First, Level, Common)
-    @ccall libcholmod.cholmod_analyze_ordering(A::Ptr{cholmod_sparse}, ordering::Cint, Perm::Ptr{Int32}, fset::Ptr{Int32}, fsize::Csize_t, Parent::Ptr{Int32}, Post::Ptr{Int32}, ColCount::Ptr{Int32}, First::Ptr{Int32}, Level::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
-end
-
-function cholmod_l_analyze_ordering(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11)
-    @ccall libcholmod.cholmod_l_analyze_ordering(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Csize_t, arg6::Ptr{Int64}, arg7::Ptr{Int64}, arg8::Ptr{Int64}, arg9::Ptr{Int64}, arg10::Ptr{Int64}, arg11::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowcolcounts(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                             arg3::Csize_t, arg4::Ptr{Int64},
+                                             arg5::Ptr{Int64}, arg6::Ptr{Int64},
+                                             arg7::Ptr{Int64}, arg8::Ptr{Int64},
+                                             arg9::Ptr{Int64},
+                                             arg10::Ptr{cholmod_common})::Cint
+end
+
+function cholmod_analyze_ordering(A, ordering, Perm, fset, fsize, Parent, Post, ColCount,
+                                  First, Level, Common)
+    @ccall libcholmod.cholmod_analyze_ordering(A::Ptr{cholmod_sparse}, ordering::Cint,
+                                               Perm::Ptr{Int32}, fset::Ptr{Int32},
+                                               fsize::Csize_t, Parent::Ptr{Int32},
+                                               Post::Ptr{Int32}, ColCount::Ptr{Int32},
+                                               First::Ptr{Int32}, Level::Ptr{Int32},
+                                               Common::Ptr{cholmod_common})::Cint
+end
+
+function cholmod_l_analyze_ordering(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9,
+                                    arg10, arg11)
+    @ccall libcholmod.cholmod_l_analyze_ordering(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                                 arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                                 arg5::Csize_t, arg6::Ptr{Int64},
+                                                 arg7::Ptr{Int64}, arg8::Ptr{Int64},
+                                                 arg9::Ptr{Int64}, arg10::Ptr{Int64},
+                                                 arg11::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_amd(A, fset, fsize, Perm, Common)
-    @ccall libcholmod.cholmod_amd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_amd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t,
+                                  Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_amd(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_amd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_amd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                    arg3::Csize_t, arg4::Ptr{Int64},
+                                    arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_colamd(A, fset, fsize, postorder, Perm, Common)
-    @ccall libcholmod.cholmod_colamd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, postorder::Cint, Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_colamd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                     fsize::Csize_t, postorder::Cint, Perm::Ptr{Int32},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_colamd(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_colamd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Cint, arg5::Ptr{Int64}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_colamd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                       arg3::Csize_t, arg4::Cint, arg5::Ptr{Int64},
+                                       arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowfac(A, F, beta, kstart, kend, L, Common)
-    @ccall libcholmod.cholmod_rowfac(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, beta::Ptr{Cdouble}, kstart::Csize_t, kend::Csize_t, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowfac(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse},
+                                     beta::Ptr{Cdouble}, kstart::Csize_t, kend::Csize_t,
+                                     L::Ptr{cholmod_factor},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowfac(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_rowfac(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Csize_t, arg5::Csize_t, arg6::Ptr{cholmod_factor}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowfac(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse},
+                                       arg3::Ptr{Cdouble}, arg4::Csize_t, arg5::Csize_t,
+                                       arg6::Ptr{cholmod_factor},
+                                       arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowfac_mask(A, F, beta, kstart, kend, mask, RLinkUp, L, Common)
-    @ccall libcholmod.cholmod_rowfac_mask(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, beta::Ptr{Cdouble}, kstart::Csize_t, kend::Csize_t, mask::Ptr{Int32}, RLinkUp::Ptr{Int32}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowfac_mask(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse},
+                                          beta::Ptr{Cdouble}, kstart::Csize_t,
+                                          kend::Csize_t, mask::Ptr{Int32},
+                                          RLinkUp::Ptr{Int32}, L::Ptr{cholmod_factor},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowfac_mask(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
-    @ccall libcholmod.cholmod_l_rowfac_mask(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Csize_t, arg5::Csize_t, arg6::Ptr{Int64}, arg7::Ptr{Int64}, arg8::Ptr{cholmod_factor}, arg9::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowfac_mask(arg1::Ptr{cholmod_sparse},
+                                            arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble},
+                                            arg4::Csize_t, arg5::Csize_t, arg6::Ptr{Int64},
+                                            arg7::Ptr{Int64}, arg8::Ptr{cholmod_factor},
+                                            arg9::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowfac_mask2(A, F, beta, kstart, kend, mask, maskmark, RLinkUp, L, Common)
-    @ccall libcholmod.cholmod_rowfac_mask2(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, beta::Ptr{Cdouble}, kstart::Csize_t, kend::Csize_t, mask::Ptr{Int32}, maskmark::Int32, RLinkUp::Ptr{Int32}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowfac_mask2(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse},
+                                           beta::Ptr{Cdouble}, kstart::Csize_t,
+                                           kend::Csize_t, mask::Ptr{Int32}, maskmark::Int32,
+                                           RLinkUp::Ptr{Int32}, L::Ptr{cholmod_factor},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowfac_mask2(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)
-    @ccall libcholmod.cholmod_l_rowfac_mask2(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Csize_t, arg5::Csize_t, arg6::Ptr{Int64}, arg7::Int64, arg8::Ptr{Int64}, arg9::Ptr{cholmod_factor}, arg10::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowfac_mask2(arg1::Ptr{cholmod_sparse},
+                                             arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble},
+                                             arg4::Csize_t, arg5::Csize_t, arg6::Ptr{Int64},
+                                             arg7::Int64, arg8::Ptr{Int64},
+                                             arg9::Ptr{cholmod_factor},
+                                             arg10::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_row_subtree(A, F, k, Parent, R, Common)
-    @ccall libcholmod.cholmod_row_subtree(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, k::Csize_t, Parent::Ptr{Int32}, R::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_row_subtree(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse},
+                                          k::Csize_t, Parent::Ptr{Int32},
+                                          R::Ptr{cholmod_sparse},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_row_subtree(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_row_subtree(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{cholmod_sparse}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_row_subtree(arg1::Ptr{cholmod_sparse},
+                                            arg2::Ptr{cholmod_sparse}, arg3::Csize_t,
+                                            arg4::Ptr{Int64}, arg5::Ptr{cholmod_sparse},
+                                            arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_lsolve_pattern(B, L, X, Common)
-    @ccall libcholmod.cholmod_lsolve_pattern(B::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_lsolve_pattern(B::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor},
+                                             X::Ptr{cholmod_sparse},
+                                             Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_lsolve_pattern(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_lsolve_pattern(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_sparse}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_lsolve_pattern(arg1::Ptr{cholmod_sparse},
+                                               arg2::Ptr{cholmod_factor},
+                                               arg3::Ptr{cholmod_sparse},
+                                               arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_row_lsubtree(A, Fi, fnz, k, L, R, Common)
-    @ccall libcholmod.cholmod_row_lsubtree(A::Ptr{cholmod_sparse}, Fi::Ptr{Int32}, fnz::Csize_t, k::Csize_t, L::Ptr{cholmod_factor}, R::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_row_lsubtree(A::Ptr{cholmod_sparse}, Fi::Ptr{Int32},
+                                           fnz::Csize_t, k::Csize_t, L::Ptr{cholmod_factor},
+                                           R::Ptr{cholmod_sparse},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_row_lsubtree(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_row_lsubtree(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Csize_t, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_sparse}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_row_lsubtree(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                             arg3::Csize_t, arg4::Csize_t,
+                                             arg5::Ptr{cholmod_factor},
+                                             arg6::Ptr{cholmod_sparse},
+                                             arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_resymbol(A, fset, fsize, pack, L, Common)
-    @ccall libcholmod.cholmod_resymbol(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, pack::Cint, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_resymbol(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                       fsize::Csize_t, pack::Cint, L::Ptr{cholmod_factor},
+                                       Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_resymbol(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_resymbol(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Cint, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_resymbol(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                         arg3::Csize_t, arg4::Cint,
+                                         arg5::Ptr{cholmod_factor},
+                                         arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_resymbol_noperm(A, fset, fsize, pack, L, Common)
-    @ccall libcholmod.cholmod_resymbol_noperm(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, pack::Cint, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_resymbol_noperm(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                              fsize::Csize_t, pack::Cint,
+                                              L::Ptr{cholmod_factor},
+                                              Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_resymbol_noperm(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_resymbol_noperm(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Cint, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_resymbol_noperm(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                                arg3::Csize_t, arg4::Cint,
+                                                arg5::Ptr{cholmod_factor},
+                                                arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rcond(L, Common)
-    @ccall libcholmod.cholmod_rcond(L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cdouble
+    @ccall libcholmod.cholmod_rcond(L::Ptr{cholmod_factor},
+                                    Common::Ptr{cholmod_common})::Cdouble
 end
 
 function cholmod_l_rcond(arg1, arg2)
-    @ccall libcholmod.cholmod_l_rcond(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_common})::Cdouble
+    @ccall libcholmod.cholmod_l_rcond(arg1::Ptr{cholmod_factor},
+                                      arg2::Ptr{cholmod_common})::Cdouble
 end
 
 function cholmod_postorder(Parent, n, Weight_p, Post, Common)
-    @ccall libcholmod.cholmod_postorder(Parent::Ptr{Int32}, n::Csize_t, Weight_p::Ptr{Int32}, Post::Ptr{Int32}, Common::Ptr{cholmod_common})::Int32
+    @ccall libcholmod.cholmod_postorder(Parent::Ptr{Int32}, n::Csize_t,
+                                        Weight_p::Ptr{Int32}, Post::Ptr{Int32},
+                                        Common::Ptr{cholmod_common})::Int32
 end
 
 function cholmod_l_postorder(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_postorder(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_l_postorder(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Ptr{Int64},
+                                          arg4::Ptr{Int64},
+                                          arg5::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_drop(tol, A, Common)
-    @ccall libcholmod.cholmod_drop(tol::Cdouble, A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_drop(tol::Cdouble, A::Ptr{cholmod_sparse},
+                                   Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_drop(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_drop(arg1::Cdouble, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_drop(arg1::Cdouble, arg2::Ptr{cholmod_sparse},
+                                     arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_norm_dense(X, norm, Common)
-    @ccall libcholmod.cholmod_norm_dense(X::Ptr{cholmod_dense}, norm::Cint, Common::Ptr{cholmod_common})::Cdouble
+    @ccall libcholmod.cholmod_norm_dense(X::Ptr{cholmod_dense}, norm::Cint,
+                                         Common::Ptr{cholmod_common})::Cdouble
 end
 
 function cholmod_l_norm_dense(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_norm_dense(arg1::Ptr{cholmod_dense}, arg2::Cint, arg3::Ptr{cholmod_common})::Cdouble
+    @ccall libcholmod.cholmod_l_norm_dense(arg1::Ptr{cholmod_dense}, arg2::Cint,
+                                           arg3::Ptr{cholmod_common})::Cdouble
 end
 
 function cholmod_norm_sparse(A, norm, Common)
-    @ccall libcholmod.cholmod_norm_sparse(A::Ptr{cholmod_sparse}, norm::Cint, Common::Ptr{cholmod_common})::Cdouble
+    @ccall libcholmod.cholmod_norm_sparse(A::Ptr{cholmod_sparse}, norm::Cint,
+                                          Common::Ptr{cholmod_common})::Cdouble
 end
 
 function cholmod_l_norm_sparse(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_norm_sparse(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{cholmod_common})::Cdouble
+    @ccall libcholmod.cholmod_l_norm_sparse(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                            arg3::Ptr{cholmod_common})::Cdouble
 end
 
 function cholmod_horzcat(A, B, values, Common)
-    @ccall libcholmod.cholmod_horzcat(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse}, values::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_horzcat(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse},
+                                      values::Cint,
+                                      Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_horzcat(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_horzcat(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_horzcat(arg1::Ptr{cholmod_sparse},
+                                        arg2::Ptr{cholmod_sparse}, arg3::Cint,
+                                        arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_scale(S, scale, A, Common)
-    @ccall libcholmod.cholmod_scale(S::Ptr{cholmod_dense}, scale::Cint, A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_scale(S::Ptr{cholmod_dense}, scale::Cint,
+                                    A::Ptr{cholmod_sparse},
+                                    Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_scale(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_scale(arg1::Ptr{cholmod_dense}, arg2::Cint, arg3::Ptr{cholmod_sparse}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_scale(arg1::Ptr{cholmod_dense}, arg2::Cint,
+                                      arg3::Ptr{cholmod_sparse},
+                                      arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_sdmult(A, transpose, alpha, beta, X, Y, Common)
-    @ccall libcholmod.cholmod_sdmult(A::Ptr{cholmod_sparse}, transpose::Cint, alpha::Ptr{Cdouble}, beta::Ptr{Cdouble}, X::Ptr{cholmod_dense}, Y::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_sdmult(A::Ptr{cholmod_sparse}, transpose::Cint,
+                                     alpha::Ptr{Cdouble}, beta::Ptr{Cdouble},
+                                     X::Ptr{cholmod_dense}, Y::Ptr{cholmod_dense},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_sdmult(arg1, arg2, arg3, arg4, arg5, Y, arg7)
-    @ccall libcholmod.cholmod_l_sdmult(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{Cdouble}, arg4::Ptr{Cdouble}, arg5::Ptr{cholmod_dense}, Y::Ptr{cholmod_dense}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_sdmult(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                       arg3::Ptr{Cdouble}, arg4::Ptr{Cdouble},
+                                       arg5::Ptr{cholmod_dense}, Y::Ptr{cholmod_dense},
+                                       arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_ssmult(A, B, stype, values, sorted, Common)
-    @ccall libcholmod.cholmod_ssmult(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse}, stype::Cint, values::Cint, sorted::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_ssmult(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse},
+                                     stype::Cint, values::Cint, sorted::Cint,
+                                     Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_ssmult(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_ssmult(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Cint, arg4::Cint, arg5::Cint, arg6::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_ssmult(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse},
+                                       arg3::Cint, arg4::Cint, arg5::Cint,
+                                       arg6::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_submatrix(A, rset, rsize, cset, csize, values, sorted, Common)
-    @ccall libcholmod.cholmod_submatrix(A::Ptr{cholmod_sparse}, rset::Ptr{Int32}, rsize::Int64, cset::Ptr{Int32}, csize::Int64, values::Cint, sorted::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_submatrix(A::Ptr{cholmod_sparse}, rset::Ptr{Int32},
+                                        rsize::Int64, cset::Ptr{Int32}, csize::Int64,
+                                        values::Cint, sorted::Cint,
+                                        Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_submatrix(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
-    @ccall libcholmod.cholmod_l_submatrix(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Int64, arg4::Ptr{Int64}, arg5::Int64, arg6::Cint, arg7::Cint, arg8::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_submatrix(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                          arg3::Int64, arg4::Ptr{Int64}, arg5::Int64,
+                                          arg6::Cint, arg7::Cint,
+                                          arg8::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_vertcat(A, B, values, Common)
-    @ccall libcholmod.cholmod_vertcat(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse}, values::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_vertcat(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse},
+                                      values::Cint,
+                                      Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_vertcat(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_vertcat(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_vertcat(arg1::Ptr{cholmod_sparse},
+                                        arg2::Ptr{cholmod_sparse}, arg3::Cint,
+                                        arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_symmetry(A, option, xmatched, pmatched, nzoffdiag, nzdiag, Common)
-    @ccall libcholmod.cholmod_symmetry(A::Ptr{cholmod_sparse}, option::Cint, xmatched::Ptr{Int32}, pmatched::Ptr{Int32}, nzoffdiag::Ptr{Int32}, nzdiag::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_symmetry(A::Ptr{cholmod_sparse}, option::Cint,
+                                       xmatched::Ptr{Int32}, pmatched::Ptr{Int32},
+                                       nzoffdiag::Ptr{Int32}, nzdiag::Ptr{Int32},
+                                       Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_symmetry(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_symmetry(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Ptr{Int64}, arg6::Ptr{Int64}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_symmetry(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                         arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                         arg5::Ptr{Int64}, arg6::Ptr{Int64},
+                                         arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_updown(update, C, L, Common)
-    @ccall libcholmod.cholmod_updown(update::Cint, C::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_updown(update::Cint, C::Ptr{cholmod_sparse},
+                                     L::Ptr{cholmod_factor},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_updown(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_updown(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_factor}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_updown(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                       arg3::Ptr{cholmod_factor},
+                                       arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_updown_solve(update, C, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_updown_solve(update::Cint, C::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_updown_solve(update::Cint, C::Ptr{cholmod_sparse},
+                                           L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense},
+                                           DeltaB::Ptr{cholmod_dense},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_updown_solve(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_updown_solve(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_factor}, arg4::Ptr{cholmod_dense}, arg5::Ptr{cholmod_dense}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_updown_solve(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                             arg3::Ptr{cholmod_factor},
+                                             arg4::Ptr{cholmod_dense},
+                                             arg5::Ptr{cholmod_dense},
+                                             arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_updown_mark(update, C, colmark, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_updown_mark(update::Cint, C::Ptr{cholmod_sparse}, colmark::Ptr{Int32}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_updown_mark(update::Cint, C::Ptr{cholmod_sparse},
+                                          colmark::Ptr{Int32}, L::Ptr{cholmod_factor},
+                                          X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_updown_mark(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_updown_mark(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Int64}, arg4::Ptr{cholmod_factor}, arg5::Ptr{cholmod_dense}, arg6::Ptr{cholmod_dense}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_updown_mark(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                            arg3::Ptr{Int64}, arg4::Ptr{cholmod_factor},
+                                            arg5::Ptr{cholmod_dense},
+                                            arg6::Ptr{cholmod_dense},
+                                            arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_updown_mask(update, C, colmark, mask, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_updown_mask(update::Cint, C::Ptr{cholmod_sparse}, colmark::Ptr{Int32}, mask::Ptr{Int32}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_updown_mask(update::Cint, C::Ptr{cholmod_sparse},
+                                          colmark::Ptr{Int32}, mask::Ptr{Int32},
+                                          L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense},
+                                          DeltaB::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_updown_mask(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
-    @ccall libcholmod.cholmod_l_updown_mask(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_dense}, arg7::Ptr{cholmod_dense}, arg8::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_updown_mask(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                            arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                            arg5::Ptr{cholmod_factor},
+                                            arg6::Ptr{cholmod_dense},
+                                            arg7::Ptr{cholmod_dense},
+                                            arg8::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_updown_mask2(update, C, colmark, mask, maskmark, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_updown_mask2(update::Cint, C::Ptr{cholmod_sparse}, colmark::Ptr{Int32}, mask::Ptr{Int32}, maskmark::Int32, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_updown_mask2(update::Cint, C::Ptr{cholmod_sparse},
+                                           colmark::Ptr{Int32}, mask::Ptr{Int32},
+                                           maskmark::Int32, L::Ptr{cholmod_factor},
+                                           X::Ptr{cholmod_dense},
+                                           DeltaB::Ptr{cholmod_dense},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_updown_mask2(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
-    @ccall libcholmod.cholmod_l_updown_mask2(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Int64, arg6::Ptr{cholmod_factor}, arg7::Ptr{cholmod_dense}, arg8::Ptr{cholmod_dense}, arg9::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_updown_mask2(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                             arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                             arg5::Int64, arg6::Ptr{cholmod_factor},
+                                             arg7::Ptr{cholmod_dense},
+                                             arg8::Ptr{cholmod_dense},
+                                             arg9::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowadd(k, R, L, Common)
-    @ccall libcholmod.cholmod_rowadd(k::Csize_t, R::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowadd(k::Csize_t, R::Ptr{cholmod_sparse},
+                                     L::Ptr{cholmod_factor},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowadd(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_rowadd(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_factor}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowadd(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                       arg3::Ptr{cholmod_factor},
+                                       arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowadd_solve(k, R, bk, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_rowadd_solve(k::Csize_t, R::Ptr{cholmod_sparse}, bk::Ptr{Cdouble}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowadd_solve(k::Csize_t, R::Ptr{cholmod_sparse},
+                                           bk::Ptr{Cdouble}, L::Ptr{cholmod_factor},
+                                           X::Ptr{cholmod_dense},
+                                           DeltaB::Ptr{cholmod_dense},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowadd_solve(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_rowadd_solve(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Ptr{cholmod_factor}, arg5::Ptr{cholmod_dense}, arg6::Ptr{cholmod_dense}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowadd_solve(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                             arg3::Ptr{Cdouble}, arg4::Ptr{cholmod_factor},
+                                             arg5::Ptr{cholmod_dense},
+                                             arg6::Ptr{cholmod_dense},
+                                             arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowadd_mark(k, R, bk, colmark, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_rowadd_mark(k::Csize_t, R::Ptr{cholmod_sparse}, bk::Ptr{Cdouble}, colmark::Ptr{Int32}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowadd_mark(k::Csize_t, R::Ptr{cholmod_sparse},
+                                          bk::Ptr{Cdouble}, colmark::Ptr{Int32},
+                                          L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense},
+                                          DeltaB::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowadd_mark(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
-    @ccall libcholmod.cholmod_l_rowadd_mark(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Ptr{Int64}, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_dense}, arg7::Ptr{cholmod_dense}, arg8::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowadd_mark(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                            arg3::Ptr{Cdouble}, arg4::Ptr{Int64},
+                                            arg5::Ptr{cholmod_factor},
+                                            arg6::Ptr{cholmod_dense},
+                                            arg7::Ptr{cholmod_dense},
+                                            arg8::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowdel(k, R, L, Common)
-    @ccall libcholmod.cholmod_rowdel(k::Csize_t, R::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowdel(k::Csize_t, R::Ptr{cholmod_sparse},
+                                     L::Ptr{cholmod_factor},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowdel(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_rowdel(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_factor}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowdel(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                       arg3::Ptr{cholmod_factor},
+                                       arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowdel_solve(k, R, yk, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_rowdel_solve(k::Csize_t, R::Ptr{cholmod_sparse}, yk::Ptr{Cdouble}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowdel_solve(k::Csize_t, R::Ptr{cholmod_sparse},
+                                           yk::Ptr{Cdouble}, L::Ptr{cholmod_factor},
+                                           X::Ptr{cholmod_dense},
+                                           DeltaB::Ptr{cholmod_dense},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowdel_solve(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_rowdel_solve(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Ptr{cholmod_factor}, arg5::Ptr{cholmod_dense}, arg6::Ptr{cholmod_dense}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowdel_solve(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                             arg3::Ptr{Cdouble}, arg4::Ptr{cholmod_factor},
+                                             arg5::Ptr{cholmod_dense},
+                                             arg6::Ptr{cholmod_dense},
+                                             arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowdel_mark(k, R, yk, colmark, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_rowdel_mark(k::Csize_t, R::Ptr{cholmod_sparse}, yk::Ptr{Cdouble}, colmark::Ptr{Int32}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowdel_mark(k::Csize_t, R::Ptr{cholmod_sparse},
+                                          yk::Ptr{Cdouble}, colmark::Ptr{Int32},
+                                          L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense},
+                                          DeltaB::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowdel_mark(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
-    @ccall libcholmod.cholmod_l_rowdel_mark(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Ptr{Int64}, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_dense}, arg7::Ptr{cholmod_dense}, arg8::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowdel_mark(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                            arg3::Ptr{Cdouble}, arg4::Ptr{Int64},
+                                            arg5::Ptr{cholmod_factor},
+                                            arg6::Ptr{cholmod_dense},
+                                            arg7::Ptr{cholmod_dense},
+                                            arg8::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_ccolamd(A, fset, fsize, Cmember, Perm, Common)
-    @ccall libcholmod.cholmod_ccolamd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, Cmember::Ptr{Int32}, Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_ccolamd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                      fsize::Csize_t, Cmember::Ptr{Int32}, Perm::Ptr{Int32},
+                                      Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_ccolamd(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_ccolamd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{Int64}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_ccolamd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                        arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{Int64},
+                                        arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_csymamd(A, Cmember, Perm, Common)
-    @ccall libcholmod.cholmod_csymamd(A::Ptr{cholmod_sparse}, Cmember::Ptr{Int32}, Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_csymamd(A::Ptr{cholmod_sparse}, Cmember::Ptr{Int32},
+                                      Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_csymamd(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_csymamd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Ptr{Int64}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_csymamd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                        arg3::Ptr{Int64}, arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_camd(A, fset, fsize, Cmember, Perm, Common)
-    @ccall libcholmod.cholmod_camd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, Cmember::Ptr{Int32}, Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_camd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t,
+                                   Cmember::Ptr{Int32}, Perm::Ptr{Int32},
+                                   Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_camd(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_camd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{Int64}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_camd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                     arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{Int64},
+                                     arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_nested_dissection(A, fset, fsize, Perm, CParent, Cmember, Common)
-    @ccall libcholmod.cholmod_nested_dissection(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, Perm::Ptr{Int32}, CParent::Ptr{Int32}, Cmember::Ptr{Int32}, Common::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_nested_dissection(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                                fsize::Csize_t, Perm::Ptr{Int32},
+                                                CParent::Ptr{Int32}, Cmember::Ptr{Int32},
+                                                Common::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_l_nested_dissection(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_nested_dissection(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{Int64}, arg6::Ptr{Int64}, arg7::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_l_nested_dissection(arg1::Ptr{cholmod_sparse},
+                                                  arg2::Ptr{Int64}, arg3::Csize_t,
+                                                  arg4::Ptr{Int64}, arg5::Ptr{Int64},
+                                                  arg6::Ptr{Int64},
+                                                  arg7::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_metis(A, fset, fsize, postorder, Perm, Common)
-    @ccall libcholmod.cholmod_metis(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, postorder::Cint, Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_metis(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                    fsize::Csize_t, postorder::Cint, Perm::Ptr{Int32},
+                                    Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_metis(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_metis(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Cint, arg5::Ptr{Int64}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_metis(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                      arg3::Csize_t, arg4::Cint, arg5::Ptr{Int64},
+                                      arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_bisect(A, fset, fsize, compress, Partition, Common)
-    @ccall libcholmod.cholmod_bisect(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, compress::Cint, Partition::Ptr{Int32}, Common::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_bisect(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                     fsize::Csize_t, compress::Cint, Partition::Ptr{Int32},
+                                     Common::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_l_bisect(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_bisect(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Cint, arg5::Ptr{Int64}, arg6::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_l_bisect(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                       arg3::Csize_t, arg4::Cint, arg5::Ptr{Int64},
+                                       arg6::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_metis_bisector(A, Anw, Aew, Partition, Common)
-    @ccall libcholmod.cholmod_metis_bisector(A::Ptr{cholmod_sparse}, Anw::Ptr{Int32}, Aew::Ptr{Int32}, Partition::Ptr{Int32}, Common::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_metis_bisector(A::Ptr{cholmod_sparse}, Anw::Ptr{Int32},
+                                             Aew::Ptr{Int32}, Partition::Ptr{Int32},
+                                             Common::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_l_metis_bisector(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_metis_bisector(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_l_metis_bisector(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                               arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                               arg5::Ptr{cholmod_common})::Int64
 end
 
-function cholmod_collapse_septree(n, ncomponents, nd_oksep, nd_small, CParent, Cmember, Common)
-    @ccall libcholmod.cholmod_collapse_septree(n::Csize_t, ncomponents::Csize_t, nd_oksep::Cdouble, nd_small::Csize_t, CParent::Ptr{Int32}, Cmember::Ptr{Int32}, Common::Ptr{cholmod_common})::Int64
+function cholmod_collapse_septree(n, ncomponents, nd_oksep, nd_small, CParent, Cmember,
+                                  Common)
+    @ccall libcholmod.cholmod_collapse_septree(n::Csize_t, ncomponents::Csize_t,
+                                               nd_oksep::Cdouble, nd_small::Csize_t,
+                                               CParent::Ptr{Int32}, Cmember::Ptr{Int32},
+                                               Common::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_l_collapse_septree(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_collapse_septree(arg1::Csize_t, arg2::Csize_t, arg3::Cdouble, arg4::Csize_t, arg5::Ptr{Int64}, arg6::Ptr{Int64}, arg7::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_l_collapse_septree(arg1::Csize_t, arg2::Csize_t,
+                                                 arg3::Cdouble, arg4::Csize_t,
+                                                 arg5::Ptr{Int64}, arg6::Ptr{Int64},
+                                                 arg7::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_super_symbolic(A, F, Parent, L, Common)
-    @ccall libcholmod.cholmod_super_symbolic(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, Parent::Ptr{Int32}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_super_symbolic(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse},
+                                             Parent::Ptr{Int32}, L::Ptr{cholmod_factor},
+                                             Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_super_symbolic(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_super_symbolic(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Int64}, arg4::Ptr{cholmod_factor}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_super_symbolic(arg1::Ptr{cholmod_sparse},
+                                               arg2::Ptr{cholmod_sparse}, arg3::Ptr{Int64},
+                                               arg4::Ptr{cholmod_factor},
+                                               arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_super_symbolic2(for_whom, A, F, Parent, L, Common)
-    @ccall libcholmod.cholmod_super_symbolic2(for_whom::Cint, A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, Parent::Ptr{Int32}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_super_symbolic2(for_whom::Cint, A::Ptr{cholmod_sparse},
+                                              F::Ptr{cholmod_sparse}, Parent::Ptr{Int32},
+                                              L::Ptr{cholmod_factor},
+                                              Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_super_symbolic2(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_super_symbolic2(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_sparse}, arg4::Ptr{Int64}, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_super_symbolic2(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                                arg3::Ptr{cholmod_sparse}, arg4::Ptr{Int64},
+                                                arg5::Ptr{cholmod_factor},
+                                                arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_super_numeric(A, F, beta, L, Common)
-    @ccall libcholmod.cholmod_super_numeric(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, beta::Ptr{Cdouble}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_super_numeric(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse},
+                                            beta::Ptr{Cdouble}, L::Ptr{cholmod_factor},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_super_numeric(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_super_numeric(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Ptr{cholmod_factor}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_super_numeric(arg1::Ptr{cholmod_sparse},
+                                              arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble},
+                                              arg4::Ptr{cholmod_factor},
+                                              arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_super_lsolve(L, X, E, Common)
-    @ccall libcholmod.cholmod_super_lsolve(L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, E::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_super_lsolve(L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense},
+                                           E::Ptr{cholmod_dense},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_super_lsolve(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_super_lsolve(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_dense}, arg3::Ptr{cholmod_dense}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_super_lsolve(arg1::Ptr{cholmod_factor},
+                                             arg2::Ptr{cholmod_dense},
+                                             arg3::Ptr{cholmod_dense},
+                                             arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_super_ltsolve(L, X, E, Common)
-    @ccall libcholmod.cholmod_super_ltsolve(L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, E::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_super_ltsolve(L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense},
+                                            E::Ptr{cholmod_dense},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_super_ltsolve(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_super_ltsolve(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_dense}, arg3::Ptr{cholmod_dense}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_super_ltsolve(arg1::Ptr{cholmod_factor},
+                                              arg2::Ptr{cholmod_dense},
+                                              arg3::Ptr{cholmod_dense},
+                                              arg4::Ptr{cholmod_common})::Cint
+end
+
+function SuiteSparseQR_C(ordering, tol, econ, getCTX, A, Bsparse, Bdense, Zsparse, Zdense,
+                         R, E, H, HPinv, HTau, cc)
+    @ccall libspqr.SuiteSparseQR_C(ordering::Cint, tol::Cdouble, econ::Int64, getCTX::Cint,
+                                   A::Ptr{cholmod_sparse}, Bsparse::Ptr{cholmod_sparse},
+                                   Bdense::Ptr{cholmod_dense},
+                                   Zsparse::Ptr{Ptr{cholmod_sparse}},
+                                   Zdense::Ptr{Ptr{cholmod_dense}},
+                                   R::Ptr{Ptr{cholmod_sparse}}, E::Ptr{Ptr{Int64}},
+                                   H::Ptr{Ptr{cholmod_sparse}}, HPinv::Ptr{Ptr{Int64}},
+                                   HTau::Ptr{Ptr{cholmod_dense}},
+                                   cc::Ptr{cholmod_common})::Int64
+end
+
+function SuiteSparseQR_i_C(ordering, tol, econ, getCTX, A, Bsparse, Bdense, Zsparse, Zdense,
+                           R, E, H, HPinv, HTau, cc)
+    @ccall libspqr.SuiteSparseQR_i_C(ordering::Cint, tol::Cdouble, econ::Int32,
+                                     getCTX::Cint, A::Ptr{cholmod_sparse},
+                                     Bsparse::Ptr{cholmod_sparse},
+                                     Bdense::Ptr{cholmod_dense},
+                                     Zsparse::Ptr{Ptr{cholmod_sparse}},
+                                     Zdense::Ptr{Ptr{cholmod_dense}},
+                                     R::Ptr{Ptr{cholmod_sparse}}, E::Ptr{Ptr{Int32}},
+                                     H::Ptr{Ptr{cholmod_sparse}}, HPinv::Ptr{Ptr{Int32}},
+                                     HTau::Ptr{Ptr{cholmod_dense}},
+                                     cc::Ptr{cholmod_common})::Int32
 end
 
-function SuiteSparseQR_C(ordering, tol, econ, getCTX, A, Bsparse, Bdense, Zsparse, Zdense, R, E, H, HPinv, HTau, cc)
-    @ccall libspqr.SuiteSparseQR_C(ordering::Cint, tol::Cdouble, econ::Int64, getCTX::Cint, A::Ptr{cholmod_sparse}, Bsparse::Ptr{cholmod_sparse}, Bdense::Ptr{cholmod_dense}, Zsparse::Ptr{Ptr{cholmod_sparse}}, Zdense::Ptr{Ptr{cholmod_dense}}, R::Ptr{Ptr{cholmod_sparse}}, E::Ptr{Ptr{Int64}}, H::Ptr{Ptr{cholmod_sparse}}, HPinv::Ptr{Ptr{Int64}}, HTau::Ptr{Ptr{cholmod_dense}}, cc::Ptr{cholmod_common})::Int64
+function SuiteSparseQR_C_QR(ordering, tol, econ, A, Q, R, E, cc)
+    @ccall libspqr.SuiteSparseQR_C_QR(ordering::Cint, tol::Cdouble, econ::Int64,
+                                      A::Ptr{cholmod_sparse}, Q::Ptr{Ptr{cholmod_sparse}},
+                                      R::Ptr{Ptr{cholmod_sparse}}, E::Ptr{Ptr{Int64}},
+                                      cc::Ptr{cholmod_common})::Int64
 end
 
-function SuiteSparseQR_C_QR(ordering, tol, econ, A, Q, R, E, cc)
-    @ccall libspqr.SuiteSparseQR_C_QR(ordering::Cint, tol::Cdouble, econ::Int64, A::Ptr{cholmod_sparse}, Q::Ptr{Ptr{cholmod_sparse}}, R::Ptr{Ptr{cholmod_sparse}}, E::Ptr{Ptr{Int64}}, cc::Ptr{cholmod_common})::Int64
+function SuiteSparseQR_i_C_QR(ordering, tol, econ, A, Q, R, E, cc)
+    @ccall libspqr.SuiteSparseQR_i_C_QR(ordering::Cint, tol::Cdouble, econ::Int32,
+                                        A::Ptr{cholmod_sparse}, Q::Ptr{Ptr{cholmod_sparse}},
+                                        R::Ptr{Ptr{cholmod_sparse}}, E::Ptr{Ptr{Int32}},
+                                        cc::Ptr{cholmod_common})::Int32
 end
 
 function SuiteSparseQR_C_backslash(ordering, tol, A, B, cc)
-    @ccall libspqr.SuiteSparseQR_C_backslash(ordering::Cint, tol::Cdouble, A::Ptr{cholmod_sparse}, B::Ptr{cholmod_dense}, cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libspqr.SuiteSparseQR_C_backslash(ordering::Cint, tol::Cdouble,
+                                             A::Ptr{cholmod_sparse}, B::Ptr{cholmod_dense},
+                                             cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function SuiteSparseQR_C_backslash_default(A, B, cc)
-    @ccall libspqr.SuiteSparseQR_C_backslash_default(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_dense}, cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libspqr.SuiteSparseQR_C_backslash_default(A::Ptr{cholmod_sparse},
+                                                     B::Ptr{cholmod_dense},
+                                                     cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function SuiteSparseQR_C_backslash_sparse(ordering, tol, A, B, cc)
-    @ccall libspqr.SuiteSparseQR_C_backslash_sparse(ordering::Cint, tol::Cdouble, A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse}, cc::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libspqr.SuiteSparseQR_C_backslash_sparse(ordering::Cint, tol::Cdouble,
+                                                    A::Ptr{cholmod_sparse},
+                                                    B::Ptr{cholmod_sparse},
+                                                    cc::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 mutable struct SuiteSparseQR_C_factorization_struct
     xtype::Cint
+    itype::Cint
     factors::Ptr{Cvoid}
     SuiteSparseQR_C_factorization_struct() = new()
 end
@@ -1536,51 +2115,78 @@ end
 const SuiteSparseQR_C_factorization = SuiteSparseQR_C_factorization_struct
 
 function SuiteSparseQR_C_factorize(ordering, tol, A, cc)
-    @ccall libspqr.SuiteSparseQR_C_factorize(ordering::Cint, tol::Cdouble, A::Ptr{cholmod_sparse}, cc::Ptr{cholmod_common})::Ptr{SuiteSparseQR_C_factorization}
+    @ccall libspqr.SuiteSparseQR_C_factorize(ordering::Cint, tol::Cdouble,
+                                             A::Ptr{cholmod_sparse},
+                                             cc::Ptr{cholmod_common})::Ptr{SuiteSparseQR_C_factorization}
 end
 
 function SuiteSparseQR_C_symbolic(ordering, allow_tol, A, cc)
-    @ccall libspqr.SuiteSparseQR_C_symbolic(ordering::Cint, allow_tol::Cint, A::Ptr{cholmod_sparse}, cc::Ptr{cholmod_common})::Ptr{SuiteSparseQR_C_factorization}
+    @ccall libspqr.SuiteSparseQR_C_symbolic(ordering::Cint, allow_tol::Cint,
+                                            A::Ptr{cholmod_sparse},
+                                            cc::Ptr{cholmod_common})::Ptr{SuiteSparseQR_C_factorization}
 end
 
 function SuiteSparseQR_C_numeric(tol, A, QR, cc)
-    @ccall libspqr.SuiteSparseQR_C_numeric(tol::Cdouble, A::Ptr{cholmod_sparse}, QR::Ptr{SuiteSparseQR_C_factorization}, cc::Ptr{cholmod_common})::Cint
+    @ccall libspqr.SuiteSparseQR_C_numeric(tol::Cdouble, A::Ptr{cholmod_sparse},
+                                           QR::Ptr{SuiteSparseQR_C_factorization},
+                                           cc::Ptr{cholmod_common})::Cint
 end
 
 function SuiteSparseQR_C_free(QR, cc)
-    @ccall libspqr.SuiteSparseQR_C_free(QR::Ptr{Ptr{SuiteSparseQR_C_factorization}}, cc::Ptr{cholmod_common})::Cint
+    @ccall libspqr.SuiteSparseQR_C_free(QR::Ptr{Ptr{SuiteSparseQR_C_factorization}},
+                                        cc::Ptr{cholmod_common})::Cint
 end
 
 function SuiteSparseQR_C_solve(system, QR, B, cc)
-    @ccall libspqr.SuiteSparseQR_C_solve(system::Cint, QR::Ptr{SuiteSparseQR_C_factorization}, B::Ptr{cholmod_dense}, cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libspqr.SuiteSparseQR_C_solve(system::Cint,
+                                         QR::Ptr{SuiteSparseQR_C_factorization},
+                                         B::Ptr{cholmod_dense},
+                                         cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function SuiteSparseQR_C_qmult(method, QR, X, cc)
-    @ccall libspqr.SuiteSparseQR_C_qmult(method::Cint, QR::Ptr{SuiteSparseQR_C_factorization}, X::Ptr{cholmod_dense}, cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libspqr.SuiteSparseQR_C_qmult(method::Cint,
+                                         QR::Ptr{SuiteSparseQR_C_factorization},
+                                         X::Ptr{cholmod_dense},
+                                         cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function amd_order(n, Ap, Ai, P, Control, Info)
-    @ccall libamd.amd_order(n::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, P::Ptr{Int32}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libamd.amd_order(n::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, P::Ptr{Int32},
+                            Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function amd_l_order(n, Ap, Ai, P, Control, Info)
-    @ccall libamd.amd_l_order(n::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, P::Ptr{Int64}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libamd.amd_l_order(n::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, P::Ptr{Int64},
+                              Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
-function amd_2(n, Pe, Iw, Len, iwlen, pfree, Nv, Next, Last, Head, Elen, Degree, W, Control, Info)
-    @ccall libamd.amd_2(n::Int32, Pe::Ptr{Int32}, Iw::Ptr{Int32}, Len::Ptr{Int32}, iwlen::Int32, pfree::Int32, Nv::Ptr{Int32}, Next::Ptr{Int32}, Last::Ptr{Int32}, Head::Ptr{Int32}, Elen::Ptr{Int32}, Degree::Ptr{Int32}, W::Ptr{Int32}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cvoid
+function amd_2(n, Pe, Iw, Len, iwlen, pfree, Nv, Next, Last, Head, Elen, Degree, W, Control,
+               Info)
+    @ccall libamd.amd_2(n::Int32, Pe::Ptr{Int32}, Iw::Ptr{Int32}, Len::Ptr{Int32},
+                        iwlen::Int32, pfree::Int32, Nv::Ptr{Int32}, Next::Ptr{Int32},
+                        Last::Ptr{Int32}, Head::Ptr{Int32}, Elen::Ptr{Int32},
+                        Degree::Ptr{Int32}, W::Ptr{Int32}, Control::Ptr{Cdouble},
+                        Info::Ptr{Cdouble})::Cvoid
 end
 
-function amd_l2(n, Pe, Iw, Len, iwlen, pfree, Nv, Next, Last, Head, Elen, Degree, W, Control, Info)
-    @ccall libamd.amd_l2(n::Int64, Pe::Ptr{Int64}, Iw::Ptr{Int64}, Len::Ptr{Int64}, iwlen::Int64, pfree::Int64, Nv::Ptr{Int64}, Next::Ptr{Int64}, Last::Ptr{Int64}, Head::Ptr{Int64}, Elen::Ptr{Int64}, Degree::Ptr{Int64}, W::Ptr{Int64}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cvoid
+function amd_l2(n, Pe, Iw, Len, iwlen, pfree, Nv, Next, Last, Head, Elen, Degree, W,
+                Control, Info)
+    @ccall libamd.amd_l2(n::Int64, Pe::Ptr{Int64}, Iw::Ptr{Int64}, Len::Ptr{Int64},
+                         iwlen::Int64, pfree::Int64, Nv::Ptr{Int64}, Next::Ptr{Int64},
+                         Last::Ptr{Int64}, Head::Ptr{Int64}, Elen::Ptr{Int64},
+                         Degree::Ptr{Int64}, W::Ptr{Int64}, Control::Ptr{Cdouble},
+                         Info::Ptr{Cdouble})::Cvoid
 end
 
 function amd_valid(n_row, n_col, Ap, Ai)
-    @ccall libamd.amd_valid(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32})::Cint
+    @ccall libamd.amd_valid(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                            Ai::Ptr{Int32})::Cint
 end
 
 function amd_l_valid(n_row, n_col, Ap, Ai)
-    @ccall libamd.amd_l_valid(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64})::Cint
+    @ccall libamd.amd_l_valid(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                              Ai::Ptr{Int64})::Cint
 end
 
 function amd_defaults(Control)
@@ -1607,188 +2213,88 @@ function amd_l_info(Info)
     @ccall libamd.amd_l_info(Info::Ptr{Cdouble})::Cvoid
 end
 
-function colamd_recommended(nnz, n_row, n_col)
-    @ccall libcolamd.colamd_recommended(nnz::Int32, n_row::Int32, n_col::Int32)::Csize_t
-end
-
-function colamd_l_recommended(nnz, n_row, n_col)
-    @ccall libcolamd.colamd_l_recommended(nnz::Int64, n_row::Int64, n_col::Int64)::Csize_t
-end
-
-function colamd_set_defaults(knobs)
-    @ccall libcolamd.colamd_set_defaults(knobs::Ptr{Cdouble})::Cvoid
-end
-
-function colamd_l_set_defaults(knobs)
-    @ccall libcolamd.colamd_l_set_defaults(knobs::Ptr{Cdouble})::Cvoid
-end
-
-function colamd(n_row, n_col, Alen, A, p, knobs, stats)
-    @ccall libcolamd.colamd(n_row::Int32, n_col::Int32, Alen::Int32, A::Ptr{Int32}, p::Ptr{Int32}, knobs::Ptr{Cdouble}, stats::Ptr{Int32})::Cint
-end
-
-function colamd_l(n_row, n_col, Alen, A, p, knobs, stats)
-    @ccall libcolamd.colamd_l(n_row::Int64, n_col::Int64, Alen::Int64, A::Ptr{Int64}, p::Ptr{Int64}, knobs::Ptr{Cdouble}, stats::Ptr{Int64})::Cint
-end
-
-function symamd(n, A, p, perm, knobs, stats, allocate, release)
-    @ccall libcolamd.symamd(n::Int32, A::Ptr{Int32}, p::Ptr{Int32}, perm::Ptr{Int32}, knobs::Ptr{Cdouble}, stats::Ptr{Int32}, allocate::Ptr{Cvoid}, release::Ptr{Cvoid})::Cint
-end
-
-function symamd_l(n, A, p, perm, knobs, stats, allocate, release)
-    @ccall libcolamd.symamd_l(n::Int64, A::Ptr{Int64}, p::Ptr{Int64}, perm::Ptr{Int64}, knobs::Ptr{Cdouble}, stats::Ptr{Int64}, allocate::Ptr{Cvoid}, release::Ptr{Cvoid})::Cint
-end
-
-function colamd_report(stats)
-    @ccall libcolamd.colamd_report(stats::Ptr{Int32})::Cvoid
-end
-
-function colamd_l_report(stats)
-    @ccall libcolamd.colamd_l_report(stats::Ptr{Int64})::Cvoid
-end
-
-function symamd_report(stats)
-    @ccall libcolamd.symamd_report(stats::Ptr{Int32})::Cvoid
-end
-
-function symamd_l_report(stats)
-    @ccall libcolamd.symamd_l_report(stats::Ptr{Int64})::Cvoid
-end
-
-function ccolamd_recommended(nnz, n_row, n_col)
-    @ccall libcolamd.ccolamd_recommended(nnz::Cint, n_row::Cint, n_col::Cint)::Csize_t
-end
-
-function ccolamd_l_recommended(nnz, n_row, n_col)
-    @ccall libcolamd.ccolamd_l_recommended(nnz::Int64, n_row::Int64, n_col::Int64)::Csize_t
-end
-
-function ccolamd_set_defaults(knobs)
-    @ccall libcolamd.ccolamd_set_defaults(knobs::Ptr{Cdouble})::Cvoid
-end
-
-function ccolamd_l_set_defaults(knobs)
-    @ccall libcolamd.ccolamd_l_set_defaults(knobs::Ptr{Cdouble})::Cvoid
-end
-
-function ccolamd(n_row, n_col, Alen, A, p, knobs, stats, cmember)
-    @ccall libcolamd.ccolamd(n_row::Cint, n_col::Cint, Alen::Cint, A::Ptr{Cint}, p::Ptr{Cint}, knobs::Ptr{Cdouble}, stats::Ptr{Cint}, cmember::Ptr{Cint})::Cint
-end
-
-function ccolamd_l(n_row, n_col, Alen, A, p, knobs, stats, cmember)
-    @ccall libcolamd.ccolamd_l(n_row::Int64, n_col::Int64, Alen::Int64, A::Ptr{Int64}, p::Ptr{Int64}, knobs::Ptr{Cdouble}, stats::Ptr{Int64}, cmember::Ptr{Int64})::Cint
-end
-
-function csymamd(n, A, p, perm, knobs, stats, allocate, release, cmember, stype)
-    @ccall libcolamd.csymamd(n::Cint, A::Ptr{Cint}, p::Ptr{Cint}, perm::Ptr{Cint}, knobs::Ptr{Cdouble}, stats::Ptr{Cint}, allocate::Ptr{Cvoid}, release::Ptr{Cvoid}, cmember::Ptr{Cint}, stype::Cint)::Cint
-end
-
-function csymamd_l(n, A, p, perm, knobs, stats, allocate, release, cmember, stype)
-    @ccall libcolamd.csymamd_l(n::Int64, A::Ptr{Int64}, p::Ptr{Int64}, perm::Ptr{Int64}, knobs::Ptr{Cdouble}, stats::Ptr{Int64}, allocate::Ptr{Cvoid}, release::Ptr{Cvoid}, cmember::Ptr{Int64}, stype::Int64)::Cint
-end
-
-function ccolamd_report(stats)
-    @ccall libcolamd.ccolamd_report(stats::Ptr{Cint})::Cvoid
-end
-
-function ccolamd_l_report(stats)
-    @ccall libcolamd.ccolamd_l_report(stats::Ptr{Int64})::Cvoid
-end
-
-function csymamd_report(stats)
-    @ccall libcolamd.csymamd_report(stats::Ptr{Cint})::Cvoid
-end
-
-function csymamd_l_report(stats)
-    @ccall libcolamd.csymamd_l_report(stats::Ptr{Int64})::Cvoid
-end
-
-function ccolamd2(n_row, n_col, Alen, A, p, knobs, stats, Front_npivcol, Front_nrows, Front_ncols, Front_parent, Front_cols, p_nfr, InFront, cmember)
-    @ccall libcolamd.ccolamd2(n_row::Cint, n_col::Cint, Alen::Cint, A::Ptr{Cint}, p::Ptr{Cint}, knobs::Ptr{Cdouble}, stats::Ptr{Cint}, Front_npivcol::Ptr{Cint}, Front_nrows::Ptr{Cint}, Front_ncols::Ptr{Cint}, Front_parent::Ptr{Cint}, Front_cols::Ptr{Cint}, p_nfr::Ptr{Cint}, InFront::Ptr{Cint}, cmember::Ptr{Cint})::Cint
-end
-
-function ccolamd2_l(n_row, n_col, Alen, A, p, knobs, stats, Front_npivcol, Front_nrows, Front_ncols, Front_parent, Front_cols, p_nfr, InFront, cmember)
-    @ccall libcolamd.ccolamd2_l(n_row::Int64, n_col::Int64, Alen::Int64, A::Ptr{Int64}, p::Ptr{Int64}, knobs::Ptr{Cdouble}, stats::Ptr{Int64}, Front_npivcol::Ptr{Int64}, Front_nrows::Ptr{Int64}, Front_ncols::Ptr{Int64}, Front_parent::Ptr{Int64}, Front_cols::Ptr{Int64}, p_nfr::Ptr{Int64}, InFront::Ptr{Int64}, cmember::Ptr{Int64})::Cint
-end
-
-function ccolamd_apply_order(Front, Order, Temp, nn, nfr)
-    @ccall libcolamd.ccolamd_apply_order(Front::Ptr{Cint}, Order::Ptr{Cint}, Temp::Ptr{Cint}, nn::Cint, nfr::Cint)::Cvoid
-end
-
-function ccolamd_l_apply_order(Front, Order, Temp, nn, nfr)
-    @ccall libcolamd.ccolamd_l_apply_order(Front::Ptr{Int64}, Order::Ptr{Int64}, Temp::Ptr{Int64}, nn::Int64, nfr::Int64)::Cvoid
-end
-
-function ccolamd_fsize(nn, MaxFsize, Fnrows, Fncols, Parent, Npiv)
-    @ccall libcolamd.ccolamd_fsize(nn::Cint, MaxFsize::Ptr{Cint}, Fnrows::Ptr{Cint}, Fncols::Ptr{Cint}, Parent::Ptr{Cint}, Npiv::Ptr{Cint})::Cvoid
-end
-
-function ccolamd_l_fsize(nn, MaxFsize, Fnrows, Fncols, Parent, Npiv)
-    @ccall libcolamd.ccolamd_l_fsize(nn::Int64, MaxFsize::Ptr{Int64}, Fnrows::Ptr{Int64}, Fncols::Ptr{Int64}, Parent::Ptr{Int64}, Npiv::Ptr{Int64})::Cvoid
-end
-
-function ccolamd_postorder(nn, Parent, Npiv, Fsize, Order, Child, Sibling, Stack, Front_cols, cmember)
-    @ccall libcolamd.ccolamd_postorder(nn::Cint, Parent::Ptr{Cint}, Npiv::Ptr{Cint}, Fsize::Ptr{Cint}, Order::Ptr{Cint}, Child::Ptr{Cint}, Sibling::Ptr{Cint}, Stack::Ptr{Cint}, Front_cols::Ptr{Cint}, cmember::Ptr{Cint})::Cvoid
-end
-
-function ccolamd_l_postorder(nn, Parent, Npiv, Fsize, Order, Child, Sibling, Stack, Front_cols, cmember)
-    @ccall libcolamd.ccolamd_l_postorder(nn::Int64, Parent::Ptr{Int64}, Npiv::Ptr{Int64}, Fsize::Ptr{Int64}, Order::Ptr{Int64}, Child::Ptr{Int64}, Sibling::Ptr{Int64}, Stack::Ptr{Int64}, Front_cols::Ptr{Int64}, cmember::Ptr{Int64})::Cvoid
-end
-
-function ccolamd_post_tree(root, k, Child, Sibling, Order, Stack)
-    @ccall libcolamd.ccolamd_post_tree(root::Cint, k::Cint, Child::Ptr{Cint}, Sibling::Ptr{Cint}, Order::Ptr{Cint}, Stack::Ptr{Cint})::Cint
-end
-
-function ccolamd_l_post_tree(root, k, Child, Sibling, Order, Stack)
-    @ccall libcolamd.ccolamd_l_post_tree(root::Int64, k::Int64, Child::Ptr{Int64}, Sibling::Ptr{Int64}, Order::Ptr{Int64}, Stack::Ptr{Int64})::Int64
-end
-
 function umfpack_di_symbolic(n_row, n_col, Ap, Ai, Ax, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_di_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                          Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                          Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                          Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_symbolic(n_row, n_col, Ap, Ai, Ax, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_dl_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                          Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                          Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                          Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_symbolic(n_row, n_col, Ap, Ai, Ax, Az, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_zi_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                          Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                          Az::Ptr{Cdouble}, Symbolic::Ptr{Ptr{Cvoid}},
+                                          Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_symbolic(n_row, n_col, Ap, Ai, Ax, Az, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_zl_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                          Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                          Az::Ptr{Cdouble}, Symbolic::Ptr{Ptr{Cvoid}},
+                                          Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_numeric(Ap, Ai, Ax, Symbolic, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_di_numeric(Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Symbolic::Ptr{Cvoid}, Numeric::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_numeric(Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                         Symbolic::Ptr{Cvoid}, Numeric::Ptr{Ptr{Cvoid}},
+                                         Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_numeric(Ap, Ai, Ax, Symbolic, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_dl_numeric(Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Symbolic::Ptr{Cvoid}, Numeric::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_numeric(Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                         Symbolic::Ptr{Cvoid}, Numeric::Ptr{Ptr{Cvoid}},
+                                         Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_numeric(Ap, Ai, Ax, Az, Symbolic, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_zi_numeric(Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Symbolic::Ptr{Cvoid}, Numeric::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_numeric(Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                         Az::Ptr{Cdouble}, Symbolic::Ptr{Cvoid},
+                                         Numeric::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                         Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_numeric(Ap, Ai, Ax, Az, Symbolic, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_zl_numeric(Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Symbolic::Ptr{Cvoid}, Numeric::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_numeric(Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                         Az::Ptr{Cdouble}, Symbolic::Ptr{Cvoid},
+                                         Numeric::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                         Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_solve(sys, Ap, Ai, Ax, X, B, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_di_solve(sys::Cint, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_solve(sys::Cint, Ap::Ptr{Int32}, Ai::Ptr{Int32},
+                                       Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble},
+                                       Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                       Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_solve(sys, Ap, Ai, Ax, X, B, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_dl_solve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_solve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64},
+                                       Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble},
+                                       Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                       Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_solve(sys, Ap, Ai, Ax, Az, Xx, Xz, Bx, Bz, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_zi_solve(sys::Cint, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_solve(sys::Cint, Ap::Ptr{Int32}, Ai::Ptr{Int32},
+                                       Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Xx::Ptr{Cdouble},
+                                       Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble},
+                                       Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                       Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_solve(sys, Ap, Ai, Ax, Az, Xx, Xz, Bx, Bz, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_zl_solve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_solve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64},
+                                       Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Xx::Ptr{Cdouble},
+                                       Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble},
+                                       Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                       Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_free_symbolic(Symbolic)
@@ -1840,51 +2346,119 @@ function umfpack_zl_defaults(Control)
 end
 
 function umfpack_di_qsymbolic(n_row, n_col, Ap, Ai, Ax, Qinit, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_di_qsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Qinit::Ptr{Int32}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_qsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                           Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                           Qinit::Ptr{Int32}, Symbolic::Ptr{Ptr{Cvoid}},
+                                           Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_qsymbolic(n_row, n_col, Ap, Ai, Ax, Qinit, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_dl_qsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Qinit::Ptr{Int64}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_qsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                           Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                           Qinit::Ptr{Int64}, Symbolic::Ptr{Ptr{Cvoid}},
+                                           Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_qsymbolic(n_row, n_col, Ap, Ai, Ax, Az, Qinit, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_zi_qsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Qinit::Ptr{Int32}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_qsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                           Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                           Az::Ptr{Cdouble}, Qinit::Ptr{Int32},
+                                           Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                           Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_qsymbolic(n_row, n_col, Ap, Ai, Ax, Az, Qinit, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_zl_qsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Qinit::Ptr{Int64}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_di_fsymbolic(n_row, n_col, Ap, Ai, Ax, user_ordering, user_params, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_di_fsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_dl_fsymbolic(n_row, n_col, Ap, Ai, Ax, user_ordering, user_params, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_dl_fsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_zi_fsymbolic(n_row, n_col, Ap, Ai, Ax, Az, user_ordering, user_params, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_zi_fsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_zl_fsymbolic(n_row, n_col, Ap, Ai, Ax, Az, user_ordering, user_params, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_zl_fsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_di_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Qinit, user_ordering, user_params, Symbolic, SW, Control, Info)
-    @ccall libumfpack.umfpack_di_paru_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Qinit::Ptr{Int32}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_dl_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Qinit, user_ordering, user_params, Symbolic, SW, Control, Info)
-    @ccall libumfpack.umfpack_dl_paru_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Qinit::Ptr{Int64}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_zi_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Az, Qinit, user_ordering, user_params, Symbolic, SW, Control, Info)
-    @ccall libumfpack.umfpack_zi_paru_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Qinit::Ptr{Int32}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_zl_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Az, Qinit, user_ordering, user_params, Symbolic, SW, Control, Info)
-    @ccall libumfpack.umfpack_zl_paru_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Qinit::Ptr{Int64}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_qsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                           Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                           Az::Ptr{Cdouble}, Qinit::Ptr{Int64},
+                                           Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                           Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_di_fsymbolic(n_row, n_col, Ap, Ai, Ax, user_ordering, user_params,
+                              Symbolic, Control, Info)
+    @ccall libumfpack.umfpack_di_fsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                           Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                           user_ordering::Ptr{Cvoid},
+                                           user_params::Ptr{Cvoid},
+                                           Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                           Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_dl_fsymbolic(n_row, n_col, Ap, Ai, Ax, user_ordering, user_params,
+                              Symbolic, Control, Info)
+    @ccall libumfpack.umfpack_dl_fsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                           Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                           user_ordering::Ptr{Cvoid},
+                                           user_params::Ptr{Cvoid},
+                                           Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                           Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_zi_fsymbolic(n_row, n_col, Ap, Ai, Ax, Az, user_ordering, user_params,
+                              Symbolic, Control, Info)
+    @ccall libumfpack.umfpack_zi_fsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                           Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                           Az::Ptr{Cdouble}, user_ordering::Ptr{Cvoid},
+                                           user_params::Ptr{Cvoid},
+                                           Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                           Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_zl_fsymbolic(n_row, n_col, Ap, Ai, Ax, Az, user_ordering, user_params,
+                              Symbolic, Control, Info)
+    @ccall libumfpack.umfpack_zl_fsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                           Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                           Az::Ptr{Cdouble}, user_ordering::Ptr{Cvoid},
+                                           user_params::Ptr{Cvoid},
+                                           Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                           Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_di_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Qinit, user_ordering,
+                                  user_params, Symbolic, SW, Control, Info)
+    @ccall libumfpack.umfpack_di_paru_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                               Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                               Qinit::Ptr{Int32}, user_ordering::Ptr{Cvoid},
+                                               user_params::Ptr{Cvoid},
+                                               Symbolic::Ptr{Ptr{Cvoid}},
+                                               SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                               Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_dl_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Qinit, user_ordering,
+                                  user_params, Symbolic, SW, Control, Info)
+    @ccall libumfpack.umfpack_dl_paru_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                               Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                               Qinit::Ptr{Int64}, user_ordering::Ptr{Cvoid},
+                                               user_params::Ptr{Cvoid},
+                                               Symbolic::Ptr{Ptr{Cvoid}},
+                                               SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                               Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_zi_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Az, Qinit, user_ordering,
+                                  user_params, Symbolic, SW, Control, Info)
+    @ccall libumfpack.umfpack_zi_paru_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                               Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                               Az::Ptr{Cdouble}, Qinit::Ptr{Int32},
+                                               user_ordering::Ptr{Cvoid},
+                                               user_params::Ptr{Cvoid},
+                                               Symbolic::Ptr{Ptr{Cvoid}},
+                                               SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                               Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_zl_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Az, Qinit, user_ordering,
+                                  user_params, Symbolic, SW, Control, Info)
+    @ccall libumfpack.umfpack_zl_paru_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                               Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                               Az::Ptr{Cdouble}, Qinit::Ptr{Int64},
+                                               user_ordering::Ptr{Cvoid},
+                                               user_params::Ptr{Cvoid},
+                                               Symbolic::Ptr{Ptr{Cvoid}},
+                                               SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                               Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_paru_free_sw(SW)
@@ -1904,339 +2478,547 @@ function umfpack_zl_paru_free_sw(SW)
 end
 
 function umfpack_di_wsolve(sys, Ap, Ai, Ax, X, B, Numeric, Control, Info, Wi, W)
-    @ccall libumfpack.umfpack_di_wsolve(sys::Cint, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble}, Wi::Ptr{Int32}, W::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_wsolve(sys::Cint, Ap::Ptr{Int32}, Ai::Ptr{Int32},
+                                        Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble},
+                                        Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                        Info::Ptr{Cdouble}, Wi::Ptr{Int32},
+                                        W::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_wsolve(sys, Ap, Ai, Ax, X, B, Numeric, Control, Info, Wi, W)
-    @ccall libumfpack.umfpack_dl_wsolve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble}, Wi::Ptr{Int64}, W::Ptr{Cdouble})::Cint
-end
-
-function umfpack_zi_wsolve(sys, Ap, Ai, Ax, Az, Xx, Xz, Bx, Bz, Numeric, Control, Info, Wi, W)
-    @ccall libumfpack.umfpack_zi_wsolve(sys::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble}, Wi::Ptr{Int32}, W::Ptr{Cdouble})::Cint
-end
-
-function umfpack_zl_wsolve(sys, Ap, Ai, Ax, Az, Xx, Xz, Bx, Bz, Numeric, Control, Info, Wi, W)
-    @ccall libumfpack.umfpack_zl_wsolve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble}, Wi::Ptr{Int64}, W::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_wsolve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64},
+                                        Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble},
+                                        Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                        Info::Ptr{Cdouble}, Wi::Ptr{Int64},
+                                        W::Ptr{Cdouble})::Cint
+end
+
+function umfpack_zi_wsolve(sys, Ap, Ai, Ax, Az, Xx, Xz, Bx, Bz, Numeric, Control, Info, Wi,
+                           W)
+    @ccall libumfpack.umfpack_zi_wsolve(sys::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32},
+                                        Ax::Ptr{Cdouble}, Az::Ptr{Cdouble},
+                                        Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble},
+                                        Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble},
+                                        Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                        Info::Ptr{Cdouble}, Wi::Ptr{Int32},
+                                        W::Ptr{Cdouble})::Cint
+end
+
+function umfpack_zl_wsolve(sys, Ap, Ai, Ax, Az, Xx, Xz, Bx, Bz, Numeric, Control, Info, Wi,
+                           W)
+    @ccall libumfpack.umfpack_zl_wsolve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64},
+                                        Ax::Ptr{Cdouble}, Az::Ptr{Cdouble},
+                                        Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble},
+                                        Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble},
+                                        Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                        Info::Ptr{Cdouble}, Wi::Ptr{Int64},
+                                        W::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_triplet_to_col(n_row, n_col, nz, Ti, Tj, Tx, Ap, Ai, Ax, Map)
-    @ccall libumfpack.umfpack_di_triplet_to_col(n_row::Int32, n_col::Int32, nz::Int32, Ti::Ptr{Int32}, Tj::Ptr{Int32}, Tx::Ptr{Cdouble}, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Map::Ptr{Int32})::Cint
+    @ccall libumfpack.umfpack_di_triplet_to_col(n_row::Int32, n_col::Int32, nz::Int32,
+                                                Ti::Ptr{Int32}, Tj::Ptr{Int32},
+                                                Tx::Ptr{Cdouble}, Ap::Ptr{Int32},
+                                                Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                                Map::Ptr{Int32})::Cint
 end
 
 function umfpack_dl_triplet_to_col(n_row, n_col, nz, Ti, Tj, Tx, Ap, Ai, Ax, Map)
-    @ccall libumfpack.umfpack_dl_triplet_to_col(n_row::Int64, n_col::Int64, nz::Int64, Ti::Ptr{Int64}, Tj::Ptr{Int64}, Tx::Ptr{Cdouble}, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Map::Ptr{Int64})::Cint
+    @ccall libumfpack.umfpack_dl_triplet_to_col(n_row::Int64, n_col::Int64, nz::Int64,
+                                                Ti::Ptr{Int64}, Tj::Ptr{Int64},
+                                                Tx::Ptr{Cdouble}, Ap::Ptr{Int64},
+                                                Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                                Map::Ptr{Int64})::Cint
 end
 
 function umfpack_zi_triplet_to_col(n_row, n_col, nz, Ti, Tj, Tx, Tz, Ap, Ai, Ax, Az, Map)
-    @ccall libumfpack.umfpack_zi_triplet_to_col(n_row::Int32, n_col::Int32, nz::Int32, Ti::Ptr{Int32}, Tj::Ptr{Int32}, Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble}, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Map::Ptr{Int32})::Cint
+    @ccall libumfpack.umfpack_zi_triplet_to_col(n_row::Int32, n_col::Int32, nz::Int32,
+                                                Ti::Ptr{Int32}, Tj::Ptr{Int32},
+                                                Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble},
+                                                Ap::Ptr{Int32}, Ai::Ptr{Int32},
+                                                Ax::Ptr{Cdouble}, Az::Ptr{Cdouble},
+                                                Map::Ptr{Int32})::Cint
 end
 
 function umfpack_zl_triplet_to_col(n_row, n_col, nz, Ti, Tj, Tx, Tz, Ap, Ai, Ax, Az, Map)
-    @ccall libumfpack.umfpack_zl_triplet_to_col(n_row::Int64, n_col::Int64, nz::Int64, Ti::Ptr{Int64}, Tj::Ptr{Int64}, Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble}, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Map::Ptr{Int64})::Cint
+    @ccall libumfpack.umfpack_zl_triplet_to_col(n_row::Int64, n_col::Int64, nz::Int64,
+                                                Ti::Ptr{Int64}, Tj::Ptr{Int64},
+                                                Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble},
+                                                Ap::Ptr{Int64}, Ai::Ptr{Int64},
+                                                Ax::Ptr{Cdouble}, Az::Ptr{Cdouble},
+                                                Map::Ptr{Int64})::Cint
 end
 
 function umfpack_di_col_to_triplet(n_col, Ap, Tj)
-    @ccall libumfpack.umfpack_di_col_to_triplet(n_col::Int32, Ap::Ptr{Int32}, Tj::Ptr{Int32})::Cint
+    @ccall libumfpack.umfpack_di_col_to_triplet(n_col::Int32, Ap::Ptr{Int32},
+                                                Tj::Ptr{Int32})::Cint
 end
 
 function umfpack_dl_col_to_triplet(n_col, Ap, Tj)
-    @ccall libumfpack.umfpack_dl_col_to_triplet(n_col::Int64, Ap::Ptr{Int64}, Tj::Ptr{Int64})::Cint
+    @ccall libumfpack.umfpack_dl_col_to_triplet(n_col::Int64, Ap::Ptr{Int64},
+                                                Tj::Ptr{Int64})::Cint
 end
 
 function umfpack_zi_col_to_triplet(n_col, Ap, Tj)
-    @ccall libumfpack.umfpack_zi_col_to_triplet(n_col::Int32, Ap::Ptr{Int32}, Tj::Ptr{Int32})::Cint
+    @ccall libumfpack.umfpack_zi_col_to_triplet(n_col::Int32, Ap::Ptr{Int32},
+                                                Tj::Ptr{Int32})::Cint
 end
 
 function umfpack_zl_col_to_triplet(n_col, Ap, Tj)
-    @ccall libumfpack.umfpack_zl_col_to_triplet(n_col::Int64, Ap::Ptr{Int64}, Tj::Ptr{Int64})::Cint
+    @ccall libumfpack.umfpack_zl_col_to_triplet(n_col::Int64, Ap::Ptr{Int64},
+                                                Tj::Ptr{Int64})::Cint
 end
 
 function umfpack_di_transpose(n_row, n_col, Ap, Ai, Ax, P, Q, Rp, Ri, Rx)
-    @ccall libumfpack.umfpack_di_transpose(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, P::Ptr{Int32}, Q::Ptr{Int32}, Rp::Ptr{Int32}, Ri::Ptr{Int32}, Rx::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_transpose(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                           Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, P::Ptr{Int32},
+                                           Q::Ptr{Int32}, Rp::Ptr{Int32}, Ri::Ptr{Int32},
+                                           Rx::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_transpose(n_row, n_col, Ap, Ai, Ax, P, Q, Rp, Ri, Rx)
-    @ccall libumfpack.umfpack_dl_transpose(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, P::Ptr{Int64}, Q::Ptr{Int64}, Rp::Ptr{Int64}, Ri::Ptr{Int64}, Rx::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_transpose(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                           Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, P::Ptr{Int64},
+                                           Q::Ptr{Int64}, Rp::Ptr{Int64}, Ri::Ptr{Int64},
+                                           Rx::Ptr{Cdouble})::Cint
 end
 
-function umfpack_zi_transpose(n_row, n_col, Ap, Ai, Ax, Az, P, Q, Rp, Ri, Rx, Rz, do_conjugate)
-    @ccall libumfpack.umfpack_zi_transpose(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, P::Ptr{Int32}, Q::Ptr{Int32}, Rp::Ptr{Int32}, Ri::Ptr{Int32}, Rx::Ptr{Cdouble}, Rz::Ptr{Cdouble}, do_conjugate::Cint)::Cint
+function umfpack_zi_transpose(n_row, n_col, Ap, Ai, Ax, Az, P, Q, Rp, Ri, Rx, Rz,
+                              do_conjugate)
+    @ccall libumfpack.umfpack_zi_transpose(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                           Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                           Az::Ptr{Cdouble}, P::Ptr{Int32}, Q::Ptr{Int32},
+                                           Rp::Ptr{Int32}, Ri::Ptr{Int32}, Rx::Ptr{Cdouble},
+                                           Rz::Ptr{Cdouble}, do_conjugate::Cint)::Cint
 end
 
-function umfpack_zl_transpose(n_row, n_col, Ap, Ai, Ax, Az, P, Q, Rp, Ri, Rx, Rz, do_conjugate)
-    @ccall libumfpack.umfpack_zl_transpose(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, P::Ptr{Int64}, Q::Ptr{Int64}, Rp::Ptr{Int64}, Ri::Ptr{Int64}, Rx::Ptr{Cdouble}, Rz::Ptr{Cdouble}, do_conjugate::Cint)::Cint
+function umfpack_zl_transpose(n_row, n_col, Ap, Ai, Ax, Az, P, Q, Rp, Ri, Rx, Rz,
+                              do_conjugate)
+    @ccall libumfpack.umfpack_zl_transpose(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                           Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                           Az::Ptr{Cdouble}, P::Ptr{Int64}, Q::Ptr{Int64},
+                                           Rp::Ptr{Int64}, Ri::Ptr{Int64}, Rx::Ptr{Cdouble},
+                                           Rz::Ptr{Cdouble}, do_conjugate::Cint)::Cint
 end
 
 function umfpack_di_scale(X, B, Numeric)
-    @ccall libumfpack.umfpack_di_scale(X::Ptr{Cdouble}, B::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_scale(X::Ptr{Cdouble}, B::Ptr{Cdouble},
+                                       Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_scale(X, B, Numeric)
-    @ccall libumfpack.umfpack_dl_scale(X::Ptr{Cdouble}, B::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_scale(X::Ptr{Cdouble}, B::Ptr{Cdouble},
+                                       Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_scale(Xx, Xz, Bx, Bz, Numeric)
-    @ccall libumfpack.umfpack_zi_scale(Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_scale(Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble},
+                                       Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_scale(Xx, Xz, Bx, Bz, Numeric)
-    @ccall libumfpack.umfpack_zl_scale(Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_scale(Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble},
+                                       Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_get_lunz(lnz, unz, n_row, n_col, nz_udiag, Numeric)
-    @ccall libumfpack.umfpack_di_get_lunz(lnz::Ptr{Int32}, unz::Ptr{Int32}, n_row::Ptr{Int32}, n_col::Ptr{Int32}, nz_udiag::Ptr{Int32}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_get_lunz(lnz::Ptr{Int32}, unz::Ptr{Int32},
+                                          n_row::Ptr{Int32}, n_col::Ptr{Int32},
+                                          nz_udiag::Ptr{Int32}, Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_get_lunz(lnz, unz, n_row, n_col, nz_udiag, Numeric)
-    @ccall libumfpack.umfpack_dl_get_lunz(lnz::Ptr{Int64}, unz::Ptr{Int64}, n_row::Ptr{Int64}, n_col::Ptr{Int64}, nz_udiag::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_get_lunz(lnz::Ptr{Int64}, unz::Ptr{Int64},
+                                          n_row::Ptr{Int64}, n_col::Ptr{Int64},
+                                          nz_udiag::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_get_lunz(lnz, unz, n_row, n_col, nz_udiag, Numeric)
-    @ccall libumfpack.umfpack_zi_get_lunz(lnz::Ptr{Int32}, unz::Ptr{Int32}, n_row::Ptr{Int32}, n_col::Ptr{Int32}, nz_udiag::Ptr{Int32}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_get_lunz(lnz::Ptr{Int32}, unz::Ptr{Int32},
+                                          n_row::Ptr{Int32}, n_col::Ptr{Int32},
+                                          nz_udiag::Ptr{Int32}, Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_get_lunz(lnz, unz, n_row, n_col, nz_udiag, Numeric)
-    @ccall libumfpack.umfpack_zl_get_lunz(lnz::Ptr{Int64}, unz::Ptr{Int64}, n_row::Ptr{Int64}, n_col::Ptr{Int64}, nz_udiag::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_get_lunz(lnz::Ptr{Int64}, unz::Ptr{Int64},
+                                          n_row::Ptr{Int64}, n_col::Ptr{Int64},
+                                          nz_udiag::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_get_numeric(Lp, Lj, Lx, Up, Ui, Ux, P, Q, Dx, do_recip, Rs, Numeric)
-    @ccall libumfpack.umfpack_di_get_numeric(Lp::Ptr{Int32}, Lj::Ptr{Int32}, Lx::Ptr{Cdouble}, Up::Ptr{Int32}, Ui::Ptr{Int32}, Ux::Ptr{Cdouble}, P::Ptr{Int32}, Q::Ptr{Int32}, Dx::Ptr{Cdouble}, do_recip::Ptr{Int32}, Rs::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_get_numeric(Lp::Ptr{Int32}, Lj::Ptr{Int32},
+                                             Lx::Ptr{Cdouble}, Up::Ptr{Int32},
+                                             Ui::Ptr{Int32}, Ux::Ptr{Cdouble},
+                                             P::Ptr{Int32}, Q::Ptr{Int32}, Dx::Ptr{Cdouble},
+                                             do_recip::Ptr{Int32}, Rs::Ptr{Cdouble},
+                                             Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_get_numeric(Lp, Lj, Lx, Up, Ui, Ux, P, Q, Dx, do_recip, Rs, Numeric)
-    @ccall libumfpack.umfpack_dl_get_numeric(Lp::Ptr{Int64}, Lj::Ptr{Int64}, Lx::Ptr{Cdouble}, Up::Ptr{Int64}, Ui::Ptr{Int64}, Ux::Ptr{Cdouble}, P::Ptr{Int64}, Q::Ptr{Int64}, Dx::Ptr{Cdouble}, do_recip::Ptr{Int64}, Rs::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
-end
-
-function umfpack_zi_get_numeric(Lp, Lj, Lx, Lz, Up, Ui, Ux, Uz, P, Q, Dx, Dz, do_recip, Rs, Numeric)
-    @ccall libumfpack.umfpack_zi_get_numeric(Lp::Ptr{Int32}, Lj::Ptr{Int32}, Lx::Ptr{Cdouble}, Lz::Ptr{Cdouble}, Up::Ptr{Int32}, Ui::Ptr{Int32}, Ux::Ptr{Cdouble}, Uz::Ptr{Cdouble}, P::Ptr{Int32}, Q::Ptr{Int32}, Dx::Ptr{Cdouble}, Dz::Ptr{Cdouble}, do_recip::Ptr{Int32}, Rs::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
-end
-
-function umfpack_zl_get_numeric(Lp, Lj, Lx, Lz, Up, Ui, Ux, Uz, P, Q, Dx, Dz, do_recip, Rs, Numeric)
-    @ccall libumfpack.umfpack_zl_get_numeric(Lp::Ptr{Int64}, Lj::Ptr{Int64}, Lx::Ptr{Cdouble}, Lz::Ptr{Cdouble}, Up::Ptr{Int64}, Ui::Ptr{Int64}, Ux::Ptr{Cdouble}, Uz::Ptr{Cdouble}, P::Ptr{Int64}, Q::Ptr{Int64}, Dx::Ptr{Cdouble}, Dz::Ptr{Cdouble}, do_recip::Ptr{Int64}, Rs::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
-end
-
-function umfpack_di_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol, Front_parent, Front_1strow, Front_leftmostdesc, Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
-    @ccall libumfpack.umfpack_di_get_symbolic(n_row::Ptr{Int32}, n_col::Ptr{Int32}, n1::Ptr{Int32}, nz::Ptr{Int32}, nfr::Ptr{Int32}, nchains::Ptr{Int32}, P::Ptr{Int32}, Q::Ptr{Int32}, Front_npivcol::Ptr{Int32}, Front_parent::Ptr{Int32}, Front_1strow::Ptr{Int32}, Front_leftmostdesc::Ptr{Int32}, Chain_start::Ptr{Int32}, Chain_maxrows::Ptr{Int32}, Chain_maxcols::Ptr{Int32}, Dmap::Ptr{Int32}, Symbolic::Ptr{Cvoid})::Cint
-end
-
-function umfpack_dl_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol, Front_parent, Front_1strow, Front_leftmostdesc, Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
-    @ccall libumfpack.umfpack_dl_get_symbolic(n_row::Ptr{Int64}, n_col::Ptr{Int64}, n1::Ptr{Int64}, nz::Ptr{Int64}, nfr::Ptr{Int64}, nchains::Ptr{Int64}, P::Ptr{Int64}, Q::Ptr{Int64}, Front_npivcol::Ptr{Int64}, Front_parent::Ptr{Int64}, Front_1strow::Ptr{Int64}, Front_leftmostdesc::Ptr{Int64}, Chain_start::Ptr{Int64}, Chain_maxrows::Ptr{Int64}, Chain_maxcols::Ptr{Int64}, Dmap::Ptr{Int64}, Symbolic::Ptr{Cvoid})::Cint
-end
-
-function umfpack_zi_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol, Front_parent, Front_1strow, Front_leftmostdesc, Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
-    @ccall libumfpack.umfpack_zi_get_symbolic(n_row::Ptr{Int32}, n_col::Ptr{Int32}, n1::Ptr{Int32}, nz::Ptr{Int32}, nfr::Ptr{Int32}, nchains::Ptr{Int32}, P::Ptr{Int32}, Q::Ptr{Int32}, Front_npivcol::Ptr{Int32}, Front_parent::Ptr{Int32}, Front_1strow::Ptr{Int32}, Front_leftmostdesc::Ptr{Int32}, Chain_start::Ptr{Int32}, Chain_maxrows::Ptr{Int32}, Chain_maxcols::Ptr{Int32}, Dmap::Ptr{Int32}, Symbolic::Ptr{Cvoid})::Cint
-end
-
-function umfpack_zl_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol, Front_parent, Front_1strow, Front_leftmostdesc, Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
-    @ccall libumfpack.umfpack_zl_get_symbolic(n_row::Ptr{Int64}, n_col::Ptr{Int64}, n1::Ptr{Int64}, nz::Ptr{Int64}, nfr::Ptr{Int64}, nchains::Ptr{Int64}, P::Ptr{Int64}, Q::Ptr{Int64}, Front_npivcol::Ptr{Int64}, Front_parent::Ptr{Int64}, Front_1strow::Ptr{Int64}, Front_leftmostdesc::Ptr{Int64}, Chain_start::Ptr{Int64}, Chain_maxrows::Ptr{Int64}, Chain_maxcols::Ptr{Int64}, Dmap::Ptr{Int64}, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_get_numeric(Lp::Ptr{Int64}, Lj::Ptr{Int64},
+                                             Lx::Ptr{Cdouble}, Up::Ptr{Int64},
+                                             Ui::Ptr{Int64}, Ux::Ptr{Cdouble},
+                                             P::Ptr{Int64}, Q::Ptr{Int64}, Dx::Ptr{Cdouble},
+                                             do_recip::Ptr{Int64}, Rs::Ptr{Cdouble},
+                                             Numeric::Ptr{Cvoid})::Cint
+end
+
+function umfpack_zi_get_numeric(Lp, Lj, Lx, Lz, Up, Ui, Ux, Uz, P, Q, Dx, Dz, do_recip, Rs,
+                                Numeric)
+    @ccall libumfpack.umfpack_zi_get_numeric(Lp::Ptr{Int32}, Lj::Ptr{Int32},
+                                             Lx::Ptr{Cdouble}, Lz::Ptr{Cdouble},
+                                             Up::Ptr{Int32}, Ui::Ptr{Int32},
+                                             Ux::Ptr{Cdouble}, Uz::Ptr{Cdouble},
+                                             P::Ptr{Int32}, Q::Ptr{Int32}, Dx::Ptr{Cdouble},
+                                             Dz::Ptr{Cdouble}, do_recip::Ptr{Int32},
+                                             Rs::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+end
+
+function umfpack_zl_get_numeric(Lp, Lj, Lx, Lz, Up, Ui, Ux, Uz, P, Q, Dx, Dz, do_recip, Rs,
+                                Numeric)
+    @ccall libumfpack.umfpack_zl_get_numeric(Lp::Ptr{Int64}, Lj::Ptr{Int64},
+                                             Lx::Ptr{Cdouble}, Lz::Ptr{Cdouble},
+                                             Up::Ptr{Int64}, Ui::Ptr{Int64},
+                                             Ux::Ptr{Cdouble}, Uz::Ptr{Cdouble},
+                                             P::Ptr{Int64}, Q::Ptr{Int64}, Dx::Ptr{Cdouble},
+                                             Dz::Ptr{Cdouble}, do_recip::Ptr{Int64},
+                                             Rs::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+end
+
+function umfpack_di_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol,
+                                 Front_parent, Front_1strow, Front_leftmostdesc,
+                                 Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
+    @ccall libumfpack.umfpack_di_get_symbolic(n_row::Ptr{Int32}, n_col::Ptr{Int32},
+                                              n1::Ptr{Int32}, nz::Ptr{Int32},
+                                              nfr::Ptr{Int32}, nchains::Ptr{Int32},
+                                              P::Ptr{Int32}, Q::Ptr{Int32},
+                                              Front_npivcol::Ptr{Int32},
+                                              Front_parent::Ptr{Int32},
+                                              Front_1strow::Ptr{Int32},
+                                              Front_leftmostdesc::Ptr{Int32},
+                                              Chain_start::Ptr{Int32},
+                                              Chain_maxrows::Ptr{Int32},
+                                              Chain_maxcols::Ptr{Int32}, Dmap::Ptr{Int32},
+                                              Symbolic::Ptr{Cvoid})::Cint
+end
+
+function umfpack_dl_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol,
+                                 Front_parent, Front_1strow, Front_leftmostdesc,
+                                 Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
+    @ccall libumfpack.umfpack_dl_get_symbolic(n_row::Ptr{Int64}, n_col::Ptr{Int64},
+                                              n1::Ptr{Int64}, nz::Ptr{Int64},
+                                              nfr::Ptr{Int64}, nchains::Ptr{Int64},
+                                              P::Ptr{Int64}, Q::Ptr{Int64},
+                                              Front_npivcol::Ptr{Int64},
+                                              Front_parent::Ptr{Int64},
+                                              Front_1strow::Ptr{Int64},
+                                              Front_leftmostdesc::Ptr{Int64},
+                                              Chain_start::Ptr{Int64},
+                                              Chain_maxrows::Ptr{Int64},
+                                              Chain_maxcols::Ptr{Int64}, Dmap::Ptr{Int64},
+                                              Symbolic::Ptr{Cvoid})::Cint
+end
+
+function umfpack_zi_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol,
+                                 Front_parent, Front_1strow, Front_leftmostdesc,
+                                 Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
+    @ccall libumfpack.umfpack_zi_get_symbolic(n_row::Ptr{Int32}, n_col::Ptr{Int32},
+                                              n1::Ptr{Int32}, nz::Ptr{Int32},
+                                              nfr::Ptr{Int32}, nchains::Ptr{Int32},
+                                              P::Ptr{Int32}, Q::Ptr{Int32},
+                                              Front_npivcol::Ptr{Int32},
+                                              Front_parent::Ptr{Int32},
+                                              Front_1strow::Ptr{Int32},
+                                              Front_leftmostdesc::Ptr{Int32},
+                                              Chain_start::Ptr{Int32},
+                                              Chain_maxrows::Ptr{Int32},
+                                              Chain_maxcols::Ptr{Int32}, Dmap::Ptr{Int32},
+                                              Symbolic::Ptr{Cvoid})::Cint
+end
+
+function umfpack_zl_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol,
+                                 Front_parent, Front_1strow, Front_leftmostdesc,
+                                 Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
+    @ccall libumfpack.umfpack_zl_get_symbolic(n_row::Ptr{Int64}, n_col::Ptr{Int64},
+                                              n1::Ptr{Int64}, nz::Ptr{Int64},
+                                              nfr::Ptr{Int64}, nchains::Ptr{Int64},
+                                              P::Ptr{Int64}, Q::Ptr{Int64},
+                                              Front_npivcol::Ptr{Int64},
+                                              Front_parent::Ptr{Int64},
+                                              Front_1strow::Ptr{Int64},
+                                              Front_leftmostdesc::Ptr{Int64},
+                                              Chain_start::Ptr{Int64},
+                                              Chain_maxrows::Ptr{Int64},
+                                              Chain_maxcols::Ptr{Int64}, Dmap::Ptr{Int64},
+                                              Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_save_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_di_save_numeric(Numeric::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_di_save_numeric(Numeric::Ptr{Cvoid},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_dl_save_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_dl_save_numeric(Numeric::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_dl_save_numeric(Numeric::Ptr{Cvoid},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zi_save_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_zi_save_numeric(Numeric::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zi_save_numeric(Numeric::Ptr{Cvoid},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zl_save_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_zl_save_numeric(Numeric::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zl_save_numeric(Numeric::Ptr{Cvoid},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_di_load_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_di_load_numeric(Numeric::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_di_load_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_dl_load_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_dl_load_numeric(Numeric::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_dl_load_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zi_load_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_zi_load_numeric(Numeric::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zi_load_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zl_load_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_zl_load_numeric(Numeric::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zl_load_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_di_copy_numeric(Numeric, Original)
-    @ccall libumfpack.umfpack_di_copy_numeric(Numeric::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_copy_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_copy_numeric(Numeric, Original)
-    @ccall libumfpack.umfpack_dl_copy_numeric(Numeric::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_copy_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_copy_numeric(Numeric, Original)
-    @ccall libumfpack.umfpack_zi_copy_numeric(Numeric::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_copy_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_copy_numeric(Numeric, Original)
-    @ccall libumfpack.umfpack_zl_copy_numeric(Numeric::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_copy_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_serialize_numeric_size(blobsize, Numeric)
-    @ccall libumfpack.umfpack_di_serialize_numeric_size(blobsize::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_serialize_numeric_size(blobsize::Ptr{Int64},
+                                                        Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_serialize_numeric_size(blobsize, Numeric)
-    @ccall libumfpack.umfpack_dl_serialize_numeric_size(blobsize::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_serialize_numeric_size(blobsize::Ptr{Int64},
+                                                        Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_serialize_numeric_size(blobsize, Numeric)
-    @ccall libumfpack.umfpack_zi_serialize_numeric_size(blobsize::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_serialize_numeric_size(blobsize::Ptr{Int64},
+                                                        Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_serialize_numeric_size(blobsize, Numeric)
-    @ccall libumfpack.umfpack_zl_serialize_numeric_size(blobsize::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_serialize_numeric_size(blobsize::Ptr{Int64},
+                                                        Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_serialize_numeric(blob, blobsize, Numeric)
-    @ccall libumfpack.umfpack_di_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64,
+                                                   Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_serialize_numeric(blob, blobsize, Numeric)
-    @ccall libumfpack.umfpack_dl_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64,
+                                                   Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_serialize_numeric(blob, blobsize, Numeric)
-    @ccall libumfpack.umfpack_zi_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64,
+                                                   Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_serialize_numeric(blob, blobsize, Numeric)
-    @ccall libumfpack.umfpack_zl_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64,
+                                                   Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_deserialize_numeric(Numeric, blob, blobsize)
-    @ccall libumfpack.umfpack_di_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_di_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                                     blob::Ptr{Int8}, blobsize::Int64)::Cint
 end
 
 function umfpack_dl_deserialize_numeric(Numeric, blob, blobsize)
-    @ccall libumfpack.umfpack_dl_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_dl_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                                     blob::Ptr{Int8}, blobsize::Int64)::Cint
 end
 
 function umfpack_zi_deserialize_numeric(Numeric, blob, blobsize)
-    @ccall libumfpack.umfpack_zi_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_zi_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                                     blob::Ptr{Int8}, blobsize::Int64)::Cint
 end
 
 function umfpack_zl_deserialize_numeric(Numeric, blob, blobsize)
-    @ccall libumfpack.umfpack_zl_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_zl_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                                     blob::Ptr{Int8}, blobsize::Int64)::Cint
 end
 
 function umfpack_di_save_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_di_save_symbolic(Symbolic::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_di_save_symbolic(Symbolic::Ptr{Cvoid},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_dl_save_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_dl_save_symbolic(Symbolic::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_dl_save_symbolic(Symbolic::Ptr{Cvoid},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zi_save_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_zi_save_symbolic(Symbolic::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zi_save_symbolic(Symbolic::Ptr{Cvoid},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zl_save_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_zl_save_symbolic(Symbolic::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zl_save_symbolic(Symbolic::Ptr{Cvoid},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_di_load_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_di_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_di_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_dl_load_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_dl_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_dl_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zi_load_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_zi_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zi_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zl_load_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_zl_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zl_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_di_copy_symbolic(Symbolic, Original)
-    @ccall libumfpack.umfpack_di_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_copy_symbolic(Symbolic, Original)
-    @ccall libumfpack.umfpack_dl_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_copy_symbolic(Symbolic, Original)
-    @ccall libumfpack.umfpack_zi_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_copy_symbolic(Symbolic, Original)
-    @ccall libumfpack.umfpack_zl_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_serialize_symbolic_size(blobsize, Symbolic)
-    @ccall libumfpack.umfpack_di_serialize_symbolic_size(blobsize::Ptr{Int64}, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_serialize_symbolic_size(blobsize::Ptr{Int64},
+                                                         Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_serialize_symbolic_size(blobsize, Symbolic)
-    @ccall libumfpack.umfpack_dl_serialize_symbolic_size(blobsize::Ptr{Int64}, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_serialize_symbolic_size(blobsize::Ptr{Int64},
+                                                         Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_serialize_symbolic_size(blobsize, Symbolic)
-    @ccall libumfpack.umfpack_zi_serialize_symbolic_size(blobsize::Ptr{Int64}, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_serialize_symbolic_size(blobsize::Ptr{Int64},
+                                                         Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_serialize_symbolic_size(blobsize, Symbolic)
-    @ccall libumfpack.umfpack_zl_serialize_symbolic_size(blobsize::Ptr{Int64}, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_serialize_symbolic_size(blobsize::Ptr{Int64},
+                                                         Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_serialize_symbolic(blob, blobsize, Symbolic)
-    @ccall libumfpack.umfpack_di_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64,
+                                                    Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_serialize_symbolic(blob, blobsize, Symbolic)
-    @ccall libumfpack.umfpack_dl_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64,
+                                                    Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_serialize_symbolic(blob, blobsize, Symbolic)
-    @ccall libumfpack.umfpack_zi_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64,
+                                                    Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_serialize_symbolic(blob, blobsize, Symbolic)
-    @ccall libumfpack.umfpack_zl_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64,
+                                                    Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_deserialize_symbolic(Symbolic, blob, blobsize)
-    @ccall libumfpack.umfpack_di_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_di_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                                      blob::Ptr{Int8},
+                                                      blobsize::Int64)::Cint
 end
 
 function umfpack_dl_deserialize_symbolic(Symbolic, blob, blobsize)
-    @ccall libumfpack.umfpack_dl_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_dl_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                                      blob::Ptr{Int8},
+                                                      blobsize::Int64)::Cint
 end
 
 function umfpack_zi_deserialize_symbolic(Symbolic, blob, blobsize)
-    @ccall libumfpack.umfpack_zi_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_zi_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                                      blob::Ptr{Int8},
+                                                      blobsize::Int64)::Cint
 end
 
 function umfpack_zl_deserialize_symbolic(Symbolic, blob, blobsize)
-    @ccall libumfpack.umfpack_zl_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_zl_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                                      blob::Ptr{Int8},
+                                                      blobsize::Int64)::Cint
 end
 
 function umfpack_di_get_determinant(Mx, Ex, Numeric, User_Info)
-    @ccall libumfpack.umfpack_di_get_determinant(Mx::Ptr{Cdouble}, Ex::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, User_Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_get_determinant(Mx::Ptr{Cdouble}, Ex::Ptr{Cdouble},
+                                                 Numeric::Ptr{Cvoid},
+                                                 User_Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_get_determinant(Mx, Ex, Numeric, User_Info)
-    @ccall libumfpack.umfpack_dl_get_determinant(Mx::Ptr{Cdouble}, Ex::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, User_Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_get_determinant(Mx::Ptr{Cdouble}, Ex::Ptr{Cdouble},
+                                                 Numeric::Ptr{Cvoid},
+                                                 User_Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_get_determinant(Mx, Mz, Ex, Numeric, User_Info)
-    @ccall libumfpack.umfpack_zi_get_determinant(Mx::Ptr{Cdouble}, Mz::Ptr{Cdouble}, Ex::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, User_Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_get_determinant(Mx::Ptr{Cdouble}, Mz::Ptr{Cdouble},
+                                                 Ex::Ptr{Cdouble}, Numeric::Ptr{Cvoid},
+                                                 User_Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_get_determinant(Mx, Mz, Ex, Numeric, User_Info)
-    @ccall libumfpack.umfpack_zl_get_determinant(Mx::Ptr{Cdouble}, Mz::Ptr{Cdouble}, Ex::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, User_Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_get_determinant(Mx::Ptr{Cdouble}, Mz::Ptr{Cdouble},
+                                                 Ex::Ptr{Cdouble}, Numeric::Ptr{Cvoid},
+                                                 User_Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_report_status(Control, status)
@@ -2256,19 +3038,23 @@ function umfpack_zl_report_status(Control, status)
 end
 
 function umfpack_di_report_info(Control, Info)
-    @ccall libumfpack.umfpack_di_report_info(Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cvoid
+    @ccall libumfpack.umfpack_di_report_info(Control::Ptr{Cdouble},
+                                             Info::Ptr{Cdouble})::Cvoid
 end
 
 function umfpack_dl_report_info(Control, Info)
-    @ccall libumfpack.umfpack_dl_report_info(Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cvoid
+    @ccall libumfpack.umfpack_dl_report_info(Control::Ptr{Cdouble},
+                                             Info::Ptr{Cdouble})::Cvoid
 end
 
 function umfpack_zi_report_info(Control, Info)
-    @ccall libumfpack.umfpack_zi_report_info(Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cvoid
+    @ccall libumfpack.umfpack_zi_report_info(Control::Ptr{Cdouble},
+                                             Info::Ptr{Cdouble})::Cvoid
 end
 
 function umfpack_zl_report_info(Control, Info)
-    @ccall libumfpack.umfpack_zl_report_info(Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cvoid
+    @ccall libumfpack.umfpack_zl_report_info(Control::Ptr{Cdouble},
+                                             Info::Ptr{Cdouble})::Cvoid
 end
 
 function umfpack_di_report_control(Control)
@@ -2288,99 +3074,137 @@ function umfpack_zl_report_control(Control)
 end
 
 function umfpack_di_report_matrix(n_row, n_col, Ap, Ai, Ax, col_form, Control)
-    @ccall libumfpack.umfpack_di_report_matrix(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, col_form::Cint, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_report_matrix(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                               Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                               col_form::Cint, Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_report_matrix(n_row, n_col, Ap, Ai, Ax, col_form, Control)
-    @ccall libumfpack.umfpack_dl_report_matrix(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, col_form::Cint, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_report_matrix(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                               Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                               col_form::Cint, Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_report_matrix(n_row, n_col, Ap, Ai, Ax, Az, col_form, Control)
-    @ccall libumfpack.umfpack_zi_report_matrix(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, col_form::Cint, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_report_matrix(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                               Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                               Az::Ptr{Cdouble}, col_form::Cint,
+                                               Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_report_matrix(n_row, n_col, Ap, Ai, Ax, Az, col_form, Control)
-    @ccall libumfpack.umfpack_zl_report_matrix(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, col_form::Cint, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_report_matrix(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                               Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                               Az::Ptr{Cdouble}, col_form::Cint,
+                                               Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_report_triplet(n_row, n_col, nz, Ti, Tj, Tx, Control)
-    @ccall libumfpack.umfpack_di_report_triplet(n_row::Int32, n_col::Int32, nz::Int32, Ti::Ptr{Int32}, Tj::Ptr{Int32}, Tx::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_report_triplet(n_row::Int32, n_col::Int32, nz::Int32,
+                                                Ti::Ptr{Int32}, Tj::Ptr{Int32},
+                                                Tx::Ptr{Cdouble},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_report_triplet(n_row, n_col, nz, Ti, Tj, Tx, Control)
-    @ccall libumfpack.umfpack_dl_report_triplet(n_row::Int64, n_col::Int64, nz::Int64, Ti::Ptr{Int64}, Tj::Ptr{Int64}, Tx::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_report_triplet(n_row::Int64, n_col::Int64, nz::Int64,
+                                                Ti::Ptr{Int64}, Tj::Ptr{Int64},
+                                                Tx::Ptr{Cdouble},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_report_triplet(n_row, n_col, nz, Ti, Tj, Tx, Tz, Control)
-    @ccall libumfpack.umfpack_zi_report_triplet(n_row::Int32, n_col::Int32, nz::Int32, Ti::Ptr{Int32}, Tj::Ptr{Int32}, Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_report_triplet(n_row::Int32, n_col::Int32, nz::Int32,
+                                                Ti::Ptr{Int32}, Tj::Ptr{Int32},
+                                                Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_report_triplet(n_row, n_col, nz, Ti, Tj, Tx, Tz, Control)
-    @ccall libumfpack.umfpack_zl_report_triplet(n_row::Int64, n_col::Int64, nz::Int64, Ti::Ptr{Int64}, Tj::Ptr{Int64}, Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_report_triplet(n_row::Int64, n_col::Int64, nz::Int64,
+                                                Ti::Ptr{Int64}, Tj::Ptr{Int64},
+                                                Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_report_vector(n, X, Control)
-    @ccall libumfpack.umfpack_di_report_vector(n::Int32, X::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_report_vector(n::Int32, X::Ptr{Cdouble},
+                                               Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_report_vector(n, X, Control)
-    @ccall libumfpack.umfpack_dl_report_vector(n::Int64, X::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_report_vector(n::Int64, X::Ptr{Cdouble},
+                                               Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_report_vector(n, Xx, Xz, Control)
-    @ccall libumfpack.umfpack_zi_report_vector(n::Int32, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_report_vector(n::Int32, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble},
+                                               Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_report_vector(n, Xx, Xz, Control)
-    @ccall libumfpack.umfpack_zl_report_vector(n::Int64, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_report_vector(n::Int64, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble},
+                                               Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_report_symbolic(Symbolic, Control)
-    @ccall libumfpack.umfpack_di_report_symbolic(Symbolic::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_report_symbolic(Symbolic::Ptr{Cvoid},
+                                                 Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_report_symbolic(Symbolic, Control)
-    @ccall libumfpack.umfpack_dl_report_symbolic(Symbolic::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_report_symbolic(Symbolic::Ptr{Cvoid},
+                                                 Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_report_symbolic(Symbolic, Control)
-    @ccall libumfpack.umfpack_zi_report_symbolic(Symbolic::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_report_symbolic(Symbolic::Ptr{Cvoid},
+                                                 Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_report_symbolic(Symbolic, Control)
-    @ccall libumfpack.umfpack_zl_report_symbolic(Symbolic::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_report_symbolic(Symbolic::Ptr{Cvoid},
+                                                 Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_report_numeric(Numeric, Control)
-    @ccall libumfpack.umfpack_di_report_numeric(Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_report_numeric(Numeric::Ptr{Cvoid},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_report_numeric(Numeric, Control)
-    @ccall libumfpack.umfpack_dl_report_numeric(Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_report_numeric(Numeric::Ptr{Cvoid},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_report_numeric(Numeric, Control)
-    @ccall libumfpack.umfpack_zi_report_numeric(Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_report_numeric(Numeric::Ptr{Cvoid},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_report_numeric(Numeric, Control)
-    @ccall libumfpack.umfpack_zl_report_numeric(Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_report_numeric(Numeric::Ptr{Cvoid},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_report_perm(np, Perm, Control)
-    @ccall libumfpack.umfpack_di_report_perm(np::Int32, Perm::Ptr{Int32}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_report_perm(np::Int32, Perm::Ptr{Int32},
+                                             Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_report_perm(np, Perm, Control)
-    @ccall libumfpack.umfpack_dl_report_perm(np::Int64, Perm::Ptr{Int64}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_report_perm(np::Int64, Perm::Ptr{Int64},
+                                             Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_report_perm(np, Perm, Control)
-    @ccall libumfpack.umfpack_zi_report_perm(np::Int32, Perm::Ptr{Int32}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_report_perm(np::Int32, Perm::Ptr{Int32},
+                                             Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_report_perm(np, Perm, Control)
-    @ccall libumfpack.umfpack_zl_report_perm(np::Int64, Perm::Ptr{Int64}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_report_perm(np::Int64, Perm::Ptr{Int64},
+                                             Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_timer()
@@ -2395,13 +3219,13 @@ function umfpack_toc(stats)
     @ccall libumfpack.umfpack_toc(stats::Ptr{Cdouble})::Cvoid
 end
 
-const CHOLMOD_DATE = "Jan 17, 2023"
+const CHOLMOD_DATE = "June 16, 2023"
 
 const CHOLMOD_MAIN_VERSION = 4
 
 const CHOLMOD_SUB_VERSION = 0
 
-const CHOLMOD_SUBSUB_VERSION = 3
+const CHOLMOD_SUBSUB_VERSION = 4
 
 const _FILE_OFFSET_BITS = 64
 
@@ -2427,17 +3251,18 @@ const SUITESPARSE_COMPILER_MSC = 0
 
 const SUITESPARSE_COMPILER_XLC = 0
 
-const SUITESPARSE_DATE = "Jan 20, 2023"
+const SUITESPARSE_DATE = "June 29, 2023"
 
 const SUITESPARSE_MAIN_VERSION = 7
 
-const SUITESPARSE_SUB_VERSION = 0
+const SUITESPARSE_SUB_VERSION = 1
 
-const SUITESPARSE_SUBSUB_VERSION = 1
+const SUITESPARSE_SUBSUB_VERSION = 0
 
 SUITESPARSE_VER_CODE(main, sub) = main * 1000 + sub
 
-const SUITESPARSE_VERSION = SUITESPARSE_VER_CODE(SUITESPARSE_MAIN_VERSION, SUITESPARSE_SUB_VERSION)
+const SUITESPARSE_VERSION = SUITESPARSE_VER_CODE(SUITESPARSE_MAIN_VERSION,
+                                                 SUITESPARSE_SUB_VERSION)
 
 CHOLMOD_VER_CODE(main, sub) = main * 1000 + sub
 
@@ -2601,20 +3426,18 @@ const SPQR_RTX_EQUALS_B = 2
 
 const SPQR_RTX_EQUALS_ETB = 3
 
-const SPQR_DATE = "Jan 17, 2023"
+const SPQR_DATE = "July FIXME, 2023"
 
-const SPQR_MAIN_VERSION = 3
+const SPQR_MAIN_VERSION = 4
 
 const SPQR_SUB_VERSION = 0
 
-const SPQR_SUBSUB_VERSION = 3
+const SPQR_SUBSUB_VERSION = 0
 
 SPQR_VER_CODE(main, sub) = main * 1000 + sub
 
 const SPQR_VERSION = SPQR_VER_CODE(SPQR_MAIN_VERSION, SPQR_SUB_VERSION)
 
-const Complex = Float64
-
 const AMD_CONTROL = 5
 
 const AMD_INFO = 20
@@ -2663,172 +3486,29 @@ const AMD_INVALID = -2
 
 const AMD_OK_BUT_JUMBLED = 1
 
-const AMD_DATE = "Jan 17, 2023"
+const AMD_DATE = "June 16, 2023"
 
 const AMD_MAIN_VERSION = 3
 
 const AMD_SUB_VERSION = 0
 
-const AMD_SUBSUB_VERSION = 3
+const AMD_SUBSUB_VERSION = 4
 
 AMD_VERSION_CODE(main, sub) = main * 1000 + sub
 
 const AMD_VERSION = AMD_VERSION_CODE(AMD_MAIN_VERSION, AMD_SUB_VERSION)
 
-const COLAMD_DATE = "Jan 17, 2023"
-
-const COLAMD_MAIN_VERSION = 3
-
-const COLAMD_SUB_VERSION = 0
-
-const COLAMD_SUBSUB_VERSION = 3
-
-COLAMD_VERSION_CODE(main, sub) = main * 1000 + sub
-
-const COLAMD_VERSION = COLAMD_VERSION_CODE(COLAMD_MAIN_VERSION, COLAMD_SUB_VERSION)
-
-const COLAMD_KNOBS = 20
-
-const COLAMD_STATS = 20
-
-const COLAMD_DENSE_ROW = 0
-
-const COLAMD_DENSE_COL = 1
-
-const COLAMD_AGGRESSIVE = 2
-
-const COLAMD_DEFRAG_COUNT = 2
-
-const COLAMD_STATUS = 3
-
-const COLAMD_INFO1 = 4
-
-const COLAMD_INFO2 = 5
-
-const COLAMD_INFO3 = 6
-
-const COLAMD_OK = 0
-
-const COLAMD_OK_BUT_JUMBLED = 1
-
-const COLAMD_ERROR_A_not_present = -1
-
-const COLAMD_ERROR_p_not_present = -2
-
-const COLAMD_ERROR_nrow_negative = -3
-
-const COLAMD_ERROR_ncol_negative = -4
-
-const COLAMD_ERROR_nnz_negative = -5
-
-const COLAMD_ERROR_p0_nonzero = -6
-
-const COLAMD_ERROR_A_too_small = -7
-
-const COLAMD_ERROR_col_length_negative = -8
-
-const COLAMD_ERROR_row_index_out_of_bounds = -9
-
-const COLAMD_ERROR_out_of_memory = -10
-
-const COLAMD_ERROR_internal_error = -999
-
-const CCOLAMD_DATE = "Jan 17, 2023"
-
-const CCOLAMD_MAIN_VERSION = 3
-
-const CCOLAMD_SUB_VERSION = 0
-
-const CCOLAMD_SUBSUB_VERSION = 3
-
-CCOLAMD_VERSION_CODE(main, sub) = main * 1000 + sub
-
-const CCOLAMD_VERSION = CCOLAMD_VERSION_CODE(CCOLAMD_MAIN_VERSION, CCOLAMD_SUB_VERSION)
-
-const CCOLAMD_KNOBS = 20
-
-const CCOLAMD_STATS = 20
-
-const CCOLAMD_DENSE_ROW = 0
-
-const CCOLAMD_DENSE_COL = 1
-
-const CCOLAMD_AGGRESSIVE = 2
-
-const CCOLAMD_LU = 3
-
-const CCOLAMD_DEFRAG_COUNT = 2
-
-const CCOLAMD_STATUS = 3
-
-const CCOLAMD_INFO1 = 4
-
-const CCOLAMD_INFO2 = 5
-
-const CCOLAMD_INFO3 = 6
-
-const CCOLAMD_EMPTY_ROW = 7
-
-const CCOLAMD_EMPTY_COL = 8
-
-const CCOLAMD_NEWLY_EMPTY_ROW = 9
-
-const CCOLAMD_NEWLY_EMPTY_COL = 10
-
-const CCOLAMD_OK = 0
-
-const CCOLAMD_OK_BUT_JUMBLED = 1
-
-const CCOLAMD_ERROR_A_not_present = -1
-
-const CCOLAMD_ERROR_p_not_present = -2
-
-const CCOLAMD_ERROR_nrow_negative = -3
-
-const CCOLAMD_ERROR_ncol_negative = -4
-
-const CCOLAMD_ERROR_nnz_negative = -5
-
-const CCOLAMD_ERROR_p0_nonzero = -6
-
-const CCOLAMD_ERROR_A_too_small = -7
-
-const CCOLAMD_ERROR_col_length_negative = -8
-
-const CCOLAMD_ERROR_row_index_out_of_bounds = -9
-
-const CCOLAMD_ERROR_out_of_memory = -10
-
-const CCOLAMD_ERROR_invalid_cmember = -11
-
-const CCOLAMD_ERROR_internal_error = -999
-
 const UMFPACK_INFO = 90
 
 const UMFPACK_CONTROL = 20
 
-# Skipping MacroDefinition: UMFPACK_COPYRIGHT \
-#"UMFPACK:  Copyright (c) 2005-2023 by Timothy A. Davis.  All Rights Reserved.\n"
-
-# Skipping MacroDefinition: UMFPACK_LICENSE_PART1 \
-#"\nUMFPACK License: SPDX-License-Identifier: GPL-2.0+\n" \
-#"   UMFPACK is available under alternate licenses,\n" \
-#"   contact T. Davis for details.\n"
-
-const UMFPACK_LICENSE_PART2 = "\n"
-
-# Skipping MacroDefinition: UMFPACK_LICENSE_PART3 \
-#"\n" \
-#"Availability: http://www.suitesparse.com" \
-#"\n"
-
-const UMFPACK_DATE = "Jan 17, 2023"
+const UMFPACK_DATE = "June 16, 2023"
 
 const UMFPACK_MAIN_VERSION = 6
 
 const UMFPACK_SUB_VERSION = 1
 
-const UMFPACK_SUBSUB_VERSION = 0
+const UMFPACK_SUBSUB_VERSION = 1
 
 UMFPACK_VER_CODE(main, sub) = main * 1000 + sub
 
@@ -3169,4 +3849,3 @@ const UMFPACK_Q_Uat = 12
 const UMFPACK_Ut = 13
 
 const UMFPACK_Uat = 14
-
diff --git a/src/solvers/lib/i686-linux-gnu.jl b/src/solvers/lib/i686-linux-gnu.jl
index fcf756d2..a5aa4e44 100644
--- a/src/solvers/lib/i686-linux-gnu.jl
+++ b/src/solvers/lib/i686-linux-gnu.jl
@@ -1,137 +1,150 @@
 function SuiteSparse_config_printf_func_get()
-    @ccall libcholmod.SuiteSparse_config_printf_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_printf_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_malloc_func_get()
-    @ccall libcholmod.SuiteSparse_config_malloc_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_malloc_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_calloc_func_get()
-    @ccall libcholmod.SuiteSparse_config_calloc_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_calloc_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_realloc_func_get()
-    @ccall libcholmod.SuiteSparse_config_realloc_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_realloc_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_free_func_get()
-    @ccall libcholmod.SuiteSparse_config_free_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_free_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_hypot_func_get()
-    @ccall libcholmod.SuiteSparse_config_hypot_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_hypot_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_divcomplex_func_get()
-    @ccall libcholmod.SuiteSparse_config_divcomplex_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_divcomplex_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_malloc_func_set(malloc_func)
-    @ccall libcholmod.SuiteSparse_config_malloc_func_set(malloc_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_malloc_func_set(malloc_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_calloc_func_set(calloc_func)
-    @ccall libcholmod.SuiteSparse_config_calloc_func_set(calloc_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_calloc_func_set(calloc_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_realloc_func_set(realloc_func)
-    @ccall libcholmod.SuiteSparse_config_realloc_func_set(realloc_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_realloc_func_set(realloc_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_free_func_set(free_func)
-    @ccall libcholmod.SuiteSparse_config_free_func_set(free_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_free_func_set(free_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_printf_func_set(printf_func)
-    @ccall libcholmod.SuiteSparse_config_printf_func_set(printf_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_printf_func_set(printf_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_hypot_func_set(hypot_func)
-    @ccall libcholmod.SuiteSparse_config_hypot_func_set(hypot_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_hypot_func_set(hypot_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_divcomplex_func_set(divcomplex_func)
-    @ccall libcholmod.SuiteSparse_config_divcomplex_func_set(divcomplex_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_divcomplex_func_set(divcomplex_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_malloc(s)
-    @ccall libcholmod.SuiteSparse_config_malloc(s::Csize_t)::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_malloc(s::Csize_t)::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_calloc(n, s)
-    @ccall libcholmod.SuiteSparse_config_calloc(n::Csize_t, s::Csize_t)::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_calloc(n::Csize_t,
+                                                          s::Csize_t)::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_realloc(arg1, s)
-    @ccall libcholmod.SuiteSparse_config_realloc(arg1::Ptr{Cvoid}, s::Csize_t)::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_realloc(arg1::Ptr{Cvoid},
+                                                           s::Csize_t)::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_free(arg1)
-    @ccall libcholmod.SuiteSparse_config_free(arg1::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_free(arg1::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_hypot(x, y)
-    @ccall libcholmod.SuiteSparse_config_hypot(x::Cdouble, y::Cdouble)::Cdouble
+    @ccall libsuitesparseconfig.SuiteSparse_config_hypot(x::Cdouble, y::Cdouble)::Cdouble
 end
 
 function SuiteSparse_config_divcomplex(xr, xi, yr, yi, zr, zi)
-    @ccall libcholmod.SuiteSparse_config_divcomplex(xr::Cdouble, xi::Cdouble, yr::Cdouble, yi::Cdouble, zr::Ptr{Cdouble}, zi::Ptr{Cdouble})::Cint
+    @ccall libsuitesparseconfig.SuiteSparse_config_divcomplex(xr::Cdouble, xi::Cdouble,
+                                                              yr::Cdouble, yi::Cdouble,
+                                                              zr::Ptr{Cdouble},
+                                                              zi::Ptr{Cdouble})::Cint
 end
 
 function SuiteSparse_start()
-    @ccall libcholmod.SuiteSparse_start()::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_start()::Cvoid
 end
 
 function SuiteSparse_finish()
-    @ccall libcholmod.SuiteSparse_finish()::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_finish()::Cvoid
 end
 
 function SuiteSparse_malloc(nitems, size_of_item)
-    @ccall libcholmod.SuiteSparse_malloc(nitems::Csize_t, size_of_item::Csize_t)::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_malloc(nitems::Csize_t,
+                                                   size_of_item::Csize_t)::Ptr{Cvoid}
 end
 
 function SuiteSparse_calloc(nitems, size_of_item)
-    @ccall libcholmod.SuiteSparse_calloc(nitems::Csize_t, size_of_item::Csize_t)::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_calloc(nitems::Csize_t,
+                                                   size_of_item::Csize_t)::Ptr{Cvoid}
 end
 
 function SuiteSparse_realloc(nitems_new, nitems_old, size_of_item, p, ok)
-    @ccall libcholmod.SuiteSparse_realloc(nitems_new::Csize_t, nitems_old::Csize_t, size_of_item::Csize_t, p::Ptr{Cvoid}, ok::Ptr{Cint})::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_realloc(nitems_new::Csize_t,
+                                                    nitems_old::Csize_t,
+                                                    size_of_item::Csize_t, p::Ptr{Cvoid},
+                                                    ok::Ptr{Cint})::Ptr{Cvoid}
 end
 
 function SuiteSparse_free(p)
-    @ccall libcholmod.SuiteSparse_free(p::Ptr{Cvoid})::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_free(p::Ptr{Cvoid})::Ptr{Cvoid}
 end
 
 function SuiteSparse_tic(tic)
-    @ccall libcholmod.SuiteSparse_tic(tic::Ptr{Cdouble})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_tic(tic::Ptr{Cdouble})::Cvoid
 end
 
 function SuiteSparse_toc(tic)
-    @ccall libcholmod.SuiteSparse_toc(tic::Ptr{Cdouble})::Cdouble
+    @ccall libsuitesparseconfig.SuiteSparse_toc(tic::Ptr{Cdouble})::Cdouble
 end
 
 function SuiteSparse_time()
-    @ccall libcholmod.SuiteSparse_time()::Cdouble
+    @ccall libsuitesparseconfig.SuiteSparse_time()::Cdouble
 end
 
 function SuiteSparse_hypot(x, y)
-    @ccall libcholmod.SuiteSparse_hypot(x::Cdouble, y::Cdouble)::Cdouble
+    @ccall libsuitesparseconfig.SuiteSparse_hypot(x::Cdouble, y::Cdouble)::Cdouble
 end
 
 function SuiteSparse_divcomplex(ar, ai, br, bi, cr, ci)
-    @ccall libcholmod.SuiteSparse_divcomplex(ar::Cdouble, ai::Cdouble, br::Cdouble, bi::Cdouble, cr::Ptr{Cdouble}, ci::Ptr{Cdouble})::Cint
+    @ccall libsuitesparseconfig.SuiteSparse_divcomplex(ar::Cdouble, ai::Cdouble,
+                                                       br::Cdouble, bi::Cdouble,
+                                                       cr::Ptr{Cdouble},
+                                                       ci::Ptr{Cdouble})::Cint
 end
 
 function SuiteSparse_version(version)
-    @ccall libcholmod.SuiteSparse_version(version::Ptr{Cint})::Cint
+    @ccall libsuitesparseconfig.SuiteSparse_version(version::Ptr{Cint})::Cint
 end
 
 function SuiteSparse_BLAS_library()
-    @ccall libcholmod.SuiteSparse_BLAS_library()::Ptr{Cchar}
+    @ccall libsuitesparseconfig.SuiteSparse_BLAS_library()::Ptr{Cchar}
 end
 
 function SuiteSparse_BLAS_integer_size()
-    @ccall libcholmod.SuiteSparse_BLAS_integer_size()::Csize_t
+    @ccall libsuitesparseconfig.SuiteSparse_BLAS_integer_size()::Csize_t
 end
 
 struct cholmod_method_struct
@@ -140,16 +153,16 @@ struct cholmod_method_struct
     prune_dense::Cdouble
     prune_dense2::Cdouble
     nd_oksep::Cdouble
-    other_1::NTuple{4, Cdouble}
+    other_1::NTuple{4,Cdouble}
     nd_small::Csize_t
-    other_2::NTuple{4, Csize_t}
+    other_2::NTuple{4,Csize_t}
     aggressive::Cint
     order_for_lu::Cint
     nd_compress::Cint
     nd_camd::Cint
     nd_components::Cint
     ordering::Cint
-    other_3::NTuple{4, Csize_t}
+    other_3::NTuple{4,Csize_t}
 end
 
 mutable struct cholmod_common_struct
@@ -166,8 +179,8 @@ mutable struct cholmod_common_struct
     final_pack::Cint
     final_monotonic::Cint
     final_resymbol::Cint
-    zrelax::NTuple{3, Cdouble}
-    nrelax::NTuple{3, Csize_t}
+    zrelax::NTuple{3,Cdouble}
+    nrelax::NTuple{3,Csize_t}
     prefer_zomplex::Cint
     prefer_upper::Cint
     quick_return_if_not_posdef::Cint
@@ -179,7 +192,7 @@ mutable struct cholmod_common_struct
     nmethods::Cint
     current::Cint
     selected::Cint
-    method::NTuple{10, cholmod_method_struct}
+    method::NTuple{10,cholmod_method_struct}
     postorder::Cint
     default_nesdis::Cint
     metis_memory::Cdouble
@@ -222,7 +235,7 @@ mutable struct cholmod_common_struct
     SPQR_flopcount_bound::Cdouble
     SPQR_tol_used::Cdouble
     SPQR_norm_E_fro::Cdouble
-    SPQR_istat::NTuple{10, Int64}
+    SPQR_istat::NTuple{10,Int64}
     useGPU::Cint
     maxGpuMemBytes::Csize_t
     maxGpuMemFraction::Cdouble
@@ -231,10 +244,10 @@ mutable struct cholmod_common_struct
     gpuFlops::Int64
     gpuNumKernelLaunches::Cint
     cublasHandle::Ptr{Cvoid}
-    gpuStream::NTuple{8, Ptr{Cvoid}}
-    cublasEventPotrf::NTuple{3, Ptr{Cvoid}}
+    gpuStream::NTuple{8,Ptr{Cvoid}}
+    cublasEventPotrf::NTuple{3,Ptr{Cvoid}}
     updateCKernelsComplete::Ptr{Cvoid}
-    updateCBuffersFree::NTuple{8, Ptr{Cvoid}}
+    updateCBuffersFree::NTuple{8,Ptr{Cvoid}}
     dev_mempool::Ptr{Cvoid}
     dev_mempool_size::Csize_t
     host_pinned_mempool::Ptr{Cvoid}
@@ -300,11 +313,14 @@ function cholmod_l_maxrank(arg1, arg2)
 end
 
 function cholmod_allocate_work(nrow, iworksize, xworksize, Common)
-    @ccall libcholmod.cholmod_allocate_work(nrow::Csize_t, iworksize::Csize_t, xworksize::Csize_t, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_allocate_work(nrow::Csize_t, iworksize::Csize_t,
+                                            xworksize::Csize_t,
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_allocate_work(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_allocate_work(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_allocate_work(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t,
+                                              arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_free_work(Common)
@@ -324,11 +340,13 @@ function cholmod_l_clear_flag(arg1)
 end
 
 function cholmod_error(status, file, line, message, Common)
-    @ccall libcholmod.cholmod_error(status::Cint, file::Ptr{Cchar}, line::Cint, message::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_error(status::Cint, file::Ptr{Cchar}, line::Cint,
+                                    message::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_error(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_error(arg1::Cint, arg2::Ptr{Cchar}, arg3::Cint, arg4::Ptr{Cchar}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_error(arg1::Cint, arg2::Ptr{Cchar}, arg3::Cint,
+                                      arg4::Ptr{Cchar}, arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_dbound(dj, Common)
@@ -348,11 +366,14 @@ function cholmod_l_hypot(arg1, arg2)
 end
 
 function cholmod_divcomplex(ar, ai, br, bi, cr, ci)
-    @ccall libcholmod.cholmod_divcomplex(ar::Cdouble, ai::Cdouble, br::Cdouble, bi::Cdouble, cr::Ptr{Cdouble}, ci::Ptr{Cdouble})::Cint
+    @ccall libcholmod.cholmod_divcomplex(ar::Cdouble, ai::Cdouble, br::Cdouble, bi::Cdouble,
+                                         cr::Ptr{Cdouble}, ci::Ptr{Cdouble})::Cint
 end
 
 function cholmod_l_divcomplex(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_divcomplex(arg1::Cdouble, arg2::Cdouble, arg3::Cdouble, arg4::Cdouble, arg5::Ptr{Cdouble}, arg6::Ptr{Cdouble})::Cint
+    @ccall libcholmod.cholmod_l_divcomplex(arg1::Cdouble, arg2::Cdouble, arg3::Cdouble,
+                                           arg4::Cdouble, arg5::Ptr{Cdouble},
+                                           arg6::Ptr{Cdouble})::Cint
 end
 
 mutable struct cholmod_sparse_struct
@@ -384,155 +405,217 @@ end
 const descendantScore = cholmod_descendant_score_t
 
 function cholmod_score_comp(i, j)
-    @ccall libcholmod.cholmod_score_comp(i::Ptr{cholmod_descendant_score_t}, j::Ptr{cholmod_descendant_score_t})::Cint
+    @ccall libcholmod.cholmod_score_comp(i::Ptr{cholmod_descendant_score_t},
+                                         j::Ptr{cholmod_descendant_score_t})::Cint
 end
 
 function cholmod_l_score_comp(i, j)
-    @ccall libcholmod.cholmod_l_score_comp(i::Ptr{cholmod_descendant_score_t}, j::Ptr{cholmod_descendant_score_t})::Cint
+    @ccall libcholmod.cholmod_l_score_comp(i::Ptr{cholmod_descendant_score_t},
+                                           j::Ptr{cholmod_descendant_score_t})::Cint
 end
 
 function cholmod_allocate_sparse(nrow, ncol, nzmax, sorted, packed, stype, xtype, Common)
-    @ccall libcholmod.cholmod_allocate_sparse(nrow::Csize_t, ncol::Csize_t, nzmax::Csize_t, sorted::Cint, packed::Cint, stype::Cint, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_allocate_sparse(nrow::Csize_t, ncol::Csize_t, nzmax::Csize_t,
+                                              sorted::Cint, packed::Cint, stype::Cint,
+                                              xtype::Cint,
+                                              Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_allocate_sparse(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
-    @ccall libcholmod.cholmod_l_allocate_sparse(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t, arg4::Cint, arg5::Cint, arg6::Cint, arg7::Cint, arg8::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_allocate_sparse(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t,
+                                                arg4::Cint, arg5::Cint, arg6::Cint,
+                                                arg7::Cint,
+                                                arg8::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_free_sparse(A, Common)
-    @ccall libcholmod.cholmod_free_sparse(A::Ptr{Ptr{cholmod_sparse}}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_free_sparse(A::Ptr{Ptr{cholmod_sparse}},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_free_sparse(arg1, arg2)
-    @ccall libcholmod.cholmod_l_free_sparse(arg1::Ptr{Ptr{cholmod_sparse}}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_free_sparse(arg1::Ptr{Ptr{cholmod_sparse}},
+                                            arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_reallocate_sparse(nznew, A, Common)
-    @ccall libcholmod.cholmod_reallocate_sparse(nznew::Csize_t, A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_reallocate_sparse(nznew::Csize_t, A::Ptr{cholmod_sparse},
+                                                Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_reallocate_sparse(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_reallocate_sparse(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_reallocate_sparse(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                                  arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_nnz(A, Common)
-    @ccall libcholmod.cholmod_nnz(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_nnz(A::Ptr{cholmod_sparse},
+                                  Common::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_l_nnz(arg1, arg2)
-    @ccall libcholmod.cholmod_l_nnz(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_l_nnz(arg1::Ptr{cholmod_sparse},
+                                    arg2::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_speye(nrow, ncol, xtype, Common)
-    @ccall libcholmod.cholmod_speye(nrow::Csize_t, ncol::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_speye(nrow::Csize_t, ncol::Csize_t, xtype::Cint,
+                                    Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_speye(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_speye(arg1::Csize_t, arg2::Csize_t, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_speye(arg1::Csize_t, arg2::Csize_t, arg3::Cint,
+                                      arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_spzeros(nrow, ncol, nzmax, xtype, Common)
-    @ccall libcholmod.cholmod_spzeros(nrow::Csize_t, ncol::Csize_t, nzmax::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_spzeros(nrow::Csize_t, ncol::Csize_t, nzmax::Csize_t,
+                                      xtype::Cint,
+                                      Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_spzeros(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_spzeros(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t, arg4::Cint, arg5::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_spzeros(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t,
+                                        arg4::Cint,
+                                        arg5::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_transpose(A, values, Common)
-    @ccall libcholmod.cholmod_transpose(A::Ptr{cholmod_sparse}, values::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_transpose(A::Ptr{cholmod_sparse}, values::Cint,
+                                        Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_transpose(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_transpose(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_transpose(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                          arg3::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_transpose_unsym(A, values, Perm, fset, fsize, F, Common)
-    @ccall libcholmod.cholmod_transpose_unsym(A::Ptr{cholmod_sparse}, values::Cint, Perm::Ptr{Int32}, fset::Ptr{Int32}, fsize::Csize_t, F::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_transpose_unsym(A::Ptr{cholmod_sparse}, values::Cint,
+                                              Perm::Ptr{Int32}, fset::Ptr{Int32},
+                                              fsize::Csize_t, F::Ptr{cholmod_sparse},
+                                              Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_transpose_unsym(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_transpose_unsym(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Csize_t, arg6::Ptr{cholmod_sparse}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_transpose_unsym(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                                arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                                arg5::Csize_t, arg6::Ptr{cholmod_sparse},
+                                                arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_transpose_sym(A, values, Perm, F, Common)
-    @ccall libcholmod.cholmod_transpose_sym(A::Ptr{cholmod_sparse}, values::Cint, Perm::Ptr{Int32}, F::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_transpose_sym(A::Ptr{cholmod_sparse}, values::Cint,
+                                            Perm::Ptr{Int32}, F::Ptr{cholmod_sparse},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_transpose_sym(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_transpose_sym(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{Int64}, arg4::Ptr{cholmod_sparse}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_transpose_sym(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                              arg3::Ptr{Int64}, arg4::Ptr{cholmod_sparse},
+                                              arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_ptranspose(A, values, Perm, fset, fsize, Common)
-    @ccall libcholmod.cholmod_ptranspose(A::Ptr{cholmod_sparse}, values::Cint, Perm::Ptr{Int32}, fset::Ptr{Int32}, fsize::Csize_t, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_ptranspose(A::Ptr{cholmod_sparse}, values::Cint,
+                                         Perm::Ptr{Int32}, fset::Ptr{Int32}, fsize::Csize_t,
+                                         Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_ptranspose(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_ptranspose(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Csize_t, arg6::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_ptranspose(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                           arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                           arg5::Csize_t,
+                                           arg6::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_sort(A, Common)
-    @ccall libcholmod.cholmod_sort(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_sort(A::Ptr{cholmod_sparse},
+                                   Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_sort(arg1, arg2)
-    @ccall libcholmod.cholmod_l_sort(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_sort(arg1::Ptr{cholmod_sparse},
+                                     arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_band(A, k1, k2, mode, Common)
-    @ccall libcholmod.cholmod_band(A::Ptr{cholmod_sparse}, k1::Int64, k2::Int64, mode::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_band(A::Ptr{cholmod_sparse}, k1::Int64, k2::Int64, mode::Cint,
+                                   Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_band(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_band(arg1::Ptr{cholmod_sparse}, arg2::Int64, arg3::Int64, arg4::Cint, arg5::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_band(arg1::Ptr{cholmod_sparse}, arg2::Int64, arg3::Int64,
+                                     arg4::Cint,
+                                     arg5::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_band_inplace(k1, k2, mode, A, Common)
-    @ccall libcholmod.cholmod_band_inplace(k1::Int64, k2::Int64, mode::Cint, A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_band_inplace(k1::Int64, k2::Int64, mode::Cint,
+                                           A::Ptr{cholmod_sparse},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_band_inplace(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_band_inplace(arg1::Int64, arg2::Int64, arg3::Cint, arg4::Ptr{cholmod_sparse}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_band_inplace(arg1::Int64, arg2::Int64, arg3::Cint,
+                                             arg4::Ptr{cholmod_sparse},
+                                             arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_aat(A, fset, fsize, mode, Common)
-    @ccall libcholmod.cholmod_aat(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, mode::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_aat(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t,
+                                  mode::Cint,
+                                  Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_aat(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_aat(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Cint, arg5::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_aat(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                    arg3::Csize_t, arg4::Cint,
+                                    arg5::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_copy_sparse(A, Common)
-    @ccall libcholmod.cholmod_copy_sparse(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_copy_sparse(A::Ptr{cholmod_sparse},
+                                          Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_copy_sparse(arg1, arg2)
-    @ccall libcholmod.cholmod_l_copy_sparse(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_copy_sparse(arg1::Ptr{cholmod_sparse},
+                                            arg2::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_copy(A, stype, mode, Common)
-    @ccall libcholmod.cholmod_copy(A::Ptr{cholmod_sparse}, stype::Cint, mode::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_copy(A::Ptr{cholmod_sparse}, stype::Cint, mode::Cint,
+                                   Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_copy(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_copy(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_copy(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Cint,
+                                     arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_add(A, B, alpha, beta, values, sorted, Common)
-    @ccall libcholmod.cholmod_add(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse}, alpha::Ptr{Cdouble}, beta::Ptr{Cdouble}, values::Cint, sorted::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_add(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse},
+                                  alpha::Ptr{Cdouble}, beta::Ptr{Cdouble}, values::Cint,
+                                  sorted::Cint,
+                                  Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_add(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_add(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Ptr{Cdouble}, arg5::Cint, arg6::Cint, arg7::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_add(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse},
+                                    arg3::Ptr{Cdouble}, arg4::Ptr{Cdouble}, arg5::Cint,
+                                    arg6::Cint,
+                                    arg7::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_sparse_xtype(to_xtype, A, Common)
-    @ccall libcholmod.cholmod_sparse_xtype(to_xtype::Cint, A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_sparse_xtype(to_xtype::Cint, A::Ptr{cholmod_sparse},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_sparse_xtype(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_sparse_xtype(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_sparse_xtype(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                             arg3::Ptr{cholmod_common})::Cint
 end
 
 mutable struct cholmod_factor_struct
@@ -572,75 +655,100 @@ end
 const cholmod_factor = cholmod_factor_struct
 
 function cholmod_allocate_factor(n, Common)
-    @ccall libcholmod.cholmod_allocate_factor(n::Csize_t, Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_allocate_factor(n::Csize_t,
+                                              Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_l_allocate_factor(arg1, arg2)
-    @ccall libcholmod.cholmod_l_allocate_factor(arg1::Csize_t, arg2::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_l_allocate_factor(arg1::Csize_t,
+                                                arg2::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_free_factor(L, Common)
-    @ccall libcholmod.cholmod_free_factor(L::Ptr{Ptr{cholmod_factor}}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_free_factor(L::Ptr{Ptr{cholmod_factor}},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_free_factor(arg1, arg2)
-    @ccall libcholmod.cholmod_l_free_factor(arg1::Ptr{Ptr{cholmod_factor}}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_free_factor(arg1::Ptr{Ptr{cholmod_factor}},
+                                            arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_reallocate_factor(nznew, L, Common)
-    @ccall libcholmod.cholmod_reallocate_factor(nznew::Csize_t, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_reallocate_factor(nznew::Csize_t, L::Ptr{cholmod_factor},
+                                                Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_reallocate_factor(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_reallocate_factor(arg1::Csize_t, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_reallocate_factor(arg1::Csize_t, arg2::Ptr{cholmod_factor},
+                                                  arg3::Ptr{cholmod_common})::Cint
 end
 
-function cholmod_change_factor(to_xtype, to_ll, to_super, to_packed, to_monotonic, L, Common)
-    @ccall libcholmod.cholmod_change_factor(to_xtype::Cint, to_ll::Cint, to_super::Cint, to_packed::Cint, to_monotonic::Cint, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+function cholmod_change_factor(to_xtype, to_ll, to_super, to_packed, to_monotonic, L,
+                               Common)
+    @ccall libcholmod.cholmod_change_factor(to_xtype::Cint, to_ll::Cint, to_super::Cint,
+                                            to_packed::Cint, to_monotonic::Cint,
+                                            L::Ptr{cholmod_factor},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_change_factor(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_change_factor(arg1::Cint, arg2::Cint, arg3::Cint, arg4::Cint, arg5::Cint, arg6::Ptr{cholmod_factor}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_change_factor(arg1::Cint, arg2::Cint, arg3::Cint,
+                                              arg4::Cint, arg5::Cint,
+                                              arg6::Ptr{cholmod_factor},
+                                              arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_pack_factor(L, Common)
-    @ccall libcholmod.cholmod_pack_factor(L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_pack_factor(L::Ptr{cholmod_factor},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_pack_factor(arg1, arg2)
-    @ccall libcholmod.cholmod_l_pack_factor(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_pack_factor(arg1::Ptr{cholmod_factor},
+                                            arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_reallocate_column(j, need, L, Common)
-    @ccall libcholmod.cholmod_reallocate_column(j::Csize_t, need::Csize_t, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_reallocate_column(j::Csize_t, need::Csize_t,
+                                                L::Ptr{cholmod_factor},
+                                                Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_reallocate_column(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_reallocate_column(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{cholmod_factor}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_reallocate_column(arg1::Csize_t, arg2::Csize_t,
+                                                  arg3::Ptr{cholmod_factor},
+                                                  arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_factor_to_sparse(L, Common)
-    @ccall libcholmod.cholmod_factor_to_sparse(L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_factor_to_sparse(L::Ptr{cholmod_factor},
+                                               Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_factor_to_sparse(arg1, arg2)
-    @ccall libcholmod.cholmod_l_factor_to_sparse(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_factor_to_sparse(arg1::Ptr{cholmod_factor},
+                                                 arg2::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_copy_factor(L, Common)
-    @ccall libcholmod.cholmod_copy_factor(L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_copy_factor(L::Ptr{cholmod_factor},
+                                          Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_l_copy_factor(arg1, arg2)
-    @ccall libcholmod.cholmod_l_copy_factor(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_l_copy_factor(arg1::Ptr{cholmod_factor},
+                                            arg2::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_factor_xtype(to_xtype, L, Common)
-    @ccall libcholmod.cholmod_factor_xtype(to_xtype::Cint, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_factor_xtype(to_xtype::Cint, L::Ptr{cholmod_factor},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_factor_xtype(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_factor_xtype(arg1::Cint, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_factor_xtype(arg1::Cint, arg2::Ptr{cholmod_factor},
+                                             arg3::Ptr{cholmod_common})::Cint
 end
 
 mutable struct cholmod_dense_struct
@@ -658,91 +766,118 @@ end
 const cholmod_dense = cholmod_dense_struct
 
 function cholmod_allocate_dense(nrow, ncol, d, xtype, Common)
-    @ccall libcholmod.cholmod_allocate_dense(nrow::Csize_t, ncol::Csize_t, d::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_allocate_dense(nrow::Csize_t, ncol::Csize_t, d::Csize_t,
+                                             xtype::Cint,
+                                             Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_allocate_dense(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_allocate_dense(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t, arg4::Cint, arg5::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_allocate_dense(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t,
+                                               arg4::Cint,
+                                               arg5::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_zeros(nrow, ncol, xtype, Common)
-    @ccall libcholmod.cholmod_zeros(nrow::Csize_t, ncol::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_zeros(nrow::Csize_t, ncol::Csize_t, xtype::Cint,
+                                    Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_zeros(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_zeros(arg1::Csize_t, arg2::Csize_t, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_zeros(arg1::Csize_t, arg2::Csize_t, arg3::Cint,
+                                      arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_ones(nrow, ncol, xtype, Common)
-    @ccall libcholmod.cholmod_ones(nrow::Csize_t, ncol::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_ones(nrow::Csize_t, ncol::Csize_t, xtype::Cint,
+                                   Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_ones(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_ones(arg1::Csize_t, arg2::Csize_t, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_ones(arg1::Csize_t, arg2::Csize_t, arg3::Cint,
+                                     arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_eye(nrow, ncol, xtype, Common)
-    @ccall libcholmod.cholmod_eye(nrow::Csize_t, ncol::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_eye(nrow::Csize_t, ncol::Csize_t, xtype::Cint,
+                                  Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_eye(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_eye(arg1::Csize_t, arg2::Csize_t, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_eye(arg1::Csize_t, arg2::Csize_t, arg3::Cint,
+                                    arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_free_dense(X, Common)
-    @ccall libcholmod.cholmod_free_dense(X::Ptr{Ptr{cholmod_dense}}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_free_dense(X::Ptr{Ptr{cholmod_dense}},
+                                         Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_free_dense(arg1, arg2)
-    @ccall libcholmod.cholmod_l_free_dense(arg1::Ptr{Ptr{cholmod_dense}}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_free_dense(arg1::Ptr{Ptr{cholmod_dense}},
+                                           arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_ensure_dense(XHandle, nrow, ncol, d, xtype, Common)
-    @ccall libcholmod.cholmod_ensure_dense(XHandle::Ptr{Ptr{cholmod_dense}}, nrow::Csize_t, ncol::Csize_t, d::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_ensure_dense(XHandle::Ptr{Ptr{cholmod_dense}}, nrow::Csize_t,
+                                           ncol::Csize_t, d::Csize_t, xtype::Cint,
+                                           Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_ensure_dense(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_ensure_dense(arg1::Ptr{Ptr{cholmod_dense}}, arg2::Csize_t, arg3::Csize_t, arg4::Csize_t, arg5::Cint, arg6::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_ensure_dense(arg1::Ptr{Ptr{cholmod_dense}}, arg2::Csize_t,
+                                             arg3::Csize_t, arg4::Csize_t, arg5::Cint,
+                                             arg6::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_sparse_to_dense(A, Common)
-    @ccall libcholmod.cholmod_sparse_to_dense(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_sparse_to_dense(A::Ptr{cholmod_sparse},
+                                              Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_sparse_to_dense(arg1, arg2)
-    @ccall libcholmod.cholmod_l_sparse_to_dense(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_sparse_to_dense(arg1::Ptr{cholmod_sparse},
+                                                arg2::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_dense_to_sparse(X, values, Common)
-    @ccall libcholmod.cholmod_dense_to_sparse(X::Ptr{cholmod_dense}, values::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_dense_to_sparse(X::Ptr{cholmod_dense}, values::Cint,
+                                              Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_dense_to_sparse(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_dense_to_sparse(arg1::Ptr{cholmod_dense}, arg2::Cint, arg3::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_dense_to_sparse(arg1::Ptr{cholmod_dense}, arg2::Cint,
+                                                arg3::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_copy_dense(X, Common)
-    @ccall libcholmod.cholmod_copy_dense(X::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_copy_dense(X::Ptr{cholmod_dense},
+                                         Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_copy_dense(arg1, arg2)
-    @ccall libcholmod.cholmod_l_copy_dense(arg1::Ptr{cholmod_dense}, arg2::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_copy_dense(arg1::Ptr{cholmod_dense},
+                                           arg2::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_copy_dense2(X, Y, Common)
-    @ccall libcholmod.cholmod_copy_dense2(X::Ptr{cholmod_dense}, Y::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_copy_dense2(X::Ptr{cholmod_dense}, Y::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_copy_dense2(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_copy_dense2(arg1::Ptr{cholmod_dense}, arg2::Ptr{cholmod_dense}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_copy_dense2(arg1::Ptr{cholmod_dense},
+                                            arg2::Ptr{cholmod_dense},
+                                            arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_dense_xtype(to_xtype, X, Common)
-    @ccall libcholmod.cholmod_dense_xtype(to_xtype::Cint, X::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_dense_xtype(to_xtype::Cint, X::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_dense_xtype(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_dense_xtype(arg1::Cint, arg2::Ptr{cholmod_dense}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_dense_xtype(arg1::Cint, arg2::Ptr{cholmod_dense},
+                                            arg3::Ptr{cholmod_common})::Cint
 end
 
 mutable struct cholmod_triplet_struct
@@ -764,99 +899,137 @@ end
 const cholmod_triplet = cholmod_triplet_struct
 
 function cholmod_allocate_triplet(nrow, ncol, nzmax, stype, xtype, Common)
-    @ccall libcholmod.cholmod_allocate_triplet(nrow::Csize_t, ncol::Csize_t, nzmax::Csize_t, stype::Cint, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_allocate_triplet(nrow::Csize_t, ncol::Csize_t, nzmax::Csize_t,
+                                               stype::Cint, xtype::Cint,
+                                               Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_l_allocate_triplet(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_allocate_triplet(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t, arg4::Cint, arg5::Cint, arg6::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_l_allocate_triplet(arg1::Csize_t, arg2::Csize_t,
+                                                 arg3::Csize_t, arg4::Cint, arg5::Cint,
+                                                 arg6::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_free_triplet(T, Common)
-    @ccall libcholmod.cholmod_free_triplet(T::Ptr{Ptr{cholmod_triplet}}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_free_triplet(T::Ptr{Ptr{cholmod_triplet}},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_free_triplet(arg1, arg2)
-    @ccall libcholmod.cholmod_l_free_triplet(arg1::Ptr{Ptr{cholmod_triplet}}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_free_triplet(arg1::Ptr{Ptr{cholmod_triplet}},
+                                             arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_reallocate_triplet(nznew, T, Common)
-    @ccall libcholmod.cholmod_reallocate_triplet(nznew::Csize_t, T::Ptr{cholmod_triplet}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_reallocate_triplet(nznew::Csize_t, T::Ptr{cholmod_triplet},
+                                                 Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_reallocate_triplet(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_reallocate_triplet(arg1::Csize_t, arg2::Ptr{cholmod_triplet}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_reallocate_triplet(arg1::Csize_t,
+                                                   arg2::Ptr{cholmod_triplet},
+                                                   arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_sparse_to_triplet(A, Common)
-    @ccall libcholmod.cholmod_sparse_to_triplet(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_sparse_to_triplet(A::Ptr{cholmod_sparse},
+                                                Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_l_sparse_to_triplet(arg1, arg2)
-    @ccall libcholmod.cholmod_l_sparse_to_triplet(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_l_sparse_to_triplet(arg1::Ptr{cholmod_sparse},
+                                                  arg2::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_triplet_to_sparse(T, nzmax, Common)
-    @ccall libcholmod.cholmod_triplet_to_sparse(T::Ptr{cholmod_triplet}, nzmax::Csize_t, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_triplet_to_sparse(T::Ptr{cholmod_triplet}, nzmax::Csize_t,
+                                                Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_triplet_to_sparse(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_triplet_to_sparse(arg1::Ptr{cholmod_triplet}, arg2::Csize_t, arg3::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_triplet_to_sparse(arg1::Ptr{cholmod_triplet}, arg2::Csize_t,
+                                                  arg3::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_copy_triplet(T, Common)
-    @ccall libcholmod.cholmod_copy_triplet(T::Ptr{cholmod_triplet}, Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_copy_triplet(T::Ptr{cholmod_triplet},
+                                           Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_l_copy_triplet(arg1, arg2)
-    @ccall libcholmod.cholmod_l_copy_triplet(arg1::Ptr{cholmod_triplet}, arg2::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_l_copy_triplet(arg1::Ptr{cholmod_triplet},
+                                             arg2::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_triplet_xtype(to_xtype, T, Common)
-    @ccall libcholmod.cholmod_triplet_xtype(to_xtype::Cint, T::Ptr{cholmod_triplet}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_triplet_xtype(to_xtype::Cint, T::Ptr{cholmod_triplet},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_triplet_xtype(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_triplet_xtype(arg1::Cint, arg2::Ptr{cholmod_triplet}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_triplet_xtype(arg1::Cint, arg2::Ptr{cholmod_triplet},
+                                              arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_malloc(n, size, Common)
-    @ccall libcholmod.cholmod_malloc(n::Csize_t, size::Csize_t, Common::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_malloc(n::Csize_t, size::Csize_t,
+                                     Common::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_l_malloc(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_malloc(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_l_malloc(arg1::Csize_t, arg2::Csize_t,
+                                       arg3::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_calloc(n, size, Common)
-    @ccall libcholmod.cholmod_calloc(n::Csize_t, size::Csize_t, Common::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_calloc(n::Csize_t, size::Csize_t,
+                                     Common::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_l_calloc(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_calloc(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_l_calloc(arg1::Csize_t, arg2::Csize_t,
+                                       arg3::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_free(n, size, p, Common)
-    @ccall libcholmod.cholmod_free(n::Csize_t, size::Csize_t, p::Ptr{Cvoid}, Common::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_free(n::Csize_t, size::Csize_t, p::Ptr{Cvoid},
+                                   Common::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_l_free(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_free(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{Cvoid}, arg4::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_l_free(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{Cvoid},
+                                     arg4::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_realloc(nnew, size, p, n, Common)
-    @ccall libcholmod.cholmod_realloc(nnew::Csize_t, size::Csize_t, p::Ptr{Cvoid}, n::Ptr{Csize_t}, Common::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_realloc(nnew::Csize_t, size::Csize_t, p::Ptr{Cvoid},
+                                      n::Ptr{Csize_t},
+                                      Common::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_l_realloc(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_realloc(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{Cvoid}, arg4::Ptr{Csize_t}, arg5::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_l_realloc(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{Cvoid},
+                                        arg4::Ptr{Csize_t},
+                                        arg5::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
-function cholmod_realloc_multiple(nnew, nint, xtype, Iblock, Jblock, Xblock, Zblock, n, Common)
-    @ccall libcholmod.cholmod_realloc_multiple(nnew::Csize_t, nint::Cint, xtype::Cint, Iblock::Ptr{Ptr{Cvoid}}, Jblock::Ptr{Ptr{Cvoid}}, Xblock::Ptr{Ptr{Cvoid}}, Zblock::Ptr{Ptr{Cvoid}}, n::Ptr{Csize_t}, Common::Ptr{cholmod_common})::Cint
+function cholmod_realloc_multiple(nnew, nint, xtype, Iblock, Jblock, Xblock, Zblock, n,
+                                  Common)
+    @ccall libcholmod.cholmod_realloc_multiple(nnew::Csize_t, nint::Cint, xtype::Cint,
+                                               Iblock::Ptr{Ptr{Cvoid}},
+                                               Jblock::Ptr{Ptr{Cvoid}},
+                                               Xblock::Ptr{Ptr{Cvoid}},
+                                               Zblock::Ptr{Ptr{Cvoid}}, n::Ptr{Csize_t},
+                                               Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_realloc_multiple(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
-    @ccall libcholmod.cholmod_l_realloc_multiple(arg1::Csize_t, arg2::Cint, arg3::Cint, arg4::Ptr{Ptr{Cvoid}}, arg5::Ptr{Ptr{Cvoid}}, arg6::Ptr{Ptr{Cvoid}}, arg7::Ptr{Ptr{Cvoid}}, arg8::Ptr{Csize_t}, arg9::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_realloc_multiple(arg1::Csize_t, arg2::Cint, arg3::Cint,
+                                                 arg4::Ptr{Ptr{Cvoid}},
+                                                 arg5::Ptr{Ptr{Cvoid}},
+                                                 arg6::Ptr{Ptr{Cvoid}},
+                                                 arg7::Ptr{Ptr{Cvoid}}, arg8::Ptr{Csize_t},
+                                                 arg9::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_version(version)
@@ -876,11 +1049,13 @@ function cholmod_l_check_common(arg1)
 end
 
 function cholmod_print_common(name, Common)
-    @ccall libcholmod.cholmod_print_common(name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_common(name::Ptr{Cchar},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_common(arg1, arg2)
-    @ccall libcholmod.cholmod_l_print_common(arg1::Ptr{Cchar}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_common(arg1::Ptr{Cchar},
+                                             arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_gpu_stats(arg1)
@@ -892,643 +1067,1047 @@ function cholmod_l_gpu_stats(arg1)
 end
 
 function cholmod_check_sparse(A, Common)
-    @ccall libcholmod.cholmod_check_sparse(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_sparse(A::Ptr{cholmod_sparse},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_sparse(arg1, arg2)
-    @ccall libcholmod.cholmod_l_check_sparse(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_sparse(arg1::Ptr{cholmod_sparse},
+                                             arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_sparse(A, name, Common)
-    @ccall libcholmod.cholmod_print_sparse(A::Ptr{cholmod_sparse}, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_sparse(A::Ptr{cholmod_sparse}, name::Ptr{Cchar},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_sparse(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_print_sparse(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Cchar}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_sparse(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Cchar},
+                                             arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_check_dense(X, Common)
-    @ccall libcholmod.cholmod_check_dense(X::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_dense(X::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_dense(arg1, arg2)
-    @ccall libcholmod.cholmod_l_check_dense(arg1::Ptr{cholmod_dense}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_dense(arg1::Ptr{cholmod_dense},
+                                            arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_dense(X, name, Common)
-    @ccall libcholmod.cholmod_print_dense(X::Ptr{cholmod_dense}, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_dense(X::Ptr{cholmod_dense}, name::Ptr{Cchar},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_dense(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_print_dense(arg1::Ptr{cholmod_dense}, arg2::Ptr{Cchar}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_dense(arg1::Ptr{cholmod_dense}, arg2::Ptr{Cchar},
+                                            arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_check_factor(L, Common)
-    @ccall libcholmod.cholmod_check_factor(L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_factor(L::Ptr{cholmod_factor},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_factor(arg1, arg2)
-    @ccall libcholmod.cholmod_l_check_factor(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_factor(arg1::Ptr{cholmod_factor},
+                                             arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_factor(L, name, Common)
-    @ccall libcholmod.cholmod_print_factor(L::Ptr{cholmod_factor}, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_factor(L::Ptr{cholmod_factor}, name::Ptr{Cchar},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_factor(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_print_factor(arg1::Ptr{cholmod_factor}, arg2::Ptr{Cchar}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_factor(arg1::Ptr{cholmod_factor}, arg2::Ptr{Cchar},
+                                             arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_check_triplet(T, Common)
-    @ccall libcholmod.cholmod_check_triplet(T::Ptr{cholmod_triplet}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_triplet(T::Ptr{cholmod_triplet},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_triplet(arg1, arg2)
-    @ccall libcholmod.cholmod_l_check_triplet(arg1::Ptr{cholmod_triplet}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_triplet(arg1::Ptr{cholmod_triplet},
+                                              arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_triplet(T, name, Common)
-    @ccall libcholmod.cholmod_print_triplet(T::Ptr{cholmod_triplet}, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_triplet(T::Ptr{cholmod_triplet}, name::Ptr{Cchar},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_triplet(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_print_triplet(arg1::Ptr{cholmod_triplet}, arg2::Ptr{Cchar}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_triplet(arg1::Ptr{cholmod_triplet}, arg2::Ptr{Cchar},
+                                              arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_check_subset(Set, len, n, Common)
-    @ccall libcholmod.cholmod_check_subset(Set::Ptr{Int32}, len::Int64, n::Csize_t, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_subset(Set::Ptr{Int32}, len::Int64, n::Csize_t,
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_subset(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_check_subset(arg1::Ptr{Int64}, arg2::Int64, arg3::Csize_t, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_subset(arg1::Ptr{Int64}, arg2::Int64, arg3::Csize_t,
+                                             arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_subset(Set, len, n, name, Common)
-    @ccall libcholmod.cholmod_print_subset(Set::Ptr{Int32}, len::Int64, n::Csize_t, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_subset(Set::Ptr{Int32}, len::Int64, n::Csize_t,
+                                           name::Ptr{Cchar},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_subset(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_print_subset(arg1::Ptr{Int64}, arg2::Int64, arg3::Csize_t, arg4::Ptr{Cchar}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_subset(arg1::Ptr{Int64}, arg2::Int64, arg3::Csize_t,
+                                             arg4::Ptr{Cchar},
+                                             arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_check_perm(Perm, len, n, Common)
-    @ccall libcholmod.cholmod_check_perm(Perm::Ptr{Int32}, len::Csize_t, n::Csize_t, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_perm(Perm::Ptr{Int32}, len::Csize_t, n::Csize_t,
+                                         Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_perm(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_check_perm(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Csize_t, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_perm(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Csize_t,
+                                           arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_perm(Perm, len, n, name, Common)
-    @ccall libcholmod.cholmod_print_perm(Perm::Ptr{Int32}, len::Csize_t, n::Csize_t, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_perm(Perm::Ptr{Int32}, len::Csize_t, n::Csize_t,
+                                         name::Ptr{Cchar},
+                                         Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_perm(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_print_perm(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Csize_t, arg4::Ptr{Cchar}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_perm(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Csize_t,
+                                           arg4::Ptr{Cchar},
+                                           arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_check_parent(Parent, n, Common)
-    @ccall libcholmod.cholmod_check_parent(Parent::Ptr{Int32}, n::Csize_t, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_parent(Parent::Ptr{Int32}, n::Csize_t,
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_parent(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_check_parent(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_parent(arg1::Ptr{Int64}, arg2::Csize_t,
+                                             arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_parent(Parent, n, name, Common)
-    @ccall libcholmod.cholmod_print_parent(Parent::Ptr{Int32}, n::Csize_t, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_parent(Parent::Ptr{Int32}, n::Csize_t, name::Ptr{Cchar},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_parent(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_print_parent(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Ptr{Cchar}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_parent(arg1::Ptr{Int64}, arg2::Csize_t,
+                                             arg3::Ptr{Cchar},
+                                             arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_read_sparse(f, Common)
-    @ccall libcholmod.cholmod_read_sparse(f::Ptr{Libc.FILE}, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_read_sparse(f::Ptr{Libc.FILE},
+                                          Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_read_sparse(arg1, arg2)
-    @ccall libcholmod.cholmod_l_read_sparse(arg1::Ptr{Libc.FILE}, arg2::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_read_sparse(arg1::Ptr{Libc.FILE},
+                                            arg2::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_read_triplet(f, Common)
-    @ccall libcholmod.cholmod_read_triplet(f::Ptr{Libc.FILE}, Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_read_triplet(f::Ptr{Libc.FILE},
+                                           Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_l_read_triplet(arg1, arg2)
-    @ccall libcholmod.cholmod_l_read_triplet(arg1::Ptr{Libc.FILE}, arg2::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_l_read_triplet(arg1::Ptr{Libc.FILE},
+                                             arg2::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_read_dense(f, Common)
-    @ccall libcholmod.cholmod_read_dense(f::Ptr{Libc.FILE}, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_read_dense(f::Ptr{Libc.FILE},
+                                         Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_read_dense(arg1, arg2)
-    @ccall libcholmod.cholmod_l_read_dense(arg1::Ptr{Libc.FILE}, arg2::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_read_dense(arg1::Ptr{Libc.FILE},
+                                           arg2::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_read_matrix(f, prefer, mtype, Common)
-    @ccall libcholmod.cholmod_read_matrix(f::Ptr{Libc.FILE}, prefer::Cint, mtype::Ptr{Cint}, Common::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_read_matrix(f::Ptr{Libc.FILE}, prefer::Cint, mtype::Ptr{Cint},
+                                          Common::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_l_read_matrix(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_read_matrix(arg1::Ptr{Libc.FILE}, arg2::Cint, arg3::Ptr{Cint}, arg4::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_l_read_matrix(arg1::Ptr{Libc.FILE}, arg2::Cint,
+                                            arg3::Ptr{Cint},
+                                            arg4::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_write_sparse(f, A, Z, comments, Common)
-    @ccall libcholmod.cholmod_write_sparse(f::Ptr{Libc.FILE}, A::Ptr{cholmod_sparse}, Z::Ptr{cholmod_sparse}, comments::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_write_sparse(f::Ptr{Libc.FILE}, A::Ptr{cholmod_sparse},
+                                           Z::Ptr{cholmod_sparse}, comments::Ptr{Cchar},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_write_sparse(arg1, arg2, arg3, c, arg5)
-    @ccall libcholmod.cholmod_l_write_sparse(arg1::Ptr{Libc.FILE}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_sparse}, c::Ptr{Cchar}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_write_sparse(arg1::Ptr{Libc.FILE},
+                                             arg2::Ptr{cholmod_sparse},
+                                             arg3::Ptr{cholmod_sparse}, c::Ptr{Cchar},
+                                             arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_write_dense(f, X, comments, Common)
-    @ccall libcholmod.cholmod_write_dense(f::Ptr{Libc.FILE}, X::Ptr{cholmod_dense}, comments::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_write_dense(f::Ptr{Libc.FILE}, X::Ptr{cholmod_dense},
+                                          comments::Ptr{Cchar},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_write_dense(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_write_dense(arg1::Ptr{Libc.FILE}, arg2::Ptr{cholmod_dense}, arg3::Ptr{Cchar}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_write_dense(arg1::Ptr{Libc.FILE}, arg2::Ptr{cholmod_dense},
+                                            arg3::Ptr{Cchar},
+                                            arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_analyze(A, Common)
-    @ccall libcholmod.cholmod_analyze(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_analyze(A::Ptr{cholmod_sparse},
+                                      Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_l_analyze(arg1, arg2)
-    @ccall libcholmod.cholmod_l_analyze(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_l_analyze(arg1::Ptr{cholmod_sparse},
+                                        arg2::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_analyze_p(A, UserPerm, fset, fsize, Common)
-    @ccall libcholmod.cholmod_analyze_p(A::Ptr{cholmod_sparse}, UserPerm::Ptr{Int32}, fset::Ptr{Int32}, fsize::Csize_t, Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_analyze_p(A::Ptr{cholmod_sparse}, UserPerm::Ptr{Int32},
+                                        fset::Ptr{Int32}, fsize::Csize_t,
+                                        Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_l_analyze_p(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_analyze_p(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Ptr{Int64}, arg4::Csize_t, arg5::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_l_analyze_p(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                          arg3::Ptr{Int64}, arg4::Csize_t,
+                                          arg5::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_analyze_p2(for_whom, A, UserPerm, fset, fsize, Common)
-    @ccall libcholmod.cholmod_analyze_p2(for_whom::Cint, A::Ptr{cholmod_sparse}, UserPerm::Ptr{Int32}, fset::Ptr{Int32}, fsize::Csize_t, Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_analyze_p2(for_whom::Cint, A::Ptr{cholmod_sparse},
+                                         UserPerm::Ptr{Int32}, fset::Ptr{Int32},
+                                         fsize::Csize_t,
+                                         Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_l_analyze_p2(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_analyze_p2(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Csize_t, arg6::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_l_analyze_p2(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                           arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                           arg5::Csize_t,
+                                           arg6::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_factorize(A, L, Common)
-    @ccall libcholmod.cholmod_factorize(A::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_factorize(A::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor},
+                                        Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_factorize(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_factorize(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_factorize(arg1::Ptr{cholmod_sparse},
+                                          arg2::Ptr{cholmod_factor},
+                                          arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_factorize_p(A, beta, fset, fsize, L, Common)
-    @ccall libcholmod.cholmod_factorize_p(A::Ptr{cholmod_sparse}, beta::Ptr{Cdouble}, fset::Ptr{Int32}, fsize::Csize_t, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_factorize_p(A::Ptr{cholmod_sparse}, beta::Ptr{Cdouble},
+                                          fset::Ptr{Int32}, fsize::Csize_t,
+                                          L::Ptr{cholmod_factor},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_factorize_p(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_factorize_p(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Cdouble}, arg3::Ptr{Int64}, arg4::Csize_t, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_factorize_p(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Cdouble},
+                                            arg3::Ptr{Int64}, arg4::Csize_t,
+                                            arg5::Ptr{cholmod_factor},
+                                            arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_solve(sys, L, B, Common)
-    @ccall libcholmod.cholmod_solve(sys::Cint, L::Ptr{cholmod_factor}, B::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_solve(sys::Cint, L::Ptr{cholmod_factor},
+                                    B::Ptr{cholmod_dense},
+                                    Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_solve(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_solve(arg1::Cint, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_dense}, arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_solve(arg1::Cint, arg2::Ptr{cholmod_factor},
+                                      arg3::Ptr{cholmod_dense},
+                                      arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_solve2(sys, L, B, Bset, X_Handle, Xset_Handle, Y_Handle, E_Handle, Common)
-    @ccall libcholmod.cholmod_solve2(sys::Cint, L::Ptr{cholmod_factor}, B::Ptr{cholmod_dense}, Bset::Ptr{cholmod_sparse}, X_Handle::Ptr{Ptr{cholmod_dense}}, Xset_Handle::Ptr{Ptr{cholmod_sparse}}, Y_Handle::Ptr{Ptr{cholmod_dense}}, E_Handle::Ptr{Ptr{cholmod_dense}}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_solve2(sys::Cint, L::Ptr{cholmod_factor},
+                                     B::Ptr{cholmod_dense}, Bset::Ptr{cholmod_sparse},
+                                     X_Handle::Ptr{Ptr{cholmod_dense}},
+                                     Xset_Handle::Ptr{Ptr{cholmod_sparse}},
+                                     Y_Handle::Ptr{Ptr{cholmod_dense}},
+                                     E_Handle::Ptr{Ptr{cholmod_dense}},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_solve2(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
-    @ccall libcholmod.cholmod_l_solve2(arg1::Cint, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_dense}, arg4::Ptr{cholmod_sparse}, arg5::Ptr{Ptr{cholmod_dense}}, arg6::Ptr{Ptr{cholmod_sparse}}, arg7::Ptr{Ptr{cholmod_dense}}, arg8::Ptr{Ptr{cholmod_dense}}, arg9::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_solve2(arg1::Cint, arg2::Ptr{cholmod_factor},
+                                       arg3::Ptr{cholmod_dense}, arg4::Ptr{cholmod_sparse},
+                                       arg5::Ptr{Ptr{cholmod_dense}},
+                                       arg6::Ptr{Ptr{cholmod_sparse}},
+                                       arg7::Ptr{Ptr{cholmod_dense}},
+                                       arg8::Ptr{Ptr{cholmod_dense}},
+                                       arg9::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_spsolve(sys, L, B, Common)
-    @ccall libcholmod.cholmod_spsolve(sys::Cint, L::Ptr{cholmod_factor}, B::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_spsolve(sys::Cint, L::Ptr{cholmod_factor},
+                                      B::Ptr{cholmod_sparse},
+                                      Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_spsolve(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_spsolve(arg1::Cint, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_sparse}, arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_spsolve(arg1::Cint, arg2::Ptr{cholmod_factor},
+                                        arg3::Ptr{cholmod_sparse},
+                                        arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_etree(A, Parent, Common)
-    @ccall libcholmod.cholmod_etree(A::Ptr{cholmod_sparse}, Parent::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_etree(A::Ptr{cholmod_sparse}, Parent::Ptr{Int32},
+                                    Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_etree(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_etree(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_etree(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                      arg3::Ptr{cholmod_common})::Cint
 end
 
-function cholmod_rowcolcounts(A, fset, fsize, Parent, Post, RowCount, ColCount, First, Level, Common)
-    @ccall libcholmod.cholmod_rowcolcounts(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, Parent::Ptr{Int32}, Post::Ptr{Int32}, RowCount::Ptr{Int32}, ColCount::Ptr{Int32}, First::Ptr{Int32}, Level::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+function cholmod_rowcolcounts(A, fset, fsize, Parent, Post, RowCount, ColCount, First,
+                              Level, Common)
+    @ccall libcholmod.cholmod_rowcolcounts(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                           fsize::Csize_t, Parent::Ptr{Int32},
+                                           Post::Ptr{Int32}, RowCount::Ptr{Int32},
+                                           ColCount::Ptr{Int32}, First::Ptr{Int32},
+                                           Level::Ptr{Int32},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowcolcounts(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)
-    @ccall libcholmod.cholmod_l_rowcolcounts(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{Int64}, arg6::Ptr{Int64}, arg7::Ptr{Int64}, arg8::Ptr{Int64}, arg9::Ptr{Int64}, arg10::Ptr{cholmod_common})::Cint
-end
-
-function cholmod_analyze_ordering(A, ordering, Perm, fset, fsize, Parent, Post, ColCount, First, Level, Common)
-    @ccall libcholmod.cholmod_analyze_ordering(A::Ptr{cholmod_sparse}, ordering::Cint, Perm::Ptr{Int32}, fset::Ptr{Int32}, fsize::Csize_t, Parent::Ptr{Int32}, Post::Ptr{Int32}, ColCount::Ptr{Int32}, First::Ptr{Int32}, Level::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
-end
-
-function cholmod_l_analyze_ordering(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11)
-    @ccall libcholmod.cholmod_l_analyze_ordering(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Csize_t, arg6::Ptr{Int64}, arg7::Ptr{Int64}, arg8::Ptr{Int64}, arg9::Ptr{Int64}, arg10::Ptr{Int64}, arg11::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowcolcounts(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                             arg3::Csize_t, arg4::Ptr{Int64},
+                                             arg5::Ptr{Int64}, arg6::Ptr{Int64},
+                                             arg7::Ptr{Int64}, arg8::Ptr{Int64},
+                                             arg9::Ptr{Int64},
+                                             arg10::Ptr{cholmod_common})::Cint
+end
+
+function cholmod_analyze_ordering(A, ordering, Perm, fset, fsize, Parent, Post, ColCount,
+                                  First, Level, Common)
+    @ccall libcholmod.cholmod_analyze_ordering(A::Ptr{cholmod_sparse}, ordering::Cint,
+                                               Perm::Ptr{Int32}, fset::Ptr{Int32},
+                                               fsize::Csize_t, Parent::Ptr{Int32},
+                                               Post::Ptr{Int32}, ColCount::Ptr{Int32},
+                                               First::Ptr{Int32}, Level::Ptr{Int32},
+                                               Common::Ptr{cholmod_common})::Cint
+end
+
+function cholmod_l_analyze_ordering(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9,
+                                    arg10, arg11)
+    @ccall libcholmod.cholmod_l_analyze_ordering(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                                 arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                                 arg5::Csize_t, arg6::Ptr{Int64},
+                                                 arg7::Ptr{Int64}, arg8::Ptr{Int64},
+                                                 arg9::Ptr{Int64}, arg10::Ptr{Int64},
+                                                 arg11::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_amd(A, fset, fsize, Perm, Common)
-    @ccall libcholmod.cholmod_amd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_amd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t,
+                                  Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_amd(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_amd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_amd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                    arg3::Csize_t, arg4::Ptr{Int64},
+                                    arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_colamd(A, fset, fsize, postorder, Perm, Common)
-    @ccall libcholmod.cholmod_colamd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, postorder::Cint, Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_colamd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                     fsize::Csize_t, postorder::Cint, Perm::Ptr{Int32},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_colamd(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_colamd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Cint, arg5::Ptr{Int64}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_colamd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                       arg3::Csize_t, arg4::Cint, arg5::Ptr{Int64},
+                                       arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowfac(A, F, beta, kstart, kend, L, Common)
-    @ccall libcholmod.cholmod_rowfac(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, beta::Ptr{Cdouble}, kstart::Csize_t, kend::Csize_t, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowfac(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse},
+                                     beta::Ptr{Cdouble}, kstart::Csize_t, kend::Csize_t,
+                                     L::Ptr{cholmod_factor},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowfac(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_rowfac(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Csize_t, arg5::Csize_t, arg6::Ptr{cholmod_factor}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowfac(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse},
+                                       arg3::Ptr{Cdouble}, arg4::Csize_t, arg5::Csize_t,
+                                       arg6::Ptr{cholmod_factor},
+                                       arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowfac_mask(A, F, beta, kstart, kend, mask, RLinkUp, L, Common)
-    @ccall libcholmod.cholmod_rowfac_mask(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, beta::Ptr{Cdouble}, kstart::Csize_t, kend::Csize_t, mask::Ptr{Int32}, RLinkUp::Ptr{Int32}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowfac_mask(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse},
+                                          beta::Ptr{Cdouble}, kstart::Csize_t,
+                                          kend::Csize_t, mask::Ptr{Int32},
+                                          RLinkUp::Ptr{Int32}, L::Ptr{cholmod_factor},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowfac_mask(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
-    @ccall libcholmod.cholmod_l_rowfac_mask(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Csize_t, arg5::Csize_t, arg6::Ptr{Int64}, arg7::Ptr{Int64}, arg8::Ptr{cholmod_factor}, arg9::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowfac_mask(arg1::Ptr{cholmod_sparse},
+                                            arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble},
+                                            arg4::Csize_t, arg5::Csize_t, arg6::Ptr{Int64},
+                                            arg7::Ptr{Int64}, arg8::Ptr{cholmod_factor},
+                                            arg9::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowfac_mask2(A, F, beta, kstart, kend, mask, maskmark, RLinkUp, L, Common)
-    @ccall libcholmod.cholmod_rowfac_mask2(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, beta::Ptr{Cdouble}, kstart::Csize_t, kend::Csize_t, mask::Ptr{Int32}, maskmark::Int32, RLinkUp::Ptr{Int32}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowfac_mask2(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse},
+                                           beta::Ptr{Cdouble}, kstart::Csize_t,
+                                           kend::Csize_t, mask::Ptr{Int32}, maskmark::Int32,
+                                           RLinkUp::Ptr{Int32}, L::Ptr{cholmod_factor},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowfac_mask2(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)
-    @ccall libcholmod.cholmod_l_rowfac_mask2(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Csize_t, arg5::Csize_t, arg6::Ptr{Int64}, arg7::Int64, arg8::Ptr{Int64}, arg9::Ptr{cholmod_factor}, arg10::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowfac_mask2(arg1::Ptr{cholmod_sparse},
+                                             arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble},
+                                             arg4::Csize_t, arg5::Csize_t, arg6::Ptr{Int64},
+                                             arg7::Int64, arg8::Ptr{Int64},
+                                             arg9::Ptr{cholmod_factor},
+                                             arg10::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_row_subtree(A, F, k, Parent, R, Common)
-    @ccall libcholmod.cholmod_row_subtree(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, k::Csize_t, Parent::Ptr{Int32}, R::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_row_subtree(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse},
+                                          k::Csize_t, Parent::Ptr{Int32},
+                                          R::Ptr{cholmod_sparse},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_row_subtree(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_row_subtree(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{cholmod_sparse}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_row_subtree(arg1::Ptr{cholmod_sparse},
+                                            arg2::Ptr{cholmod_sparse}, arg3::Csize_t,
+                                            arg4::Ptr{Int64}, arg5::Ptr{cholmod_sparse},
+                                            arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_lsolve_pattern(B, L, X, Common)
-    @ccall libcholmod.cholmod_lsolve_pattern(B::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_lsolve_pattern(B::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor},
+                                             X::Ptr{cholmod_sparse},
+                                             Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_lsolve_pattern(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_lsolve_pattern(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_sparse}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_lsolve_pattern(arg1::Ptr{cholmod_sparse},
+                                               arg2::Ptr{cholmod_factor},
+                                               arg3::Ptr{cholmod_sparse},
+                                               arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_row_lsubtree(A, Fi, fnz, k, L, R, Common)
-    @ccall libcholmod.cholmod_row_lsubtree(A::Ptr{cholmod_sparse}, Fi::Ptr{Int32}, fnz::Csize_t, k::Csize_t, L::Ptr{cholmod_factor}, R::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_row_lsubtree(A::Ptr{cholmod_sparse}, Fi::Ptr{Int32},
+                                           fnz::Csize_t, k::Csize_t, L::Ptr{cholmod_factor},
+                                           R::Ptr{cholmod_sparse},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_row_lsubtree(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_row_lsubtree(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Csize_t, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_sparse}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_row_lsubtree(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                             arg3::Csize_t, arg4::Csize_t,
+                                             arg5::Ptr{cholmod_factor},
+                                             arg6::Ptr{cholmod_sparse},
+                                             arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_resymbol(A, fset, fsize, pack, L, Common)
-    @ccall libcholmod.cholmod_resymbol(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, pack::Cint, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_resymbol(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                       fsize::Csize_t, pack::Cint, L::Ptr{cholmod_factor},
+                                       Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_resymbol(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_resymbol(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Cint, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_resymbol(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                         arg3::Csize_t, arg4::Cint,
+                                         arg5::Ptr{cholmod_factor},
+                                         arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_resymbol_noperm(A, fset, fsize, pack, L, Common)
-    @ccall libcholmod.cholmod_resymbol_noperm(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, pack::Cint, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_resymbol_noperm(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                              fsize::Csize_t, pack::Cint,
+                                              L::Ptr{cholmod_factor},
+                                              Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_resymbol_noperm(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_resymbol_noperm(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Cint, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_resymbol_noperm(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                                arg3::Csize_t, arg4::Cint,
+                                                arg5::Ptr{cholmod_factor},
+                                                arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rcond(L, Common)
-    @ccall libcholmod.cholmod_rcond(L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cdouble
+    @ccall libcholmod.cholmod_rcond(L::Ptr{cholmod_factor},
+                                    Common::Ptr{cholmod_common})::Cdouble
 end
 
 function cholmod_l_rcond(arg1, arg2)
-    @ccall libcholmod.cholmod_l_rcond(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_common})::Cdouble
+    @ccall libcholmod.cholmod_l_rcond(arg1::Ptr{cholmod_factor},
+                                      arg2::Ptr{cholmod_common})::Cdouble
 end
 
 function cholmod_postorder(Parent, n, Weight_p, Post, Common)
-    @ccall libcholmod.cholmod_postorder(Parent::Ptr{Int32}, n::Csize_t, Weight_p::Ptr{Int32}, Post::Ptr{Int32}, Common::Ptr{cholmod_common})::Int32
+    @ccall libcholmod.cholmod_postorder(Parent::Ptr{Int32}, n::Csize_t,
+                                        Weight_p::Ptr{Int32}, Post::Ptr{Int32},
+                                        Common::Ptr{cholmod_common})::Int32
 end
 
 function cholmod_l_postorder(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_postorder(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_l_postorder(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Ptr{Int64},
+                                          arg4::Ptr{Int64},
+                                          arg5::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_drop(tol, A, Common)
-    @ccall libcholmod.cholmod_drop(tol::Cdouble, A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_drop(tol::Cdouble, A::Ptr{cholmod_sparse},
+                                   Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_drop(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_drop(arg1::Cdouble, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_drop(arg1::Cdouble, arg2::Ptr{cholmod_sparse},
+                                     arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_norm_dense(X, norm, Common)
-    @ccall libcholmod.cholmod_norm_dense(X::Ptr{cholmod_dense}, norm::Cint, Common::Ptr{cholmod_common})::Cdouble
+    @ccall libcholmod.cholmod_norm_dense(X::Ptr{cholmod_dense}, norm::Cint,
+                                         Common::Ptr{cholmod_common})::Cdouble
 end
 
 function cholmod_l_norm_dense(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_norm_dense(arg1::Ptr{cholmod_dense}, arg2::Cint, arg3::Ptr{cholmod_common})::Cdouble
+    @ccall libcholmod.cholmod_l_norm_dense(arg1::Ptr{cholmod_dense}, arg2::Cint,
+                                           arg3::Ptr{cholmod_common})::Cdouble
 end
 
 function cholmod_norm_sparse(A, norm, Common)
-    @ccall libcholmod.cholmod_norm_sparse(A::Ptr{cholmod_sparse}, norm::Cint, Common::Ptr{cholmod_common})::Cdouble
+    @ccall libcholmod.cholmod_norm_sparse(A::Ptr{cholmod_sparse}, norm::Cint,
+                                          Common::Ptr{cholmod_common})::Cdouble
 end
 
 function cholmod_l_norm_sparse(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_norm_sparse(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{cholmod_common})::Cdouble
+    @ccall libcholmod.cholmod_l_norm_sparse(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                            arg3::Ptr{cholmod_common})::Cdouble
 end
 
 function cholmod_horzcat(A, B, values, Common)
-    @ccall libcholmod.cholmod_horzcat(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse}, values::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_horzcat(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse},
+                                      values::Cint,
+                                      Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_horzcat(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_horzcat(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_horzcat(arg1::Ptr{cholmod_sparse},
+                                        arg2::Ptr{cholmod_sparse}, arg3::Cint,
+                                        arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_scale(S, scale, A, Common)
-    @ccall libcholmod.cholmod_scale(S::Ptr{cholmod_dense}, scale::Cint, A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_scale(S::Ptr{cholmod_dense}, scale::Cint,
+                                    A::Ptr{cholmod_sparse},
+                                    Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_scale(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_scale(arg1::Ptr{cholmod_dense}, arg2::Cint, arg3::Ptr{cholmod_sparse}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_scale(arg1::Ptr{cholmod_dense}, arg2::Cint,
+                                      arg3::Ptr{cholmod_sparse},
+                                      arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_sdmult(A, transpose, alpha, beta, X, Y, Common)
-    @ccall libcholmod.cholmod_sdmult(A::Ptr{cholmod_sparse}, transpose::Cint, alpha::Ptr{Cdouble}, beta::Ptr{Cdouble}, X::Ptr{cholmod_dense}, Y::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_sdmult(A::Ptr{cholmod_sparse}, transpose::Cint,
+                                     alpha::Ptr{Cdouble}, beta::Ptr{Cdouble},
+                                     X::Ptr{cholmod_dense}, Y::Ptr{cholmod_dense},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_sdmult(arg1, arg2, arg3, arg4, arg5, Y, arg7)
-    @ccall libcholmod.cholmod_l_sdmult(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{Cdouble}, arg4::Ptr{Cdouble}, arg5::Ptr{cholmod_dense}, Y::Ptr{cholmod_dense}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_sdmult(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                       arg3::Ptr{Cdouble}, arg4::Ptr{Cdouble},
+                                       arg5::Ptr{cholmod_dense}, Y::Ptr{cholmod_dense},
+                                       arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_ssmult(A, B, stype, values, sorted, Common)
-    @ccall libcholmod.cholmod_ssmult(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse}, stype::Cint, values::Cint, sorted::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_ssmult(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse},
+                                     stype::Cint, values::Cint, sorted::Cint,
+                                     Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_ssmult(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_ssmult(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Cint, arg4::Cint, arg5::Cint, arg6::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_ssmult(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse},
+                                       arg3::Cint, arg4::Cint, arg5::Cint,
+                                       arg6::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_submatrix(A, rset, rsize, cset, csize, values, sorted, Common)
-    @ccall libcholmod.cholmod_submatrix(A::Ptr{cholmod_sparse}, rset::Ptr{Int32}, rsize::Int64, cset::Ptr{Int32}, csize::Int64, values::Cint, sorted::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_submatrix(A::Ptr{cholmod_sparse}, rset::Ptr{Int32},
+                                        rsize::Int64, cset::Ptr{Int32}, csize::Int64,
+                                        values::Cint, sorted::Cint,
+                                        Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_submatrix(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
-    @ccall libcholmod.cholmod_l_submatrix(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Int64, arg4::Ptr{Int64}, arg5::Int64, arg6::Cint, arg7::Cint, arg8::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_submatrix(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                          arg3::Int64, arg4::Ptr{Int64}, arg5::Int64,
+                                          arg6::Cint, arg7::Cint,
+                                          arg8::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_vertcat(A, B, values, Common)
-    @ccall libcholmod.cholmod_vertcat(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse}, values::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_vertcat(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse},
+                                      values::Cint,
+                                      Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_vertcat(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_vertcat(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_vertcat(arg1::Ptr{cholmod_sparse},
+                                        arg2::Ptr{cholmod_sparse}, arg3::Cint,
+                                        arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_symmetry(A, option, xmatched, pmatched, nzoffdiag, nzdiag, Common)
-    @ccall libcholmod.cholmod_symmetry(A::Ptr{cholmod_sparse}, option::Cint, xmatched::Ptr{Int32}, pmatched::Ptr{Int32}, nzoffdiag::Ptr{Int32}, nzdiag::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_symmetry(A::Ptr{cholmod_sparse}, option::Cint,
+                                       xmatched::Ptr{Int32}, pmatched::Ptr{Int32},
+                                       nzoffdiag::Ptr{Int32}, nzdiag::Ptr{Int32},
+                                       Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_symmetry(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_symmetry(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Ptr{Int64}, arg6::Ptr{Int64}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_symmetry(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                         arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                         arg5::Ptr{Int64}, arg6::Ptr{Int64},
+                                         arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_updown(update, C, L, Common)
-    @ccall libcholmod.cholmod_updown(update::Cint, C::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_updown(update::Cint, C::Ptr{cholmod_sparse},
+                                     L::Ptr{cholmod_factor},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_updown(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_updown(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_factor}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_updown(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                       arg3::Ptr{cholmod_factor},
+                                       arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_updown_solve(update, C, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_updown_solve(update::Cint, C::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_updown_solve(update::Cint, C::Ptr{cholmod_sparse},
+                                           L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense},
+                                           DeltaB::Ptr{cholmod_dense},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_updown_solve(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_updown_solve(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_factor}, arg4::Ptr{cholmod_dense}, arg5::Ptr{cholmod_dense}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_updown_solve(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                             arg3::Ptr{cholmod_factor},
+                                             arg4::Ptr{cholmod_dense},
+                                             arg5::Ptr{cholmod_dense},
+                                             arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_updown_mark(update, C, colmark, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_updown_mark(update::Cint, C::Ptr{cholmod_sparse}, colmark::Ptr{Int32}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_updown_mark(update::Cint, C::Ptr{cholmod_sparse},
+                                          colmark::Ptr{Int32}, L::Ptr{cholmod_factor},
+                                          X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_updown_mark(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_updown_mark(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Int64}, arg4::Ptr{cholmod_factor}, arg5::Ptr{cholmod_dense}, arg6::Ptr{cholmod_dense}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_updown_mark(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                            arg3::Ptr{Int64}, arg4::Ptr{cholmod_factor},
+                                            arg5::Ptr{cholmod_dense},
+                                            arg6::Ptr{cholmod_dense},
+                                            arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_updown_mask(update, C, colmark, mask, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_updown_mask(update::Cint, C::Ptr{cholmod_sparse}, colmark::Ptr{Int32}, mask::Ptr{Int32}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_updown_mask(update::Cint, C::Ptr{cholmod_sparse},
+                                          colmark::Ptr{Int32}, mask::Ptr{Int32},
+                                          L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense},
+                                          DeltaB::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_updown_mask(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
-    @ccall libcholmod.cholmod_l_updown_mask(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_dense}, arg7::Ptr{cholmod_dense}, arg8::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_updown_mask(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                            arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                            arg5::Ptr{cholmod_factor},
+                                            arg6::Ptr{cholmod_dense},
+                                            arg7::Ptr{cholmod_dense},
+                                            arg8::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_updown_mask2(update, C, colmark, mask, maskmark, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_updown_mask2(update::Cint, C::Ptr{cholmod_sparse}, colmark::Ptr{Int32}, mask::Ptr{Int32}, maskmark::Int32, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_updown_mask2(update::Cint, C::Ptr{cholmod_sparse},
+                                           colmark::Ptr{Int32}, mask::Ptr{Int32},
+                                           maskmark::Int32, L::Ptr{cholmod_factor},
+                                           X::Ptr{cholmod_dense},
+                                           DeltaB::Ptr{cholmod_dense},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_updown_mask2(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
-    @ccall libcholmod.cholmod_l_updown_mask2(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Int64, arg6::Ptr{cholmod_factor}, arg7::Ptr{cholmod_dense}, arg8::Ptr{cholmod_dense}, arg9::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_updown_mask2(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                             arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                             arg5::Int64, arg6::Ptr{cholmod_factor},
+                                             arg7::Ptr{cholmod_dense},
+                                             arg8::Ptr{cholmod_dense},
+                                             arg9::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowadd(k, R, L, Common)
-    @ccall libcholmod.cholmod_rowadd(k::Csize_t, R::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowadd(k::Csize_t, R::Ptr{cholmod_sparse},
+                                     L::Ptr{cholmod_factor},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowadd(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_rowadd(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_factor}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowadd(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                       arg3::Ptr{cholmod_factor},
+                                       arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowadd_solve(k, R, bk, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_rowadd_solve(k::Csize_t, R::Ptr{cholmod_sparse}, bk::Ptr{Cdouble}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowadd_solve(k::Csize_t, R::Ptr{cholmod_sparse},
+                                           bk::Ptr{Cdouble}, L::Ptr{cholmod_factor},
+                                           X::Ptr{cholmod_dense},
+                                           DeltaB::Ptr{cholmod_dense},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowadd_solve(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_rowadd_solve(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Ptr{cholmod_factor}, arg5::Ptr{cholmod_dense}, arg6::Ptr{cholmod_dense}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowadd_solve(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                             arg3::Ptr{Cdouble}, arg4::Ptr{cholmod_factor},
+                                             arg5::Ptr{cholmod_dense},
+                                             arg6::Ptr{cholmod_dense},
+                                             arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowadd_mark(k, R, bk, colmark, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_rowadd_mark(k::Csize_t, R::Ptr{cholmod_sparse}, bk::Ptr{Cdouble}, colmark::Ptr{Int32}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowadd_mark(k::Csize_t, R::Ptr{cholmod_sparse},
+                                          bk::Ptr{Cdouble}, colmark::Ptr{Int32},
+                                          L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense},
+                                          DeltaB::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowadd_mark(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
-    @ccall libcholmod.cholmod_l_rowadd_mark(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Ptr{Int64}, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_dense}, arg7::Ptr{cholmod_dense}, arg8::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowadd_mark(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                            arg3::Ptr{Cdouble}, arg4::Ptr{Int64},
+                                            arg5::Ptr{cholmod_factor},
+                                            arg6::Ptr{cholmod_dense},
+                                            arg7::Ptr{cholmod_dense},
+                                            arg8::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowdel(k, R, L, Common)
-    @ccall libcholmod.cholmod_rowdel(k::Csize_t, R::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowdel(k::Csize_t, R::Ptr{cholmod_sparse},
+                                     L::Ptr{cholmod_factor},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowdel(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_rowdel(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_factor}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowdel(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                       arg3::Ptr{cholmod_factor},
+                                       arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowdel_solve(k, R, yk, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_rowdel_solve(k::Csize_t, R::Ptr{cholmod_sparse}, yk::Ptr{Cdouble}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowdel_solve(k::Csize_t, R::Ptr{cholmod_sparse},
+                                           yk::Ptr{Cdouble}, L::Ptr{cholmod_factor},
+                                           X::Ptr{cholmod_dense},
+                                           DeltaB::Ptr{cholmod_dense},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowdel_solve(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_rowdel_solve(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Ptr{cholmod_factor}, arg5::Ptr{cholmod_dense}, arg6::Ptr{cholmod_dense}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowdel_solve(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                             arg3::Ptr{Cdouble}, arg4::Ptr{cholmod_factor},
+                                             arg5::Ptr{cholmod_dense},
+                                             arg6::Ptr{cholmod_dense},
+                                             arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowdel_mark(k, R, yk, colmark, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_rowdel_mark(k::Csize_t, R::Ptr{cholmod_sparse}, yk::Ptr{Cdouble}, colmark::Ptr{Int32}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowdel_mark(k::Csize_t, R::Ptr{cholmod_sparse},
+                                          yk::Ptr{Cdouble}, colmark::Ptr{Int32},
+                                          L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense},
+                                          DeltaB::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowdel_mark(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
-    @ccall libcholmod.cholmod_l_rowdel_mark(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Ptr{Int64}, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_dense}, arg7::Ptr{cholmod_dense}, arg8::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowdel_mark(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                            arg3::Ptr{Cdouble}, arg4::Ptr{Int64},
+                                            arg5::Ptr{cholmod_factor},
+                                            arg6::Ptr{cholmod_dense},
+                                            arg7::Ptr{cholmod_dense},
+                                            arg8::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_ccolamd(A, fset, fsize, Cmember, Perm, Common)
-    @ccall libcholmod.cholmod_ccolamd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, Cmember::Ptr{Int32}, Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_ccolamd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                      fsize::Csize_t, Cmember::Ptr{Int32}, Perm::Ptr{Int32},
+                                      Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_ccolamd(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_ccolamd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{Int64}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_ccolamd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                        arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{Int64},
+                                        arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_csymamd(A, Cmember, Perm, Common)
-    @ccall libcholmod.cholmod_csymamd(A::Ptr{cholmod_sparse}, Cmember::Ptr{Int32}, Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_csymamd(A::Ptr{cholmod_sparse}, Cmember::Ptr{Int32},
+                                      Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_csymamd(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_csymamd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Ptr{Int64}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_csymamd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                        arg3::Ptr{Int64}, arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_camd(A, fset, fsize, Cmember, Perm, Common)
-    @ccall libcholmod.cholmod_camd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, Cmember::Ptr{Int32}, Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_camd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t,
+                                   Cmember::Ptr{Int32}, Perm::Ptr{Int32},
+                                   Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_camd(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_camd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{Int64}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_camd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                     arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{Int64},
+                                     arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_nested_dissection(A, fset, fsize, Perm, CParent, Cmember, Common)
-    @ccall libcholmod.cholmod_nested_dissection(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, Perm::Ptr{Int32}, CParent::Ptr{Int32}, Cmember::Ptr{Int32}, Common::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_nested_dissection(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                                fsize::Csize_t, Perm::Ptr{Int32},
+                                                CParent::Ptr{Int32}, Cmember::Ptr{Int32},
+                                                Common::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_l_nested_dissection(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_nested_dissection(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{Int64}, arg6::Ptr{Int64}, arg7::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_l_nested_dissection(arg1::Ptr{cholmod_sparse},
+                                                  arg2::Ptr{Int64}, arg3::Csize_t,
+                                                  arg4::Ptr{Int64}, arg5::Ptr{Int64},
+                                                  arg6::Ptr{Int64},
+                                                  arg7::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_metis(A, fset, fsize, postorder, Perm, Common)
-    @ccall libcholmod.cholmod_metis(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, postorder::Cint, Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_metis(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                    fsize::Csize_t, postorder::Cint, Perm::Ptr{Int32},
+                                    Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_metis(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_metis(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Cint, arg5::Ptr{Int64}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_metis(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                      arg3::Csize_t, arg4::Cint, arg5::Ptr{Int64},
+                                      arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_bisect(A, fset, fsize, compress, Partition, Common)
-    @ccall libcholmod.cholmod_bisect(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, compress::Cint, Partition::Ptr{Int32}, Common::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_bisect(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                     fsize::Csize_t, compress::Cint, Partition::Ptr{Int32},
+                                     Common::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_l_bisect(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_bisect(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Cint, arg5::Ptr{Int64}, arg6::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_l_bisect(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                       arg3::Csize_t, arg4::Cint, arg5::Ptr{Int64},
+                                       arg6::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_metis_bisector(A, Anw, Aew, Partition, Common)
-    @ccall libcholmod.cholmod_metis_bisector(A::Ptr{cholmod_sparse}, Anw::Ptr{Int32}, Aew::Ptr{Int32}, Partition::Ptr{Int32}, Common::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_metis_bisector(A::Ptr{cholmod_sparse}, Anw::Ptr{Int32},
+                                             Aew::Ptr{Int32}, Partition::Ptr{Int32},
+                                             Common::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_l_metis_bisector(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_metis_bisector(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_l_metis_bisector(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                               arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                               arg5::Ptr{cholmod_common})::Int64
 end
 
-function cholmod_collapse_septree(n, ncomponents, nd_oksep, nd_small, CParent, Cmember, Common)
-    @ccall libcholmod.cholmod_collapse_septree(n::Csize_t, ncomponents::Csize_t, nd_oksep::Cdouble, nd_small::Csize_t, CParent::Ptr{Int32}, Cmember::Ptr{Int32}, Common::Ptr{cholmod_common})::Int64
+function cholmod_collapse_septree(n, ncomponents, nd_oksep, nd_small, CParent, Cmember,
+                                  Common)
+    @ccall libcholmod.cholmod_collapse_septree(n::Csize_t, ncomponents::Csize_t,
+                                               nd_oksep::Cdouble, nd_small::Csize_t,
+                                               CParent::Ptr{Int32}, Cmember::Ptr{Int32},
+                                               Common::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_l_collapse_septree(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_collapse_septree(arg1::Csize_t, arg2::Csize_t, arg3::Cdouble, arg4::Csize_t, arg5::Ptr{Int64}, arg6::Ptr{Int64}, arg7::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_l_collapse_septree(arg1::Csize_t, arg2::Csize_t,
+                                                 arg3::Cdouble, arg4::Csize_t,
+                                                 arg5::Ptr{Int64}, arg6::Ptr{Int64},
+                                                 arg7::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_super_symbolic(A, F, Parent, L, Common)
-    @ccall libcholmod.cholmod_super_symbolic(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, Parent::Ptr{Int32}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_super_symbolic(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse},
+                                             Parent::Ptr{Int32}, L::Ptr{cholmod_factor},
+                                             Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_super_symbolic(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_super_symbolic(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Int64}, arg4::Ptr{cholmod_factor}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_super_symbolic(arg1::Ptr{cholmod_sparse},
+                                               arg2::Ptr{cholmod_sparse}, arg3::Ptr{Int64},
+                                               arg4::Ptr{cholmod_factor},
+                                               arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_super_symbolic2(for_whom, A, F, Parent, L, Common)
-    @ccall libcholmod.cholmod_super_symbolic2(for_whom::Cint, A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, Parent::Ptr{Int32}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_super_symbolic2(for_whom::Cint, A::Ptr{cholmod_sparse},
+                                              F::Ptr{cholmod_sparse}, Parent::Ptr{Int32},
+                                              L::Ptr{cholmod_factor},
+                                              Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_super_symbolic2(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_super_symbolic2(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_sparse}, arg4::Ptr{Int64}, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_super_symbolic2(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                                arg3::Ptr{cholmod_sparse}, arg4::Ptr{Int64},
+                                                arg5::Ptr{cholmod_factor},
+                                                arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_super_numeric(A, F, beta, L, Common)
-    @ccall libcholmod.cholmod_super_numeric(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, beta::Ptr{Cdouble}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_super_numeric(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse},
+                                            beta::Ptr{Cdouble}, L::Ptr{cholmod_factor},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_super_numeric(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_super_numeric(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Ptr{cholmod_factor}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_super_numeric(arg1::Ptr{cholmod_sparse},
+                                              arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble},
+                                              arg4::Ptr{cholmod_factor},
+                                              arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_super_lsolve(L, X, E, Common)
-    @ccall libcholmod.cholmod_super_lsolve(L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, E::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_super_lsolve(L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense},
+                                           E::Ptr{cholmod_dense},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_super_lsolve(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_super_lsolve(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_dense}, arg3::Ptr{cholmod_dense}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_super_lsolve(arg1::Ptr{cholmod_factor},
+                                             arg2::Ptr{cholmod_dense},
+                                             arg3::Ptr{cholmod_dense},
+                                             arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_super_ltsolve(L, X, E, Common)
-    @ccall libcholmod.cholmod_super_ltsolve(L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, E::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_super_ltsolve(L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense},
+                                            E::Ptr{cholmod_dense},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_super_ltsolve(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_super_ltsolve(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_dense}, arg3::Ptr{cholmod_dense}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_super_ltsolve(arg1::Ptr{cholmod_factor},
+                                              arg2::Ptr{cholmod_dense},
+                                              arg3::Ptr{cholmod_dense},
+                                              arg4::Ptr{cholmod_common})::Cint
+end
+
+function SuiteSparseQR_C(ordering, tol, econ, getCTX, A, Bsparse, Bdense, Zsparse, Zdense,
+                         R, E, H, HPinv, HTau, cc)
+    @ccall libspqr.SuiteSparseQR_C(ordering::Cint, tol::Cdouble, econ::Int64, getCTX::Cint,
+                                   A::Ptr{cholmod_sparse}, Bsparse::Ptr{cholmod_sparse},
+                                   Bdense::Ptr{cholmod_dense},
+                                   Zsparse::Ptr{Ptr{cholmod_sparse}},
+                                   Zdense::Ptr{Ptr{cholmod_dense}},
+                                   R::Ptr{Ptr{cholmod_sparse}}, E::Ptr{Ptr{Int64}},
+                                   H::Ptr{Ptr{cholmod_sparse}}, HPinv::Ptr{Ptr{Int64}},
+                                   HTau::Ptr{Ptr{cholmod_dense}},
+                                   cc::Ptr{cholmod_common})::Int64
+end
+
+function SuiteSparseQR_i_C(ordering, tol, econ, getCTX, A, Bsparse, Bdense, Zsparse, Zdense,
+                           R, E, H, HPinv, HTau, cc)
+    @ccall libspqr.SuiteSparseQR_i_C(ordering::Cint, tol::Cdouble, econ::Int32,
+                                     getCTX::Cint, A::Ptr{cholmod_sparse},
+                                     Bsparse::Ptr{cholmod_sparse},
+                                     Bdense::Ptr{cholmod_dense},
+                                     Zsparse::Ptr{Ptr{cholmod_sparse}},
+                                     Zdense::Ptr{Ptr{cholmod_dense}},
+                                     R::Ptr{Ptr{cholmod_sparse}}, E::Ptr{Ptr{Int32}},
+                                     H::Ptr{Ptr{cholmod_sparse}}, HPinv::Ptr{Ptr{Int32}},
+                                     HTau::Ptr{Ptr{cholmod_dense}},
+                                     cc::Ptr{cholmod_common})::Int32
 end
 
-function SuiteSparseQR_C(ordering, tol, econ, getCTX, A, Bsparse, Bdense, Zsparse, Zdense, R, E, H, HPinv, HTau, cc)
-    @ccall libspqr.SuiteSparseQR_C(ordering::Cint, tol::Cdouble, econ::Int64, getCTX::Cint, A::Ptr{cholmod_sparse}, Bsparse::Ptr{cholmod_sparse}, Bdense::Ptr{cholmod_dense}, Zsparse::Ptr{Ptr{cholmod_sparse}}, Zdense::Ptr{Ptr{cholmod_dense}}, R::Ptr{Ptr{cholmod_sparse}}, E::Ptr{Ptr{Int64}}, H::Ptr{Ptr{cholmod_sparse}}, HPinv::Ptr{Ptr{Int64}}, HTau::Ptr{Ptr{cholmod_dense}}, cc::Ptr{cholmod_common})::Int64
+function SuiteSparseQR_C_QR(ordering, tol, econ, A, Q, R, E, cc)
+    @ccall libspqr.SuiteSparseQR_C_QR(ordering::Cint, tol::Cdouble, econ::Int64,
+                                      A::Ptr{cholmod_sparse}, Q::Ptr{Ptr{cholmod_sparse}},
+                                      R::Ptr{Ptr{cholmod_sparse}}, E::Ptr{Ptr{Int64}},
+                                      cc::Ptr{cholmod_common})::Int64
 end
 
-function SuiteSparseQR_C_QR(ordering, tol, econ, A, Q, R, E, cc)
-    @ccall libspqr.SuiteSparseQR_C_QR(ordering::Cint, tol::Cdouble, econ::Int64, A::Ptr{cholmod_sparse}, Q::Ptr{Ptr{cholmod_sparse}}, R::Ptr{Ptr{cholmod_sparse}}, E::Ptr{Ptr{Int64}}, cc::Ptr{cholmod_common})::Int64
+function SuiteSparseQR_i_C_QR(ordering, tol, econ, A, Q, R, E, cc)
+    @ccall libspqr.SuiteSparseQR_i_C_QR(ordering::Cint, tol::Cdouble, econ::Int32,
+                                        A::Ptr{cholmod_sparse}, Q::Ptr{Ptr{cholmod_sparse}},
+                                        R::Ptr{Ptr{cholmod_sparse}}, E::Ptr{Ptr{Int32}},
+                                        cc::Ptr{cholmod_common})::Int32
 end
 
 function SuiteSparseQR_C_backslash(ordering, tol, A, B, cc)
-    @ccall libspqr.SuiteSparseQR_C_backslash(ordering::Cint, tol::Cdouble, A::Ptr{cholmod_sparse}, B::Ptr{cholmod_dense}, cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libspqr.SuiteSparseQR_C_backslash(ordering::Cint, tol::Cdouble,
+                                             A::Ptr{cholmod_sparse}, B::Ptr{cholmod_dense},
+                                             cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function SuiteSparseQR_C_backslash_default(A, B, cc)
-    @ccall libspqr.SuiteSparseQR_C_backslash_default(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_dense}, cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libspqr.SuiteSparseQR_C_backslash_default(A::Ptr{cholmod_sparse},
+                                                     B::Ptr{cholmod_dense},
+                                                     cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function SuiteSparseQR_C_backslash_sparse(ordering, tol, A, B, cc)
-    @ccall libspqr.SuiteSparseQR_C_backslash_sparse(ordering::Cint, tol::Cdouble, A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse}, cc::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libspqr.SuiteSparseQR_C_backslash_sparse(ordering::Cint, tol::Cdouble,
+                                                    A::Ptr{cholmod_sparse},
+                                                    B::Ptr{cholmod_sparse},
+                                                    cc::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 mutable struct SuiteSparseQR_C_factorization_struct
     xtype::Cint
+    itype::Cint
     factors::Ptr{Cvoid}
     SuiteSparseQR_C_factorization_struct() = new()
 end
@@ -1536,51 +2115,78 @@ end
 const SuiteSparseQR_C_factorization = SuiteSparseQR_C_factorization_struct
 
 function SuiteSparseQR_C_factorize(ordering, tol, A, cc)
-    @ccall libspqr.SuiteSparseQR_C_factorize(ordering::Cint, tol::Cdouble, A::Ptr{cholmod_sparse}, cc::Ptr{cholmod_common})::Ptr{SuiteSparseQR_C_factorization}
+    @ccall libspqr.SuiteSparseQR_C_factorize(ordering::Cint, tol::Cdouble,
+                                             A::Ptr{cholmod_sparse},
+                                             cc::Ptr{cholmod_common})::Ptr{SuiteSparseQR_C_factorization}
 end
 
 function SuiteSparseQR_C_symbolic(ordering, allow_tol, A, cc)
-    @ccall libspqr.SuiteSparseQR_C_symbolic(ordering::Cint, allow_tol::Cint, A::Ptr{cholmod_sparse}, cc::Ptr{cholmod_common})::Ptr{SuiteSparseQR_C_factorization}
+    @ccall libspqr.SuiteSparseQR_C_symbolic(ordering::Cint, allow_tol::Cint,
+                                            A::Ptr{cholmod_sparse},
+                                            cc::Ptr{cholmod_common})::Ptr{SuiteSparseQR_C_factorization}
 end
 
 function SuiteSparseQR_C_numeric(tol, A, QR, cc)
-    @ccall libspqr.SuiteSparseQR_C_numeric(tol::Cdouble, A::Ptr{cholmod_sparse}, QR::Ptr{SuiteSparseQR_C_factorization}, cc::Ptr{cholmod_common})::Cint
+    @ccall libspqr.SuiteSparseQR_C_numeric(tol::Cdouble, A::Ptr{cholmod_sparse},
+                                           QR::Ptr{SuiteSparseQR_C_factorization},
+                                           cc::Ptr{cholmod_common})::Cint
 end
 
 function SuiteSparseQR_C_free(QR, cc)
-    @ccall libspqr.SuiteSparseQR_C_free(QR::Ptr{Ptr{SuiteSparseQR_C_factorization}}, cc::Ptr{cholmod_common})::Cint
+    @ccall libspqr.SuiteSparseQR_C_free(QR::Ptr{Ptr{SuiteSparseQR_C_factorization}},
+                                        cc::Ptr{cholmod_common})::Cint
 end
 
 function SuiteSparseQR_C_solve(system, QR, B, cc)
-    @ccall libspqr.SuiteSparseQR_C_solve(system::Cint, QR::Ptr{SuiteSparseQR_C_factorization}, B::Ptr{cholmod_dense}, cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libspqr.SuiteSparseQR_C_solve(system::Cint,
+                                         QR::Ptr{SuiteSparseQR_C_factorization},
+                                         B::Ptr{cholmod_dense},
+                                         cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function SuiteSparseQR_C_qmult(method, QR, X, cc)
-    @ccall libspqr.SuiteSparseQR_C_qmult(method::Cint, QR::Ptr{SuiteSparseQR_C_factorization}, X::Ptr{cholmod_dense}, cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libspqr.SuiteSparseQR_C_qmult(method::Cint,
+                                         QR::Ptr{SuiteSparseQR_C_factorization},
+                                         X::Ptr{cholmod_dense},
+                                         cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function amd_order(n, Ap, Ai, P, Control, Info)
-    @ccall libamd.amd_order(n::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, P::Ptr{Int32}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libamd.amd_order(n::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, P::Ptr{Int32},
+                            Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function amd_l_order(n, Ap, Ai, P, Control, Info)
-    @ccall libamd.amd_l_order(n::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, P::Ptr{Int64}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libamd.amd_l_order(n::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, P::Ptr{Int64},
+                              Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
-function amd_2(n, Pe, Iw, Len, iwlen, pfree, Nv, Next, Last, Head, Elen, Degree, W, Control, Info)
-    @ccall libamd.amd_2(n::Int32, Pe::Ptr{Int32}, Iw::Ptr{Int32}, Len::Ptr{Int32}, iwlen::Int32, pfree::Int32, Nv::Ptr{Int32}, Next::Ptr{Int32}, Last::Ptr{Int32}, Head::Ptr{Int32}, Elen::Ptr{Int32}, Degree::Ptr{Int32}, W::Ptr{Int32}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cvoid
+function amd_2(n, Pe, Iw, Len, iwlen, pfree, Nv, Next, Last, Head, Elen, Degree, W, Control,
+               Info)
+    @ccall libamd.amd_2(n::Int32, Pe::Ptr{Int32}, Iw::Ptr{Int32}, Len::Ptr{Int32},
+                        iwlen::Int32, pfree::Int32, Nv::Ptr{Int32}, Next::Ptr{Int32},
+                        Last::Ptr{Int32}, Head::Ptr{Int32}, Elen::Ptr{Int32},
+                        Degree::Ptr{Int32}, W::Ptr{Int32}, Control::Ptr{Cdouble},
+                        Info::Ptr{Cdouble})::Cvoid
 end
 
-function amd_l2(n, Pe, Iw, Len, iwlen, pfree, Nv, Next, Last, Head, Elen, Degree, W, Control, Info)
-    @ccall libamd.amd_l2(n::Int64, Pe::Ptr{Int64}, Iw::Ptr{Int64}, Len::Ptr{Int64}, iwlen::Int64, pfree::Int64, Nv::Ptr{Int64}, Next::Ptr{Int64}, Last::Ptr{Int64}, Head::Ptr{Int64}, Elen::Ptr{Int64}, Degree::Ptr{Int64}, W::Ptr{Int64}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cvoid
+function amd_l2(n, Pe, Iw, Len, iwlen, pfree, Nv, Next, Last, Head, Elen, Degree, W,
+                Control, Info)
+    @ccall libamd.amd_l2(n::Int64, Pe::Ptr{Int64}, Iw::Ptr{Int64}, Len::Ptr{Int64},
+                         iwlen::Int64, pfree::Int64, Nv::Ptr{Int64}, Next::Ptr{Int64},
+                         Last::Ptr{Int64}, Head::Ptr{Int64}, Elen::Ptr{Int64},
+                         Degree::Ptr{Int64}, W::Ptr{Int64}, Control::Ptr{Cdouble},
+                         Info::Ptr{Cdouble})::Cvoid
 end
 
 function amd_valid(n_row, n_col, Ap, Ai)
-    @ccall libamd.amd_valid(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32})::Cint
+    @ccall libamd.amd_valid(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                            Ai::Ptr{Int32})::Cint
 end
 
 function amd_l_valid(n_row, n_col, Ap, Ai)
-    @ccall libamd.amd_l_valid(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64})::Cint
+    @ccall libamd.amd_l_valid(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                              Ai::Ptr{Int64})::Cint
 end
 
 function amd_defaults(Control)
@@ -1607,188 +2213,88 @@ function amd_l_info(Info)
     @ccall libamd.amd_l_info(Info::Ptr{Cdouble})::Cvoid
 end
 
-function colamd_recommended(nnz, n_row, n_col)
-    @ccall libcolamd.colamd_recommended(nnz::Int32, n_row::Int32, n_col::Int32)::Csize_t
-end
-
-function colamd_l_recommended(nnz, n_row, n_col)
-    @ccall libcolamd.colamd_l_recommended(nnz::Int64, n_row::Int64, n_col::Int64)::Csize_t
-end
-
-function colamd_set_defaults(knobs)
-    @ccall libcolamd.colamd_set_defaults(knobs::Ptr{Cdouble})::Cvoid
-end
-
-function colamd_l_set_defaults(knobs)
-    @ccall libcolamd.colamd_l_set_defaults(knobs::Ptr{Cdouble})::Cvoid
-end
-
-function colamd(n_row, n_col, Alen, A, p, knobs, stats)
-    @ccall libcolamd.colamd(n_row::Int32, n_col::Int32, Alen::Int32, A::Ptr{Int32}, p::Ptr{Int32}, knobs::Ptr{Cdouble}, stats::Ptr{Int32})::Cint
-end
-
-function colamd_l(n_row, n_col, Alen, A, p, knobs, stats)
-    @ccall libcolamd.colamd_l(n_row::Int64, n_col::Int64, Alen::Int64, A::Ptr{Int64}, p::Ptr{Int64}, knobs::Ptr{Cdouble}, stats::Ptr{Int64})::Cint
-end
-
-function symamd(n, A, p, perm, knobs, stats, allocate, release)
-    @ccall libcolamd.symamd(n::Int32, A::Ptr{Int32}, p::Ptr{Int32}, perm::Ptr{Int32}, knobs::Ptr{Cdouble}, stats::Ptr{Int32}, allocate::Ptr{Cvoid}, release::Ptr{Cvoid})::Cint
-end
-
-function symamd_l(n, A, p, perm, knobs, stats, allocate, release)
-    @ccall libcolamd.symamd_l(n::Int64, A::Ptr{Int64}, p::Ptr{Int64}, perm::Ptr{Int64}, knobs::Ptr{Cdouble}, stats::Ptr{Int64}, allocate::Ptr{Cvoid}, release::Ptr{Cvoid})::Cint
-end
-
-function colamd_report(stats)
-    @ccall libcolamd.colamd_report(stats::Ptr{Int32})::Cvoid
-end
-
-function colamd_l_report(stats)
-    @ccall libcolamd.colamd_l_report(stats::Ptr{Int64})::Cvoid
-end
-
-function symamd_report(stats)
-    @ccall libcolamd.symamd_report(stats::Ptr{Int32})::Cvoid
-end
-
-function symamd_l_report(stats)
-    @ccall libcolamd.symamd_l_report(stats::Ptr{Int64})::Cvoid
-end
-
-function ccolamd_recommended(nnz, n_row, n_col)
-    @ccall libcolamd.ccolamd_recommended(nnz::Cint, n_row::Cint, n_col::Cint)::Csize_t
-end
-
-function ccolamd_l_recommended(nnz, n_row, n_col)
-    @ccall libcolamd.ccolamd_l_recommended(nnz::Int64, n_row::Int64, n_col::Int64)::Csize_t
-end
-
-function ccolamd_set_defaults(knobs)
-    @ccall libcolamd.ccolamd_set_defaults(knobs::Ptr{Cdouble})::Cvoid
-end
-
-function ccolamd_l_set_defaults(knobs)
-    @ccall libcolamd.ccolamd_l_set_defaults(knobs::Ptr{Cdouble})::Cvoid
-end
-
-function ccolamd(n_row, n_col, Alen, A, p, knobs, stats, cmember)
-    @ccall libcolamd.ccolamd(n_row::Cint, n_col::Cint, Alen::Cint, A::Ptr{Cint}, p::Ptr{Cint}, knobs::Ptr{Cdouble}, stats::Ptr{Cint}, cmember::Ptr{Cint})::Cint
-end
-
-function ccolamd_l(n_row, n_col, Alen, A, p, knobs, stats, cmember)
-    @ccall libcolamd.ccolamd_l(n_row::Int64, n_col::Int64, Alen::Int64, A::Ptr{Int64}, p::Ptr{Int64}, knobs::Ptr{Cdouble}, stats::Ptr{Int64}, cmember::Ptr{Int64})::Cint
-end
-
-function csymamd(n, A, p, perm, knobs, stats, allocate, release, cmember, stype)
-    @ccall libcolamd.csymamd(n::Cint, A::Ptr{Cint}, p::Ptr{Cint}, perm::Ptr{Cint}, knobs::Ptr{Cdouble}, stats::Ptr{Cint}, allocate::Ptr{Cvoid}, release::Ptr{Cvoid}, cmember::Ptr{Cint}, stype::Cint)::Cint
-end
-
-function csymamd_l(n, A, p, perm, knobs, stats, allocate, release, cmember, stype)
-    @ccall libcolamd.csymamd_l(n::Int64, A::Ptr{Int64}, p::Ptr{Int64}, perm::Ptr{Int64}, knobs::Ptr{Cdouble}, stats::Ptr{Int64}, allocate::Ptr{Cvoid}, release::Ptr{Cvoid}, cmember::Ptr{Int64}, stype::Int64)::Cint
-end
-
-function ccolamd_report(stats)
-    @ccall libcolamd.ccolamd_report(stats::Ptr{Cint})::Cvoid
-end
-
-function ccolamd_l_report(stats)
-    @ccall libcolamd.ccolamd_l_report(stats::Ptr{Int64})::Cvoid
-end
-
-function csymamd_report(stats)
-    @ccall libcolamd.csymamd_report(stats::Ptr{Cint})::Cvoid
-end
-
-function csymamd_l_report(stats)
-    @ccall libcolamd.csymamd_l_report(stats::Ptr{Int64})::Cvoid
-end
-
-function ccolamd2(n_row, n_col, Alen, A, p, knobs, stats, Front_npivcol, Front_nrows, Front_ncols, Front_parent, Front_cols, p_nfr, InFront, cmember)
-    @ccall libcolamd.ccolamd2(n_row::Cint, n_col::Cint, Alen::Cint, A::Ptr{Cint}, p::Ptr{Cint}, knobs::Ptr{Cdouble}, stats::Ptr{Cint}, Front_npivcol::Ptr{Cint}, Front_nrows::Ptr{Cint}, Front_ncols::Ptr{Cint}, Front_parent::Ptr{Cint}, Front_cols::Ptr{Cint}, p_nfr::Ptr{Cint}, InFront::Ptr{Cint}, cmember::Ptr{Cint})::Cint
-end
-
-function ccolamd2_l(n_row, n_col, Alen, A, p, knobs, stats, Front_npivcol, Front_nrows, Front_ncols, Front_parent, Front_cols, p_nfr, InFront, cmember)
-    @ccall libcolamd.ccolamd2_l(n_row::Int64, n_col::Int64, Alen::Int64, A::Ptr{Int64}, p::Ptr{Int64}, knobs::Ptr{Cdouble}, stats::Ptr{Int64}, Front_npivcol::Ptr{Int64}, Front_nrows::Ptr{Int64}, Front_ncols::Ptr{Int64}, Front_parent::Ptr{Int64}, Front_cols::Ptr{Int64}, p_nfr::Ptr{Int64}, InFront::Ptr{Int64}, cmember::Ptr{Int64})::Cint
-end
-
-function ccolamd_apply_order(Front, Order, Temp, nn, nfr)
-    @ccall libcolamd.ccolamd_apply_order(Front::Ptr{Cint}, Order::Ptr{Cint}, Temp::Ptr{Cint}, nn::Cint, nfr::Cint)::Cvoid
-end
-
-function ccolamd_l_apply_order(Front, Order, Temp, nn, nfr)
-    @ccall libcolamd.ccolamd_l_apply_order(Front::Ptr{Int64}, Order::Ptr{Int64}, Temp::Ptr{Int64}, nn::Int64, nfr::Int64)::Cvoid
-end
-
-function ccolamd_fsize(nn, MaxFsize, Fnrows, Fncols, Parent, Npiv)
-    @ccall libcolamd.ccolamd_fsize(nn::Cint, MaxFsize::Ptr{Cint}, Fnrows::Ptr{Cint}, Fncols::Ptr{Cint}, Parent::Ptr{Cint}, Npiv::Ptr{Cint})::Cvoid
-end
-
-function ccolamd_l_fsize(nn, MaxFsize, Fnrows, Fncols, Parent, Npiv)
-    @ccall libcolamd.ccolamd_l_fsize(nn::Int64, MaxFsize::Ptr{Int64}, Fnrows::Ptr{Int64}, Fncols::Ptr{Int64}, Parent::Ptr{Int64}, Npiv::Ptr{Int64})::Cvoid
-end
-
-function ccolamd_postorder(nn, Parent, Npiv, Fsize, Order, Child, Sibling, Stack, Front_cols, cmember)
-    @ccall libcolamd.ccolamd_postorder(nn::Cint, Parent::Ptr{Cint}, Npiv::Ptr{Cint}, Fsize::Ptr{Cint}, Order::Ptr{Cint}, Child::Ptr{Cint}, Sibling::Ptr{Cint}, Stack::Ptr{Cint}, Front_cols::Ptr{Cint}, cmember::Ptr{Cint})::Cvoid
-end
-
-function ccolamd_l_postorder(nn, Parent, Npiv, Fsize, Order, Child, Sibling, Stack, Front_cols, cmember)
-    @ccall libcolamd.ccolamd_l_postorder(nn::Int64, Parent::Ptr{Int64}, Npiv::Ptr{Int64}, Fsize::Ptr{Int64}, Order::Ptr{Int64}, Child::Ptr{Int64}, Sibling::Ptr{Int64}, Stack::Ptr{Int64}, Front_cols::Ptr{Int64}, cmember::Ptr{Int64})::Cvoid
-end
-
-function ccolamd_post_tree(root, k, Child, Sibling, Order, Stack)
-    @ccall libcolamd.ccolamd_post_tree(root::Cint, k::Cint, Child::Ptr{Cint}, Sibling::Ptr{Cint}, Order::Ptr{Cint}, Stack::Ptr{Cint})::Cint
-end
-
-function ccolamd_l_post_tree(root, k, Child, Sibling, Order, Stack)
-    @ccall libcolamd.ccolamd_l_post_tree(root::Int64, k::Int64, Child::Ptr{Int64}, Sibling::Ptr{Int64}, Order::Ptr{Int64}, Stack::Ptr{Int64})::Int64
-end
-
 function umfpack_di_symbolic(n_row, n_col, Ap, Ai, Ax, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_di_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                          Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                          Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                          Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_symbolic(n_row, n_col, Ap, Ai, Ax, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_dl_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                          Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                          Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                          Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_symbolic(n_row, n_col, Ap, Ai, Ax, Az, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_zi_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                          Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                          Az::Ptr{Cdouble}, Symbolic::Ptr{Ptr{Cvoid}},
+                                          Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_symbolic(n_row, n_col, Ap, Ai, Ax, Az, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_zl_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                          Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                          Az::Ptr{Cdouble}, Symbolic::Ptr{Ptr{Cvoid}},
+                                          Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_numeric(Ap, Ai, Ax, Symbolic, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_di_numeric(Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Symbolic::Ptr{Cvoid}, Numeric::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_numeric(Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                         Symbolic::Ptr{Cvoid}, Numeric::Ptr{Ptr{Cvoid}},
+                                         Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_numeric(Ap, Ai, Ax, Symbolic, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_dl_numeric(Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Symbolic::Ptr{Cvoid}, Numeric::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_numeric(Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                         Symbolic::Ptr{Cvoid}, Numeric::Ptr{Ptr{Cvoid}},
+                                         Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_numeric(Ap, Ai, Ax, Az, Symbolic, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_zi_numeric(Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Symbolic::Ptr{Cvoid}, Numeric::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_numeric(Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                         Az::Ptr{Cdouble}, Symbolic::Ptr{Cvoid},
+                                         Numeric::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                         Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_numeric(Ap, Ai, Ax, Az, Symbolic, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_zl_numeric(Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Symbolic::Ptr{Cvoid}, Numeric::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_numeric(Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                         Az::Ptr{Cdouble}, Symbolic::Ptr{Cvoid},
+                                         Numeric::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                         Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_solve(sys, Ap, Ai, Ax, X, B, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_di_solve(sys::Cint, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_solve(sys::Cint, Ap::Ptr{Int32}, Ai::Ptr{Int32},
+                                       Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble},
+                                       Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                       Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_solve(sys, Ap, Ai, Ax, X, B, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_dl_solve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_solve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64},
+                                       Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble},
+                                       Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                       Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_solve(sys, Ap, Ai, Ax, Az, Xx, Xz, Bx, Bz, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_zi_solve(sys::Cint, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_solve(sys::Cint, Ap::Ptr{Int32}, Ai::Ptr{Int32},
+                                       Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Xx::Ptr{Cdouble},
+                                       Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble},
+                                       Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                       Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_solve(sys, Ap, Ai, Ax, Az, Xx, Xz, Bx, Bz, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_zl_solve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_solve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64},
+                                       Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Xx::Ptr{Cdouble},
+                                       Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble},
+                                       Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                       Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_free_symbolic(Symbolic)
@@ -1840,51 +2346,119 @@ function umfpack_zl_defaults(Control)
 end
 
 function umfpack_di_qsymbolic(n_row, n_col, Ap, Ai, Ax, Qinit, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_di_qsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Qinit::Ptr{Int32}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_qsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                           Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                           Qinit::Ptr{Int32}, Symbolic::Ptr{Ptr{Cvoid}},
+                                           Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_qsymbolic(n_row, n_col, Ap, Ai, Ax, Qinit, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_dl_qsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Qinit::Ptr{Int64}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_qsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                           Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                           Qinit::Ptr{Int64}, Symbolic::Ptr{Ptr{Cvoid}},
+                                           Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_qsymbolic(n_row, n_col, Ap, Ai, Ax, Az, Qinit, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_zi_qsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Qinit::Ptr{Int32}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_qsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                           Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                           Az::Ptr{Cdouble}, Qinit::Ptr{Int32},
+                                           Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                           Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_qsymbolic(n_row, n_col, Ap, Ai, Ax, Az, Qinit, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_zl_qsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Qinit::Ptr{Int64}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_di_fsymbolic(n_row, n_col, Ap, Ai, Ax, user_ordering, user_params, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_di_fsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_dl_fsymbolic(n_row, n_col, Ap, Ai, Ax, user_ordering, user_params, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_dl_fsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_zi_fsymbolic(n_row, n_col, Ap, Ai, Ax, Az, user_ordering, user_params, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_zi_fsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_zl_fsymbolic(n_row, n_col, Ap, Ai, Ax, Az, user_ordering, user_params, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_zl_fsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_di_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Qinit, user_ordering, user_params, Symbolic, SW, Control, Info)
-    @ccall libumfpack.umfpack_di_paru_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Qinit::Ptr{Int32}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_dl_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Qinit, user_ordering, user_params, Symbolic, SW, Control, Info)
-    @ccall libumfpack.umfpack_dl_paru_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Qinit::Ptr{Int64}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_zi_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Az, Qinit, user_ordering, user_params, Symbolic, SW, Control, Info)
-    @ccall libumfpack.umfpack_zi_paru_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Qinit::Ptr{Int32}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_zl_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Az, Qinit, user_ordering, user_params, Symbolic, SW, Control, Info)
-    @ccall libumfpack.umfpack_zl_paru_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Qinit::Ptr{Int64}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_qsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                           Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                           Az::Ptr{Cdouble}, Qinit::Ptr{Int64},
+                                           Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                           Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_di_fsymbolic(n_row, n_col, Ap, Ai, Ax, user_ordering, user_params,
+                              Symbolic, Control, Info)
+    @ccall libumfpack.umfpack_di_fsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                           Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                           user_ordering::Ptr{Cvoid},
+                                           user_params::Ptr{Cvoid},
+                                           Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                           Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_dl_fsymbolic(n_row, n_col, Ap, Ai, Ax, user_ordering, user_params,
+                              Symbolic, Control, Info)
+    @ccall libumfpack.umfpack_dl_fsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                           Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                           user_ordering::Ptr{Cvoid},
+                                           user_params::Ptr{Cvoid},
+                                           Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                           Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_zi_fsymbolic(n_row, n_col, Ap, Ai, Ax, Az, user_ordering, user_params,
+                              Symbolic, Control, Info)
+    @ccall libumfpack.umfpack_zi_fsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                           Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                           Az::Ptr{Cdouble}, user_ordering::Ptr{Cvoid},
+                                           user_params::Ptr{Cvoid},
+                                           Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                           Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_zl_fsymbolic(n_row, n_col, Ap, Ai, Ax, Az, user_ordering, user_params,
+                              Symbolic, Control, Info)
+    @ccall libumfpack.umfpack_zl_fsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                           Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                           Az::Ptr{Cdouble}, user_ordering::Ptr{Cvoid},
+                                           user_params::Ptr{Cvoid},
+                                           Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                           Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_di_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Qinit, user_ordering,
+                                  user_params, Symbolic, SW, Control, Info)
+    @ccall libumfpack.umfpack_di_paru_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                               Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                               Qinit::Ptr{Int32}, user_ordering::Ptr{Cvoid},
+                                               user_params::Ptr{Cvoid},
+                                               Symbolic::Ptr{Ptr{Cvoid}},
+                                               SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                               Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_dl_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Qinit, user_ordering,
+                                  user_params, Symbolic, SW, Control, Info)
+    @ccall libumfpack.umfpack_dl_paru_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                               Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                               Qinit::Ptr{Int64}, user_ordering::Ptr{Cvoid},
+                                               user_params::Ptr{Cvoid},
+                                               Symbolic::Ptr{Ptr{Cvoid}},
+                                               SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                               Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_zi_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Az, Qinit, user_ordering,
+                                  user_params, Symbolic, SW, Control, Info)
+    @ccall libumfpack.umfpack_zi_paru_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                               Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                               Az::Ptr{Cdouble}, Qinit::Ptr{Int32},
+                                               user_ordering::Ptr{Cvoid},
+                                               user_params::Ptr{Cvoid},
+                                               Symbolic::Ptr{Ptr{Cvoid}},
+                                               SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                               Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_zl_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Az, Qinit, user_ordering,
+                                  user_params, Symbolic, SW, Control, Info)
+    @ccall libumfpack.umfpack_zl_paru_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                               Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                               Az::Ptr{Cdouble}, Qinit::Ptr{Int64},
+                                               user_ordering::Ptr{Cvoid},
+                                               user_params::Ptr{Cvoid},
+                                               Symbolic::Ptr{Ptr{Cvoid}},
+                                               SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                               Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_paru_free_sw(SW)
@@ -1904,339 +2478,547 @@ function umfpack_zl_paru_free_sw(SW)
 end
 
 function umfpack_di_wsolve(sys, Ap, Ai, Ax, X, B, Numeric, Control, Info, Wi, W)
-    @ccall libumfpack.umfpack_di_wsolve(sys::Cint, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble}, Wi::Ptr{Int32}, W::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_wsolve(sys::Cint, Ap::Ptr{Int32}, Ai::Ptr{Int32},
+                                        Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble},
+                                        Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                        Info::Ptr{Cdouble}, Wi::Ptr{Int32},
+                                        W::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_wsolve(sys, Ap, Ai, Ax, X, B, Numeric, Control, Info, Wi, W)
-    @ccall libumfpack.umfpack_dl_wsolve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble}, Wi::Ptr{Int64}, W::Ptr{Cdouble})::Cint
-end
-
-function umfpack_zi_wsolve(sys, Ap, Ai, Ax, Az, Xx, Xz, Bx, Bz, Numeric, Control, Info, Wi, W)
-    @ccall libumfpack.umfpack_zi_wsolve(sys::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble}, Wi::Ptr{Int32}, W::Ptr{Cdouble})::Cint
-end
-
-function umfpack_zl_wsolve(sys, Ap, Ai, Ax, Az, Xx, Xz, Bx, Bz, Numeric, Control, Info, Wi, W)
-    @ccall libumfpack.umfpack_zl_wsolve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble}, Wi::Ptr{Int64}, W::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_wsolve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64},
+                                        Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble},
+                                        Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                        Info::Ptr{Cdouble}, Wi::Ptr{Int64},
+                                        W::Ptr{Cdouble})::Cint
+end
+
+function umfpack_zi_wsolve(sys, Ap, Ai, Ax, Az, Xx, Xz, Bx, Bz, Numeric, Control, Info, Wi,
+                           W)
+    @ccall libumfpack.umfpack_zi_wsolve(sys::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32},
+                                        Ax::Ptr{Cdouble}, Az::Ptr{Cdouble},
+                                        Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble},
+                                        Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble},
+                                        Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                        Info::Ptr{Cdouble}, Wi::Ptr{Int32},
+                                        W::Ptr{Cdouble})::Cint
+end
+
+function umfpack_zl_wsolve(sys, Ap, Ai, Ax, Az, Xx, Xz, Bx, Bz, Numeric, Control, Info, Wi,
+                           W)
+    @ccall libumfpack.umfpack_zl_wsolve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64},
+                                        Ax::Ptr{Cdouble}, Az::Ptr{Cdouble},
+                                        Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble},
+                                        Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble},
+                                        Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                        Info::Ptr{Cdouble}, Wi::Ptr{Int64},
+                                        W::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_triplet_to_col(n_row, n_col, nz, Ti, Tj, Tx, Ap, Ai, Ax, Map)
-    @ccall libumfpack.umfpack_di_triplet_to_col(n_row::Int32, n_col::Int32, nz::Int32, Ti::Ptr{Int32}, Tj::Ptr{Int32}, Tx::Ptr{Cdouble}, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Map::Ptr{Int32})::Cint
+    @ccall libumfpack.umfpack_di_triplet_to_col(n_row::Int32, n_col::Int32, nz::Int32,
+                                                Ti::Ptr{Int32}, Tj::Ptr{Int32},
+                                                Tx::Ptr{Cdouble}, Ap::Ptr{Int32},
+                                                Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                                Map::Ptr{Int32})::Cint
 end
 
 function umfpack_dl_triplet_to_col(n_row, n_col, nz, Ti, Tj, Tx, Ap, Ai, Ax, Map)
-    @ccall libumfpack.umfpack_dl_triplet_to_col(n_row::Int64, n_col::Int64, nz::Int64, Ti::Ptr{Int64}, Tj::Ptr{Int64}, Tx::Ptr{Cdouble}, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Map::Ptr{Int64})::Cint
+    @ccall libumfpack.umfpack_dl_triplet_to_col(n_row::Int64, n_col::Int64, nz::Int64,
+                                                Ti::Ptr{Int64}, Tj::Ptr{Int64},
+                                                Tx::Ptr{Cdouble}, Ap::Ptr{Int64},
+                                                Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                                Map::Ptr{Int64})::Cint
 end
 
 function umfpack_zi_triplet_to_col(n_row, n_col, nz, Ti, Tj, Tx, Tz, Ap, Ai, Ax, Az, Map)
-    @ccall libumfpack.umfpack_zi_triplet_to_col(n_row::Int32, n_col::Int32, nz::Int32, Ti::Ptr{Int32}, Tj::Ptr{Int32}, Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble}, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Map::Ptr{Int32})::Cint
+    @ccall libumfpack.umfpack_zi_triplet_to_col(n_row::Int32, n_col::Int32, nz::Int32,
+                                                Ti::Ptr{Int32}, Tj::Ptr{Int32},
+                                                Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble},
+                                                Ap::Ptr{Int32}, Ai::Ptr{Int32},
+                                                Ax::Ptr{Cdouble}, Az::Ptr{Cdouble},
+                                                Map::Ptr{Int32})::Cint
 end
 
 function umfpack_zl_triplet_to_col(n_row, n_col, nz, Ti, Tj, Tx, Tz, Ap, Ai, Ax, Az, Map)
-    @ccall libumfpack.umfpack_zl_triplet_to_col(n_row::Int64, n_col::Int64, nz::Int64, Ti::Ptr{Int64}, Tj::Ptr{Int64}, Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble}, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Map::Ptr{Int64})::Cint
+    @ccall libumfpack.umfpack_zl_triplet_to_col(n_row::Int64, n_col::Int64, nz::Int64,
+                                                Ti::Ptr{Int64}, Tj::Ptr{Int64},
+                                                Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble},
+                                                Ap::Ptr{Int64}, Ai::Ptr{Int64},
+                                                Ax::Ptr{Cdouble}, Az::Ptr{Cdouble},
+                                                Map::Ptr{Int64})::Cint
 end
 
 function umfpack_di_col_to_triplet(n_col, Ap, Tj)
-    @ccall libumfpack.umfpack_di_col_to_triplet(n_col::Int32, Ap::Ptr{Int32}, Tj::Ptr{Int32})::Cint
+    @ccall libumfpack.umfpack_di_col_to_triplet(n_col::Int32, Ap::Ptr{Int32},
+                                                Tj::Ptr{Int32})::Cint
 end
 
 function umfpack_dl_col_to_triplet(n_col, Ap, Tj)
-    @ccall libumfpack.umfpack_dl_col_to_triplet(n_col::Int64, Ap::Ptr{Int64}, Tj::Ptr{Int64})::Cint
+    @ccall libumfpack.umfpack_dl_col_to_triplet(n_col::Int64, Ap::Ptr{Int64},
+                                                Tj::Ptr{Int64})::Cint
 end
 
 function umfpack_zi_col_to_triplet(n_col, Ap, Tj)
-    @ccall libumfpack.umfpack_zi_col_to_triplet(n_col::Int32, Ap::Ptr{Int32}, Tj::Ptr{Int32})::Cint
+    @ccall libumfpack.umfpack_zi_col_to_triplet(n_col::Int32, Ap::Ptr{Int32},
+                                                Tj::Ptr{Int32})::Cint
 end
 
 function umfpack_zl_col_to_triplet(n_col, Ap, Tj)
-    @ccall libumfpack.umfpack_zl_col_to_triplet(n_col::Int64, Ap::Ptr{Int64}, Tj::Ptr{Int64})::Cint
+    @ccall libumfpack.umfpack_zl_col_to_triplet(n_col::Int64, Ap::Ptr{Int64},
+                                                Tj::Ptr{Int64})::Cint
 end
 
 function umfpack_di_transpose(n_row, n_col, Ap, Ai, Ax, P, Q, Rp, Ri, Rx)
-    @ccall libumfpack.umfpack_di_transpose(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, P::Ptr{Int32}, Q::Ptr{Int32}, Rp::Ptr{Int32}, Ri::Ptr{Int32}, Rx::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_transpose(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                           Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, P::Ptr{Int32},
+                                           Q::Ptr{Int32}, Rp::Ptr{Int32}, Ri::Ptr{Int32},
+                                           Rx::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_transpose(n_row, n_col, Ap, Ai, Ax, P, Q, Rp, Ri, Rx)
-    @ccall libumfpack.umfpack_dl_transpose(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, P::Ptr{Int64}, Q::Ptr{Int64}, Rp::Ptr{Int64}, Ri::Ptr{Int64}, Rx::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_transpose(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                           Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, P::Ptr{Int64},
+                                           Q::Ptr{Int64}, Rp::Ptr{Int64}, Ri::Ptr{Int64},
+                                           Rx::Ptr{Cdouble})::Cint
 end
 
-function umfpack_zi_transpose(n_row, n_col, Ap, Ai, Ax, Az, P, Q, Rp, Ri, Rx, Rz, do_conjugate)
-    @ccall libumfpack.umfpack_zi_transpose(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, P::Ptr{Int32}, Q::Ptr{Int32}, Rp::Ptr{Int32}, Ri::Ptr{Int32}, Rx::Ptr{Cdouble}, Rz::Ptr{Cdouble}, do_conjugate::Cint)::Cint
+function umfpack_zi_transpose(n_row, n_col, Ap, Ai, Ax, Az, P, Q, Rp, Ri, Rx, Rz,
+                              do_conjugate)
+    @ccall libumfpack.umfpack_zi_transpose(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                           Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                           Az::Ptr{Cdouble}, P::Ptr{Int32}, Q::Ptr{Int32},
+                                           Rp::Ptr{Int32}, Ri::Ptr{Int32}, Rx::Ptr{Cdouble},
+                                           Rz::Ptr{Cdouble}, do_conjugate::Cint)::Cint
 end
 
-function umfpack_zl_transpose(n_row, n_col, Ap, Ai, Ax, Az, P, Q, Rp, Ri, Rx, Rz, do_conjugate)
-    @ccall libumfpack.umfpack_zl_transpose(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, P::Ptr{Int64}, Q::Ptr{Int64}, Rp::Ptr{Int64}, Ri::Ptr{Int64}, Rx::Ptr{Cdouble}, Rz::Ptr{Cdouble}, do_conjugate::Cint)::Cint
+function umfpack_zl_transpose(n_row, n_col, Ap, Ai, Ax, Az, P, Q, Rp, Ri, Rx, Rz,
+                              do_conjugate)
+    @ccall libumfpack.umfpack_zl_transpose(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                           Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                           Az::Ptr{Cdouble}, P::Ptr{Int64}, Q::Ptr{Int64},
+                                           Rp::Ptr{Int64}, Ri::Ptr{Int64}, Rx::Ptr{Cdouble},
+                                           Rz::Ptr{Cdouble}, do_conjugate::Cint)::Cint
 end
 
 function umfpack_di_scale(X, B, Numeric)
-    @ccall libumfpack.umfpack_di_scale(X::Ptr{Cdouble}, B::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_scale(X::Ptr{Cdouble}, B::Ptr{Cdouble},
+                                       Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_scale(X, B, Numeric)
-    @ccall libumfpack.umfpack_dl_scale(X::Ptr{Cdouble}, B::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_scale(X::Ptr{Cdouble}, B::Ptr{Cdouble},
+                                       Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_scale(Xx, Xz, Bx, Bz, Numeric)
-    @ccall libumfpack.umfpack_zi_scale(Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_scale(Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble},
+                                       Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_scale(Xx, Xz, Bx, Bz, Numeric)
-    @ccall libumfpack.umfpack_zl_scale(Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_scale(Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble},
+                                       Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_get_lunz(lnz, unz, n_row, n_col, nz_udiag, Numeric)
-    @ccall libumfpack.umfpack_di_get_lunz(lnz::Ptr{Int32}, unz::Ptr{Int32}, n_row::Ptr{Int32}, n_col::Ptr{Int32}, nz_udiag::Ptr{Int32}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_get_lunz(lnz::Ptr{Int32}, unz::Ptr{Int32},
+                                          n_row::Ptr{Int32}, n_col::Ptr{Int32},
+                                          nz_udiag::Ptr{Int32}, Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_get_lunz(lnz, unz, n_row, n_col, nz_udiag, Numeric)
-    @ccall libumfpack.umfpack_dl_get_lunz(lnz::Ptr{Int64}, unz::Ptr{Int64}, n_row::Ptr{Int64}, n_col::Ptr{Int64}, nz_udiag::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_get_lunz(lnz::Ptr{Int64}, unz::Ptr{Int64},
+                                          n_row::Ptr{Int64}, n_col::Ptr{Int64},
+                                          nz_udiag::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_get_lunz(lnz, unz, n_row, n_col, nz_udiag, Numeric)
-    @ccall libumfpack.umfpack_zi_get_lunz(lnz::Ptr{Int32}, unz::Ptr{Int32}, n_row::Ptr{Int32}, n_col::Ptr{Int32}, nz_udiag::Ptr{Int32}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_get_lunz(lnz::Ptr{Int32}, unz::Ptr{Int32},
+                                          n_row::Ptr{Int32}, n_col::Ptr{Int32},
+                                          nz_udiag::Ptr{Int32}, Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_get_lunz(lnz, unz, n_row, n_col, nz_udiag, Numeric)
-    @ccall libumfpack.umfpack_zl_get_lunz(lnz::Ptr{Int64}, unz::Ptr{Int64}, n_row::Ptr{Int64}, n_col::Ptr{Int64}, nz_udiag::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_get_lunz(lnz::Ptr{Int64}, unz::Ptr{Int64},
+                                          n_row::Ptr{Int64}, n_col::Ptr{Int64},
+                                          nz_udiag::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_get_numeric(Lp, Lj, Lx, Up, Ui, Ux, P, Q, Dx, do_recip, Rs, Numeric)
-    @ccall libumfpack.umfpack_di_get_numeric(Lp::Ptr{Int32}, Lj::Ptr{Int32}, Lx::Ptr{Cdouble}, Up::Ptr{Int32}, Ui::Ptr{Int32}, Ux::Ptr{Cdouble}, P::Ptr{Int32}, Q::Ptr{Int32}, Dx::Ptr{Cdouble}, do_recip::Ptr{Int32}, Rs::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_get_numeric(Lp::Ptr{Int32}, Lj::Ptr{Int32},
+                                             Lx::Ptr{Cdouble}, Up::Ptr{Int32},
+                                             Ui::Ptr{Int32}, Ux::Ptr{Cdouble},
+                                             P::Ptr{Int32}, Q::Ptr{Int32}, Dx::Ptr{Cdouble},
+                                             do_recip::Ptr{Int32}, Rs::Ptr{Cdouble},
+                                             Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_get_numeric(Lp, Lj, Lx, Up, Ui, Ux, P, Q, Dx, do_recip, Rs, Numeric)
-    @ccall libumfpack.umfpack_dl_get_numeric(Lp::Ptr{Int64}, Lj::Ptr{Int64}, Lx::Ptr{Cdouble}, Up::Ptr{Int64}, Ui::Ptr{Int64}, Ux::Ptr{Cdouble}, P::Ptr{Int64}, Q::Ptr{Int64}, Dx::Ptr{Cdouble}, do_recip::Ptr{Int64}, Rs::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
-end
-
-function umfpack_zi_get_numeric(Lp, Lj, Lx, Lz, Up, Ui, Ux, Uz, P, Q, Dx, Dz, do_recip, Rs, Numeric)
-    @ccall libumfpack.umfpack_zi_get_numeric(Lp::Ptr{Int32}, Lj::Ptr{Int32}, Lx::Ptr{Cdouble}, Lz::Ptr{Cdouble}, Up::Ptr{Int32}, Ui::Ptr{Int32}, Ux::Ptr{Cdouble}, Uz::Ptr{Cdouble}, P::Ptr{Int32}, Q::Ptr{Int32}, Dx::Ptr{Cdouble}, Dz::Ptr{Cdouble}, do_recip::Ptr{Int32}, Rs::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
-end
-
-function umfpack_zl_get_numeric(Lp, Lj, Lx, Lz, Up, Ui, Ux, Uz, P, Q, Dx, Dz, do_recip, Rs, Numeric)
-    @ccall libumfpack.umfpack_zl_get_numeric(Lp::Ptr{Int64}, Lj::Ptr{Int64}, Lx::Ptr{Cdouble}, Lz::Ptr{Cdouble}, Up::Ptr{Int64}, Ui::Ptr{Int64}, Ux::Ptr{Cdouble}, Uz::Ptr{Cdouble}, P::Ptr{Int64}, Q::Ptr{Int64}, Dx::Ptr{Cdouble}, Dz::Ptr{Cdouble}, do_recip::Ptr{Int64}, Rs::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
-end
-
-function umfpack_di_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol, Front_parent, Front_1strow, Front_leftmostdesc, Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
-    @ccall libumfpack.umfpack_di_get_symbolic(n_row::Ptr{Int32}, n_col::Ptr{Int32}, n1::Ptr{Int32}, nz::Ptr{Int32}, nfr::Ptr{Int32}, nchains::Ptr{Int32}, P::Ptr{Int32}, Q::Ptr{Int32}, Front_npivcol::Ptr{Int32}, Front_parent::Ptr{Int32}, Front_1strow::Ptr{Int32}, Front_leftmostdesc::Ptr{Int32}, Chain_start::Ptr{Int32}, Chain_maxrows::Ptr{Int32}, Chain_maxcols::Ptr{Int32}, Dmap::Ptr{Int32}, Symbolic::Ptr{Cvoid})::Cint
-end
-
-function umfpack_dl_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol, Front_parent, Front_1strow, Front_leftmostdesc, Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
-    @ccall libumfpack.umfpack_dl_get_symbolic(n_row::Ptr{Int64}, n_col::Ptr{Int64}, n1::Ptr{Int64}, nz::Ptr{Int64}, nfr::Ptr{Int64}, nchains::Ptr{Int64}, P::Ptr{Int64}, Q::Ptr{Int64}, Front_npivcol::Ptr{Int64}, Front_parent::Ptr{Int64}, Front_1strow::Ptr{Int64}, Front_leftmostdesc::Ptr{Int64}, Chain_start::Ptr{Int64}, Chain_maxrows::Ptr{Int64}, Chain_maxcols::Ptr{Int64}, Dmap::Ptr{Int64}, Symbolic::Ptr{Cvoid})::Cint
-end
-
-function umfpack_zi_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol, Front_parent, Front_1strow, Front_leftmostdesc, Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
-    @ccall libumfpack.umfpack_zi_get_symbolic(n_row::Ptr{Int32}, n_col::Ptr{Int32}, n1::Ptr{Int32}, nz::Ptr{Int32}, nfr::Ptr{Int32}, nchains::Ptr{Int32}, P::Ptr{Int32}, Q::Ptr{Int32}, Front_npivcol::Ptr{Int32}, Front_parent::Ptr{Int32}, Front_1strow::Ptr{Int32}, Front_leftmostdesc::Ptr{Int32}, Chain_start::Ptr{Int32}, Chain_maxrows::Ptr{Int32}, Chain_maxcols::Ptr{Int32}, Dmap::Ptr{Int32}, Symbolic::Ptr{Cvoid})::Cint
-end
-
-function umfpack_zl_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol, Front_parent, Front_1strow, Front_leftmostdesc, Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
-    @ccall libumfpack.umfpack_zl_get_symbolic(n_row::Ptr{Int64}, n_col::Ptr{Int64}, n1::Ptr{Int64}, nz::Ptr{Int64}, nfr::Ptr{Int64}, nchains::Ptr{Int64}, P::Ptr{Int64}, Q::Ptr{Int64}, Front_npivcol::Ptr{Int64}, Front_parent::Ptr{Int64}, Front_1strow::Ptr{Int64}, Front_leftmostdesc::Ptr{Int64}, Chain_start::Ptr{Int64}, Chain_maxrows::Ptr{Int64}, Chain_maxcols::Ptr{Int64}, Dmap::Ptr{Int64}, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_get_numeric(Lp::Ptr{Int64}, Lj::Ptr{Int64},
+                                             Lx::Ptr{Cdouble}, Up::Ptr{Int64},
+                                             Ui::Ptr{Int64}, Ux::Ptr{Cdouble},
+                                             P::Ptr{Int64}, Q::Ptr{Int64}, Dx::Ptr{Cdouble},
+                                             do_recip::Ptr{Int64}, Rs::Ptr{Cdouble},
+                                             Numeric::Ptr{Cvoid})::Cint
+end
+
+function umfpack_zi_get_numeric(Lp, Lj, Lx, Lz, Up, Ui, Ux, Uz, P, Q, Dx, Dz, do_recip, Rs,
+                                Numeric)
+    @ccall libumfpack.umfpack_zi_get_numeric(Lp::Ptr{Int32}, Lj::Ptr{Int32},
+                                             Lx::Ptr{Cdouble}, Lz::Ptr{Cdouble},
+                                             Up::Ptr{Int32}, Ui::Ptr{Int32},
+                                             Ux::Ptr{Cdouble}, Uz::Ptr{Cdouble},
+                                             P::Ptr{Int32}, Q::Ptr{Int32}, Dx::Ptr{Cdouble},
+                                             Dz::Ptr{Cdouble}, do_recip::Ptr{Int32},
+                                             Rs::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+end
+
+function umfpack_zl_get_numeric(Lp, Lj, Lx, Lz, Up, Ui, Ux, Uz, P, Q, Dx, Dz, do_recip, Rs,
+                                Numeric)
+    @ccall libumfpack.umfpack_zl_get_numeric(Lp::Ptr{Int64}, Lj::Ptr{Int64},
+                                             Lx::Ptr{Cdouble}, Lz::Ptr{Cdouble},
+                                             Up::Ptr{Int64}, Ui::Ptr{Int64},
+                                             Ux::Ptr{Cdouble}, Uz::Ptr{Cdouble},
+                                             P::Ptr{Int64}, Q::Ptr{Int64}, Dx::Ptr{Cdouble},
+                                             Dz::Ptr{Cdouble}, do_recip::Ptr{Int64},
+                                             Rs::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+end
+
+function umfpack_di_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol,
+                                 Front_parent, Front_1strow, Front_leftmostdesc,
+                                 Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
+    @ccall libumfpack.umfpack_di_get_symbolic(n_row::Ptr{Int32}, n_col::Ptr{Int32},
+                                              n1::Ptr{Int32}, nz::Ptr{Int32},
+                                              nfr::Ptr{Int32}, nchains::Ptr{Int32},
+                                              P::Ptr{Int32}, Q::Ptr{Int32},
+                                              Front_npivcol::Ptr{Int32},
+                                              Front_parent::Ptr{Int32},
+                                              Front_1strow::Ptr{Int32},
+                                              Front_leftmostdesc::Ptr{Int32},
+                                              Chain_start::Ptr{Int32},
+                                              Chain_maxrows::Ptr{Int32},
+                                              Chain_maxcols::Ptr{Int32}, Dmap::Ptr{Int32},
+                                              Symbolic::Ptr{Cvoid})::Cint
+end
+
+function umfpack_dl_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol,
+                                 Front_parent, Front_1strow, Front_leftmostdesc,
+                                 Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
+    @ccall libumfpack.umfpack_dl_get_symbolic(n_row::Ptr{Int64}, n_col::Ptr{Int64},
+                                              n1::Ptr{Int64}, nz::Ptr{Int64},
+                                              nfr::Ptr{Int64}, nchains::Ptr{Int64},
+                                              P::Ptr{Int64}, Q::Ptr{Int64},
+                                              Front_npivcol::Ptr{Int64},
+                                              Front_parent::Ptr{Int64},
+                                              Front_1strow::Ptr{Int64},
+                                              Front_leftmostdesc::Ptr{Int64},
+                                              Chain_start::Ptr{Int64},
+                                              Chain_maxrows::Ptr{Int64},
+                                              Chain_maxcols::Ptr{Int64}, Dmap::Ptr{Int64},
+                                              Symbolic::Ptr{Cvoid})::Cint
+end
+
+function umfpack_zi_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol,
+                                 Front_parent, Front_1strow, Front_leftmostdesc,
+                                 Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
+    @ccall libumfpack.umfpack_zi_get_symbolic(n_row::Ptr{Int32}, n_col::Ptr{Int32},
+                                              n1::Ptr{Int32}, nz::Ptr{Int32},
+                                              nfr::Ptr{Int32}, nchains::Ptr{Int32},
+                                              P::Ptr{Int32}, Q::Ptr{Int32},
+                                              Front_npivcol::Ptr{Int32},
+                                              Front_parent::Ptr{Int32},
+                                              Front_1strow::Ptr{Int32},
+                                              Front_leftmostdesc::Ptr{Int32},
+                                              Chain_start::Ptr{Int32},
+                                              Chain_maxrows::Ptr{Int32},
+                                              Chain_maxcols::Ptr{Int32}, Dmap::Ptr{Int32},
+                                              Symbolic::Ptr{Cvoid})::Cint
+end
+
+function umfpack_zl_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol,
+                                 Front_parent, Front_1strow, Front_leftmostdesc,
+                                 Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
+    @ccall libumfpack.umfpack_zl_get_symbolic(n_row::Ptr{Int64}, n_col::Ptr{Int64},
+                                              n1::Ptr{Int64}, nz::Ptr{Int64},
+                                              nfr::Ptr{Int64}, nchains::Ptr{Int64},
+                                              P::Ptr{Int64}, Q::Ptr{Int64},
+                                              Front_npivcol::Ptr{Int64},
+                                              Front_parent::Ptr{Int64},
+                                              Front_1strow::Ptr{Int64},
+                                              Front_leftmostdesc::Ptr{Int64},
+                                              Chain_start::Ptr{Int64},
+                                              Chain_maxrows::Ptr{Int64},
+                                              Chain_maxcols::Ptr{Int64}, Dmap::Ptr{Int64},
+                                              Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_save_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_di_save_numeric(Numeric::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_di_save_numeric(Numeric::Ptr{Cvoid},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_dl_save_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_dl_save_numeric(Numeric::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_dl_save_numeric(Numeric::Ptr{Cvoid},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zi_save_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_zi_save_numeric(Numeric::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zi_save_numeric(Numeric::Ptr{Cvoid},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zl_save_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_zl_save_numeric(Numeric::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zl_save_numeric(Numeric::Ptr{Cvoid},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_di_load_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_di_load_numeric(Numeric::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_di_load_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_dl_load_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_dl_load_numeric(Numeric::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_dl_load_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zi_load_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_zi_load_numeric(Numeric::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zi_load_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zl_load_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_zl_load_numeric(Numeric::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zl_load_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_di_copy_numeric(Numeric, Original)
-    @ccall libumfpack.umfpack_di_copy_numeric(Numeric::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_copy_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_copy_numeric(Numeric, Original)
-    @ccall libumfpack.umfpack_dl_copy_numeric(Numeric::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_copy_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_copy_numeric(Numeric, Original)
-    @ccall libumfpack.umfpack_zi_copy_numeric(Numeric::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_copy_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_copy_numeric(Numeric, Original)
-    @ccall libumfpack.umfpack_zl_copy_numeric(Numeric::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_copy_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_serialize_numeric_size(blobsize, Numeric)
-    @ccall libumfpack.umfpack_di_serialize_numeric_size(blobsize::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_serialize_numeric_size(blobsize::Ptr{Int64},
+                                                        Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_serialize_numeric_size(blobsize, Numeric)
-    @ccall libumfpack.umfpack_dl_serialize_numeric_size(blobsize::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_serialize_numeric_size(blobsize::Ptr{Int64},
+                                                        Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_serialize_numeric_size(blobsize, Numeric)
-    @ccall libumfpack.umfpack_zi_serialize_numeric_size(blobsize::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_serialize_numeric_size(blobsize::Ptr{Int64},
+                                                        Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_serialize_numeric_size(blobsize, Numeric)
-    @ccall libumfpack.umfpack_zl_serialize_numeric_size(blobsize::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_serialize_numeric_size(blobsize::Ptr{Int64},
+                                                        Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_serialize_numeric(blob, blobsize, Numeric)
-    @ccall libumfpack.umfpack_di_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64,
+                                                   Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_serialize_numeric(blob, blobsize, Numeric)
-    @ccall libumfpack.umfpack_dl_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64,
+                                                   Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_serialize_numeric(blob, blobsize, Numeric)
-    @ccall libumfpack.umfpack_zi_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64,
+                                                   Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_serialize_numeric(blob, blobsize, Numeric)
-    @ccall libumfpack.umfpack_zl_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64,
+                                                   Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_deserialize_numeric(Numeric, blob, blobsize)
-    @ccall libumfpack.umfpack_di_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_di_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                                     blob::Ptr{Int8}, blobsize::Int64)::Cint
 end
 
 function umfpack_dl_deserialize_numeric(Numeric, blob, blobsize)
-    @ccall libumfpack.umfpack_dl_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_dl_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                                     blob::Ptr{Int8}, blobsize::Int64)::Cint
 end
 
 function umfpack_zi_deserialize_numeric(Numeric, blob, blobsize)
-    @ccall libumfpack.umfpack_zi_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_zi_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                                     blob::Ptr{Int8}, blobsize::Int64)::Cint
 end
 
 function umfpack_zl_deserialize_numeric(Numeric, blob, blobsize)
-    @ccall libumfpack.umfpack_zl_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_zl_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                                     blob::Ptr{Int8}, blobsize::Int64)::Cint
 end
 
 function umfpack_di_save_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_di_save_symbolic(Symbolic::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_di_save_symbolic(Symbolic::Ptr{Cvoid},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_dl_save_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_dl_save_symbolic(Symbolic::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_dl_save_symbolic(Symbolic::Ptr{Cvoid},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zi_save_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_zi_save_symbolic(Symbolic::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zi_save_symbolic(Symbolic::Ptr{Cvoid},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zl_save_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_zl_save_symbolic(Symbolic::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zl_save_symbolic(Symbolic::Ptr{Cvoid},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_di_load_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_di_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_di_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_dl_load_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_dl_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_dl_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zi_load_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_zi_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zi_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zl_load_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_zl_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zl_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_di_copy_symbolic(Symbolic, Original)
-    @ccall libumfpack.umfpack_di_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_copy_symbolic(Symbolic, Original)
-    @ccall libumfpack.umfpack_dl_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_copy_symbolic(Symbolic, Original)
-    @ccall libumfpack.umfpack_zi_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_copy_symbolic(Symbolic, Original)
-    @ccall libumfpack.umfpack_zl_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_serialize_symbolic_size(blobsize, Symbolic)
-    @ccall libumfpack.umfpack_di_serialize_symbolic_size(blobsize::Ptr{Int64}, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_serialize_symbolic_size(blobsize::Ptr{Int64},
+                                                         Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_serialize_symbolic_size(blobsize, Symbolic)
-    @ccall libumfpack.umfpack_dl_serialize_symbolic_size(blobsize::Ptr{Int64}, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_serialize_symbolic_size(blobsize::Ptr{Int64},
+                                                         Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_serialize_symbolic_size(blobsize, Symbolic)
-    @ccall libumfpack.umfpack_zi_serialize_symbolic_size(blobsize::Ptr{Int64}, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_serialize_symbolic_size(blobsize::Ptr{Int64},
+                                                         Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_serialize_symbolic_size(blobsize, Symbolic)
-    @ccall libumfpack.umfpack_zl_serialize_symbolic_size(blobsize::Ptr{Int64}, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_serialize_symbolic_size(blobsize::Ptr{Int64},
+                                                         Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_serialize_symbolic(blob, blobsize, Symbolic)
-    @ccall libumfpack.umfpack_di_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64,
+                                                    Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_serialize_symbolic(blob, blobsize, Symbolic)
-    @ccall libumfpack.umfpack_dl_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64,
+                                                    Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_serialize_symbolic(blob, blobsize, Symbolic)
-    @ccall libumfpack.umfpack_zi_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64,
+                                                    Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_serialize_symbolic(blob, blobsize, Symbolic)
-    @ccall libumfpack.umfpack_zl_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64,
+                                                    Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_deserialize_symbolic(Symbolic, blob, blobsize)
-    @ccall libumfpack.umfpack_di_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_di_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                                      blob::Ptr{Int8},
+                                                      blobsize::Int64)::Cint
 end
 
 function umfpack_dl_deserialize_symbolic(Symbolic, blob, blobsize)
-    @ccall libumfpack.umfpack_dl_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_dl_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                                      blob::Ptr{Int8},
+                                                      blobsize::Int64)::Cint
 end
 
 function umfpack_zi_deserialize_symbolic(Symbolic, blob, blobsize)
-    @ccall libumfpack.umfpack_zi_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_zi_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                                      blob::Ptr{Int8},
+                                                      blobsize::Int64)::Cint
 end
 
 function umfpack_zl_deserialize_symbolic(Symbolic, blob, blobsize)
-    @ccall libumfpack.umfpack_zl_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_zl_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                                      blob::Ptr{Int8},
+                                                      blobsize::Int64)::Cint
 end
 
 function umfpack_di_get_determinant(Mx, Ex, Numeric, User_Info)
-    @ccall libumfpack.umfpack_di_get_determinant(Mx::Ptr{Cdouble}, Ex::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, User_Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_get_determinant(Mx::Ptr{Cdouble}, Ex::Ptr{Cdouble},
+                                                 Numeric::Ptr{Cvoid},
+                                                 User_Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_get_determinant(Mx, Ex, Numeric, User_Info)
-    @ccall libumfpack.umfpack_dl_get_determinant(Mx::Ptr{Cdouble}, Ex::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, User_Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_get_determinant(Mx::Ptr{Cdouble}, Ex::Ptr{Cdouble},
+                                                 Numeric::Ptr{Cvoid},
+                                                 User_Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_get_determinant(Mx, Mz, Ex, Numeric, User_Info)
-    @ccall libumfpack.umfpack_zi_get_determinant(Mx::Ptr{Cdouble}, Mz::Ptr{Cdouble}, Ex::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, User_Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_get_determinant(Mx::Ptr{Cdouble}, Mz::Ptr{Cdouble},
+                                                 Ex::Ptr{Cdouble}, Numeric::Ptr{Cvoid},
+                                                 User_Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_get_determinant(Mx, Mz, Ex, Numeric, User_Info)
-    @ccall libumfpack.umfpack_zl_get_determinant(Mx::Ptr{Cdouble}, Mz::Ptr{Cdouble}, Ex::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, User_Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_get_determinant(Mx::Ptr{Cdouble}, Mz::Ptr{Cdouble},
+                                                 Ex::Ptr{Cdouble}, Numeric::Ptr{Cvoid},
+                                                 User_Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_report_status(Control, status)
@@ -2256,19 +3038,23 @@ function umfpack_zl_report_status(Control, status)
 end
 
 function umfpack_di_report_info(Control, Info)
-    @ccall libumfpack.umfpack_di_report_info(Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cvoid
+    @ccall libumfpack.umfpack_di_report_info(Control::Ptr{Cdouble},
+                                             Info::Ptr{Cdouble})::Cvoid
 end
 
 function umfpack_dl_report_info(Control, Info)
-    @ccall libumfpack.umfpack_dl_report_info(Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cvoid
+    @ccall libumfpack.umfpack_dl_report_info(Control::Ptr{Cdouble},
+                                             Info::Ptr{Cdouble})::Cvoid
 end
 
 function umfpack_zi_report_info(Control, Info)
-    @ccall libumfpack.umfpack_zi_report_info(Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cvoid
+    @ccall libumfpack.umfpack_zi_report_info(Control::Ptr{Cdouble},
+                                             Info::Ptr{Cdouble})::Cvoid
 end
 
 function umfpack_zl_report_info(Control, Info)
-    @ccall libumfpack.umfpack_zl_report_info(Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cvoid
+    @ccall libumfpack.umfpack_zl_report_info(Control::Ptr{Cdouble},
+                                             Info::Ptr{Cdouble})::Cvoid
 end
 
 function umfpack_di_report_control(Control)
@@ -2288,99 +3074,137 @@ function umfpack_zl_report_control(Control)
 end
 
 function umfpack_di_report_matrix(n_row, n_col, Ap, Ai, Ax, col_form, Control)
-    @ccall libumfpack.umfpack_di_report_matrix(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, col_form::Cint, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_report_matrix(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                               Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                               col_form::Cint, Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_report_matrix(n_row, n_col, Ap, Ai, Ax, col_form, Control)
-    @ccall libumfpack.umfpack_dl_report_matrix(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, col_form::Cint, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_report_matrix(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                               Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                               col_form::Cint, Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_report_matrix(n_row, n_col, Ap, Ai, Ax, Az, col_form, Control)
-    @ccall libumfpack.umfpack_zi_report_matrix(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, col_form::Cint, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_report_matrix(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                               Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                               Az::Ptr{Cdouble}, col_form::Cint,
+                                               Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_report_matrix(n_row, n_col, Ap, Ai, Ax, Az, col_form, Control)
-    @ccall libumfpack.umfpack_zl_report_matrix(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, col_form::Cint, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_report_matrix(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                               Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                               Az::Ptr{Cdouble}, col_form::Cint,
+                                               Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_report_triplet(n_row, n_col, nz, Ti, Tj, Tx, Control)
-    @ccall libumfpack.umfpack_di_report_triplet(n_row::Int32, n_col::Int32, nz::Int32, Ti::Ptr{Int32}, Tj::Ptr{Int32}, Tx::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_report_triplet(n_row::Int32, n_col::Int32, nz::Int32,
+                                                Ti::Ptr{Int32}, Tj::Ptr{Int32},
+                                                Tx::Ptr{Cdouble},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_report_triplet(n_row, n_col, nz, Ti, Tj, Tx, Control)
-    @ccall libumfpack.umfpack_dl_report_triplet(n_row::Int64, n_col::Int64, nz::Int64, Ti::Ptr{Int64}, Tj::Ptr{Int64}, Tx::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_report_triplet(n_row::Int64, n_col::Int64, nz::Int64,
+                                                Ti::Ptr{Int64}, Tj::Ptr{Int64},
+                                                Tx::Ptr{Cdouble},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_report_triplet(n_row, n_col, nz, Ti, Tj, Tx, Tz, Control)
-    @ccall libumfpack.umfpack_zi_report_triplet(n_row::Int32, n_col::Int32, nz::Int32, Ti::Ptr{Int32}, Tj::Ptr{Int32}, Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_report_triplet(n_row::Int32, n_col::Int32, nz::Int32,
+                                                Ti::Ptr{Int32}, Tj::Ptr{Int32},
+                                                Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_report_triplet(n_row, n_col, nz, Ti, Tj, Tx, Tz, Control)
-    @ccall libumfpack.umfpack_zl_report_triplet(n_row::Int64, n_col::Int64, nz::Int64, Ti::Ptr{Int64}, Tj::Ptr{Int64}, Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_report_triplet(n_row::Int64, n_col::Int64, nz::Int64,
+                                                Ti::Ptr{Int64}, Tj::Ptr{Int64},
+                                                Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_report_vector(n, X, Control)
-    @ccall libumfpack.umfpack_di_report_vector(n::Int32, X::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_report_vector(n::Int32, X::Ptr{Cdouble},
+                                               Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_report_vector(n, X, Control)
-    @ccall libumfpack.umfpack_dl_report_vector(n::Int64, X::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_report_vector(n::Int64, X::Ptr{Cdouble},
+                                               Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_report_vector(n, Xx, Xz, Control)
-    @ccall libumfpack.umfpack_zi_report_vector(n::Int32, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_report_vector(n::Int32, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble},
+                                               Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_report_vector(n, Xx, Xz, Control)
-    @ccall libumfpack.umfpack_zl_report_vector(n::Int64, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_report_vector(n::Int64, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble},
+                                               Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_report_symbolic(Symbolic, Control)
-    @ccall libumfpack.umfpack_di_report_symbolic(Symbolic::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_report_symbolic(Symbolic::Ptr{Cvoid},
+                                                 Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_report_symbolic(Symbolic, Control)
-    @ccall libumfpack.umfpack_dl_report_symbolic(Symbolic::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_report_symbolic(Symbolic::Ptr{Cvoid},
+                                                 Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_report_symbolic(Symbolic, Control)
-    @ccall libumfpack.umfpack_zi_report_symbolic(Symbolic::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_report_symbolic(Symbolic::Ptr{Cvoid},
+                                                 Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_report_symbolic(Symbolic, Control)
-    @ccall libumfpack.umfpack_zl_report_symbolic(Symbolic::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_report_symbolic(Symbolic::Ptr{Cvoid},
+                                                 Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_report_numeric(Numeric, Control)
-    @ccall libumfpack.umfpack_di_report_numeric(Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_report_numeric(Numeric::Ptr{Cvoid},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_report_numeric(Numeric, Control)
-    @ccall libumfpack.umfpack_dl_report_numeric(Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_report_numeric(Numeric::Ptr{Cvoid},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_report_numeric(Numeric, Control)
-    @ccall libumfpack.umfpack_zi_report_numeric(Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_report_numeric(Numeric::Ptr{Cvoid},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_report_numeric(Numeric, Control)
-    @ccall libumfpack.umfpack_zl_report_numeric(Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_report_numeric(Numeric::Ptr{Cvoid},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_report_perm(np, Perm, Control)
-    @ccall libumfpack.umfpack_di_report_perm(np::Int32, Perm::Ptr{Int32}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_report_perm(np::Int32, Perm::Ptr{Int32},
+                                             Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_report_perm(np, Perm, Control)
-    @ccall libumfpack.umfpack_dl_report_perm(np::Int64, Perm::Ptr{Int64}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_report_perm(np::Int64, Perm::Ptr{Int64},
+                                             Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_report_perm(np, Perm, Control)
-    @ccall libumfpack.umfpack_zi_report_perm(np::Int32, Perm::Ptr{Int32}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_report_perm(np::Int32, Perm::Ptr{Int32},
+                                             Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_report_perm(np, Perm, Control)
-    @ccall libumfpack.umfpack_zl_report_perm(np::Int64, Perm::Ptr{Int64}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_report_perm(np::Int64, Perm::Ptr{Int64},
+                                             Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_timer()
@@ -2395,13 +3219,13 @@ function umfpack_toc(stats)
     @ccall libumfpack.umfpack_toc(stats::Ptr{Cdouble})::Cvoid
 end
 
-const CHOLMOD_DATE = "Jan 17, 2023"
+const CHOLMOD_DATE = "June 16, 2023"
 
 const CHOLMOD_MAIN_VERSION = 4
 
 const CHOLMOD_SUB_VERSION = 0
 
-const CHOLMOD_SUBSUB_VERSION = 3
+const CHOLMOD_SUBSUB_VERSION = 4
 
 const _FILE_OFFSET_BITS = 64
 
@@ -2427,17 +3251,18 @@ const SUITESPARSE_COMPILER_MSC = 0
 
 const SUITESPARSE_COMPILER_XLC = 0
 
-const SUITESPARSE_DATE = "Jan 20, 2023"
+const SUITESPARSE_DATE = "June 29, 2023"
 
 const SUITESPARSE_MAIN_VERSION = 7
 
-const SUITESPARSE_SUB_VERSION = 0
+const SUITESPARSE_SUB_VERSION = 1
 
-const SUITESPARSE_SUBSUB_VERSION = 1
+const SUITESPARSE_SUBSUB_VERSION = 0
 
 SUITESPARSE_VER_CODE(main, sub) = main * 1000 + sub
 
-const SUITESPARSE_VERSION = SUITESPARSE_VER_CODE(SUITESPARSE_MAIN_VERSION, SUITESPARSE_SUB_VERSION)
+const SUITESPARSE_VERSION = SUITESPARSE_VER_CODE(SUITESPARSE_MAIN_VERSION,
+                                                 SUITESPARSE_SUB_VERSION)
 
 CHOLMOD_VER_CODE(main, sub) = main * 1000 + sub
 
@@ -2601,20 +3426,18 @@ const SPQR_RTX_EQUALS_B = 2
 
 const SPQR_RTX_EQUALS_ETB = 3
 
-const SPQR_DATE = "Jan 17, 2023"
+const SPQR_DATE = "July FIXME, 2023"
 
-const SPQR_MAIN_VERSION = 3
+const SPQR_MAIN_VERSION = 4
 
 const SPQR_SUB_VERSION = 0
 
-const SPQR_SUBSUB_VERSION = 3
+const SPQR_SUBSUB_VERSION = 0
 
 SPQR_VER_CODE(main, sub) = main * 1000 + sub
 
 const SPQR_VERSION = SPQR_VER_CODE(SPQR_MAIN_VERSION, SPQR_SUB_VERSION)
 
-const Complex = Float64
-
 const AMD_CONTROL = 5
 
 const AMD_INFO = 20
@@ -2663,172 +3486,29 @@ const AMD_INVALID = -2
 
 const AMD_OK_BUT_JUMBLED = 1
 
-const AMD_DATE = "Jan 17, 2023"
+const AMD_DATE = "June 16, 2023"
 
 const AMD_MAIN_VERSION = 3
 
 const AMD_SUB_VERSION = 0
 
-const AMD_SUBSUB_VERSION = 3
+const AMD_SUBSUB_VERSION = 4
 
 AMD_VERSION_CODE(main, sub) = main * 1000 + sub
 
 const AMD_VERSION = AMD_VERSION_CODE(AMD_MAIN_VERSION, AMD_SUB_VERSION)
 
-const COLAMD_DATE = "Jan 17, 2023"
-
-const COLAMD_MAIN_VERSION = 3
-
-const COLAMD_SUB_VERSION = 0
-
-const COLAMD_SUBSUB_VERSION = 3
-
-COLAMD_VERSION_CODE(main, sub) = main * 1000 + sub
-
-const COLAMD_VERSION = COLAMD_VERSION_CODE(COLAMD_MAIN_VERSION, COLAMD_SUB_VERSION)
-
-const COLAMD_KNOBS = 20
-
-const COLAMD_STATS = 20
-
-const COLAMD_DENSE_ROW = 0
-
-const COLAMD_DENSE_COL = 1
-
-const COLAMD_AGGRESSIVE = 2
-
-const COLAMD_DEFRAG_COUNT = 2
-
-const COLAMD_STATUS = 3
-
-const COLAMD_INFO1 = 4
-
-const COLAMD_INFO2 = 5
-
-const COLAMD_INFO3 = 6
-
-const COLAMD_OK = 0
-
-const COLAMD_OK_BUT_JUMBLED = 1
-
-const COLAMD_ERROR_A_not_present = -1
-
-const COLAMD_ERROR_p_not_present = -2
-
-const COLAMD_ERROR_nrow_negative = -3
-
-const COLAMD_ERROR_ncol_negative = -4
-
-const COLAMD_ERROR_nnz_negative = -5
-
-const COLAMD_ERROR_p0_nonzero = -6
-
-const COLAMD_ERROR_A_too_small = -7
-
-const COLAMD_ERROR_col_length_negative = -8
-
-const COLAMD_ERROR_row_index_out_of_bounds = -9
-
-const COLAMD_ERROR_out_of_memory = -10
-
-const COLAMD_ERROR_internal_error = -999
-
-const CCOLAMD_DATE = "Jan 17, 2023"
-
-const CCOLAMD_MAIN_VERSION = 3
-
-const CCOLAMD_SUB_VERSION = 0
-
-const CCOLAMD_SUBSUB_VERSION = 3
-
-CCOLAMD_VERSION_CODE(main, sub) = main * 1000 + sub
-
-const CCOLAMD_VERSION = CCOLAMD_VERSION_CODE(CCOLAMD_MAIN_VERSION, CCOLAMD_SUB_VERSION)
-
-const CCOLAMD_KNOBS = 20
-
-const CCOLAMD_STATS = 20
-
-const CCOLAMD_DENSE_ROW = 0
-
-const CCOLAMD_DENSE_COL = 1
-
-const CCOLAMD_AGGRESSIVE = 2
-
-const CCOLAMD_LU = 3
-
-const CCOLAMD_DEFRAG_COUNT = 2
-
-const CCOLAMD_STATUS = 3
-
-const CCOLAMD_INFO1 = 4
-
-const CCOLAMD_INFO2 = 5
-
-const CCOLAMD_INFO3 = 6
-
-const CCOLAMD_EMPTY_ROW = 7
-
-const CCOLAMD_EMPTY_COL = 8
-
-const CCOLAMD_NEWLY_EMPTY_ROW = 9
-
-const CCOLAMD_NEWLY_EMPTY_COL = 10
-
-const CCOLAMD_OK = 0
-
-const CCOLAMD_OK_BUT_JUMBLED = 1
-
-const CCOLAMD_ERROR_A_not_present = -1
-
-const CCOLAMD_ERROR_p_not_present = -2
-
-const CCOLAMD_ERROR_nrow_negative = -3
-
-const CCOLAMD_ERROR_ncol_negative = -4
-
-const CCOLAMD_ERROR_nnz_negative = -5
-
-const CCOLAMD_ERROR_p0_nonzero = -6
-
-const CCOLAMD_ERROR_A_too_small = -7
-
-const CCOLAMD_ERROR_col_length_negative = -8
-
-const CCOLAMD_ERROR_row_index_out_of_bounds = -9
-
-const CCOLAMD_ERROR_out_of_memory = -10
-
-const CCOLAMD_ERROR_invalid_cmember = -11
-
-const CCOLAMD_ERROR_internal_error = -999
-
 const UMFPACK_INFO = 90
 
 const UMFPACK_CONTROL = 20
 
-# Skipping MacroDefinition: UMFPACK_COPYRIGHT \
-#"UMFPACK:  Copyright (c) 2005-2023 by Timothy A. Davis.  All Rights Reserved.\n"
-
-# Skipping MacroDefinition: UMFPACK_LICENSE_PART1 \
-#"\nUMFPACK License: SPDX-License-Identifier: GPL-2.0+\n" \
-#"   UMFPACK is available under alternate licenses,\n" \
-#"   contact T. Davis for details.\n"
-
-const UMFPACK_LICENSE_PART2 = "\n"
-
-# Skipping MacroDefinition: UMFPACK_LICENSE_PART3 \
-#"\n" \
-#"Availability: http://www.suitesparse.com" \
-#"\n"
-
-const UMFPACK_DATE = "Jan 17, 2023"
+const UMFPACK_DATE = "June 16, 2023"
 
 const UMFPACK_MAIN_VERSION = 6
 
 const UMFPACK_SUB_VERSION = 1
 
-const UMFPACK_SUBSUB_VERSION = 0
+const UMFPACK_SUBSUB_VERSION = 1
 
 UMFPACK_VER_CODE(main, sub) = main * 1000 + sub
 
@@ -3169,4 +3849,3 @@ const UMFPACK_Q_Uat = 12
 const UMFPACK_Ut = 13
 
 const UMFPACK_Uat = 14
-
diff --git a/src/solvers/lib/i686-linux-musl.jl b/src/solvers/lib/i686-linux-musl.jl
index fcf756d2..a5aa4e44 100644
--- a/src/solvers/lib/i686-linux-musl.jl
+++ b/src/solvers/lib/i686-linux-musl.jl
@@ -1,137 +1,150 @@
 function SuiteSparse_config_printf_func_get()
-    @ccall libcholmod.SuiteSparse_config_printf_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_printf_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_malloc_func_get()
-    @ccall libcholmod.SuiteSparse_config_malloc_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_malloc_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_calloc_func_get()
-    @ccall libcholmod.SuiteSparse_config_calloc_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_calloc_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_realloc_func_get()
-    @ccall libcholmod.SuiteSparse_config_realloc_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_realloc_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_free_func_get()
-    @ccall libcholmod.SuiteSparse_config_free_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_free_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_hypot_func_get()
-    @ccall libcholmod.SuiteSparse_config_hypot_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_hypot_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_divcomplex_func_get()
-    @ccall libcholmod.SuiteSparse_config_divcomplex_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_divcomplex_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_malloc_func_set(malloc_func)
-    @ccall libcholmod.SuiteSparse_config_malloc_func_set(malloc_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_malloc_func_set(malloc_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_calloc_func_set(calloc_func)
-    @ccall libcholmod.SuiteSparse_config_calloc_func_set(calloc_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_calloc_func_set(calloc_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_realloc_func_set(realloc_func)
-    @ccall libcholmod.SuiteSparse_config_realloc_func_set(realloc_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_realloc_func_set(realloc_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_free_func_set(free_func)
-    @ccall libcholmod.SuiteSparse_config_free_func_set(free_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_free_func_set(free_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_printf_func_set(printf_func)
-    @ccall libcholmod.SuiteSparse_config_printf_func_set(printf_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_printf_func_set(printf_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_hypot_func_set(hypot_func)
-    @ccall libcholmod.SuiteSparse_config_hypot_func_set(hypot_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_hypot_func_set(hypot_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_divcomplex_func_set(divcomplex_func)
-    @ccall libcholmod.SuiteSparse_config_divcomplex_func_set(divcomplex_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_divcomplex_func_set(divcomplex_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_malloc(s)
-    @ccall libcholmod.SuiteSparse_config_malloc(s::Csize_t)::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_malloc(s::Csize_t)::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_calloc(n, s)
-    @ccall libcholmod.SuiteSparse_config_calloc(n::Csize_t, s::Csize_t)::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_calloc(n::Csize_t,
+                                                          s::Csize_t)::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_realloc(arg1, s)
-    @ccall libcholmod.SuiteSparse_config_realloc(arg1::Ptr{Cvoid}, s::Csize_t)::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_realloc(arg1::Ptr{Cvoid},
+                                                           s::Csize_t)::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_free(arg1)
-    @ccall libcholmod.SuiteSparse_config_free(arg1::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_free(arg1::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_hypot(x, y)
-    @ccall libcholmod.SuiteSparse_config_hypot(x::Cdouble, y::Cdouble)::Cdouble
+    @ccall libsuitesparseconfig.SuiteSparse_config_hypot(x::Cdouble, y::Cdouble)::Cdouble
 end
 
 function SuiteSparse_config_divcomplex(xr, xi, yr, yi, zr, zi)
-    @ccall libcholmod.SuiteSparse_config_divcomplex(xr::Cdouble, xi::Cdouble, yr::Cdouble, yi::Cdouble, zr::Ptr{Cdouble}, zi::Ptr{Cdouble})::Cint
+    @ccall libsuitesparseconfig.SuiteSparse_config_divcomplex(xr::Cdouble, xi::Cdouble,
+                                                              yr::Cdouble, yi::Cdouble,
+                                                              zr::Ptr{Cdouble},
+                                                              zi::Ptr{Cdouble})::Cint
 end
 
 function SuiteSparse_start()
-    @ccall libcholmod.SuiteSparse_start()::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_start()::Cvoid
 end
 
 function SuiteSparse_finish()
-    @ccall libcholmod.SuiteSparse_finish()::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_finish()::Cvoid
 end
 
 function SuiteSparse_malloc(nitems, size_of_item)
-    @ccall libcholmod.SuiteSparse_malloc(nitems::Csize_t, size_of_item::Csize_t)::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_malloc(nitems::Csize_t,
+                                                   size_of_item::Csize_t)::Ptr{Cvoid}
 end
 
 function SuiteSparse_calloc(nitems, size_of_item)
-    @ccall libcholmod.SuiteSparse_calloc(nitems::Csize_t, size_of_item::Csize_t)::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_calloc(nitems::Csize_t,
+                                                   size_of_item::Csize_t)::Ptr{Cvoid}
 end
 
 function SuiteSparse_realloc(nitems_new, nitems_old, size_of_item, p, ok)
-    @ccall libcholmod.SuiteSparse_realloc(nitems_new::Csize_t, nitems_old::Csize_t, size_of_item::Csize_t, p::Ptr{Cvoid}, ok::Ptr{Cint})::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_realloc(nitems_new::Csize_t,
+                                                    nitems_old::Csize_t,
+                                                    size_of_item::Csize_t, p::Ptr{Cvoid},
+                                                    ok::Ptr{Cint})::Ptr{Cvoid}
 end
 
 function SuiteSparse_free(p)
-    @ccall libcholmod.SuiteSparse_free(p::Ptr{Cvoid})::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_free(p::Ptr{Cvoid})::Ptr{Cvoid}
 end
 
 function SuiteSparse_tic(tic)
-    @ccall libcholmod.SuiteSparse_tic(tic::Ptr{Cdouble})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_tic(tic::Ptr{Cdouble})::Cvoid
 end
 
 function SuiteSparse_toc(tic)
-    @ccall libcholmod.SuiteSparse_toc(tic::Ptr{Cdouble})::Cdouble
+    @ccall libsuitesparseconfig.SuiteSparse_toc(tic::Ptr{Cdouble})::Cdouble
 end
 
 function SuiteSparse_time()
-    @ccall libcholmod.SuiteSparse_time()::Cdouble
+    @ccall libsuitesparseconfig.SuiteSparse_time()::Cdouble
 end
 
 function SuiteSparse_hypot(x, y)
-    @ccall libcholmod.SuiteSparse_hypot(x::Cdouble, y::Cdouble)::Cdouble
+    @ccall libsuitesparseconfig.SuiteSparse_hypot(x::Cdouble, y::Cdouble)::Cdouble
 end
 
 function SuiteSparse_divcomplex(ar, ai, br, bi, cr, ci)
-    @ccall libcholmod.SuiteSparse_divcomplex(ar::Cdouble, ai::Cdouble, br::Cdouble, bi::Cdouble, cr::Ptr{Cdouble}, ci::Ptr{Cdouble})::Cint
+    @ccall libsuitesparseconfig.SuiteSparse_divcomplex(ar::Cdouble, ai::Cdouble,
+                                                       br::Cdouble, bi::Cdouble,
+                                                       cr::Ptr{Cdouble},
+                                                       ci::Ptr{Cdouble})::Cint
 end
 
 function SuiteSparse_version(version)
-    @ccall libcholmod.SuiteSparse_version(version::Ptr{Cint})::Cint
+    @ccall libsuitesparseconfig.SuiteSparse_version(version::Ptr{Cint})::Cint
 end
 
 function SuiteSparse_BLAS_library()
-    @ccall libcholmod.SuiteSparse_BLAS_library()::Ptr{Cchar}
+    @ccall libsuitesparseconfig.SuiteSparse_BLAS_library()::Ptr{Cchar}
 end
 
 function SuiteSparse_BLAS_integer_size()
-    @ccall libcholmod.SuiteSparse_BLAS_integer_size()::Csize_t
+    @ccall libsuitesparseconfig.SuiteSparse_BLAS_integer_size()::Csize_t
 end
 
 struct cholmod_method_struct
@@ -140,16 +153,16 @@ struct cholmod_method_struct
     prune_dense::Cdouble
     prune_dense2::Cdouble
     nd_oksep::Cdouble
-    other_1::NTuple{4, Cdouble}
+    other_1::NTuple{4,Cdouble}
     nd_small::Csize_t
-    other_2::NTuple{4, Csize_t}
+    other_2::NTuple{4,Csize_t}
     aggressive::Cint
     order_for_lu::Cint
     nd_compress::Cint
     nd_camd::Cint
     nd_components::Cint
     ordering::Cint
-    other_3::NTuple{4, Csize_t}
+    other_3::NTuple{4,Csize_t}
 end
 
 mutable struct cholmod_common_struct
@@ -166,8 +179,8 @@ mutable struct cholmod_common_struct
     final_pack::Cint
     final_monotonic::Cint
     final_resymbol::Cint
-    zrelax::NTuple{3, Cdouble}
-    nrelax::NTuple{3, Csize_t}
+    zrelax::NTuple{3,Cdouble}
+    nrelax::NTuple{3,Csize_t}
     prefer_zomplex::Cint
     prefer_upper::Cint
     quick_return_if_not_posdef::Cint
@@ -179,7 +192,7 @@ mutable struct cholmod_common_struct
     nmethods::Cint
     current::Cint
     selected::Cint
-    method::NTuple{10, cholmod_method_struct}
+    method::NTuple{10,cholmod_method_struct}
     postorder::Cint
     default_nesdis::Cint
     metis_memory::Cdouble
@@ -222,7 +235,7 @@ mutable struct cholmod_common_struct
     SPQR_flopcount_bound::Cdouble
     SPQR_tol_used::Cdouble
     SPQR_norm_E_fro::Cdouble
-    SPQR_istat::NTuple{10, Int64}
+    SPQR_istat::NTuple{10,Int64}
     useGPU::Cint
     maxGpuMemBytes::Csize_t
     maxGpuMemFraction::Cdouble
@@ -231,10 +244,10 @@ mutable struct cholmod_common_struct
     gpuFlops::Int64
     gpuNumKernelLaunches::Cint
     cublasHandle::Ptr{Cvoid}
-    gpuStream::NTuple{8, Ptr{Cvoid}}
-    cublasEventPotrf::NTuple{3, Ptr{Cvoid}}
+    gpuStream::NTuple{8,Ptr{Cvoid}}
+    cublasEventPotrf::NTuple{3,Ptr{Cvoid}}
     updateCKernelsComplete::Ptr{Cvoid}
-    updateCBuffersFree::NTuple{8, Ptr{Cvoid}}
+    updateCBuffersFree::NTuple{8,Ptr{Cvoid}}
     dev_mempool::Ptr{Cvoid}
     dev_mempool_size::Csize_t
     host_pinned_mempool::Ptr{Cvoid}
@@ -300,11 +313,14 @@ function cholmod_l_maxrank(arg1, arg2)
 end
 
 function cholmod_allocate_work(nrow, iworksize, xworksize, Common)
-    @ccall libcholmod.cholmod_allocate_work(nrow::Csize_t, iworksize::Csize_t, xworksize::Csize_t, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_allocate_work(nrow::Csize_t, iworksize::Csize_t,
+                                            xworksize::Csize_t,
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_allocate_work(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_allocate_work(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_allocate_work(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t,
+                                              arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_free_work(Common)
@@ -324,11 +340,13 @@ function cholmod_l_clear_flag(arg1)
 end
 
 function cholmod_error(status, file, line, message, Common)
-    @ccall libcholmod.cholmod_error(status::Cint, file::Ptr{Cchar}, line::Cint, message::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_error(status::Cint, file::Ptr{Cchar}, line::Cint,
+                                    message::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_error(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_error(arg1::Cint, arg2::Ptr{Cchar}, arg3::Cint, arg4::Ptr{Cchar}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_error(arg1::Cint, arg2::Ptr{Cchar}, arg3::Cint,
+                                      arg4::Ptr{Cchar}, arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_dbound(dj, Common)
@@ -348,11 +366,14 @@ function cholmod_l_hypot(arg1, arg2)
 end
 
 function cholmod_divcomplex(ar, ai, br, bi, cr, ci)
-    @ccall libcholmod.cholmod_divcomplex(ar::Cdouble, ai::Cdouble, br::Cdouble, bi::Cdouble, cr::Ptr{Cdouble}, ci::Ptr{Cdouble})::Cint
+    @ccall libcholmod.cholmod_divcomplex(ar::Cdouble, ai::Cdouble, br::Cdouble, bi::Cdouble,
+                                         cr::Ptr{Cdouble}, ci::Ptr{Cdouble})::Cint
 end
 
 function cholmod_l_divcomplex(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_divcomplex(arg1::Cdouble, arg2::Cdouble, arg3::Cdouble, arg4::Cdouble, arg5::Ptr{Cdouble}, arg6::Ptr{Cdouble})::Cint
+    @ccall libcholmod.cholmod_l_divcomplex(arg1::Cdouble, arg2::Cdouble, arg3::Cdouble,
+                                           arg4::Cdouble, arg5::Ptr{Cdouble},
+                                           arg6::Ptr{Cdouble})::Cint
 end
 
 mutable struct cholmod_sparse_struct
@@ -384,155 +405,217 @@ end
 const descendantScore = cholmod_descendant_score_t
 
 function cholmod_score_comp(i, j)
-    @ccall libcholmod.cholmod_score_comp(i::Ptr{cholmod_descendant_score_t}, j::Ptr{cholmod_descendant_score_t})::Cint
+    @ccall libcholmod.cholmod_score_comp(i::Ptr{cholmod_descendant_score_t},
+                                         j::Ptr{cholmod_descendant_score_t})::Cint
 end
 
 function cholmod_l_score_comp(i, j)
-    @ccall libcholmod.cholmod_l_score_comp(i::Ptr{cholmod_descendant_score_t}, j::Ptr{cholmod_descendant_score_t})::Cint
+    @ccall libcholmod.cholmod_l_score_comp(i::Ptr{cholmod_descendant_score_t},
+                                           j::Ptr{cholmod_descendant_score_t})::Cint
 end
 
 function cholmod_allocate_sparse(nrow, ncol, nzmax, sorted, packed, stype, xtype, Common)
-    @ccall libcholmod.cholmod_allocate_sparse(nrow::Csize_t, ncol::Csize_t, nzmax::Csize_t, sorted::Cint, packed::Cint, stype::Cint, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_allocate_sparse(nrow::Csize_t, ncol::Csize_t, nzmax::Csize_t,
+                                              sorted::Cint, packed::Cint, stype::Cint,
+                                              xtype::Cint,
+                                              Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_allocate_sparse(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
-    @ccall libcholmod.cholmod_l_allocate_sparse(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t, arg4::Cint, arg5::Cint, arg6::Cint, arg7::Cint, arg8::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_allocate_sparse(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t,
+                                                arg4::Cint, arg5::Cint, arg6::Cint,
+                                                arg7::Cint,
+                                                arg8::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_free_sparse(A, Common)
-    @ccall libcholmod.cholmod_free_sparse(A::Ptr{Ptr{cholmod_sparse}}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_free_sparse(A::Ptr{Ptr{cholmod_sparse}},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_free_sparse(arg1, arg2)
-    @ccall libcholmod.cholmod_l_free_sparse(arg1::Ptr{Ptr{cholmod_sparse}}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_free_sparse(arg1::Ptr{Ptr{cholmod_sparse}},
+                                            arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_reallocate_sparse(nznew, A, Common)
-    @ccall libcholmod.cholmod_reallocate_sparse(nznew::Csize_t, A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_reallocate_sparse(nznew::Csize_t, A::Ptr{cholmod_sparse},
+                                                Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_reallocate_sparse(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_reallocate_sparse(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_reallocate_sparse(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                                  arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_nnz(A, Common)
-    @ccall libcholmod.cholmod_nnz(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_nnz(A::Ptr{cholmod_sparse},
+                                  Common::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_l_nnz(arg1, arg2)
-    @ccall libcholmod.cholmod_l_nnz(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_l_nnz(arg1::Ptr{cholmod_sparse},
+                                    arg2::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_speye(nrow, ncol, xtype, Common)
-    @ccall libcholmod.cholmod_speye(nrow::Csize_t, ncol::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_speye(nrow::Csize_t, ncol::Csize_t, xtype::Cint,
+                                    Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_speye(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_speye(arg1::Csize_t, arg2::Csize_t, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_speye(arg1::Csize_t, arg2::Csize_t, arg3::Cint,
+                                      arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_spzeros(nrow, ncol, nzmax, xtype, Common)
-    @ccall libcholmod.cholmod_spzeros(nrow::Csize_t, ncol::Csize_t, nzmax::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_spzeros(nrow::Csize_t, ncol::Csize_t, nzmax::Csize_t,
+                                      xtype::Cint,
+                                      Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_spzeros(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_spzeros(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t, arg4::Cint, arg5::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_spzeros(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t,
+                                        arg4::Cint,
+                                        arg5::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_transpose(A, values, Common)
-    @ccall libcholmod.cholmod_transpose(A::Ptr{cholmod_sparse}, values::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_transpose(A::Ptr{cholmod_sparse}, values::Cint,
+                                        Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_transpose(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_transpose(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_transpose(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                          arg3::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_transpose_unsym(A, values, Perm, fset, fsize, F, Common)
-    @ccall libcholmod.cholmod_transpose_unsym(A::Ptr{cholmod_sparse}, values::Cint, Perm::Ptr{Int32}, fset::Ptr{Int32}, fsize::Csize_t, F::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_transpose_unsym(A::Ptr{cholmod_sparse}, values::Cint,
+                                              Perm::Ptr{Int32}, fset::Ptr{Int32},
+                                              fsize::Csize_t, F::Ptr{cholmod_sparse},
+                                              Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_transpose_unsym(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_transpose_unsym(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Csize_t, arg6::Ptr{cholmod_sparse}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_transpose_unsym(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                                arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                                arg5::Csize_t, arg6::Ptr{cholmod_sparse},
+                                                arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_transpose_sym(A, values, Perm, F, Common)
-    @ccall libcholmod.cholmod_transpose_sym(A::Ptr{cholmod_sparse}, values::Cint, Perm::Ptr{Int32}, F::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_transpose_sym(A::Ptr{cholmod_sparse}, values::Cint,
+                                            Perm::Ptr{Int32}, F::Ptr{cholmod_sparse},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_transpose_sym(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_transpose_sym(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{Int64}, arg4::Ptr{cholmod_sparse}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_transpose_sym(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                              arg3::Ptr{Int64}, arg4::Ptr{cholmod_sparse},
+                                              arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_ptranspose(A, values, Perm, fset, fsize, Common)
-    @ccall libcholmod.cholmod_ptranspose(A::Ptr{cholmod_sparse}, values::Cint, Perm::Ptr{Int32}, fset::Ptr{Int32}, fsize::Csize_t, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_ptranspose(A::Ptr{cholmod_sparse}, values::Cint,
+                                         Perm::Ptr{Int32}, fset::Ptr{Int32}, fsize::Csize_t,
+                                         Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_ptranspose(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_ptranspose(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Csize_t, arg6::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_ptranspose(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                           arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                           arg5::Csize_t,
+                                           arg6::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_sort(A, Common)
-    @ccall libcholmod.cholmod_sort(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_sort(A::Ptr{cholmod_sparse},
+                                   Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_sort(arg1, arg2)
-    @ccall libcholmod.cholmod_l_sort(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_sort(arg1::Ptr{cholmod_sparse},
+                                     arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_band(A, k1, k2, mode, Common)
-    @ccall libcholmod.cholmod_band(A::Ptr{cholmod_sparse}, k1::Int64, k2::Int64, mode::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_band(A::Ptr{cholmod_sparse}, k1::Int64, k2::Int64, mode::Cint,
+                                   Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_band(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_band(arg1::Ptr{cholmod_sparse}, arg2::Int64, arg3::Int64, arg4::Cint, arg5::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_band(arg1::Ptr{cholmod_sparse}, arg2::Int64, arg3::Int64,
+                                     arg4::Cint,
+                                     arg5::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_band_inplace(k1, k2, mode, A, Common)
-    @ccall libcholmod.cholmod_band_inplace(k1::Int64, k2::Int64, mode::Cint, A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_band_inplace(k1::Int64, k2::Int64, mode::Cint,
+                                           A::Ptr{cholmod_sparse},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_band_inplace(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_band_inplace(arg1::Int64, arg2::Int64, arg3::Cint, arg4::Ptr{cholmod_sparse}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_band_inplace(arg1::Int64, arg2::Int64, arg3::Cint,
+                                             arg4::Ptr{cholmod_sparse},
+                                             arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_aat(A, fset, fsize, mode, Common)
-    @ccall libcholmod.cholmod_aat(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, mode::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_aat(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t,
+                                  mode::Cint,
+                                  Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_aat(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_aat(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Cint, arg5::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_aat(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                    arg3::Csize_t, arg4::Cint,
+                                    arg5::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_copy_sparse(A, Common)
-    @ccall libcholmod.cholmod_copy_sparse(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_copy_sparse(A::Ptr{cholmod_sparse},
+                                          Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_copy_sparse(arg1, arg2)
-    @ccall libcholmod.cholmod_l_copy_sparse(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_copy_sparse(arg1::Ptr{cholmod_sparse},
+                                            arg2::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_copy(A, stype, mode, Common)
-    @ccall libcholmod.cholmod_copy(A::Ptr{cholmod_sparse}, stype::Cint, mode::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_copy(A::Ptr{cholmod_sparse}, stype::Cint, mode::Cint,
+                                   Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_copy(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_copy(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_copy(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Cint,
+                                     arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_add(A, B, alpha, beta, values, sorted, Common)
-    @ccall libcholmod.cholmod_add(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse}, alpha::Ptr{Cdouble}, beta::Ptr{Cdouble}, values::Cint, sorted::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_add(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse},
+                                  alpha::Ptr{Cdouble}, beta::Ptr{Cdouble}, values::Cint,
+                                  sorted::Cint,
+                                  Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_add(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_add(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Ptr{Cdouble}, arg5::Cint, arg6::Cint, arg7::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_add(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse},
+                                    arg3::Ptr{Cdouble}, arg4::Ptr{Cdouble}, arg5::Cint,
+                                    arg6::Cint,
+                                    arg7::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_sparse_xtype(to_xtype, A, Common)
-    @ccall libcholmod.cholmod_sparse_xtype(to_xtype::Cint, A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_sparse_xtype(to_xtype::Cint, A::Ptr{cholmod_sparse},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_sparse_xtype(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_sparse_xtype(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_sparse_xtype(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                             arg3::Ptr{cholmod_common})::Cint
 end
 
 mutable struct cholmod_factor_struct
@@ -572,75 +655,100 @@ end
 const cholmod_factor = cholmod_factor_struct
 
 function cholmod_allocate_factor(n, Common)
-    @ccall libcholmod.cholmod_allocate_factor(n::Csize_t, Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_allocate_factor(n::Csize_t,
+                                              Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_l_allocate_factor(arg1, arg2)
-    @ccall libcholmod.cholmod_l_allocate_factor(arg1::Csize_t, arg2::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_l_allocate_factor(arg1::Csize_t,
+                                                arg2::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_free_factor(L, Common)
-    @ccall libcholmod.cholmod_free_factor(L::Ptr{Ptr{cholmod_factor}}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_free_factor(L::Ptr{Ptr{cholmod_factor}},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_free_factor(arg1, arg2)
-    @ccall libcholmod.cholmod_l_free_factor(arg1::Ptr{Ptr{cholmod_factor}}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_free_factor(arg1::Ptr{Ptr{cholmod_factor}},
+                                            arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_reallocate_factor(nznew, L, Common)
-    @ccall libcholmod.cholmod_reallocate_factor(nznew::Csize_t, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_reallocate_factor(nznew::Csize_t, L::Ptr{cholmod_factor},
+                                                Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_reallocate_factor(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_reallocate_factor(arg1::Csize_t, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_reallocate_factor(arg1::Csize_t, arg2::Ptr{cholmod_factor},
+                                                  arg3::Ptr{cholmod_common})::Cint
 end
 
-function cholmod_change_factor(to_xtype, to_ll, to_super, to_packed, to_monotonic, L, Common)
-    @ccall libcholmod.cholmod_change_factor(to_xtype::Cint, to_ll::Cint, to_super::Cint, to_packed::Cint, to_monotonic::Cint, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+function cholmod_change_factor(to_xtype, to_ll, to_super, to_packed, to_monotonic, L,
+                               Common)
+    @ccall libcholmod.cholmod_change_factor(to_xtype::Cint, to_ll::Cint, to_super::Cint,
+                                            to_packed::Cint, to_monotonic::Cint,
+                                            L::Ptr{cholmod_factor},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_change_factor(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_change_factor(arg1::Cint, arg2::Cint, arg3::Cint, arg4::Cint, arg5::Cint, arg6::Ptr{cholmod_factor}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_change_factor(arg1::Cint, arg2::Cint, arg3::Cint,
+                                              arg4::Cint, arg5::Cint,
+                                              arg6::Ptr{cholmod_factor},
+                                              arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_pack_factor(L, Common)
-    @ccall libcholmod.cholmod_pack_factor(L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_pack_factor(L::Ptr{cholmod_factor},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_pack_factor(arg1, arg2)
-    @ccall libcholmod.cholmod_l_pack_factor(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_pack_factor(arg1::Ptr{cholmod_factor},
+                                            arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_reallocate_column(j, need, L, Common)
-    @ccall libcholmod.cholmod_reallocate_column(j::Csize_t, need::Csize_t, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_reallocate_column(j::Csize_t, need::Csize_t,
+                                                L::Ptr{cholmod_factor},
+                                                Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_reallocate_column(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_reallocate_column(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{cholmod_factor}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_reallocate_column(arg1::Csize_t, arg2::Csize_t,
+                                                  arg3::Ptr{cholmod_factor},
+                                                  arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_factor_to_sparse(L, Common)
-    @ccall libcholmod.cholmod_factor_to_sparse(L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_factor_to_sparse(L::Ptr{cholmod_factor},
+                                               Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_factor_to_sparse(arg1, arg2)
-    @ccall libcholmod.cholmod_l_factor_to_sparse(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_factor_to_sparse(arg1::Ptr{cholmod_factor},
+                                                 arg2::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_copy_factor(L, Common)
-    @ccall libcholmod.cholmod_copy_factor(L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_copy_factor(L::Ptr{cholmod_factor},
+                                          Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_l_copy_factor(arg1, arg2)
-    @ccall libcholmod.cholmod_l_copy_factor(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_l_copy_factor(arg1::Ptr{cholmod_factor},
+                                            arg2::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_factor_xtype(to_xtype, L, Common)
-    @ccall libcholmod.cholmod_factor_xtype(to_xtype::Cint, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_factor_xtype(to_xtype::Cint, L::Ptr{cholmod_factor},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_factor_xtype(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_factor_xtype(arg1::Cint, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_factor_xtype(arg1::Cint, arg2::Ptr{cholmod_factor},
+                                             arg3::Ptr{cholmod_common})::Cint
 end
 
 mutable struct cholmod_dense_struct
@@ -658,91 +766,118 @@ end
 const cholmod_dense = cholmod_dense_struct
 
 function cholmod_allocate_dense(nrow, ncol, d, xtype, Common)
-    @ccall libcholmod.cholmod_allocate_dense(nrow::Csize_t, ncol::Csize_t, d::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_allocate_dense(nrow::Csize_t, ncol::Csize_t, d::Csize_t,
+                                             xtype::Cint,
+                                             Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_allocate_dense(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_allocate_dense(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t, arg4::Cint, arg5::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_allocate_dense(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t,
+                                               arg4::Cint,
+                                               arg5::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_zeros(nrow, ncol, xtype, Common)
-    @ccall libcholmod.cholmod_zeros(nrow::Csize_t, ncol::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_zeros(nrow::Csize_t, ncol::Csize_t, xtype::Cint,
+                                    Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_zeros(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_zeros(arg1::Csize_t, arg2::Csize_t, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_zeros(arg1::Csize_t, arg2::Csize_t, arg3::Cint,
+                                      arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_ones(nrow, ncol, xtype, Common)
-    @ccall libcholmod.cholmod_ones(nrow::Csize_t, ncol::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_ones(nrow::Csize_t, ncol::Csize_t, xtype::Cint,
+                                   Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_ones(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_ones(arg1::Csize_t, arg2::Csize_t, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_ones(arg1::Csize_t, arg2::Csize_t, arg3::Cint,
+                                     arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_eye(nrow, ncol, xtype, Common)
-    @ccall libcholmod.cholmod_eye(nrow::Csize_t, ncol::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_eye(nrow::Csize_t, ncol::Csize_t, xtype::Cint,
+                                  Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_eye(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_eye(arg1::Csize_t, arg2::Csize_t, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_eye(arg1::Csize_t, arg2::Csize_t, arg3::Cint,
+                                    arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_free_dense(X, Common)
-    @ccall libcholmod.cholmod_free_dense(X::Ptr{Ptr{cholmod_dense}}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_free_dense(X::Ptr{Ptr{cholmod_dense}},
+                                         Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_free_dense(arg1, arg2)
-    @ccall libcholmod.cholmod_l_free_dense(arg1::Ptr{Ptr{cholmod_dense}}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_free_dense(arg1::Ptr{Ptr{cholmod_dense}},
+                                           arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_ensure_dense(XHandle, nrow, ncol, d, xtype, Common)
-    @ccall libcholmod.cholmod_ensure_dense(XHandle::Ptr{Ptr{cholmod_dense}}, nrow::Csize_t, ncol::Csize_t, d::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_ensure_dense(XHandle::Ptr{Ptr{cholmod_dense}}, nrow::Csize_t,
+                                           ncol::Csize_t, d::Csize_t, xtype::Cint,
+                                           Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_ensure_dense(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_ensure_dense(arg1::Ptr{Ptr{cholmod_dense}}, arg2::Csize_t, arg3::Csize_t, arg4::Csize_t, arg5::Cint, arg6::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_ensure_dense(arg1::Ptr{Ptr{cholmod_dense}}, arg2::Csize_t,
+                                             arg3::Csize_t, arg4::Csize_t, arg5::Cint,
+                                             arg6::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_sparse_to_dense(A, Common)
-    @ccall libcholmod.cholmod_sparse_to_dense(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_sparse_to_dense(A::Ptr{cholmod_sparse},
+                                              Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_sparse_to_dense(arg1, arg2)
-    @ccall libcholmod.cholmod_l_sparse_to_dense(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_sparse_to_dense(arg1::Ptr{cholmod_sparse},
+                                                arg2::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_dense_to_sparse(X, values, Common)
-    @ccall libcholmod.cholmod_dense_to_sparse(X::Ptr{cholmod_dense}, values::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_dense_to_sparse(X::Ptr{cholmod_dense}, values::Cint,
+                                              Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_dense_to_sparse(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_dense_to_sparse(arg1::Ptr{cholmod_dense}, arg2::Cint, arg3::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_dense_to_sparse(arg1::Ptr{cholmod_dense}, arg2::Cint,
+                                                arg3::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_copy_dense(X, Common)
-    @ccall libcholmod.cholmod_copy_dense(X::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_copy_dense(X::Ptr{cholmod_dense},
+                                         Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_copy_dense(arg1, arg2)
-    @ccall libcholmod.cholmod_l_copy_dense(arg1::Ptr{cholmod_dense}, arg2::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_copy_dense(arg1::Ptr{cholmod_dense},
+                                           arg2::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_copy_dense2(X, Y, Common)
-    @ccall libcholmod.cholmod_copy_dense2(X::Ptr{cholmod_dense}, Y::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_copy_dense2(X::Ptr{cholmod_dense}, Y::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_copy_dense2(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_copy_dense2(arg1::Ptr{cholmod_dense}, arg2::Ptr{cholmod_dense}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_copy_dense2(arg1::Ptr{cholmod_dense},
+                                            arg2::Ptr{cholmod_dense},
+                                            arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_dense_xtype(to_xtype, X, Common)
-    @ccall libcholmod.cholmod_dense_xtype(to_xtype::Cint, X::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_dense_xtype(to_xtype::Cint, X::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_dense_xtype(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_dense_xtype(arg1::Cint, arg2::Ptr{cholmod_dense}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_dense_xtype(arg1::Cint, arg2::Ptr{cholmod_dense},
+                                            arg3::Ptr{cholmod_common})::Cint
 end
 
 mutable struct cholmod_triplet_struct
@@ -764,99 +899,137 @@ end
 const cholmod_triplet = cholmod_triplet_struct
 
 function cholmod_allocate_triplet(nrow, ncol, nzmax, stype, xtype, Common)
-    @ccall libcholmod.cholmod_allocate_triplet(nrow::Csize_t, ncol::Csize_t, nzmax::Csize_t, stype::Cint, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_allocate_triplet(nrow::Csize_t, ncol::Csize_t, nzmax::Csize_t,
+                                               stype::Cint, xtype::Cint,
+                                               Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_l_allocate_triplet(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_allocate_triplet(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t, arg4::Cint, arg5::Cint, arg6::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_l_allocate_triplet(arg1::Csize_t, arg2::Csize_t,
+                                                 arg3::Csize_t, arg4::Cint, arg5::Cint,
+                                                 arg6::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_free_triplet(T, Common)
-    @ccall libcholmod.cholmod_free_triplet(T::Ptr{Ptr{cholmod_triplet}}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_free_triplet(T::Ptr{Ptr{cholmod_triplet}},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_free_triplet(arg1, arg2)
-    @ccall libcholmod.cholmod_l_free_triplet(arg1::Ptr{Ptr{cholmod_triplet}}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_free_triplet(arg1::Ptr{Ptr{cholmod_triplet}},
+                                             arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_reallocate_triplet(nznew, T, Common)
-    @ccall libcholmod.cholmod_reallocate_triplet(nznew::Csize_t, T::Ptr{cholmod_triplet}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_reallocate_triplet(nznew::Csize_t, T::Ptr{cholmod_triplet},
+                                                 Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_reallocate_triplet(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_reallocate_triplet(arg1::Csize_t, arg2::Ptr{cholmod_triplet}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_reallocate_triplet(arg1::Csize_t,
+                                                   arg2::Ptr{cholmod_triplet},
+                                                   arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_sparse_to_triplet(A, Common)
-    @ccall libcholmod.cholmod_sparse_to_triplet(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_sparse_to_triplet(A::Ptr{cholmod_sparse},
+                                                Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_l_sparse_to_triplet(arg1, arg2)
-    @ccall libcholmod.cholmod_l_sparse_to_triplet(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_l_sparse_to_triplet(arg1::Ptr{cholmod_sparse},
+                                                  arg2::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_triplet_to_sparse(T, nzmax, Common)
-    @ccall libcholmod.cholmod_triplet_to_sparse(T::Ptr{cholmod_triplet}, nzmax::Csize_t, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_triplet_to_sparse(T::Ptr{cholmod_triplet}, nzmax::Csize_t,
+                                                Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_triplet_to_sparse(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_triplet_to_sparse(arg1::Ptr{cholmod_triplet}, arg2::Csize_t, arg3::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_triplet_to_sparse(arg1::Ptr{cholmod_triplet}, arg2::Csize_t,
+                                                  arg3::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_copy_triplet(T, Common)
-    @ccall libcholmod.cholmod_copy_triplet(T::Ptr{cholmod_triplet}, Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_copy_triplet(T::Ptr{cholmod_triplet},
+                                           Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_l_copy_triplet(arg1, arg2)
-    @ccall libcholmod.cholmod_l_copy_triplet(arg1::Ptr{cholmod_triplet}, arg2::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_l_copy_triplet(arg1::Ptr{cholmod_triplet},
+                                             arg2::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_triplet_xtype(to_xtype, T, Common)
-    @ccall libcholmod.cholmod_triplet_xtype(to_xtype::Cint, T::Ptr{cholmod_triplet}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_triplet_xtype(to_xtype::Cint, T::Ptr{cholmod_triplet},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_triplet_xtype(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_triplet_xtype(arg1::Cint, arg2::Ptr{cholmod_triplet}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_triplet_xtype(arg1::Cint, arg2::Ptr{cholmod_triplet},
+                                              arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_malloc(n, size, Common)
-    @ccall libcholmod.cholmod_malloc(n::Csize_t, size::Csize_t, Common::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_malloc(n::Csize_t, size::Csize_t,
+                                     Common::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_l_malloc(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_malloc(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_l_malloc(arg1::Csize_t, arg2::Csize_t,
+                                       arg3::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_calloc(n, size, Common)
-    @ccall libcholmod.cholmod_calloc(n::Csize_t, size::Csize_t, Common::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_calloc(n::Csize_t, size::Csize_t,
+                                     Common::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_l_calloc(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_calloc(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_l_calloc(arg1::Csize_t, arg2::Csize_t,
+                                       arg3::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_free(n, size, p, Common)
-    @ccall libcholmod.cholmod_free(n::Csize_t, size::Csize_t, p::Ptr{Cvoid}, Common::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_free(n::Csize_t, size::Csize_t, p::Ptr{Cvoid},
+                                   Common::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_l_free(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_free(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{Cvoid}, arg4::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_l_free(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{Cvoid},
+                                     arg4::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_realloc(nnew, size, p, n, Common)
-    @ccall libcholmod.cholmod_realloc(nnew::Csize_t, size::Csize_t, p::Ptr{Cvoid}, n::Ptr{Csize_t}, Common::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_realloc(nnew::Csize_t, size::Csize_t, p::Ptr{Cvoid},
+                                      n::Ptr{Csize_t},
+                                      Common::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_l_realloc(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_realloc(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{Cvoid}, arg4::Ptr{Csize_t}, arg5::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_l_realloc(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{Cvoid},
+                                        arg4::Ptr{Csize_t},
+                                        arg5::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
-function cholmod_realloc_multiple(nnew, nint, xtype, Iblock, Jblock, Xblock, Zblock, n, Common)
-    @ccall libcholmod.cholmod_realloc_multiple(nnew::Csize_t, nint::Cint, xtype::Cint, Iblock::Ptr{Ptr{Cvoid}}, Jblock::Ptr{Ptr{Cvoid}}, Xblock::Ptr{Ptr{Cvoid}}, Zblock::Ptr{Ptr{Cvoid}}, n::Ptr{Csize_t}, Common::Ptr{cholmod_common})::Cint
+function cholmod_realloc_multiple(nnew, nint, xtype, Iblock, Jblock, Xblock, Zblock, n,
+                                  Common)
+    @ccall libcholmod.cholmod_realloc_multiple(nnew::Csize_t, nint::Cint, xtype::Cint,
+                                               Iblock::Ptr{Ptr{Cvoid}},
+                                               Jblock::Ptr{Ptr{Cvoid}},
+                                               Xblock::Ptr{Ptr{Cvoid}},
+                                               Zblock::Ptr{Ptr{Cvoid}}, n::Ptr{Csize_t},
+                                               Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_realloc_multiple(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
-    @ccall libcholmod.cholmod_l_realloc_multiple(arg1::Csize_t, arg2::Cint, arg3::Cint, arg4::Ptr{Ptr{Cvoid}}, arg5::Ptr{Ptr{Cvoid}}, arg6::Ptr{Ptr{Cvoid}}, arg7::Ptr{Ptr{Cvoid}}, arg8::Ptr{Csize_t}, arg9::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_realloc_multiple(arg1::Csize_t, arg2::Cint, arg3::Cint,
+                                                 arg4::Ptr{Ptr{Cvoid}},
+                                                 arg5::Ptr{Ptr{Cvoid}},
+                                                 arg6::Ptr{Ptr{Cvoid}},
+                                                 arg7::Ptr{Ptr{Cvoid}}, arg8::Ptr{Csize_t},
+                                                 arg9::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_version(version)
@@ -876,11 +1049,13 @@ function cholmod_l_check_common(arg1)
 end
 
 function cholmod_print_common(name, Common)
-    @ccall libcholmod.cholmod_print_common(name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_common(name::Ptr{Cchar},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_common(arg1, arg2)
-    @ccall libcholmod.cholmod_l_print_common(arg1::Ptr{Cchar}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_common(arg1::Ptr{Cchar},
+                                             arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_gpu_stats(arg1)
@@ -892,643 +1067,1047 @@ function cholmod_l_gpu_stats(arg1)
 end
 
 function cholmod_check_sparse(A, Common)
-    @ccall libcholmod.cholmod_check_sparse(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_sparse(A::Ptr{cholmod_sparse},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_sparse(arg1, arg2)
-    @ccall libcholmod.cholmod_l_check_sparse(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_sparse(arg1::Ptr{cholmod_sparse},
+                                             arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_sparse(A, name, Common)
-    @ccall libcholmod.cholmod_print_sparse(A::Ptr{cholmod_sparse}, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_sparse(A::Ptr{cholmod_sparse}, name::Ptr{Cchar},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_sparse(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_print_sparse(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Cchar}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_sparse(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Cchar},
+                                             arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_check_dense(X, Common)
-    @ccall libcholmod.cholmod_check_dense(X::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_dense(X::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_dense(arg1, arg2)
-    @ccall libcholmod.cholmod_l_check_dense(arg1::Ptr{cholmod_dense}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_dense(arg1::Ptr{cholmod_dense},
+                                            arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_dense(X, name, Common)
-    @ccall libcholmod.cholmod_print_dense(X::Ptr{cholmod_dense}, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_dense(X::Ptr{cholmod_dense}, name::Ptr{Cchar},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_dense(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_print_dense(arg1::Ptr{cholmod_dense}, arg2::Ptr{Cchar}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_dense(arg1::Ptr{cholmod_dense}, arg2::Ptr{Cchar},
+                                            arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_check_factor(L, Common)
-    @ccall libcholmod.cholmod_check_factor(L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_factor(L::Ptr{cholmod_factor},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_factor(arg1, arg2)
-    @ccall libcholmod.cholmod_l_check_factor(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_factor(arg1::Ptr{cholmod_factor},
+                                             arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_factor(L, name, Common)
-    @ccall libcholmod.cholmod_print_factor(L::Ptr{cholmod_factor}, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_factor(L::Ptr{cholmod_factor}, name::Ptr{Cchar},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_factor(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_print_factor(arg1::Ptr{cholmod_factor}, arg2::Ptr{Cchar}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_factor(arg1::Ptr{cholmod_factor}, arg2::Ptr{Cchar},
+                                             arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_check_triplet(T, Common)
-    @ccall libcholmod.cholmod_check_triplet(T::Ptr{cholmod_triplet}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_triplet(T::Ptr{cholmod_triplet},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_triplet(arg1, arg2)
-    @ccall libcholmod.cholmod_l_check_triplet(arg1::Ptr{cholmod_triplet}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_triplet(arg1::Ptr{cholmod_triplet},
+                                              arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_triplet(T, name, Common)
-    @ccall libcholmod.cholmod_print_triplet(T::Ptr{cholmod_triplet}, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_triplet(T::Ptr{cholmod_triplet}, name::Ptr{Cchar},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_triplet(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_print_triplet(arg1::Ptr{cholmod_triplet}, arg2::Ptr{Cchar}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_triplet(arg1::Ptr{cholmod_triplet}, arg2::Ptr{Cchar},
+                                              arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_check_subset(Set, len, n, Common)
-    @ccall libcholmod.cholmod_check_subset(Set::Ptr{Int32}, len::Int64, n::Csize_t, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_subset(Set::Ptr{Int32}, len::Int64, n::Csize_t,
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_subset(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_check_subset(arg1::Ptr{Int64}, arg2::Int64, arg3::Csize_t, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_subset(arg1::Ptr{Int64}, arg2::Int64, arg3::Csize_t,
+                                             arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_subset(Set, len, n, name, Common)
-    @ccall libcholmod.cholmod_print_subset(Set::Ptr{Int32}, len::Int64, n::Csize_t, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_subset(Set::Ptr{Int32}, len::Int64, n::Csize_t,
+                                           name::Ptr{Cchar},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_subset(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_print_subset(arg1::Ptr{Int64}, arg2::Int64, arg3::Csize_t, arg4::Ptr{Cchar}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_subset(arg1::Ptr{Int64}, arg2::Int64, arg3::Csize_t,
+                                             arg4::Ptr{Cchar},
+                                             arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_check_perm(Perm, len, n, Common)
-    @ccall libcholmod.cholmod_check_perm(Perm::Ptr{Int32}, len::Csize_t, n::Csize_t, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_perm(Perm::Ptr{Int32}, len::Csize_t, n::Csize_t,
+                                         Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_perm(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_check_perm(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Csize_t, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_perm(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Csize_t,
+                                           arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_perm(Perm, len, n, name, Common)
-    @ccall libcholmod.cholmod_print_perm(Perm::Ptr{Int32}, len::Csize_t, n::Csize_t, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_perm(Perm::Ptr{Int32}, len::Csize_t, n::Csize_t,
+                                         name::Ptr{Cchar},
+                                         Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_perm(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_print_perm(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Csize_t, arg4::Ptr{Cchar}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_perm(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Csize_t,
+                                           arg4::Ptr{Cchar},
+                                           arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_check_parent(Parent, n, Common)
-    @ccall libcholmod.cholmod_check_parent(Parent::Ptr{Int32}, n::Csize_t, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_parent(Parent::Ptr{Int32}, n::Csize_t,
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_parent(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_check_parent(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_parent(arg1::Ptr{Int64}, arg2::Csize_t,
+                                             arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_parent(Parent, n, name, Common)
-    @ccall libcholmod.cholmod_print_parent(Parent::Ptr{Int32}, n::Csize_t, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_parent(Parent::Ptr{Int32}, n::Csize_t, name::Ptr{Cchar},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_parent(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_print_parent(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Ptr{Cchar}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_parent(arg1::Ptr{Int64}, arg2::Csize_t,
+                                             arg3::Ptr{Cchar},
+                                             arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_read_sparse(f, Common)
-    @ccall libcholmod.cholmod_read_sparse(f::Ptr{Libc.FILE}, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_read_sparse(f::Ptr{Libc.FILE},
+                                          Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_read_sparse(arg1, arg2)
-    @ccall libcholmod.cholmod_l_read_sparse(arg1::Ptr{Libc.FILE}, arg2::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_read_sparse(arg1::Ptr{Libc.FILE},
+                                            arg2::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_read_triplet(f, Common)
-    @ccall libcholmod.cholmod_read_triplet(f::Ptr{Libc.FILE}, Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_read_triplet(f::Ptr{Libc.FILE},
+                                           Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_l_read_triplet(arg1, arg2)
-    @ccall libcholmod.cholmod_l_read_triplet(arg1::Ptr{Libc.FILE}, arg2::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_l_read_triplet(arg1::Ptr{Libc.FILE},
+                                             arg2::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_read_dense(f, Common)
-    @ccall libcholmod.cholmod_read_dense(f::Ptr{Libc.FILE}, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_read_dense(f::Ptr{Libc.FILE},
+                                         Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_read_dense(arg1, arg2)
-    @ccall libcholmod.cholmod_l_read_dense(arg1::Ptr{Libc.FILE}, arg2::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_read_dense(arg1::Ptr{Libc.FILE},
+                                           arg2::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_read_matrix(f, prefer, mtype, Common)
-    @ccall libcholmod.cholmod_read_matrix(f::Ptr{Libc.FILE}, prefer::Cint, mtype::Ptr{Cint}, Common::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_read_matrix(f::Ptr{Libc.FILE}, prefer::Cint, mtype::Ptr{Cint},
+                                          Common::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_l_read_matrix(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_read_matrix(arg1::Ptr{Libc.FILE}, arg2::Cint, arg3::Ptr{Cint}, arg4::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_l_read_matrix(arg1::Ptr{Libc.FILE}, arg2::Cint,
+                                            arg3::Ptr{Cint},
+                                            arg4::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_write_sparse(f, A, Z, comments, Common)
-    @ccall libcholmod.cholmod_write_sparse(f::Ptr{Libc.FILE}, A::Ptr{cholmod_sparse}, Z::Ptr{cholmod_sparse}, comments::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_write_sparse(f::Ptr{Libc.FILE}, A::Ptr{cholmod_sparse},
+                                           Z::Ptr{cholmod_sparse}, comments::Ptr{Cchar},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_write_sparse(arg1, arg2, arg3, c, arg5)
-    @ccall libcholmod.cholmod_l_write_sparse(arg1::Ptr{Libc.FILE}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_sparse}, c::Ptr{Cchar}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_write_sparse(arg1::Ptr{Libc.FILE},
+                                             arg2::Ptr{cholmod_sparse},
+                                             arg3::Ptr{cholmod_sparse}, c::Ptr{Cchar},
+                                             arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_write_dense(f, X, comments, Common)
-    @ccall libcholmod.cholmod_write_dense(f::Ptr{Libc.FILE}, X::Ptr{cholmod_dense}, comments::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_write_dense(f::Ptr{Libc.FILE}, X::Ptr{cholmod_dense},
+                                          comments::Ptr{Cchar},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_write_dense(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_write_dense(arg1::Ptr{Libc.FILE}, arg2::Ptr{cholmod_dense}, arg3::Ptr{Cchar}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_write_dense(arg1::Ptr{Libc.FILE}, arg2::Ptr{cholmod_dense},
+                                            arg3::Ptr{Cchar},
+                                            arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_analyze(A, Common)
-    @ccall libcholmod.cholmod_analyze(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_analyze(A::Ptr{cholmod_sparse},
+                                      Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_l_analyze(arg1, arg2)
-    @ccall libcholmod.cholmod_l_analyze(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_l_analyze(arg1::Ptr{cholmod_sparse},
+                                        arg2::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_analyze_p(A, UserPerm, fset, fsize, Common)
-    @ccall libcholmod.cholmod_analyze_p(A::Ptr{cholmod_sparse}, UserPerm::Ptr{Int32}, fset::Ptr{Int32}, fsize::Csize_t, Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_analyze_p(A::Ptr{cholmod_sparse}, UserPerm::Ptr{Int32},
+                                        fset::Ptr{Int32}, fsize::Csize_t,
+                                        Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_l_analyze_p(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_analyze_p(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Ptr{Int64}, arg4::Csize_t, arg5::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_l_analyze_p(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                          arg3::Ptr{Int64}, arg4::Csize_t,
+                                          arg5::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_analyze_p2(for_whom, A, UserPerm, fset, fsize, Common)
-    @ccall libcholmod.cholmod_analyze_p2(for_whom::Cint, A::Ptr{cholmod_sparse}, UserPerm::Ptr{Int32}, fset::Ptr{Int32}, fsize::Csize_t, Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_analyze_p2(for_whom::Cint, A::Ptr{cholmod_sparse},
+                                         UserPerm::Ptr{Int32}, fset::Ptr{Int32},
+                                         fsize::Csize_t,
+                                         Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_l_analyze_p2(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_analyze_p2(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Csize_t, arg6::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_l_analyze_p2(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                           arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                           arg5::Csize_t,
+                                           arg6::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_factorize(A, L, Common)
-    @ccall libcholmod.cholmod_factorize(A::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_factorize(A::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor},
+                                        Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_factorize(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_factorize(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_factorize(arg1::Ptr{cholmod_sparse},
+                                          arg2::Ptr{cholmod_factor},
+                                          arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_factorize_p(A, beta, fset, fsize, L, Common)
-    @ccall libcholmod.cholmod_factorize_p(A::Ptr{cholmod_sparse}, beta::Ptr{Cdouble}, fset::Ptr{Int32}, fsize::Csize_t, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_factorize_p(A::Ptr{cholmod_sparse}, beta::Ptr{Cdouble},
+                                          fset::Ptr{Int32}, fsize::Csize_t,
+                                          L::Ptr{cholmod_factor},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_factorize_p(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_factorize_p(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Cdouble}, arg3::Ptr{Int64}, arg4::Csize_t, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_factorize_p(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Cdouble},
+                                            arg3::Ptr{Int64}, arg4::Csize_t,
+                                            arg5::Ptr{cholmod_factor},
+                                            arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_solve(sys, L, B, Common)
-    @ccall libcholmod.cholmod_solve(sys::Cint, L::Ptr{cholmod_factor}, B::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_solve(sys::Cint, L::Ptr{cholmod_factor},
+                                    B::Ptr{cholmod_dense},
+                                    Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_solve(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_solve(arg1::Cint, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_dense}, arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_solve(arg1::Cint, arg2::Ptr{cholmod_factor},
+                                      arg3::Ptr{cholmod_dense},
+                                      arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_solve2(sys, L, B, Bset, X_Handle, Xset_Handle, Y_Handle, E_Handle, Common)
-    @ccall libcholmod.cholmod_solve2(sys::Cint, L::Ptr{cholmod_factor}, B::Ptr{cholmod_dense}, Bset::Ptr{cholmod_sparse}, X_Handle::Ptr{Ptr{cholmod_dense}}, Xset_Handle::Ptr{Ptr{cholmod_sparse}}, Y_Handle::Ptr{Ptr{cholmod_dense}}, E_Handle::Ptr{Ptr{cholmod_dense}}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_solve2(sys::Cint, L::Ptr{cholmod_factor},
+                                     B::Ptr{cholmod_dense}, Bset::Ptr{cholmod_sparse},
+                                     X_Handle::Ptr{Ptr{cholmod_dense}},
+                                     Xset_Handle::Ptr{Ptr{cholmod_sparse}},
+                                     Y_Handle::Ptr{Ptr{cholmod_dense}},
+                                     E_Handle::Ptr{Ptr{cholmod_dense}},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_solve2(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
-    @ccall libcholmod.cholmod_l_solve2(arg1::Cint, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_dense}, arg4::Ptr{cholmod_sparse}, arg5::Ptr{Ptr{cholmod_dense}}, arg6::Ptr{Ptr{cholmod_sparse}}, arg7::Ptr{Ptr{cholmod_dense}}, arg8::Ptr{Ptr{cholmod_dense}}, arg9::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_solve2(arg1::Cint, arg2::Ptr{cholmod_factor},
+                                       arg3::Ptr{cholmod_dense}, arg4::Ptr{cholmod_sparse},
+                                       arg5::Ptr{Ptr{cholmod_dense}},
+                                       arg6::Ptr{Ptr{cholmod_sparse}},
+                                       arg7::Ptr{Ptr{cholmod_dense}},
+                                       arg8::Ptr{Ptr{cholmod_dense}},
+                                       arg9::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_spsolve(sys, L, B, Common)
-    @ccall libcholmod.cholmod_spsolve(sys::Cint, L::Ptr{cholmod_factor}, B::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_spsolve(sys::Cint, L::Ptr{cholmod_factor},
+                                      B::Ptr{cholmod_sparse},
+                                      Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_spsolve(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_spsolve(arg1::Cint, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_sparse}, arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_spsolve(arg1::Cint, arg2::Ptr{cholmod_factor},
+                                        arg3::Ptr{cholmod_sparse},
+                                        arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_etree(A, Parent, Common)
-    @ccall libcholmod.cholmod_etree(A::Ptr{cholmod_sparse}, Parent::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_etree(A::Ptr{cholmod_sparse}, Parent::Ptr{Int32},
+                                    Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_etree(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_etree(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_etree(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                      arg3::Ptr{cholmod_common})::Cint
 end
 
-function cholmod_rowcolcounts(A, fset, fsize, Parent, Post, RowCount, ColCount, First, Level, Common)
-    @ccall libcholmod.cholmod_rowcolcounts(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, Parent::Ptr{Int32}, Post::Ptr{Int32}, RowCount::Ptr{Int32}, ColCount::Ptr{Int32}, First::Ptr{Int32}, Level::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+function cholmod_rowcolcounts(A, fset, fsize, Parent, Post, RowCount, ColCount, First,
+                              Level, Common)
+    @ccall libcholmod.cholmod_rowcolcounts(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                           fsize::Csize_t, Parent::Ptr{Int32},
+                                           Post::Ptr{Int32}, RowCount::Ptr{Int32},
+                                           ColCount::Ptr{Int32}, First::Ptr{Int32},
+                                           Level::Ptr{Int32},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowcolcounts(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)
-    @ccall libcholmod.cholmod_l_rowcolcounts(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{Int64}, arg6::Ptr{Int64}, arg7::Ptr{Int64}, arg8::Ptr{Int64}, arg9::Ptr{Int64}, arg10::Ptr{cholmod_common})::Cint
-end
-
-function cholmod_analyze_ordering(A, ordering, Perm, fset, fsize, Parent, Post, ColCount, First, Level, Common)
-    @ccall libcholmod.cholmod_analyze_ordering(A::Ptr{cholmod_sparse}, ordering::Cint, Perm::Ptr{Int32}, fset::Ptr{Int32}, fsize::Csize_t, Parent::Ptr{Int32}, Post::Ptr{Int32}, ColCount::Ptr{Int32}, First::Ptr{Int32}, Level::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
-end
-
-function cholmod_l_analyze_ordering(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11)
-    @ccall libcholmod.cholmod_l_analyze_ordering(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Csize_t, arg6::Ptr{Int64}, arg7::Ptr{Int64}, arg8::Ptr{Int64}, arg9::Ptr{Int64}, arg10::Ptr{Int64}, arg11::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowcolcounts(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                             arg3::Csize_t, arg4::Ptr{Int64},
+                                             arg5::Ptr{Int64}, arg6::Ptr{Int64},
+                                             arg7::Ptr{Int64}, arg8::Ptr{Int64},
+                                             arg9::Ptr{Int64},
+                                             arg10::Ptr{cholmod_common})::Cint
+end
+
+function cholmod_analyze_ordering(A, ordering, Perm, fset, fsize, Parent, Post, ColCount,
+                                  First, Level, Common)
+    @ccall libcholmod.cholmod_analyze_ordering(A::Ptr{cholmod_sparse}, ordering::Cint,
+                                               Perm::Ptr{Int32}, fset::Ptr{Int32},
+                                               fsize::Csize_t, Parent::Ptr{Int32},
+                                               Post::Ptr{Int32}, ColCount::Ptr{Int32},
+                                               First::Ptr{Int32}, Level::Ptr{Int32},
+                                               Common::Ptr{cholmod_common})::Cint
+end
+
+function cholmod_l_analyze_ordering(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9,
+                                    arg10, arg11)
+    @ccall libcholmod.cholmod_l_analyze_ordering(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                                 arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                                 arg5::Csize_t, arg6::Ptr{Int64},
+                                                 arg7::Ptr{Int64}, arg8::Ptr{Int64},
+                                                 arg9::Ptr{Int64}, arg10::Ptr{Int64},
+                                                 arg11::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_amd(A, fset, fsize, Perm, Common)
-    @ccall libcholmod.cholmod_amd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_amd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t,
+                                  Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_amd(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_amd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_amd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                    arg3::Csize_t, arg4::Ptr{Int64},
+                                    arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_colamd(A, fset, fsize, postorder, Perm, Common)
-    @ccall libcholmod.cholmod_colamd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, postorder::Cint, Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_colamd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                     fsize::Csize_t, postorder::Cint, Perm::Ptr{Int32},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_colamd(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_colamd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Cint, arg5::Ptr{Int64}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_colamd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                       arg3::Csize_t, arg4::Cint, arg5::Ptr{Int64},
+                                       arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowfac(A, F, beta, kstart, kend, L, Common)
-    @ccall libcholmod.cholmod_rowfac(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, beta::Ptr{Cdouble}, kstart::Csize_t, kend::Csize_t, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowfac(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse},
+                                     beta::Ptr{Cdouble}, kstart::Csize_t, kend::Csize_t,
+                                     L::Ptr{cholmod_factor},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowfac(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_rowfac(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Csize_t, arg5::Csize_t, arg6::Ptr{cholmod_factor}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowfac(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse},
+                                       arg3::Ptr{Cdouble}, arg4::Csize_t, arg5::Csize_t,
+                                       arg6::Ptr{cholmod_factor},
+                                       arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowfac_mask(A, F, beta, kstart, kend, mask, RLinkUp, L, Common)
-    @ccall libcholmod.cholmod_rowfac_mask(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, beta::Ptr{Cdouble}, kstart::Csize_t, kend::Csize_t, mask::Ptr{Int32}, RLinkUp::Ptr{Int32}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowfac_mask(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse},
+                                          beta::Ptr{Cdouble}, kstart::Csize_t,
+                                          kend::Csize_t, mask::Ptr{Int32},
+                                          RLinkUp::Ptr{Int32}, L::Ptr{cholmod_factor},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowfac_mask(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
-    @ccall libcholmod.cholmod_l_rowfac_mask(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Csize_t, arg5::Csize_t, arg6::Ptr{Int64}, arg7::Ptr{Int64}, arg8::Ptr{cholmod_factor}, arg9::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowfac_mask(arg1::Ptr{cholmod_sparse},
+                                            arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble},
+                                            arg4::Csize_t, arg5::Csize_t, arg6::Ptr{Int64},
+                                            arg7::Ptr{Int64}, arg8::Ptr{cholmod_factor},
+                                            arg9::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowfac_mask2(A, F, beta, kstart, kend, mask, maskmark, RLinkUp, L, Common)
-    @ccall libcholmod.cholmod_rowfac_mask2(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, beta::Ptr{Cdouble}, kstart::Csize_t, kend::Csize_t, mask::Ptr{Int32}, maskmark::Int32, RLinkUp::Ptr{Int32}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowfac_mask2(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse},
+                                           beta::Ptr{Cdouble}, kstart::Csize_t,
+                                           kend::Csize_t, mask::Ptr{Int32}, maskmark::Int32,
+                                           RLinkUp::Ptr{Int32}, L::Ptr{cholmod_factor},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowfac_mask2(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)
-    @ccall libcholmod.cholmod_l_rowfac_mask2(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Csize_t, arg5::Csize_t, arg6::Ptr{Int64}, arg7::Int64, arg8::Ptr{Int64}, arg9::Ptr{cholmod_factor}, arg10::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowfac_mask2(arg1::Ptr{cholmod_sparse},
+                                             arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble},
+                                             arg4::Csize_t, arg5::Csize_t, arg6::Ptr{Int64},
+                                             arg7::Int64, arg8::Ptr{Int64},
+                                             arg9::Ptr{cholmod_factor},
+                                             arg10::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_row_subtree(A, F, k, Parent, R, Common)
-    @ccall libcholmod.cholmod_row_subtree(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, k::Csize_t, Parent::Ptr{Int32}, R::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_row_subtree(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse},
+                                          k::Csize_t, Parent::Ptr{Int32},
+                                          R::Ptr{cholmod_sparse},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_row_subtree(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_row_subtree(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{cholmod_sparse}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_row_subtree(arg1::Ptr{cholmod_sparse},
+                                            arg2::Ptr{cholmod_sparse}, arg3::Csize_t,
+                                            arg4::Ptr{Int64}, arg5::Ptr{cholmod_sparse},
+                                            arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_lsolve_pattern(B, L, X, Common)
-    @ccall libcholmod.cholmod_lsolve_pattern(B::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_lsolve_pattern(B::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor},
+                                             X::Ptr{cholmod_sparse},
+                                             Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_lsolve_pattern(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_lsolve_pattern(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_sparse}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_lsolve_pattern(arg1::Ptr{cholmod_sparse},
+                                               arg2::Ptr{cholmod_factor},
+                                               arg3::Ptr{cholmod_sparse},
+                                               arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_row_lsubtree(A, Fi, fnz, k, L, R, Common)
-    @ccall libcholmod.cholmod_row_lsubtree(A::Ptr{cholmod_sparse}, Fi::Ptr{Int32}, fnz::Csize_t, k::Csize_t, L::Ptr{cholmod_factor}, R::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_row_lsubtree(A::Ptr{cholmod_sparse}, Fi::Ptr{Int32},
+                                           fnz::Csize_t, k::Csize_t, L::Ptr{cholmod_factor},
+                                           R::Ptr{cholmod_sparse},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_row_lsubtree(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_row_lsubtree(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Csize_t, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_sparse}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_row_lsubtree(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                             arg3::Csize_t, arg4::Csize_t,
+                                             arg5::Ptr{cholmod_factor},
+                                             arg6::Ptr{cholmod_sparse},
+                                             arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_resymbol(A, fset, fsize, pack, L, Common)
-    @ccall libcholmod.cholmod_resymbol(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, pack::Cint, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_resymbol(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                       fsize::Csize_t, pack::Cint, L::Ptr{cholmod_factor},
+                                       Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_resymbol(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_resymbol(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Cint, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_resymbol(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                         arg3::Csize_t, arg4::Cint,
+                                         arg5::Ptr{cholmod_factor},
+                                         arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_resymbol_noperm(A, fset, fsize, pack, L, Common)
-    @ccall libcholmod.cholmod_resymbol_noperm(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, pack::Cint, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_resymbol_noperm(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                              fsize::Csize_t, pack::Cint,
+                                              L::Ptr{cholmod_factor},
+                                              Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_resymbol_noperm(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_resymbol_noperm(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Cint, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_resymbol_noperm(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                                arg3::Csize_t, arg4::Cint,
+                                                arg5::Ptr{cholmod_factor},
+                                                arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rcond(L, Common)
-    @ccall libcholmod.cholmod_rcond(L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cdouble
+    @ccall libcholmod.cholmod_rcond(L::Ptr{cholmod_factor},
+                                    Common::Ptr{cholmod_common})::Cdouble
 end
 
 function cholmod_l_rcond(arg1, arg2)
-    @ccall libcholmod.cholmod_l_rcond(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_common})::Cdouble
+    @ccall libcholmod.cholmod_l_rcond(arg1::Ptr{cholmod_factor},
+                                      arg2::Ptr{cholmod_common})::Cdouble
 end
 
 function cholmod_postorder(Parent, n, Weight_p, Post, Common)
-    @ccall libcholmod.cholmod_postorder(Parent::Ptr{Int32}, n::Csize_t, Weight_p::Ptr{Int32}, Post::Ptr{Int32}, Common::Ptr{cholmod_common})::Int32
+    @ccall libcholmod.cholmod_postorder(Parent::Ptr{Int32}, n::Csize_t,
+                                        Weight_p::Ptr{Int32}, Post::Ptr{Int32},
+                                        Common::Ptr{cholmod_common})::Int32
 end
 
 function cholmod_l_postorder(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_postorder(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_l_postorder(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Ptr{Int64},
+                                          arg4::Ptr{Int64},
+                                          arg5::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_drop(tol, A, Common)
-    @ccall libcholmod.cholmod_drop(tol::Cdouble, A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_drop(tol::Cdouble, A::Ptr{cholmod_sparse},
+                                   Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_drop(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_drop(arg1::Cdouble, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_drop(arg1::Cdouble, arg2::Ptr{cholmod_sparse},
+                                     arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_norm_dense(X, norm, Common)
-    @ccall libcholmod.cholmod_norm_dense(X::Ptr{cholmod_dense}, norm::Cint, Common::Ptr{cholmod_common})::Cdouble
+    @ccall libcholmod.cholmod_norm_dense(X::Ptr{cholmod_dense}, norm::Cint,
+                                         Common::Ptr{cholmod_common})::Cdouble
 end
 
 function cholmod_l_norm_dense(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_norm_dense(arg1::Ptr{cholmod_dense}, arg2::Cint, arg3::Ptr{cholmod_common})::Cdouble
+    @ccall libcholmod.cholmod_l_norm_dense(arg1::Ptr{cholmod_dense}, arg2::Cint,
+                                           arg3::Ptr{cholmod_common})::Cdouble
 end
 
 function cholmod_norm_sparse(A, norm, Common)
-    @ccall libcholmod.cholmod_norm_sparse(A::Ptr{cholmod_sparse}, norm::Cint, Common::Ptr{cholmod_common})::Cdouble
+    @ccall libcholmod.cholmod_norm_sparse(A::Ptr{cholmod_sparse}, norm::Cint,
+                                          Common::Ptr{cholmod_common})::Cdouble
 end
 
 function cholmod_l_norm_sparse(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_norm_sparse(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{cholmod_common})::Cdouble
+    @ccall libcholmod.cholmod_l_norm_sparse(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                            arg3::Ptr{cholmod_common})::Cdouble
 end
 
 function cholmod_horzcat(A, B, values, Common)
-    @ccall libcholmod.cholmod_horzcat(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse}, values::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_horzcat(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse},
+                                      values::Cint,
+                                      Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_horzcat(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_horzcat(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_horzcat(arg1::Ptr{cholmod_sparse},
+                                        arg2::Ptr{cholmod_sparse}, arg3::Cint,
+                                        arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_scale(S, scale, A, Common)
-    @ccall libcholmod.cholmod_scale(S::Ptr{cholmod_dense}, scale::Cint, A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_scale(S::Ptr{cholmod_dense}, scale::Cint,
+                                    A::Ptr{cholmod_sparse},
+                                    Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_scale(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_scale(arg1::Ptr{cholmod_dense}, arg2::Cint, arg3::Ptr{cholmod_sparse}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_scale(arg1::Ptr{cholmod_dense}, arg2::Cint,
+                                      arg3::Ptr{cholmod_sparse},
+                                      arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_sdmult(A, transpose, alpha, beta, X, Y, Common)
-    @ccall libcholmod.cholmod_sdmult(A::Ptr{cholmod_sparse}, transpose::Cint, alpha::Ptr{Cdouble}, beta::Ptr{Cdouble}, X::Ptr{cholmod_dense}, Y::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_sdmult(A::Ptr{cholmod_sparse}, transpose::Cint,
+                                     alpha::Ptr{Cdouble}, beta::Ptr{Cdouble},
+                                     X::Ptr{cholmod_dense}, Y::Ptr{cholmod_dense},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_sdmult(arg1, arg2, arg3, arg4, arg5, Y, arg7)
-    @ccall libcholmod.cholmod_l_sdmult(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{Cdouble}, arg4::Ptr{Cdouble}, arg5::Ptr{cholmod_dense}, Y::Ptr{cholmod_dense}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_sdmult(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                       arg3::Ptr{Cdouble}, arg4::Ptr{Cdouble},
+                                       arg5::Ptr{cholmod_dense}, Y::Ptr{cholmod_dense},
+                                       arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_ssmult(A, B, stype, values, sorted, Common)
-    @ccall libcholmod.cholmod_ssmult(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse}, stype::Cint, values::Cint, sorted::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_ssmult(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse},
+                                     stype::Cint, values::Cint, sorted::Cint,
+                                     Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_ssmult(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_ssmult(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Cint, arg4::Cint, arg5::Cint, arg6::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_ssmult(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse},
+                                       arg3::Cint, arg4::Cint, arg5::Cint,
+                                       arg6::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_submatrix(A, rset, rsize, cset, csize, values, sorted, Common)
-    @ccall libcholmod.cholmod_submatrix(A::Ptr{cholmod_sparse}, rset::Ptr{Int32}, rsize::Int64, cset::Ptr{Int32}, csize::Int64, values::Cint, sorted::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_submatrix(A::Ptr{cholmod_sparse}, rset::Ptr{Int32},
+                                        rsize::Int64, cset::Ptr{Int32}, csize::Int64,
+                                        values::Cint, sorted::Cint,
+                                        Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_submatrix(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
-    @ccall libcholmod.cholmod_l_submatrix(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Int64, arg4::Ptr{Int64}, arg5::Int64, arg6::Cint, arg7::Cint, arg8::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_submatrix(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                          arg3::Int64, arg4::Ptr{Int64}, arg5::Int64,
+                                          arg6::Cint, arg7::Cint,
+                                          arg8::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_vertcat(A, B, values, Common)
-    @ccall libcholmod.cholmod_vertcat(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse}, values::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_vertcat(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse},
+                                      values::Cint,
+                                      Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_vertcat(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_vertcat(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_vertcat(arg1::Ptr{cholmod_sparse},
+                                        arg2::Ptr{cholmod_sparse}, arg3::Cint,
+                                        arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_symmetry(A, option, xmatched, pmatched, nzoffdiag, nzdiag, Common)
-    @ccall libcholmod.cholmod_symmetry(A::Ptr{cholmod_sparse}, option::Cint, xmatched::Ptr{Int32}, pmatched::Ptr{Int32}, nzoffdiag::Ptr{Int32}, nzdiag::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_symmetry(A::Ptr{cholmod_sparse}, option::Cint,
+                                       xmatched::Ptr{Int32}, pmatched::Ptr{Int32},
+                                       nzoffdiag::Ptr{Int32}, nzdiag::Ptr{Int32},
+                                       Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_symmetry(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_symmetry(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Ptr{Int64}, arg6::Ptr{Int64}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_symmetry(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                         arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                         arg5::Ptr{Int64}, arg6::Ptr{Int64},
+                                         arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_updown(update, C, L, Common)
-    @ccall libcholmod.cholmod_updown(update::Cint, C::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_updown(update::Cint, C::Ptr{cholmod_sparse},
+                                     L::Ptr{cholmod_factor},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_updown(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_updown(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_factor}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_updown(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                       arg3::Ptr{cholmod_factor},
+                                       arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_updown_solve(update, C, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_updown_solve(update::Cint, C::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_updown_solve(update::Cint, C::Ptr{cholmod_sparse},
+                                           L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense},
+                                           DeltaB::Ptr{cholmod_dense},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_updown_solve(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_updown_solve(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_factor}, arg4::Ptr{cholmod_dense}, arg5::Ptr{cholmod_dense}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_updown_solve(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                             arg3::Ptr{cholmod_factor},
+                                             arg4::Ptr{cholmod_dense},
+                                             arg5::Ptr{cholmod_dense},
+                                             arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_updown_mark(update, C, colmark, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_updown_mark(update::Cint, C::Ptr{cholmod_sparse}, colmark::Ptr{Int32}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_updown_mark(update::Cint, C::Ptr{cholmod_sparse},
+                                          colmark::Ptr{Int32}, L::Ptr{cholmod_factor},
+                                          X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_updown_mark(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_updown_mark(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Int64}, arg4::Ptr{cholmod_factor}, arg5::Ptr{cholmod_dense}, arg6::Ptr{cholmod_dense}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_updown_mark(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                            arg3::Ptr{Int64}, arg4::Ptr{cholmod_factor},
+                                            arg5::Ptr{cholmod_dense},
+                                            arg6::Ptr{cholmod_dense},
+                                            arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_updown_mask(update, C, colmark, mask, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_updown_mask(update::Cint, C::Ptr{cholmod_sparse}, colmark::Ptr{Int32}, mask::Ptr{Int32}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_updown_mask(update::Cint, C::Ptr{cholmod_sparse},
+                                          colmark::Ptr{Int32}, mask::Ptr{Int32},
+                                          L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense},
+                                          DeltaB::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_updown_mask(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
-    @ccall libcholmod.cholmod_l_updown_mask(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_dense}, arg7::Ptr{cholmod_dense}, arg8::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_updown_mask(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                            arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                            arg5::Ptr{cholmod_factor},
+                                            arg6::Ptr{cholmod_dense},
+                                            arg7::Ptr{cholmod_dense},
+                                            arg8::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_updown_mask2(update, C, colmark, mask, maskmark, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_updown_mask2(update::Cint, C::Ptr{cholmod_sparse}, colmark::Ptr{Int32}, mask::Ptr{Int32}, maskmark::Int32, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_updown_mask2(update::Cint, C::Ptr{cholmod_sparse},
+                                           colmark::Ptr{Int32}, mask::Ptr{Int32},
+                                           maskmark::Int32, L::Ptr{cholmod_factor},
+                                           X::Ptr{cholmod_dense},
+                                           DeltaB::Ptr{cholmod_dense},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_updown_mask2(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
-    @ccall libcholmod.cholmod_l_updown_mask2(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Int64, arg6::Ptr{cholmod_factor}, arg7::Ptr{cholmod_dense}, arg8::Ptr{cholmod_dense}, arg9::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_updown_mask2(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                             arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                             arg5::Int64, arg6::Ptr{cholmod_factor},
+                                             arg7::Ptr{cholmod_dense},
+                                             arg8::Ptr{cholmod_dense},
+                                             arg9::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowadd(k, R, L, Common)
-    @ccall libcholmod.cholmod_rowadd(k::Csize_t, R::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowadd(k::Csize_t, R::Ptr{cholmod_sparse},
+                                     L::Ptr{cholmod_factor},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowadd(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_rowadd(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_factor}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowadd(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                       arg3::Ptr{cholmod_factor},
+                                       arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowadd_solve(k, R, bk, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_rowadd_solve(k::Csize_t, R::Ptr{cholmod_sparse}, bk::Ptr{Cdouble}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowadd_solve(k::Csize_t, R::Ptr{cholmod_sparse},
+                                           bk::Ptr{Cdouble}, L::Ptr{cholmod_factor},
+                                           X::Ptr{cholmod_dense},
+                                           DeltaB::Ptr{cholmod_dense},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowadd_solve(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_rowadd_solve(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Ptr{cholmod_factor}, arg5::Ptr{cholmod_dense}, arg6::Ptr{cholmod_dense}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowadd_solve(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                             arg3::Ptr{Cdouble}, arg4::Ptr{cholmod_factor},
+                                             arg5::Ptr{cholmod_dense},
+                                             arg6::Ptr{cholmod_dense},
+                                             arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowadd_mark(k, R, bk, colmark, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_rowadd_mark(k::Csize_t, R::Ptr{cholmod_sparse}, bk::Ptr{Cdouble}, colmark::Ptr{Int32}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowadd_mark(k::Csize_t, R::Ptr{cholmod_sparse},
+                                          bk::Ptr{Cdouble}, colmark::Ptr{Int32},
+                                          L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense},
+                                          DeltaB::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowadd_mark(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
-    @ccall libcholmod.cholmod_l_rowadd_mark(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Ptr{Int64}, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_dense}, arg7::Ptr{cholmod_dense}, arg8::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowadd_mark(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                            arg3::Ptr{Cdouble}, arg4::Ptr{Int64},
+                                            arg5::Ptr{cholmod_factor},
+                                            arg6::Ptr{cholmod_dense},
+                                            arg7::Ptr{cholmod_dense},
+                                            arg8::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowdel(k, R, L, Common)
-    @ccall libcholmod.cholmod_rowdel(k::Csize_t, R::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowdel(k::Csize_t, R::Ptr{cholmod_sparse},
+                                     L::Ptr{cholmod_factor},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowdel(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_rowdel(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_factor}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowdel(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                       arg3::Ptr{cholmod_factor},
+                                       arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowdel_solve(k, R, yk, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_rowdel_solve(k::Csize_t, R::Ptr{cholmod_sparse}, yk::Ptr{Cdouble}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowdel_solve(k::Csize_t, R::Ptr{cholmod_sparse},
+                                           yk::Ptr{Cdouble}, L::Ptr{cholmod_factor},
+                                           X::Ptr{cholmod_dense},
+                                           DeltaB::Ptr{cholmod_dense},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowdel_solve(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_rowdel_solve(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Ptr{cholmod_factor}, arg5::Ptr{cholmod_dense}, arg6::Ptr{cholmod_dense}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowdel_solve(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                             arg3::Ptr{Cdouble}, arg4::Ptr{cholmod_factor},
+                                             arg5::Ptr{cholmod_dense},
+                                             arg6::Ptr{cholmod_dense},
+                                             arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowdel_mark(k, R, yk, colmark, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_rowdel_mark(k::Csize_t, R::Ptr{cholmod_sparse}, yk::Ptr{Cdouble}, colmark::Ptr{Int32}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowdel_mark(k::Csize_t, R::Ptr{cholmod_sparse},
+                                          yk::Ptr{Cdouble}, colmark::Ptr{Int32},
+                                          L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense},
+                                          DeltaB::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowdel_mark(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
-    @ccall libcholmod.cholmod_l_rowdel_mark(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Ptr{Int64}, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_dense}, arg7::Ptr{cholmod_dense}, arg8::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowdel_mark(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                            arg3::Ptr{Cdouble}, arg4::Ptr{Int64},
+                                            arg5::Ptr{cholmod_factor},
+                                            arg6::Ptr{cholmod_dense},
+                                            arg7::Ptr{cholmod_dense},
+                                            arg8::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_ccolamd(A, fset, fsize, Cmember, Perm, Common)
-    @ccall libcholmod.cholmod_ccolamd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, Cmember::Ptr{Int32}, Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_ccolamd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                      fsize::Csize_t, Cmember::Ptr{Int32}, Perm::Ptr{Int32},
+                                      Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_ccolamd(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_ccolamd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{Int64}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_ccolamd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                        arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{Int64},
+                                        arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_csymamd(A, Cmember, Perm, Common)
-    @ccall libcholmod.cholmod_csymamd(A::Ptr{cholmod_sparse}, Cmember::Ptr{Int32}, Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_csymamd(A::Ptr{cholmod_sparse}, Cmember::Ptr{Int32},
+                                      Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_csymamd(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_csymamd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Ptr{Int64}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_csymamd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                        arg3::Ptr{Int64}, arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_camd(A, fset, fsize, Cmember, Perm, Common)
-    @ccall libcholmod.cholmod_camd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, Cmember::Ptr{Int32}, Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_camd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t,
+                                   Cmember::Ptr{Int32}, Perm::Ptr{Int32},
+                                   Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_camd(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_camd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{Int64}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_camd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                     arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{Int64},
+                                     arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_nested_dissection(A, fset, fsize, Perm, CParent, Cmember, Common)
-    @ccall libcholmod.cholmod_nested_dissection(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, Perm::Ptr{Int32}, CParent::Ptr{Int32}, Cmember::Ptr{Int32}, Common::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_nested_dissection(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                                fsize::Csize_t, Perm::Ptr{Int32},
+                                                CParent::Ptr{Int32}, Cmember::Ptr{Int32},
+                                                Common::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_l_nested_dissection(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_nested_dissection(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{Int64}, arg6::Ptr{Int64}, arg7::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_l_nested_dissection(arg1::Ptr{cholmod_sparse},
+                                                  arg2::Ptr{Int64}, arg3::Csize_t,
+                                                  arg4::Ptr{Int64}, arg5::Ptr{Int64},
+                                                  arg6::Ptr{Int64},
+                                                  arg7::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_metis(A, fset, fsize, postorder, Perm, Common)
-    @ccall libcholmod.cholmod_metis(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, postorder::Cint, Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_metis(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                    fsize::Csize_t, postorder::Cint, Perm::Ptr{Int32},
+                                    Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_metis(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_metis(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Cint, arg5::Ptr{Int64}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_metis(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                      arg3::Csize_t, arg4::Cint, arg5::Ptr{Int64},
+                                      arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_bisect(A, fset, fsize, compress, Partition, Common)
-    @ccall libcholmod.cholmod_bisect(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, compress::Cint, Partition::Ptr{Int32}, Common::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_bisect(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                     fsize::Csize_t, compress::Cint, Partition::Ptr{Int32},
+                                     Common::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_l_bisect(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_bisect(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Cint, arg5::Ptr{Int64}, arg6::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_l_bisect(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                       arg3::Csize_t, arg4::Cint, arg5::Ptr{Int64},
+                                       arg6::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_metis_bisector(A, Anw, Aew, Partition, Common)
-    @ccall libcholmod.cholmod_metis_bisector(A::Ptr{cholmod_sparse}, Anw::Ptr{Int32}, Aew::Ptr{Int32}, Partition::Ptr{Int32}, Common::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_metis_bisector(A::Ptr{cholmod_sparse}, Anw::Ptr{Int32},
+                                             Aew::Ptr{Int32}, Partition::Ptr{Int32},
+                                             Common::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_l_metis_bisector(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_metis_bisector(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_l_metis_bisector(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                               arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                               arg5::Ptr{cholmod_common})::Int64
 end
 
-function cholmod_collapse_septree(n, ncomponents, nd_oksep, nd_small, CParent, Cmember, Common)
-    @ccall libcholmod.cholmod_collapse_septree(n::Csize_t, ncomponents::Csize_t, nd_oksep::Cdouble, nd_small::Csize_t, CParent::Ptr{Int32}, Cmember::Ptr{Int32}, Common::Ptr{cholmod_common})::Int64
+function cholmod_collapse_septree(n, ncomponents, nd_oksep, nd_small, CParent, Cmember,
+                                  Common)
+    @ccall libcholmod.cholmod_collapse_septree(n::Csize_t, ncomponents::Csize_t,
+                                               nd_oksep::Cdouble, nd_small::Csize_t,
+                                               CParent::Ptr{Int32}, Cmember::Ptr{Int32},
+                                               Common::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_l_collapse_septree(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_collapse_septree(arg1::Csize_t, arg2::Csize_t, arg3::Cdouble, arg4::Csize_t, arg5::Ptr{Int64}, arg6::Ptr{Int64}, arg7::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_l_collapse_septree(arg1::Csize_t, arg2::Csize_t,
+                                                 arg3::Cdouble, arg4::Csize_t,
+                                                 arg5::Ptr{Int64}, arg6::Ptr{Int64},
+                                                 arg7::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_super_symbolic(A, F, Parent, L, Common)
-    @ccall libcholmod.cholmod_super_symbolic(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, Parent::Ptr{Int32}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_super_symbolic(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse},
+                                             Parent::Ptr{Int32}, L::Ptr{cholmod_factor},
+                                             Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_super_symbolic(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_super_symbolic(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Int64}, arg4::Ptr{cholmod_factor}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_super_symbolic(arg1::Ptr{cholmod_sparse},
+                                               arg2::Ptr{cholmod_sparse}, arg3::Ptr{Int64},
+                                               arg4::Ptr{cholmod_factor},
+                                               arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_super_symbolic2(for_whom, A, F, Parent, L, Common)
-    @ccall libcholmod.cholmod_super_symbolic2(for_whom::Cint, A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, Parent::Ptr{Int32}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_super_symbolic2(for_whom::Cint, A::Ptr{cholmod_sparse},
+                                              F::Ptr{cholmod_sparse}, Parent::Ptr{Int32},
+                                              L::Ptr{cholmod_factor},
+                                              Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_super_symbolic2(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_super_symbolic2(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_sparse}, arg4::Ptr{Int64}, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_super_symbolic2(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                                arg3::Ptr{cholmod_sparse}, arg4::Ptr{Int64},
+                                                arg5::Ptr{cholmod_factor},
+                                                arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_super_numeric(A, F, beta, L, Common)
-    @ccall libcholmod.cholmod_super_numeric(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, beta::Ptr{Cdouble}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_super_numeric(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse},
+                                            beta::Ptr{Cdouble}, L::Ptr{cholmod_factor},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_super_numeric(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_super_numeric(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Ptr{cholmod_factor}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_super_numeric(arg1::Ptr{cholmod_sparse},
+                                              arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble},
+                                              arg4::Ptr{cholmod_factor},
+                                              arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_super_lsolve(L, X, E, Common)
-    @ccall libcholmod.cholmod_super_lsolve(L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, E::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_super_lsolve(L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense},
+                                           E::Ptr{cholmod_dense},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_super_lsolve(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_super_lsolve(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_dense}, arg3::Ptr{cholmod_dense}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_super_lsolve(arg1::Ptr{cholmod_factor},
+                                             arg2::Ptr{cholmod_dense},
+                                             arg3::Ptr{cholmod_dense},
+                                             arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_super_ltsolve(L, X, E, Common)
-    @ccall libcholmod.cholmod_super_ltsolve(L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, E::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_super_ltsolve(L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense},
+                                            E::Ptr{cholmod_dense},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_super_ltsolve(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_super_ltsolve(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_dense}, arg3::Ptr{cholmod_dense}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_super_ltsolve(arg1::Ptr{cholmod_factor},
+                                              arg2::Ptr{cholmod_dense},
+                                              arg3::Ptr{cholmod_dense},
+                                              arg4::Ptr{cholmod_common})::Cint
+end
+
+function SuiteSparseQR_C(ordering, tol, econ, getCTX, A, Bsparse, Bdense, Zsparse, Zdense,
+                         R, E, H, HPinv, HTau, cc)
+    @ccall libspqr.SuiteSparseQR_C(ordering::Cint, tol::Cdouble, econ::Int64, getCTX::Cint,
+                                   A::Ptr{cholmod_sparse}, Bsparse::Ptr{cholmod_sparse},
+                                   Bdense::Ptr{cholmod_dense},
+                                   Zsparse::Ptr{Ptr{cholmod_sparse}},
+                                   Zdense::Ptr{Ptr{cholmod_dense}},
+                                   R::Ptr{Ptr{cholmod_sparse}}, E::Ptr{Ptr{Int64}},
+                                   H::Ptr{Ptr{cholmod_sparse}}, HPinv::Ptr{Ptr{Int64}},
+                                   HTau::Ptr{Ptr{cholmod_dense}},
+                                   cc::Ptr{cholmod_common})::Int64
+end
+
+function SuiteSparseQR_i_C(ordering, tol, econ, getCTX, A, Bsparse, Bdense, Zsparse, Zdense,
+                           R, E, H, HPinv, HTau, cc)
+    @ccall libspqr.SuiteSparseQR_i_C(ordering::Cint, tol::Cdouble, econ::Int32,
+                                     getCTX::Cint, A::Ptr{cholmod_sparse},
+                                     Bsparse::Ptr{cholmod_sparse},
+                                     Bdense::Ptr{cholmod_dense},
+                                     Zsparse::Ptr{Ptr{cholmod_sparse}},
+                                     Zdense::Ptr{Ptr{cholmod_dense}},
+                                     R::Ptr{Ptr{cholmod_sparse}}, E::Ptr{Ptr{Int32}},
+                                     H::Ptr{Ptr{cholmod_sparse}}, HPinv::Ptr{Ptr{Int32}},
+                                     HTau::Ptr{Ptr{cholmod_dense}},
+                                     cc::Ptr{cholmod_common})::Int32
 end
 
-function SuiteSparseQR_C(ordering, tol, econ, getCTX, A, Bsparse, Bdense, Zsparse, Zdense, R, E, H, HPinv, HTau, cc)
-    @ccall libspqr.SuiteSparseQR_C(ordering::Cint, tol::Cdouble, econ::Int64, getCTX::Cint, A::Ptr{cholmod_sparse}, Bsparse::Ptr{cholmod_sparse}, Bdense::Ptr{cholmod_dense}, Zsparse::Ptr{Ptr{cholmod_sparse}}, Zdense::Ptr{Ptr{cholmod_dense}}, R::Ptr{Ptr{cholmod_sparse}}, E::Ptr{Ptr{Int64}}, H::Ptr{Ptr{cholmod_sparse}}, HPinv::Ptr{Ptr{Int64}}, HTau::Ptr{Ptr{cholmod_dense}}, cc::Ptr{cholmod_common})::Int64
+function SuiteSparseQR_C_QR(ordering, tol, econ, A, Q, R, E, cc)
+    @ccall libspqr.SuiteSparseQR_C_QR(ordering::Cint, tol::Cdouble, econ::Int64,
+                                      A::Ptr{cholmod_sparse}, Q::Ptr{Ptr{cholmod_sparse}},
+                                      R::Ptr{Ptr{cholmod_sparse}}, E::Ptr{Ptr{Int64}},
+                                      cc::Ptr{cholmod_common})::Int64
 end
 
-function SuiteSparseQR_C_QR(ordering, tol, econ, A, Q, R, E, cc)
-    @ccall libspqr.SuiteSparseQR_C_QR(ordering::Cint, tol::Cdouble, econ::Int64, A::Ptr{cholmod_sparse}, Q::Ptr{Ptr{cholmod_sparse}}, R::Ptr{Ptr{cholmod_sparse}}, E::Ptr{Ptr{Int64}}, cc::Ptr{cholmod_common})::Int64
+function SuiteSparseQR_i_C_QR(ordering, tol, econ, A, Q, R, E, cc)
+    @ccall libspqr.SuiteSparseQR_i_C_QR(ordering::Cint, tol::Cdouble, econ::Int32,
+                                        A::Ptr{cholmod_sparse}, Q::Ptr{Ptr{cholmod_sparse}},
+                                        R::Ptr{Ptr{cholmod_sparse}}, E::Ptr{Ptr{Int32}},
+                                        cc::Ptr{cholmod_common})::Int32
 end
 
 function SuiteSparseQR_C_backslash(ordering, tol, A, B, cc)
-    @ccall libspqr.SuiteSparseQR_C_backslash(ordering::Cint, tol::Cdouble, A::Ptr{cholmod_sparse}, B::Ptr{cholmod_dense}, cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libspqr.SuiteSparseQR_C_backslash(ordering::Cint, tol::Cdouble,
+                                             A::Ptr{cholmod_sparse}, B::Ptr{cholmod_dense},
+                                             cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function SuiteSparseQR_C_backslash_default(A, B, cc)
-    @ccall libspqr.SuiteSparseQR_C_backslash_default(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_dense}, cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libspqr.SuiteSparseQR_C_backslash_default(A::Ptr{cholmod_sparse},
+                                                     B::Ptr{cholmod_dense},
+                                                     cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function SuiteSparseQR_C_backslash_sparse(ordering, tol, A, B, cc)
-    @ccall libspqr.SuiteSparseQR_C_backslash_sparse(ordering::Cint, tol::Cdouble, A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse}, cc::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libspqr.SuiteSparseQR_C_backslash_sparse(ordering::Cint, tol::Cdouble,
+                                                    A::Ptr{cholmod_sparse},
+                                                    B::Ptr{cholmod_sparse},
+                                                    cc::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 mutable struct SuiteSparseQR_C_factorization_struct
     xtype::Cint
+    itype::Cint
     factors::Ptr{Cvoid}
     SuiteSparseQR_C_factorization_struct() = new()
 end
@@ -1536,51 +2115,78 @@ end
 const SuiteSparseQR_C_factorization = SuiteSparseQR_C_factorization_struct
 
 function SuiteSparseQR_C_factorize(ordering, tol, A, cc)
-    @ccall libspqr.SuiteSparseQR_C_factorize(ordering::Cint, tol::Cdouble, A::Ptr{cholmod_sparse}, cc::Ptr{cholmod_common})::Ptr{SuiteSparseQR_C_factorization}
+    @ccall libspqr.SuiteSparseQR_C_factorize(ordering::Cint, tol::Cdouble,
+                                             A::Ptr{cholmod_sparse},
+                                             cc::Ptr{cholmod_common})::Ptr{SuiteSparseQR_C_factorization}
 end
 
 function SuiteSparseQR_C_symbolic(ordering, allow_tol, A, cc)
-    @ccall libspqr.SuiteSparseQR_C_symbolic(ordering::Cint, allow_tol::Cint, A::Ptr{cholmod_sparse}, cc::Ptr{cholmod_common})::Ptr{SuiteSparseQR_C_factorization}
+    @ccall libspqr.SuiteSparseQR_C_symbolic(ordering::Cint, allow_tol::Cint,
+                                            A::Ptr{cholmod_sparse},
+                                            cc::Ptr{cholmod_common})::Ptr{SuiteSparseQR_C_factorization}
 end
 
 function SuiteSparseQR_C_numeric(tol, A, QR, cc)
-    @ccall libspqr.SuiteSparseQR_C_numeric(tol::Cdouble, A::Ptr{cholmod_sparse}, QR::Ptr{SuiteSparseQR_C_factorization}, cc::Ptr{cholmod_common})::Cint
+    @ccall libspqr.SuiteSparseQR_C_numeric(tol::Cdouble, A::Ptr{cholmod_sparse},
+                                           QR::Ptr{SuiteSparseQR_C_factorization},
+                                           cc::Ptr{cholmod_common})::Cint
 end
 
 function SuiteSparseQR_C_free(QR, cc)
-    @ccall libspqr.SuiteSparseQR_C_free(QR::Ptr{Ptr{SuiteSparseQR_C_factorization}}, cc::Ptr{cholmod_common})::Cint
+    @ccall libspqr.SuiteSparseQR_C_free(QR::Ptr{Ptr{SuiteSparseQR_C_factorization}},
+                                        cc::Ptr{cholmod_common})::Cint
 end
 
 function SuiteSparseQR_C_solve(system, QR, B, cc)
-    @ccall libspqr.SuiteSparseQR_C_solve(system::Cint, QR::Ptr{SuiteSparseQR_C_factorization}, B::Ptr{cholmod_dense}, cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libspqr.SuiteSparseQR_C_solve(system::Cint,
+                                         QR::Ptr{SuiteSparseQR_C_factorization},
+                                         B::Ptr{cholmod_dense},
+                                         cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function SuiteSparseQR_C_qmult(method, QR, X, cc)
-    @ccall libspqr.SuiteSparseQR_C_qmult(method::Cint, QR::Ptr{SuiteSparseQR_C_factorization}, X::Ptr{cholmod_dense}, cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libspqr.SuiteSparseQR_C_qmult(method::Cint,
+                                         QR::Ptr{SuiteSparseQR_C_factorization},
+                                         X::Ptr{cholmod_dense},
+                                         cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function amd_order(n, Ap, Ai, P, Control, Info)
-    @ccall libamd.amd_order(n::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, P::Ptr{Int32}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libamd.amd_order(n::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, P::Ptr{Int32},
+                            Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function amd_l_order(n, Ap, Ai, P, Control, Info)
-    @ccall libamd.amd_l_order(n::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, P::Ptr{Int64}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libamd.amd_l_order(n::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, P::Ptr{Int64},
+                              Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
-function amd_2(n, Pe, Iw, Len, iwlen, pfree, Nv, Next, Last, Head, Elen, Degree, W, Control, Info)
-    @ccall libamd.amd_2(n::Int32, Pe::Ptr{Int32}, Iw::Ptr{Int32}, Len::Ptr{Int32}, iwlen::Int32, pfree::Int32, Nv::Ptr{Int32}, Next::Ptr{Int32}, Last::Ptr{Int32}, Head::Ptr{Int32}, Elen::Ptr{Int32}, Degree::Ptr{Int32}, W::Ptr{Int32}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cvoid
+function amd_2(n, Pe, Iw, Len, iwlen, pfree, Nv, Next, Last, Head, Elen, Degree, W, Control,
+               Info)
+    @ccall libamd.amd_2(n::Int32, Pe::Ptr{Int32}, Iw::Ptr{Int32}, Len::Ptr{Int32},
+                        iwlen::Int32, pfree::Int32, Nv::Ptr{Int32}, Next::Ptr{Int32},
+                        Last::Ptr{Int32}, Head::Ptr{Int32}, Elen::Ptr{Int32},
+                        Degree::Ptr{Int32}, W::Ptr{Int32}, Control::Ptr{Cdouble},
+                        Info::Ptr{Cdouble})::Cvoid
 end
 
-function amd_l2(n, Pe, Iw, Len, iwlen, pfree, Nv, Next, Last, Head, Elen, Degree, W, Control, Info)
-    @ccall libamd.amd_l2(n::Int64, Pe::Ptr{Int64}, Iw::Ptr{Int64}, Len::Ptr{Int64}, iwlen::Int64, pfree::Int64, Nv::Ptr{Int64}, Next::Ptr{Int64}, Last::Ptr{Int64}, Head::Ptr{Int64}, Elen::Ptr{Int64}, Degree::Ptr{Int64}, W::Ptr{Int64}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cvoid
+function amd_l2(n, Pe, Iw, Len, iwlen, pfree, Nv, Next, Last, Head, Elen, Degree, W,
+                Control, Info)
+    @ccall libamd.amd_l2(n::Int64, Pe::Ptr{Int64}, Iw::Ptr{Int64}, Len::Ptr{Int64},
+                         iwlen::Int64, pfree::Int64, Nv::Ptr{Int64}, Next::Ptr{Int64},
+                         Last::Ptr{Int64}, Head::Ptr{Int64}, Elen::Ptr{Int64},
+                         Degree::Ptr{Int64}, W::Ptr{Int64}, Control::Ptr{Cdouble},
+                         Info::Ptr{Cdouble})::Cvoid
 end
 
 function amd_valid(n_row, n_col, Ap, Ai)
-    @ccall libamd.amd_valid(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32})::Cint
+    @ccall libamd.amd_valid(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                            Ai::Ptr{Int32})::Cint
 end
 
 function amd_l_valid(n_row, n_col, Ap, Ai)
-    @ccall libamd.amd_l_valid(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64})::Cint
+    @ccall libamd.amd_l_valid(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                              Ai::Ptr{Int64})::Cint
 end
 
 function amd_defaults(Control)
@@ -1607,188 +2213,88 @@ function amd_l_info(Info)
     @ccall libamd.amd_l_info(Info::Ptr{Cdouble})::Cvoid
 end
 
-function colamd_recommended(nnz, n_row, n_col)
-    @ccall libcolamd.colamd_recommended(nnz::Int32, n_row::Int32, n_col::Int32)::Csize_t
-end
-
-function colamd_l_recommended(nnz, n_row, n_col)
-    @ccall libcolamd.colamd_l_recommended(nnz::Int64, n_row::Int64, n_col::Int64)::Csize_t
-end
-
-function colamd_set_defaults(knobs)
-    @ccall libcolamd.colamd_set_defaults(knobs::Ptr{Cdouble})::Cvoid
-end
-
-function colamd_l_set_defaults(knobs)
-    @ccall libcolamd.colamd_l_set_defaults(knobs::Ptr{Cdouble})::Cvoid
-end
-
-function colamd(n_row, n_col, Alen, A, p, knobs, stats)
-    @ccall libcolamd.colamd(n_row::Int32, n_col::Int32, Alen::Int32, A::Ptr{Int32}, p::Ptr{Int32}, knobs::Ptr{Cdouble}, stats::Ptr{Int32})::Cint
-end
-
-function colamd_l(n_row, n_col, Alen, A, p, knobs, stats)
-    @ccall libcolamd.colamd_l(n_row::Int64, n_col::Int64, Alen::Int64, A::Ptr{Int64}, p::Ptr{Int64}, knobs::Ptr{Cdouble}, stats::Ptr{Int64})::Cint
-end
-
-function symamd(n, A, p, perm, knobs, stats, allocate, release)
-    @ccall libcolamd.symamd(n::Int32, A::Ptr{Int32}, p::Ptr{Int32}, perm::Ptr{Int32}, knobs::Ptr{Cdouble}, stats::Ptr{Int32}, allocate::Ptr{Cvoid}, release::Ptr{Cvoid})::Cint
-end
-
-function symamd_l(n, A, p, perm, knobs, stats, allocate, release)
-    @ccall libcolamd.symamd_l(n::Int64, A::Ptr{Int64}, p::Ptr{Int64}, perm::Ptr{Int64}, knobs::Ptr{Cdouble}, stats::Ptr{Int64}, allocate::Ptr{Cvoid}, release::Ptr{Cvoid})::Cint
-end
-
-function colamd_report(stats)
-    @ccall libcolamd.colamd_report(stats::Ptr{Int32})::Cvoid
-end
-
-function colamd_l_report(stats)
-    @ccall libcolamd.colamd_l_report(stats::Ptr{Int64})::Cvoid
-end
-
-function symamd_report(stats)
-    @ccall libcolamd.symamd_report(stats::Ptr{Int32})::Cvoid
-end
-
-function symamd_l_report(stats)
-    @ccall libcolamd.symamd_l_report(stats::Ptr{Int64})::Cvoid
-end
-
-function ccolamd_recommended(nnz, n_row, n_col)
-    @ccall libcolamd.ccolamd_recommended(nnz::Cint, n_row::Cint, n_col::Cint)::Csize_t
-end
-
-function ccolamd_l_recommended(nnz, n_row, n_col)
-    @ccall libcolamd.ccolamd_l_recommended(nnz::Int64, n_row::Int64, n_col::Int64)::Csize_t
-end
-
-function ccolamd_set_defaults(knobs)
-    @ccall libcolamd.ccolamd_set_defaults(knobs::Ptr{Cdouble})::Cvoid
-end
-
-function ccolamd_l_set_defaults(knobs)
-    @ccall libcolamd.ccolamd_l_set_defaults(knobs::Ptr{Cdouble})::Cvoid
-end
-
-function ccolamd(n_row, n_col, Alen, A, p, knobs, stats, cmember)
-    @ccall libcolamd.ccolamd(n_row::Cint, n_col::Cint, Alen::Cint, A::Ptr{Cint}, p::Ptr{Cint}, knobs::Ptr{Cdouble}, stats::Ptr{Cint}, cmember::Ptr{Cint})::Cint
-end
-
-function ccolamd_l(n_row, n_col, Alen, A, p, knobs, stats, cmember)
-    @ccall libcolamd.ccolamd_l(n_row::Int64, n_col::Int64, Alen::Int64, A::Ptr{Int64}, p::Ptr{Int64}, knobs::Ptr{Cdouble}, stats::Ptr{Int64}, cmember::Ptr{Int64})::Cint
-end
-
-function csymamd(n, A, p, perm, knobs, stats, allocate, release, cmember, stype)
-    @ccall libcolamd.csymamd(n::Cint, A::Ptr{Cint}, p::Ptr{Cint}, perm::Ptr{Cint}, knobs::Ptr{Cdouble}, stats::Ptr{Cint}, allocate::Ptr{Cvoid}, release::Ptr{Cvoid}, cmember::Ptr{Cint}, stype::Cint)::Cint
-end
-
-function csymamd_l(n, A, p, perm, knobs, stats, allocate, release, cmember, stype)
-    @ccall libcolamd.csymamd_l(n::Int64, A::Ptr{Int64}, p::Ptr{Int64}, perm::Ptr{Int64}, knobs::Ptr{Cdouble}, stats::Ptr{Int64}, allocate::Ptr{Cvoid}, release::Ptr{Cvoid}, cmember::Ptr{Int64}, stype::Int64)::Cint
-end
-
-function ccolamd_report(stats)
-    @ccall libcolamd.ccolamd_report(stats::Ptr{Cint})::Cvoid
-end
-
-function ccolamd_l_report(stats)
-    @ccall libcolamd.ccolamd_l_report(stats::Ptr{Int64})::Cvoid
-end
-
-function csymamd_report(stats)
-    @ccall libcolamd.csymamd_report(stats::Ptr{Cint})::Cvoid
-end
-
-function csymamd_l_report(stats)
-    @ccall libcolamd.csymamd_l_report(stats::Ptr{Int64})::Cvoid
-end
-
-function ccolamd2(n_row, n_col, Alen, A, p, knobs, stats, Front_npivcol, Front_nrows, Front_ncols, Front_parent, Front_cols, p_nfr, InFront, cmember)
-    @ccall libcolamd.ccolamd2(n_row::Cint, n_col::Cint, Alen::Cint, A::Ptr{Cint}, p::Ptr{Cint}, knobs::Ptr{Cdouble}, stats::Ptr{Cint}, Front_npivcol::Ptr{Cint}, Front_nrows::Ptr{Cint}, Front_ncols::Ptr{Cint}, Front_parent::Ptr{Cint}, Front_cols::Ptr{Cint}, p_nfr::Ptr{Cint}, InFront::Ptr{Cint}, cmember::Ptr{Cint})::Cint
-end
-
-function ccolamd2_l(n_row, n_col, Alen, A, p, knobs, stats, Front_npivcol, Front_nrows, Front_ncols, Front_parent, Front_cols, p_nfr, InFront, cmember)
-    @ccall libcolamd.ccolamd2_l(n_row::Int64, n_col::Int64, Alen::Int64, A::Ptr{Int64}, p::Ptr{Int64}, knobs::Ptr{Cdouble}, stats::Ptr{Int64}, Front_npivcol::Ptr{Int64}, Front_nrows::Ptr{Int64}, Front_ncols::Ptr{Int64}, Front_parent::Ptr{Int64}, Front_cols::Ptr{Int64}, p_nfr::Ptr{Int64}, InFront::Ptr{Int64}, cmember::Ptr{Int64})::Cint
-end
-
-function ccolamd_apply_order(Front, Order, Temp, nn, nfr)
-    @ccall libcolamd.ccolamd_apply_order(Front::Ptr{Cint}, Order::Ptr{Cint}, Temp::Ptr{Cint}, nn::Cint, nfr::Cint)::Cvoid
-end
-
-function ccolamd_l_apply_order(Front, Order, Temp, nn, nfr)
-    @ccall libcolamd.ccolamd_l_apply_order(Front::Ptr{Int64}, Order::Ptr{Int64}, Temp::Ptr{Int64}, nn::Int64, nfr::Int64)::Cvoid
-end
-
-function ccolamd_fsize(nn, MaxFsize, Fnrows, Fncols, Parent, Npiv)
-    @ccall libcolamd.ccolamd_fsize(nn::Cint, MaxFsize::Ptr{Cint}, Fnrows::Ptr{Cint}, Fncols::Ptr{Cint}, Parent::Ptr{Cint}, Npiv::Ptr{Cint})::Cvoid
-end
-
-function ccolamd_l_fsize(nn, MaxFsize, Fnrows, Fncols, Parent, Npiv)
-    @ccall libcolamd.ccolamd_l_fsize(nn::Int64, MaxFsize::Ptr{Int64}, Fnrows::Ptr{Int64}, Fncols::Ptr{Int64}, Parent::Ptr{Int64}, Npiv::Ptr{Int64})::Cvoid
-end
-
-function ccolamd_postorder(nn, Parent, Npiv, Fsize, Order, Child, Sibling, Stack, Front_cols, cmember)
-    @ccall libcolamd.ccolamd_postorder(nn::Cint, Parent::Ptr{Cint}, Npiv::Ptr{Cint}, Fsize::Ptr{Cint}, Order::Ptr{Cint}, Child::Ptr{Cint}, Sibling::Ptr{Cint}, Stack::Ptr{Cint}, Front_cols::Ptr{Cint}, cmember::Ptr{Cint})::Cvoid
-end
-
-function ccolamd_l_postorder(nn, Parent, Npiv, Fsize, Order, Child, Sibling, Stack, Front_cols, cmember)
-    @ccall libcolamd.ccolamd_l_postorder(nn::Int64, Parent::Ptr{Int64}, Npiv::Ptr{Int64}, Fsize::Ptr{Int64}, Order::Ptr{Int64}, Child::Ptr{Int64}, Sibling::Ptr{Int64}, Stack::Ptr{Int64}, Front_cols::Ptr{Int64}, cmember::Ptr{Int64})::Cvoid
-end
-
-function ccolamd_post_tree(root, k, Child, Sibling, Order, Stack)
-    @ccall libcolamd.ccolamd_post_tree(root::Cint, k::Cint, Child::Ptr{Cint}, Sibling::Ptr{Cint}, Order::Ptr{Cint}, Stack::Ptr{Cint})::Cint
-end
-
-function ccolamd_l_post_tree(root, k, Child, Sibling, Order, Stack)
-    @ccall libcolamd.ccolamd_l_post_tree(root::Int64, k::Int64, Child::Ptr{Int64}, Sibling::Ptr{Int64}, Order::Ptr{Int64}, Stack::Ptr{Int64})::Int64
-end
-
 function umfpack_di_symbolic(n_row, n_col, Ap, Ai, Ax, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_di_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                          Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                          Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                          Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_symbolic(n_row, n_col, Ap, Ai, Ax, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_dl_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                          Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                          Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                          Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_symbolic(n_row, n_col, Ap, Ai, Ax, Az, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_zi_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                          Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                          Az::Ptr{Cdouble}, Symbolic::Ptr{Ptr{Cvoid}},
+                                          Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_symbolic(n_row, n_col, Ap, Ai, Ax, Az, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_zl_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                          Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                          Az::Ptr{Cdouble}, Symbolic::Ptr{Ptr{Cvoid}},
+                                          Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_numeric(Ap, Ai, Ax, Symbolic, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_di_numeric(Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Symbolic::Ptr{Cvoid}, Numeric::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_numeric(Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                         Symbolic::Ptr{Cvoid}, Numeric::Ptr{Ptr{Cvoid}},
+                                         Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_numeric(Ap, Ai, Ax, Symbolic, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_dl_numeric(Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Symbolic::Ptr{Cvoid}, Numeric::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_numeric(Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                         Symbolic::Ptr{Cvoid}, Numeric::Ptr{Ptr{Cvoid}},
+                                         Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_numeric(Ap, Ai, Ax, Az, Symbolic, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_zi_numeric(Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Symbolic::Ptr{Cvoid}, Numeric::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_numeric(Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                         Az::Ptr{Cdouble}, Symbolic::Ptr{Cvoid},
+                                         Numeric::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                         Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_numeric(Ap, Ai, Ax, Az, Symbolic, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_zl_numeric(Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Symbolic::Ptr{Cvoid}, Numeric::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_numeric(Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                         Az::Ptr{Cdouble}, Symbolic::Ptr{Cvoid},
+                                         Numeric::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                         Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_solve(sys, Ap, Ai, Ax, X, B, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_di_solve(sys::Cint, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_solve(sys::Cint, Ap::Ptr{Int32}, Ai::Ptr{Int32},
+                                       Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble},
+                                       Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                       Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_solve(sys, Ap, Ai, Ax, X, B, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_dl_solve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_solve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64},
+                                       Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble},
+                                       Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                       Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_solve(sys, Ap, Ai, Ax, Az, Xx, Xz, Bx, Bz, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_zi_solve(sys::Cint, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_solve(sys::Cint, Ap::Ptr{Int32}, Ai::Ptr{Int32},
+                                       Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Xx::Ptr{Cdouble},
+                                       Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble},
+                                       Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                       Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_solve(sys, Ap, Ai, Ax, Az, Xx, Xz, Bx, Bz, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_zl_solve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_solve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64},
+                                       Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Xx::Ptr{Cdouble},
+                                       Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble},
+                                       Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                       Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_free_symbolic(Symbolic)
@@ -1840,51 +2346,119 @@ function umfpack_zl_defaults(Control)
 end
 
 function umfpack_di_qsymbolic(n_row, n_col, Ap, Ai, Ax, Qinit, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_di_qsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Qinit::Ptr{Int32}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_qsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                           Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                           Qinit::Ptr{Int32}, Symbolic::Ptr{Ptr{Cvoid}},
+                                           Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_qsymbolic(n_row, n_col, Ap, Ai, Ax, Qinit, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_dl_qsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Qinit::Ptr{Int64}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_qsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                           Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                           Qinit::Ptr{Int64}, Symbolic::Ptr{Ptr{Cvoid}},
+                                           Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_qsymbolic(n_row, n_col, Ap, Ai, Ax, Az, Qinit, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_zi_qsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Qinit::Ptr{Int32}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_qsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                           Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                           Az::Ptr{Cdouble}, Qinit::Ptr{Int32},
+                                           Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                           Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_qsymbolic(n_row, n_col, Ap, Ai, Ax, Az, Qinit, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_zl_qsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Qinit::Ptr{Int64}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_di_fsymbolic(n_row, n_col, Ap, Ai, Ax, user_ordering, user_params, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_di_fsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_dl_fsymbolic(n_row, n_col, Ap, Ai, Ax, user_ordering, user_params, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_dl_fsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_zi_fsymbolic(n_row, n_col, Ap, Ai, Ax, Az, user_ordering, user_params, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_zi_fsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_zl_fsymbolic(n_row, n_col, Ap, Ai, Ax, Az, user_ordering, user_params, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_zl_fsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_di_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Qinit, user_ordering, user_params, Symbolic, SW, Control, Info)
-    @ccall libumfpack.umfpack_di_paru_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Qinit::Ptr{Int32}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_dl_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Qinit, user_ordering, user_params, Symbolic, SW, Control, Info)
-    @ccall libumfpack.umfpack_dl_paru_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Qinit::Ptr{Int64}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_zi_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Az, Qinit, user_ordering, user_params, Symbolic, SW, Control, Info)
-    @ccall libumfpack.umfpack_zi_paru_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Qinit::Ptr{Int32}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_zl_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Az, Qinit, user_ordering, user_params, Symbolic, SW, Control, Info)
-    @ccall libumfpack.umfpack_zl_paru_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Qinit::Ptr{Int64}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_qsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                           Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                           Az::Ptr{Cdouble}, Qinit::Ptr{Int64},
+                                           Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                           Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_di_fsymbolic(n_row, n_col, Ap, Ai, Ax, user_ordering, user_params,
+                              Symbolic, Control, Info)
+    @ccall libumfpack.umfpack_di_fsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                           Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                           user_ordering::Ptr{Cvoid},
+                                           user_params::Ptr{Cvoid},
+                                           Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                           Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_dl_fsymbolic(n_row, n_col, Ap, Ai, Ax, user_ordering, user_params,
+                              Symbolic, Control, Info)
+    @ccall libumfpack.umfpack_dl_fsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                           Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                           user_ordering::Ptr{Cvoid},
+                                           user_params::Ptr{Cvoid},
+                                           Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                           Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_zi_fsymbolic(n_row, n_col, Ap, Ai, Ax, Az, user_ordering, user_params,
+                              Symbolic, Control, Info)
+    @ccall libumfpack.umfpack_zi_fsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                           Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                           Az::Ptr{Cdouble}, user_ordering::Ptr{Cvoid},
+                                           user_params::Ptr{Cvoid},
+                                           Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                           Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_zl_fsymbolic(n_row, n_col, Ap, Ai, Ax, Az, user_ordering, user_params,
+                              Symbolic, Control, Info)
+    @ccall libumfpack.umfpack_zl_fsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                           Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                           Az::Ptr{Cdouble}, user_ordering::Ptr{Cvoid},
+                                           user_params::Ptr{Cvoid},
+                                           Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                           Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_di_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Qinit, user_ordering,
+                                  user_params, Symbolic, SW, Control, Info)
+    @ccall libumfpack.umfpack_di_paru_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                               Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                               Qinit::Ptr{Int32}, user_ordering::Ptr{Cvoid},
+                                               user_params::Ptr{Cvoid},
+                                               Symbolic::Ptr{Ptr{Cvoid}},
+                                               SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                               Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_dl_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Qinit, user_ordering,
+                                  user_params, Symbolic, SW, Control, Info)
+    @ccall libumfpack.umfpack_dl_paru_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                               Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                               Qinit::Ptr{Int64}, user_ordering::Ptr{Cvoid},
+                                               user_params::Ptr{Cvoid},
+                                               Symbolic::Ptr{Ptr{Cvoid}},
+                                               SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                               Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_zi_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Az, Qinit, user_ordering,
+                                  user_params, Symbolic, SW, Control, Info)
+    @ccall libumfpack.umfpack_zi_paru_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                               Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                               Az::Ptr{Cdouble}, Qinit::Ptr{Int32},
+                                               user_ordering::Ptr{Cvoid},
+                                               user_params::Ptr{Cvoid},
+                                               Symbolic::Ptr{Ptr{Cvoid}},
+                                               SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                               Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_zl_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Az, Qinit, user_ordering,
+                                  user_params, Symbolic, SW, Control, Info)
+    @ccall libumfpack.umfpack_zl_paru_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                               Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                               Az::Ptr{Cdouble}, Qinit::Ptr{Int64},
+                                               user_ordering::Ptr{Cvoid},
+                                               user_params::Ptr{Cvoid},
+                                               Symbolic::Ptr{Ptr{Cvoid}},
+                                               SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                               Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_paru_free_sw(SW)
@@ -1904,339 +2478,547 @@ function umfpack_zl_paru_free_sw(SW)
 end
 
 function umfpack_di_wsolve(sys, Ap, Ai, Ax, X, B, Numeric, Control, Info, Wi, W)
-    @ccall libumfpack.umfpack_di_wsolve(sys::Cint, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble}, Wi::Ptr{Int32}, W::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_wsolve(sys::Cint, Ap::Ptr{Int32}, Ai::Ptr{Int32},
+                                        Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble},
+                                        Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                        Info::Ptr{Cdouble}, Wi::Ptr{Int32},
+                                        W::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_wsolve(sys, Ap, Ai, Ax, X, B, Numeric, Control, Info, Wi, W)
-    @ccall libumfpack.umfpack_dl_wsolve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble}, Wi::Ptr{Int64}, W::Ptr{Cdouble})::Cint
-end
-
-function umfpack_zi_wsolve(sys, Ap, Ai, Ax, Az, Xx, Xz, Bx, Bz, Numeric, Control, Info, Wi, W)
-    @ccall libumfpack.umfpack_zi_wsolve(sys::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble}, Wi::Ptr{Int32}, W::Ptr{Cdouble})::Cint
-end
-
-function umfpack_zl_wsolve(sys, Ap, Ai, Ax, Az, Xx, Xz, Bx, Bz, Numeric, Control, Info, Wi, W)
-    @ccall libumfpack.umfpack_zl_wsolve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble}, Wi::Ptr{Int64}, W::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_wsolve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64},
+                                        Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble},
+                                        Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                        Info::Ptr{Cdouble}, Wi::Ptr{Int64},
+                                        W::Ptr{Cdouble})::Cint
+end
+
+function umfpack_zi_wsolve(sys, Ap, Ai, Ax, Az, Xx, Xz, Bx, Bz, Numeric, Control, Info, Wi,
+                           W)
+    @ccall libumfpack.umfpack_zi_wsolve(sys::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32},
+                                        Ax::Ptr{Cdouble}, Az::Ptr{Cdouble},
+                                        Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble},
+                                        Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble},
+                                        Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                        Info::Ptr{Cdouble}, Wi::Ptr{Int32},
+                                        W::Ptr{Cdouble})::Cint
+end
+
+function umfpack_zl_wsolve(sys, Ap, Ai, Ax, Az, Xx, Xz, Bx, Bz, Numeric, Control, Info, Wi,
+                           W)
+    @ccall libumfpack.umfpack_zl_wsolve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64},
+                                        Ax::Ptr{Cdouble}, Az::Ptr{Cdouble},
+                                        Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble},
+                                        Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble},
+                                        Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                        Info::Ptr{Cdouble}, Wi::Ptr{Int64},
+                                        W::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_triplet_to_col(n_row, n_col, nz, Ti, Tj, Tx, Ap, Ai, Ax, Map)
-    @ccall libumfpack.umfpack_di_triplet_to_col(n_row::Int32, n_col::Int32, nz::Int32, Ti::Ptr{Int32}, Tj::Ptr{Int32}, Tx::Ptr{Cdouble}, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Map::Ptr{Int32})::Cint
+    @ccall libumfpack.umfpack_di_triplet_to_col(n_row::Int32, n_col::Int32, nz::Int32,
+                                                Ti::Ptr{Int32}, Tj::Ptr{Int32},
+                                                Tx::Ptr{Cdouble}, Ap::Ptr{Int32},
+                                                Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                                Map::Ptr{Int32})::Cint
 end
 
 function umfpack_dl_triplet_to_col(n_row, n_col, nz, Ti, Tj, Tx, Ap, Ai, Ax, Map)
-    @ccall libumfpack.umfpack_dl_triplet_to_col(n_row::Int64, n_col::Int64, nz::Int64, Ti::Ptr{Int64}, Tj::Ptr{Int64}, Tx::Ptr{Cdouble}, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Map::Ptr{Int64})::Cint
+    @ccall libumfpack.umfpack_dl_triplet_to_col(n_row::Int64, n_col::Int64, nz::Int64,
+                                                Ti::Ptr{Int64}, Tj::Ptr{Int64},
+                                                Tx::Ptr{Cdouble}, Ap::Ptr{Int64},
+                                                Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                                Map::Ptr{Int64})::Cint
 end
 
 function umfpack_zi_triplet_to_col(n_row, n_col, nz, Ti, Tj, Tx, Tz, Ap, Ai, Ax, Az, Map)
-    @ccall libumfpack.umfpack_zi_triplet_to_col(n_row::Int32, n_col::Int32, nz::Int32, Ti::Ptr{Int32}, Tj::Ptr{Int32}, Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble}, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Map::Ptr{Int32})::Cint
+    @ccall libumfpack.umfpack_zi_triplet_to_col(n_row::Int32, n_col::Int32, nz::Int32,
+                                                Ti::Ptr{Int32}, Tj::Ptr{Int32},
+                                                Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble},
+                                                Ap::Ptr{Int32}, Ai::Ptr{Int32},
+                                                Ax::Ptr{Cdouble}, Az::Ptr{Cdouble},
+                                                Map::Ptr{Int32})::Cint
 end
 
 function umfpack_zl_triplet_to_col(n_row, n_col, nz, Ti, Tj, Tx, Tz, Ap, Ai, Ax, Az, Map)
-    @ccall libumfpack.umfpack_zl_triplet_to_col(n_row::Int64, n_col::Int64, nz::Int64, Ti::Ptr{Int64}, Tj::Ptr{Int64}, Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble}, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Map::Ptr{Int64})::Cint
+    @ccall libumfpack.umfpack_zl_triplet_to_col(n_row::Int64, n_col::Int64, nz::Int64,
+                                                Ti::Ptr{Int64}, Tj::Ptr{Int64},
+                                                Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble},
+                                                Ap::Ptr{Int64}, Ai::Ptr{Int64},
+                                                Ax::Ptr{Cdouble}, Az::Ptr{Cdouble},
+                                                Map::Ptr{Int64})::Cint
 end
 
 function umfpack_di_col_to_triplet(n_col, Ap, Tj)
-    @ccall libumfpack.umfpack_di_col_to_triplet(n_col::Int32, Ap::Ptr{Int32}, Tj::Ptr{Int32})::Cint
+    @ccall libumfpack.umfpack_di_col_to_triplet(n_col::Int32, Ap::Ptr{Int32},
+                                                Tj::Ptr{Int32})::Cint
 end
 
 function umfpack_dl_col_to_triplet(n_col, Ap, Tj)
-    @ccall libumfpack.umfpack_dl_col_to_triplet(n_col::Int64, Ap::Ptr{Int64}, Tj::Ptr{Int64})::Cint
+    @ccall libumfpack.umfpack_dl_col_to_triplet(n_col::Int64, Ap::Ptr{Int64},
+                                                Tj::Ptr{Int64})::Cint
 end
 
 function umfpack_zi_col_to_triplet(n_col, Ap, Tj)
-    @ccall libumfpack.umfpack_zi_col_to_triplet(n_col::Int32, Ap::Ptr{Int32}, Tj::Ptr{Int32})::Cint
+    @ccall libumfpack.umfpack_zi_col_to_triplet(n_col::Int32, Ap::Ptr{Int32},
+                                                Tj::Ptr{Int32})::Cint
 end
 
 function umfpack_zl_col_to_triplet(n_col, Ap, Tj)
-    @ccall libumfpack.umfpack_zl_col_to_triplet(n_col::Int64, Ap::Ptr{Int64}, Tj::Ptr{Int64})::Cint
+    @ccall libumfpack.umfpack_zl_col_to_triplet(n_col::Int64, Ap::Ptr{Int64},
+                                                Tj::Ptr{Int64})::Cint
 end
 
 function umfpack_di_transpose(n_row, n_col, Ap, Ai, Ax, P, Q, Rp, Ri, Rx)
-    @ccall libumfpack.umfpack_di_transpose(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, P::Ptr{Int32}, Q::Ptr{Int32}, Rp::Ptr{Int32}, Ri::Ptr{Int32}, Rx::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_transpose(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                           Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, P::Ptr{Int32},
+                                           Q::Ptr{Int32}, Rp::Ptr{Int32}, Ri::Ptr{Int32},
+                                           Rx::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_transpose(n_row, n_col, Ap, Ai, Ax, P, Q, Rp, Ri, Rx)
-    @ccall libumfpack.umfpack_dl_transpose(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, P::Ptr{Int64}, Q::Ptr{Int64}, Rp::Ptr{Int64}, Ri::Ptr{Int64}, Rx::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_transpose(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                           Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, P::Ptr{Int64},
+                                           Q::Ptr{Int64}, Rp::Ptr{Int64}, Ri::Ptr{Int64},
+                                           Rx::Ptr{Cdouble})::Cint
 end
 
-function umfpack_zi_transpose(n_row, n_col, Ap, Ai, Ax, Az, P, Q, Rp, Ri, Rx, Rz, do_conjugate)
-    @ccall libumfpack.umfpack_zi_transpose(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, P::Ptr{Int32}, Q::Ptr{Int32}, Rp::Ptr{Int32}, Ri::Ptr{Int32}, Rx::Ptr{Cdouble}, Rz::Ptr{Cdouble}, do_conjugate::Cint)::Cint
+function umfpack_zi_transpose(n_row, n_col, Ap, Ai, Ax, Az, P, Q, Rp, Ri, Rx, Rz,
+                              do_conjugate)
+    @ccall libumfpack.umfpack_zi_transpose(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                           Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                           Az::Ptr{Cdouble}, P::Ptr{Int32}, Q::Ptr{Int32},
+                                           Rp::Ptr{Int32}, Ri::Ptr{Int32}, Rx::Ptr{Cdouble},
+                                           Rz::Ptr{Cdouble}, do_conjugate::Cint)::Cint
 end
 
-function umfpack_zl_transpose(n_row, n_col, Ap, Ai, Ax, Az, P, Q, Rp, Ri, Rx, Rz, do_conjugate)
-    @ccall libumfpack.umfpack_zl_transpose(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, P::Ptr{Int64}, Q::Ptr{Int64}, Rp::Ptr{Int64}, Ri::Ptr{Int64}, Rx::Ptr{Cdouble}, Rz::Ptr{Cdouble}, do_conjugate::Cint)::Cint
+function umfpack_zl_transpose(n_row, n_col, Ap, Ai, Ax, Az, P, Q, Rp, Ri, Rx, Rz,
+                              do_conjugate)
+    @ccall libumfpack.umfpack_zl_transpose(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                           Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                           Az::Ptr{Cdouble}, P::Ptr{Int64}, Q::Ptr{Int64},
+                                           Rp::Ptr{Int64}, Ri::Ptr{Int64}, Rx::Ptr{Cdouble},
+                                           Rz::Ptr{Cdouble}, do_conjugate::Cint)::Cint
 end
 
 function umfpack_di_scale(X, B, Numeric)
-    @ccall libumfpack.umfpack_di_scale(X::Ptr{Cdouble}, B::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_scale(X::Ptr{Cdouble}, B::Ptr{Cdouble},
+                                       Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_scale(X, B, Numeric)
-    @ccall libumfpack.umfpack_dl_scale(X::Ptr{Cdouble}, B::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_scale(X::Ptr{Cdouble}, B::Ptr{Cdouble},
+                                       Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_scale(Xx, Xz, Bx, Bz, Numeric)
-    @ccall libumfpack.umfpack_zi_scale(Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_scale(Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble},
+                                       Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_scale(Xx, Xz, Bx, Bz, Numeric)
-    @ccall libumfpack.umfpack_zl_scale(Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_scale(Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble},
+                                       Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_get_lunz(lnz, unz, n_row, n_col, nz_udiag, Numeric)
-    @ccall libumfpack.umfpack_di_get_lunz(lnz::Ptr{Int32}, unz::Ptr{Int32}, n_row::Ptr{Int32}, n_col::Ptr{Int32}, nz_udiag::Ptr{Int32}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_get_lunz(lnz::Ptr{Int32}, unz::Ptr{Int32},
+                                          n_row::Ptr{Int32}, n_col::Ptr{Int32},
+                                          nz_udiag::Ptr{Int32}, Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_get_lunz(lnz, unz, n_row, n_col, nz_udiag, Numeric)
-    @ccall libumfpack.umfpack_dl_get_lunz(lnz::Ptr{Int64}, unz::Ptr{Int64}, n_row::Ptr{Int64}, n_col::Ptr{Int64}, nz_udiag::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_get_lunz(lnz::Ptr{Int64}, unz::Ptr{Int64},
+                                          n_row::Ptr{Int64}, n_col::Ptr{Int64},
+                                          nz_udiag::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_get_lunz(lnz, unz, n_row, n_col, nz_udiag, Numeric)
-    @ccall libumfpack.umfpack_zi_get_lunz(lnz::Ptr{Int32}, unz::Ptr{Int32}, n_row::Ptr{Int32}, n_col::Ptr{Int32}, nz_udiag::Ptr{Int32}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_get_lunz(lnz::Ptr{Int32}, unz::Ptr{Int32},
+                                          n_row::Ptr{Int32}, n_col::Ptr{Int32},
+                                          nz_udiag::Ptr{Int32}, Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_get_lunz(lnz, unz, n_row, n_col, nz_udiag, Numeric)
-    @ccall libumfpack.umfpack_zl_get_lunz(lnz::Ptr{Int64}, unz::Ptr{Int64}, n_row::Ptr{Int64}, n_col::Ptr{Int64}, nz_udiag::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_get_lunz(lnz::Ptr{Int64}, unz::Ptr{Int64},
+                                          n_row::Ptr{Int64}, n_col::Ptr{Int64},
+                                          nz_udiag::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_get_numeric(Lp, Lj, Lx, Up, Ui, Ux, P, Q, Dx, do_recip, Rs, Numeric)
-    @ccall libumfpack.umfpack_di_get_numeric(Lp::Ptr{Int32}, Lj::Ptr{Int32}, Lx::Ptr{Cdouble}, Up::Ptr{Int32}, Ui::Ptr{Int32}, Ux::Ptr{Cdouble}, P::Ptr{Int32}, Q::Ptr{Int32}, Dx::Ptr{Cdouble}, do_recip::Ptr{Int32}, Rs::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_get_numeric(Lp::Ptr{Int32}, Lj::Ptr{Int32},
+                                             Lx::Ptr{Cdouble}, Up::Ptr{Int32},
+                                             Ui::Ptr{Int32}, Ux::Ptr{Cdouble},
+                                             P::Ptr{Int32}, Q::Ptr{Int32}, Dx::Ptr{Cdouble},
+                                             do_recip::Ptr{Int32}, Rs::Ptr{Cdouble},
+                                             Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_get_numeric(Lp, Lj, Lx, Up, Ui, Ux, P, Q, Dx, do_recip, Rs, Numeric)
-    @ccall libumfpack.umfpack_dl_get_numeric(Lp::Ptr{Int64}, Lj::Ptr{Int64}, Lx::Ptr{Cdouble}, Up::Ptr{Int64}, Ui::Ptr{Int64}, Ux::Ptr{Cdouble}, P::Ptr{Int64}, Q::Ptr{Int64}, Dx::Ptr{Cdouble}, do_recip::Ptr{Int64}, Rs::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
-end
-
-function umfpack_zi_get_numeric(Lp, Lj, Lx, Lz, Up, Ui, Ux, Uz, P, Q, Dx, Dz, do_recip, Rs, Numeric)
-    @ccall libumfpack.umfpack_zi_get_numeric(Lp::Ptr{Int32}, Lj::Ptr{Int32}, Lx::Ptr{Cdouble}, Lz::Ptr{Cdouble}, Up::Ptr{Int32}, Ui::Ptr{Int32}, Ux::Ptr{Cdouble}, Uz::Ptr{Cdouble}, P::Ptr{Int32}, Q::Ptr{Int32}, Dx::Ptr{Cdouble}, Dz::Ptr{Cdouble}, do_recip::Ptr{Int32}, Rs::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
-end
-
-function umfpack_zl_get_numeric(Lp, Lj, Lx, Lz, Up, Ui, Ux, Uz, P, Q, Dx, Dz, do_recip, Rs, Numeric)
-    @ccall libumfpack.umfpack_zl_get_numeric(Lp::Ptr{Int64}, Lj::Ptr{Int64}, Lx::Ptr{Cdouble}, Lz::Ptr{Cdouble}, Up::Ptr{Int64}, Ui::Ptr{Int64}, Ux::Ptr{Cdouble}, Uz::Ptr{Cdouble}, P::Ptr{Int64}, Q::Ptr{Int64}, Dx::Ptr{Cdouble}, Dz::Ptr{Cdouble}, do_recip::Ptr{Int64}, Rs::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
-end
-
-function umfpack_di_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol, Front_parent, Front_1strow, Front_leftmostdesc, Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
-    @ccall libumfpack.umfpack_di_get_symbolic(n_row::Ptr{Int32}, n_col::Ptr{Int32}, n1::Ptr{Int32}, nz::Ptr{Int32}, nfr::Ptr{Int32}, nchains::Ptr{Int32}, P::Ptr{Int32}, Q::Ptr{Int32}, Front_npivcol::Ptr{Int32}, Front_parent::Ptr{Int32}, Front_1strow::Ptr{Int32}, Front_leftmostdesc::Ptr{Int32}, Chain_start::Ptr{Int32}, Chain_maxrows::Ptr{Int32}, Chain_maxcols::Ptr{Int32}, Dmap::Ptr{Int32}, Symbolic::Ptr{Cvoid})::Cint
-end
-
-function umfpack_dl_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol, Front_parent, Front_1strow, Front_leftmostdesc, Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
-    @ccall libumfpack.umfpack_dl_get_symbolic(n_row::Ptr{Int64}, n_col::Ptr{Int64}, n1::Ptr{Int64}, nz::Ptr{Int64}, nfr::Ptr{Int64}, nchains::Ptr{Int64}, P::Ptr{Int64}, Q::Ptr{Int64}, Front_npivcol::Ptr{Int64}, Front_parent::Ptr{Int64}, Front_1strow::Ptr{Int64}, Front_leftmostdesc::Ptr{Int64}, Chain_start::Ptr{Int64}, Chain_maxrows::Ptr{Int64}, Chain_maxcols::Ptr{Int64}, Dmap::Ptr{Int64}, Symbolic::Ptr{Cvoid})::Cint
-end
-
-function umfpack_zi_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol, Front_parent, Front_1strow, Front_leftmostdesc, Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
-    @ccall libumfpack.umfpack_zi_get_symbolic(n_row::Ptr{Int32}, n_col::Ptr{Int32}, n1::Ptr{Int32}, nz::Ptr{Int32}, nfr::Ptr{Int32}, nchains::Ptr{Int32}, P::Ptr{Int32}, Q::Ptr{Int32}, Front_npivcol::Ptr{Int32}, Front_parent::Ptr{Int32}, Front_1strow::Ptr{Int32}, Front_leftmostdesc::Ptr{Int32}, Chain_start::Ptr{Int32}, Chain_maxrows::Ptr{Int32}, Chain_maxcols::Ptr{Int32}, Dmap::Ptr{Int32}, Symbolic::Ptr{Cvoid})::Cint
-end
-
-function umfpack_zl_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol, Front_parent, Front_1strow, Front_leftmostdesc, Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
-    @ccall libumfpack.umfpack_zl_get_symbolic(n_row::Ptr{Int64}, n_col::Ptr{Int64}, n1::Ptr{Int64}, nz::Ptr{Int64}, nfr::Ptr{Int64}, nchains::Ptr{Int64}, P::Ptr{Int64}, Q::Ptr{Int64}, Front_npivcol::Ptr{Int64}, Front_parent::Ptr{Int64}, Front_1strow::Ptr{Int64}, Front_leftmostdesc::Ptr{Int64}, Chain_start::Ptr{Int64}, Chain_maxrows::Ptr{Int64}, Chain_maxcols::Ptr{Int64}, Dmap::Ptr{Int64}, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_get_numeric(Lp::Ptr{Int64}, Lj::Ptr{Int64},
+                                             Lx::Ptr{Cdouble}, Up::Ptr{Int64},
+                                             Ui::Ptr{Int64}, Ux::Ptr{Cdouble},
+                                             P::Ptr{Int64}, Q::Ptr{Int64}, Dx::Ptr{Cdouble},
+                                             do_recip::Ptr{Int64}, Rs::Ptr{Cdouble},
+                                             Numeric::Ptr{Cvoid})::Cint
+end
+
+function umfpack_zi_get_numeric(Lp, Lj, Lx, Lz, Up, Ui, Ux, Uz, P, Q, Dx, Dz, do_recip, Rs,
+                                Numeric)
+    @ccall libumfpack.umfpack_zi_get_numeric(Lp::Ptr{Int32}, Lj::Ptr{Int32},
+                                             Lx::Ptr{Cdouble}, Lz::Ptr{Cdouble},
+                                             Up::Ptr{Int32}, Ui::Ptr{Int32},
+                                             Ux::Ptr{Cdouble}, Uz::Ptr{Cdouble},
+                                             P::Ptr{Int32}, Q::Ptr{Int32}, Dx::Ptr{Cdouble},
+                                             Dz::Ptr{Cdouble}, do_recip::Ptr{Int32},
+                                             Rs::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+end
+
+function umfpack_zl_get_numeric(Lp, Lj, Lx, Lz, Up, Ui, Ux, Uz, P, Q, Dx, Dz, do_recip, Rs,
+                                Numeric)
+    @ccall libumfpack.umfpack_zl_get_numeric(Lp::Ptr{Int64}, Lj::Ptr{Int64},
+                                             Lx::Ptr{Cdouble}, Lz::Ptr{Cdouble},
+                                             Up::Ptr{Int64}, Ui::Ptr{Int64},
+                                             Ux::Ptr{Cdouble}, Uz::Ptr{Cdouble},
+                                             P::Ptr{Int64}, Q::Ptr{Int64}, Dx::Ptr{Cdouble},
+                                             Dz::Ptr{Cdouble}, do_recip::Ptr{Int64},
+                                             Rs::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+end
+
+function umfpack_di_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol,
+                                 Front_parent, Front_1strow, Front_leftmostdesc,
+                                 Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
+    @ccall libumfpack.umfpack_di_get_symbolic(n_row::Ptr{Int32}, n_col::Ptr{Int32},
+                                              n1::Ptr{Int32}, nz::Ptr{Int32},
+                                              nfr::Ptr{Int32}, nchains::Ptr{Int32},
+                                              P::Ptr{Int32}, Q::Ptr{Int32},
+                                              Front_npivcol::Ptr{Int32},
+                                              Front_parent::Ptr{Int32},
+                                              Front_1strow::Ptr{Int32},
+                                              Front_leftmostdesc::Ptr{Int32},
+                                              Chain_start::Ptr{Int32},
+                                              Chain_maxrows::Ptr{Int32},
+                                              Chain_maxcols::Ptr{Int32}, Dmap::Ptr{Int32},
+                                              Symbolic::Ptr{Cvoid})::Cint
+end
+
+function umfpack_dl_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol,
+                                 Front_parent, Front_1strow, Front_leftmostdesc,
+                                 Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
+    @ccall libumfpack.umfpack_dl_get_symbolic(n_row::Ptr{Int64}, n_col::Ptr{Int64},
+                                              n1::Ptr{Int64}, nz::Ptr{Int64},
+                                              nfr::Ptr{Int64}, nchains::Ptr{Int64},
+                                              P::Ptr{Int64}, Q::Ptr{Int64},
+                                              Front_npivcol::Ptr{Int64},
+                                              Front_parent::Ptr{Int64},
+                                              Front_1strow::Ptr{Int64},
+                                              Front_leftmostdesc::Ptr{Int64},
+                                              Chain_start::Ptr{Int64},
+                                              Chain_maxrows::Ptr{Int64},
+                                              Chain_maxcols::Ptr{Int64}, Dmap::Ptr{Int64},
+                                              Symbolic::Ptr{Cvoid})::Cint
+end
+
+function umfpack_zi_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol,
+                                 Front_parent, Front_1strow, Front_leftmostdesc,
+                                 Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
+    @ccall libumfpack.umfpack_zi_get_symbolic(n_row::Ptr{Int32}, n_col::Ptr{Int32},
+                                              n1::Ptr{Int32}, nz::Ptr{Int32},
+                                              nfr::Ptr{Int32}, nchains::Ptr{Int32},
+                                              P::Ptr{Int32}, Q::Ptr{Int32},
+                                              Front_npivcol::Ptr{Int32},
+                                              Front_parent::Ptr{Int32},
+                                              Front_1strow::Ptr{Int32},
+                                              Front_leftmostdesc::Ptr{Int32},
+                                              Chain_start::Ptr{Int32},
+                                              Chain_maxrows::Ptr{Int32},
+                                              Chain_maxcols::Ptr{Int32}, Dmap::Ptr{Int32},
+                                              Symbolic::Ptr{Cvoid})::Cint
+end
+
+function umfpack_zl_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol,
+                                 Front_parent, Front_1strow, Front_leftmostdesc,
+                                 Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
+    @ccall libumfpack.umfpack_zl_get_symbolic(n_row::Ptr{Int64}, n_col::Ptr{Int64},
+                                              n1::Ptr{Int64}, nz::Ptr{Int64},
+                                              nfr::Ptr{Int64}, nchains::Ptr{Int64},
+                                              P::Ptr{Int64}, Q::Ptr{Int64},
+                                              Front_npivcol::Ptr{Int64},
+                                              Front_parent::Ptr{Int64},
+                                              Front_1strow::Ptr{Int64},
+                                              Front_leftmostdesc::Ptr{Int64},
+                                              Chain_start::Ptr{Int64},
+                                              Chain_maxrows::Ptr{Int64},
+                                              Chain_maxcols::Ptr{Int64}, Dmap::Ptr{Int64},
+                                              Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_save_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_di_save_numeric(Numeric::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_di_save_numeric(Numeric::Ptr{Cvoid},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_dl_save_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_dl_save_numeric(Numeric::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_dl_save_numeric(Numeric::Ptr{Cvoid},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zi_save_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_zi_save_numeric(Numeric::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zi_save_numeric(Numeric::Ptr{Cvoid},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zl_save_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_zl_save_numeric(Numeric::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zl_save_numeric(Numeric::Ptr{Cvoid},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_di_load_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_di_load_numeric(Numeric::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_di_load_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_dl_load_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_dl_load_numeric(Numeric::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_dl_load_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zi_load_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_zi_load_numeric(Numeric::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zi_load_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zl_load_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_zl_load_numeric(Numeric::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zl_load_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_di_copy_numeric(Numeric, Original)
-    @ccall libumfpack.umfpack_di_copy_numeric(Numeric::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_copy_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_copy_numeric(Numeric, Original)
-    @ccall libumfpack.umfpack_dl_copy_numeric(Numeric::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_copy_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_copy_numeric(Numeric, Original)
-    @ccall libumfpack.umfpack_zi_copy_numeric(Numeric::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_copy_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_copy_numeric(Numeric, Original)
-    @ccall libumfpack.umfpack_zl_copy_numeric(Numeric::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_copy_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_serialize_numeric_size(blobsize, Numeric)
-    @ccall libumfpack.umfpack_di_serialize_numeric_size(blobsize::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_serialize_numeric_size(blobsize::Ptr{Int64},
+                                                        Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_serialize_numeric_size(blobsize, Numeric)
-    @ccall libumfpack.umfpack_dl_serialize_numeric_size(blobsize::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_serialize_numeric_size(blobsize::Ptr{Int64},
+                                                        Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_serialize_numeric_size(blobsize, Numeric)
-    @ccall libumfpack.umfpack_zi_serialize_numeric_size(blobsize::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_serialize_numeric_size(blobsize::Ptr{Int64},
+                                                        Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_serialize_numeric_size(blobsize, Numeric)
-    @ccall libumfpack.umfpack_zl_serialize_numeric_size(blobsize::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_serialize_numeric_size(blobsize::Ptr{Int64},
+                                                        Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_serialize_numeric(blob, blobsize, Numeric)
-    @ccall libumfpack.umfpack_di_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64,
+                                                   Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_serialize_numeric(blob, blobsize, Numeric)
-    @ccall libumfpack.umfpack_dl_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64,
+                                                   Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_serialize_numeric(blob, blobsize, Numeric)
-    @ccall libumfpack.umfpack_zi_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64,
+                                                   Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_serialize_numeric(blob, blobsize, Numeric)
-    @ccall libumfpack.umfpack_zl_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64,
+                                                   Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_deserialize_numeric(Numeric, blob, blobsize)
-    @ccall libumfpack.umfpack_di_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_di_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                                     blob::Ptr{Int8}, blobsize::Int64)::Cint
 end
 
 function umfpack_dl_deserialize_numeric(Numeric, blob, blobsize)
-    @ccall libumfpack.umfpack_dl_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_dl_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                                     blob::Ptr{Int8}, blobsize::Int64)::Cint
 end
 
 function umfpack_zi_deserialize_numeric(Numeric, blob, blobsize)
-    @ccall libumfpack.umfpack_zi_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_zi_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                                     blob::Ptr{Int8}, blobsize::Int64)::Cint
 end
 
 function umfpack_zl_deserialize_numeric(Numeric, blob, blobsize)
-    @ccall libumfpack.umfpack_zl_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_zl_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                                     blob::Ptr{Int8}, blobsize::Int64)::Cint
 end
 
 function umfpack_di_save_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_di_save_symbolic(Symbolic::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_di_save_symbolic(Symbolic::Ptr{Cvoid},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_dl_save_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_dl_save_symbolic(Symbolic::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_dl_save_symbolic(Symbolic::Ptr{Cvoid},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zi_save_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_zi_save_symbolic(Symbolic::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zi_save_symbolic(Symbolic::Ptr{Cvoid},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zl_save_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_zl_save_symbolic(Symbolic::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zl_save_symbolic(Symbolic::Ptr{Cvoid},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_di_load_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_di_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_di_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_dl_load_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_dl_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_dl_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zi_load_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_zi_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zi_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zl_load_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_zl_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zl_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_di_copy_symbolic(Symbolic, Original)
-    @ccall libumfpack.umfpack_di_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_copy_symbolic(Symbolic, Original)
-    @ccall libumfpack.umfpack_dl_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_copy_symbolic(Symbolic, Original)
-    @ccall libumfpack.umfpack_zi_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_copy_symbolic(Symbolic, Original)
-    @ccall libumfpack.umfpack_zl_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_serialize_symbolic_size(blobsize, Symbolic)
-    @ccall libumfpack.umfpack_di_serialize_symbolic_size(blobsize::Ptr{Int64}, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_serialize_symbolic_size(blobsize::Ptr{Int64},
+                                                         Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_serialize_symbolic_size(blobsize, Symbolic)
-    @ccall libumfpack.umfpack_dl_serialize_symbolic_size(blobsize::Ptr{Int64}, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_serialize_symbolic_size(blobsize::Ptr{Int64},
+                                                         Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_serialize_symbolic_size(blobsize, Symbolic)
-    @ccall libumfpack.umfpack_zi_serialize_symbolic_size(blobsize::Ptr{Int64}, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_serialize_symbolic_size(blobsize::Ptr{Int64},
+                                                         Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_serialize_symbolic_size(blobsize, Symbolic)
-    @ccall libumfpack.umfpack_zl_serialize_symbolic_size(blobsize::Ptr{Int64}, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_serialize_symbolic_size(blobsize::Ptr{Int64},
+                                                         Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_serialize_symbolic(blob, blobsize, Symbolic)
-    @ccall libumfpack.umfpack_di_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64,
+                                                    Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_serialize_symbolic(blob, blobsize, Symbolic)
-    @ccall libumfpack.umfpack_dl_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64,
+                                                    Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_serialize_symbolic(blob, blobsize, Symbolic)
-    @ccall libumfpack.umfpack_zi_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64,
+                                                    Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_serialize_symbolic(blob, blobsize, Symbolic)
-    @ccall libumfpack.umfpack_zl_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64,
+                                                    Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_deserialize_symbolic(Symbolic, blob, blobsize)
-    @ccall libumfpack.umfpack_di_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_di_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                                      blob::Ptr{Int8},
+                                                      blobsize::Int64)::Cint
 end
 
 function umfpack_dl_deserialize_symbolic(Symbolic, blob, blobsize)
-    @ccall libumfpack.umfpack_dl_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_dl_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                                      blob::Ptr{Int8},
+                                                      blobsize::Int64)::Cint
 end
 
 function umfpack_zi_deserialize_symbolic(Symbolic, blob, blobsize)
-    @ccall libumfpack.umfpack_zi_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_zi_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                                      blob::Ptr{Int8},
+                                                      blobsize::Int64)::Cint
 end
 
 function umfpack_zl_deserialize_symbolic(Symbolic, blob, blobsize)
-    @ccall libumfpack.umfpack_zl_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_zl_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                                      blob::Ptr{Int8},
+                                                      blobsize::Int64)::Cint
 end
 
 function umfpack_di_get_determinant(Mx, Ex, Numeric, User_Info)
-    @ccall libumfpack.umfpack_di_get_determinant(Mx::Ptr{Cdouble}, Ex::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, User_Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_get_determinant(Mx::Ptr{Cdouble}, Ex::Ptr{Cdouble},
+                                                 Numeric::Ptr{Cvoid},
+                                                 User_Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_get_determinant(Mx, Ex, Numeric, User_Info)
-    @ccall libumfpack.umfpack_dl_get_determinant(Mx::Ptr{Cdouble}, Ex::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, User_Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_get_determinant(Mx::Ptr{Cdouble}, Ex::Ptr{Cdouble},
+                                                 Numeric::Ptr{Cvoid},
+                                                 User_Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_get_determinant(Mx, Mz, Ex, Numeric, User_Info)
-    @ccall libumfpack.umfpack_zi_get_determinant(Mx::Ptr{Cdouble}, Mz::Ptr{Cdouble}, Ex::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, User_Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_get_determinant(Mx::Ptr{Cdouble}, Mz::Ptr{Cdouble},
+                                                 Ex::Ptr{Cdouble}, Numeric::Ptr{Cvoid},
+                                                 User_Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_get_determinant(Mx, Mz, Ex, Numeric, User_Info)
-    @ccall libumfpack.umfpack_zl_get_determinant(Mx::Ptr{Cdouble}, Mz::Ptr{Cdouble}, Ex::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, User_Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_get_determinant(Mx::Ptr{Cdouble}, Mz::Ptr{Cdouble},
+                                                 Ex::Ptr{Cdouble}, Numeric::Ptr{Cvoid},
+                                                 User_Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_report_status(Control, status)
@@ -2256,19 +3038,23 @@ function umfpack_zl_report_status(Control, status)
 end
 
 function umfpack_di_report_info(Control, Info)
-    @ccall libumfpack.umfpack_di_report_info(Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cvoid
+    @ccall libumfpack.umfpack_di_report_info(Control::Ptr{Cdouble},
+                                             Info::Ptr{Cdouble})::Cvoid
 end
 
 function umfpack_dl_report_info(Control, Info)
-    @ccall libumfpack.umfpack_dl_report_info(Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cvoid
+    @ccall libumfpack.umfpack_dl_report_info(Control::Ptr{Cdouble},
+                                             Info::Ptr{Cdouble})::Cvoid
 end
 
 function umfpack_zi_report_info(Control, Info)
-    @ccall libumfpack.umfpack_zi_report_info(Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cvoid
+    @ccall libumfpack.umfpack_zi_report_info(Control::Ptr{Cdouble},
+                                             Info::Ptr{Cdouble})::Cvoid
 end
 
 function umfpack_zl_report_info(Control, Info)
-    @ccall libumfpack.umfpack_zl_report_info(Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cvoid
+    @ccall libumfpack.umfpack_zl_report_info(Control::Ptr{Cdouble},
+                                             Info::Ptr{Cdouble})::Cvoid
 end
 
 function umfpack_di_report_control(Control)
@@ -2288,99 +3074,137 @@ function umfpack_zl_report_control(Control)
 end
 
 function umfpack_di_report_matrix(n_row, n_col, Ap, Ai, Ax, col_form, Control)
-    @ccall libumfpack.umfpack_di_report_matrix(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, col_form::Cint, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_report_matrix(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                               Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                               col_form::Cint, Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_report_matrix(n_row, n_col, Ap, Ai, Ax, col_form, Control)
-    @ccall libumfpack.umfpack_dl_report_matrix(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, col_form::Cint, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_report_matrix(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                               Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                               col_form::Cint, Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_report_matrix(n_row, n_col, Ap, Ai, Ax, Az, col_form, Control)
-    @ccall libumfpack.umfpack_zi_report_matrix(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, col_form::Cint, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_report_matrix(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                               Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                               Az::Ptr{Cdouble}, col_form::Cint,
+                                               Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_report_matrix(n_row, n_col, Ap, Ai, Ax, Az, col_form, Control)
-    @ccall libumfpack.umfpack_zl_report_matrix(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, col_form::Cint, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_report_matrix(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                               Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                               Az::Ptr{Cdouble}, col_form::Cint,
+                                               Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_report_triplet(n_row, n_col, nz, Ti, Tj, Tx, Control)
-    @ccall libumfpack.umfpack_di_report_triplet(n_row::Int32, n_col::Int32, nz::Int32, Ti::Ptr{Int32}, Tj::Ptr{Int32}, Tx::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_report_triplet(n_row::Int32, n_col::Int32, nz::Int32,
+                                                Ti::Ptr{Int32}, Tj::Ptr{Int32},
+                                                Tx::Ptr{Cdouble},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_report_triplet(n_row, n_col, nz, Ti, Tj, Tx, Control)
-    @ccall libumfpack.umfpack_dl_report_triplet(n_row::Int64, n_col::Int64, nz::Int64, Ti::Ptr{Int64}, Tj::Ptr{Int64}, Tx::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_report_triplet(n_row::Int64, n_col::Int64, nz::Int64,
+                                                Ti::Ptr{Int64}, Tj::Ptr{Int64},
+                                                Tx::Ptr{Cdouble},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_report_triplet(n_row, n_col, nz, Ti, Tj, Tx, Tz, Control)
-    @ccall libumfpack.umfpack_zi_report_triplet(n_row::Int32, n_col::Int32, nz::Int32, Ti::Ptr{Int32}, Tj::Ptr{Int32}, Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_report_triplet(n_row::Int32, n_col::Int32, nz::Int32,
+                                                Ti::Ptr{Int32}, Tj::Ptr{Int32},
+                                                Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_report_triplet(n_row, n_col, nz, Ti, Tj, Tx, Tz, Control)
-    @ccall libumfpack.umfpack_zl_report_triplet(n_row::Int64, n_col::Int64, nz::Int64, Ti::Ptr{Int64}, Tj::Ptr{Int64}, Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_report_triplet(n_row::Int64, n_col::Int64, nz::Int64,
+                                                Ti::Ptr{Int64}, Tj::Ptr{Int64},
+                                                Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_report_vector(n, X, Control)
-    @ccall libumfpack.umfpack_di_report_vector(n::Int32, X::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_report_vector(n::Int32, X::Ptr{Cdouble},
+                                               Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_report_vector(n, X, Control)
-    @ccall libumfpack.umfpack_dl_report_vector(n::Int64, X::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_report_vector(n::Int64, X::Ptr{Cdouble},
+                                               Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_report_vector(n, Xx, Xz, Control)
-    @ccall libumfpack.umfpack_zi_report_vector(n::Int32, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_report_vector(n::Int32, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble},
+                                               Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_report_vector(n, Xx, Xz, Control)
-    @ccall libumfpack.umfpack_zl_report_vector(n::Int64, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_report_vector(n::Int64, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble},
+                                               Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_report_symbolic(Symbolic, Control)
-    @ccall libumfpack.umfpack_di_report_symbolic(Symbolic::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_report_symbolic(Symbolic::Ptr{Cvoid},
+                                                 Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_report_symbolic(Symbolic, Control)
-    @ccall libumfpack.umfpack_dl_report_symbolic(Symbolic::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_report_symbolic(Symbolic::Ptr{Cvoid},
+                                                 Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_report_symbolic(Symbolic, Control)
-    @ccall libumfpack.umfpack_zi_report_symbolic(Symbolic::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_report_symbolic(Symbolic::Ptr{Cvoid},
+                                                 Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_report_symbolic(Symbolic, Control)
-    @ccall libumfpack.umfpack_zl_report_symbolic(Symbolic::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_report_symbolic(Symbolic::Ptr{Cvoid},
+                                                 Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_report_numeric(Numeric, Control)
-    @ccall libumfpack.umfpack_di_report_numeric(Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_report_numeric(Numeric::Ptr{Cvoid},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_report_numeric(Numeric, Control)
-    @ccall libumfpack.umfpack_dl_report_numeric(Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_report_numeric(Numeric::Ptr{Cvoid},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_report_numeric(Numeric, Control)
-    @ccall libumfpack.umfpack_zi_report_numeric(Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_report_numeric(Numeric::Ptr{Cvoid},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_report_numeric(Numeric, Control)
-    @ccall libumfpack.umfpack_zl_report_numeric(Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_report_numeric(Numeric::Ptr{Cvoid},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_report_perm(np, Perm, Control)
-    @ccall libumfpack.umfpack_di_report_perm(np::Int32, Perm::Ptr{Int32}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_report_perm(np::Int32, Perm::Ptr{Int32},
+                                             Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_report_perm(np, Perm, Control)
-    @ccall libumfpack.umfpack_dl_report_perm(np::Int64, Perm::Ptr{Int64}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_report_perm(np::Int64, Perm::Ptr{Int64},
+                                             Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_report_perm(np, Perm, Control)
-    @ccall libumfpack.umfpack_zi_report_perm(np::Int32, Perm::Ptr{Int32}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_report_perm(np::Int32, Perm::Ptr{Int32},
+                                             Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_report_perm(np, Perm, Control)
-    @ccall libumfpack.umfpack_zl_report_perm(np::Int64, Perm::Ptr{Int64}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_report_perm(np::Int64, Perm::Ptr{Int64},
+                                             Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_timer()
@@ -2395,13 +3219,13 @@ function umfpack_toc(stats)
     @ccall libumfpack.umfpack_toc(stats::Ptr{Cdouble})::Cvoid
 end
 
-const CHOLMOD_DATE = "Jan 17, 2023"
+const CHOLMOD_DATE = "June 16, 2023"
 
 const CHOLMOD_MAIN_VERSION = 4
 
 const CHOLMOD_SUB_VERSION = 0
 
-const CHOLMOD_SUBSUB_VERSION = 3
+const CHOLMOD_SUBSUB_VERSION = 4
 
 const _FILE_OFFSET_BITS = 64
 
@@ -2427,17 +3251,18 @@ const SUITESPARSE_COMPILER_MSC = 0
 
 const SUITESPARSE_COMPILER_XLC = 0
 
-const SUITESPARSE_DATE = "Jan 20, 2023"
+const SUITESPARSE_DATE = "June 29, 2023"
 
 const SUITESPARSE_MAIN_VERSION = 7
 
-const SUITESPARSE_SUB_VERSION = 0
+const SUITESPARSE_SUB_VERSION = 1
 
-const SUITESPARSE_SUBSUB_VERSION = 1
+const SUITESPARSE_SUBSUB_VERSION = 0
 
 SUITESPARSE_VER_CODE(main, sub) = main * 1000 + sub
 
-const SUITESPARSE_VERSION = SUITESPARSE_VER_CODE(SUITESPARSE_MAIN_VERSION, SUITESPARSE_SUB_VERSION)
+const SUITESPARSE_VERSION = SUITESPARSE_VER_CODE(SUITESPARSE_MAIN_VERSION,
+                                                 SUITESPARSE_SUB_VERSION)
 
 CHOLMOD_VER_CODE(main, sub) = main * 1000 + sub
 
@@ -2601,20 +3426,18 @@ const SPQR_RTX_EQUALS_B = 2
 
 const SPQR_RTX_EQUALS_ETB = 3
 
-const SPQR_DATE = "Jan 17, 2023"
+const SPQR_DATE = "July FIXME, 2023"
 
-const SPQR_MAIN_VERSION = 3
+const SPQR_MAIN_VERSION = 4
 
 const SPQR_SUB_VERSION = 0
 
-const SPQR_SUBSUB_VERSION = 3
+const SPQR_SUBSUB_VERSION = 0
 
 SPQR_VER_CODE(main, sub) = main * 1000 + sub
 
 const SPQR_VERSION = SPQR_VER_CODE(SPQR_MAIN_VERSION, SPQR_SUB_VERSION)
 
-const Complex = Float64
-
 const AMD_CONTROL = 5
 
 const AMD_INFO = 20
@@ -2663,172 +3486,29 @@ const AMD_INVALID = -2
 
 const AMD_OK_BUT_JUMBLED = 1
 
-const AMD_DATE = "Jan 17, 2023"
+const AMD_DATE = "June 16, 2023"
 
 const AMD_MAIN_VERSION = 3
 
 const AMD_SUB_VERSION = 0
 
-const AMD_SUBSUB_VERSION = 3
+const AMD_SUBSUB_VERSION = 4
 
 AMD_VERSION_CODE(main, sub) = main * 1000 + sub
 
 const AMD_VERSION = AMD_VERSION_CODE(AMD_MAIN_VERSION, AMD_SUB_VERSION)
 
-const COLAMD_DATE = "Jan 17, 2023"
-
-const COLAMD_MAIN_VERSION = 3
-
-const COLAMD_SUB_VERSION = 0
-
-const COLAMD_SUBSUB_VERSION = 3
-
-COLAMD_VERSION_CODE(main, sub) = main * 1000 + sub
-
-const COLAMD_VERSION = COLAMD_VERSION_CODE(COLAMD_MAIN_VERSION, COLAMD_SUB_VERSION)
-
-const COLAMD_KNOBS = 20
-
-const COLAMD_STATS = 20
-
-const COLAMD_DENSE_ROW = 0
-
-const COLAMD_DENSE_COL = 1
-
-const COLAMD_AGGRESSIVE = 2
-
-const COLAMD_DEFRAG_COUNT = 2
-
-const COLAMD_STATUS = 3
-
-const COLAMD_INFO1 = 4
-
-const COLAMD_INFO2 = 5
-
-const COLAMD_INFO3 = 6
-
-const COLAMD_OK = 0
-
-const COLAMD_OK_BUT_JUMBLED = 1
-
-const COLAMD_ERROR_A_not_present = -1
-
-const COLAMD_ERROR_p_not_present = -2
-
-const COLAMD_ERROR_nrow_negative = -3
-
-const COLAMD_ERROR_ncol_negative = -4
-
-const COLAMD_ERROR_nnz_negative = -5
-
-const COLAMD_ERROR_p0_nonzero = -6
-
-const COLAMD_ERROR_A_too_small = -7
-
-const COLAMD_ERROR_col_length_negative = -8
-
-const COLAMD_ERROR_row_index_out_of_bounds = -9
-
-const COLAMD_ERROR_out_of_memory = -10
-
-const COLAMD_ERROR_internal_error = -999
-
-const CCOLAMD_DATE = "Jan 17, 2023"
-
-const CCOLAMD_MAIN_VERSION = 3
-
-const CCOLAMD_SUB_VERSION = 0
-
-const CCOLAMD_SUBSUB_VERSION = 3
-
-CCOLAMD_VERSION_CODE(main, sub) = main * 1000 + sub
-
-const CCOLAMD_VERSION = CCOLAMD_VERSION_CODE(CCOLAMD_MAIN_VERSION, CCOLAMD_SUB_VERSION)
-
-const CCOLAMD_KNOBS = 20
-
-const CCOLAMD_STATS = 20
-
-const CCOLAMD_DENSE_ROW = 0
-
-const CCOLAMD_DENSE_COL = 1
-
-const CCOLAMD_AGGRESSIVE = 2
-
-const CCOLAMD_LU = 3
-
-const CCOLAMD_DEFRAG_COUNT = 2
-
-const CCOLAMD_STATUS = 3
-
-const CCOLAMD_INFO1 = 4
-
-const CCOLAMD_INFO2 = 5
-
-const CCOLAMD_INFO3 = 6
-
-const CCOLAMD_EMPTY_ROW = 7
-
-const CCOLAMD_EMPTY_COL = 8
-
-const CCOLAMD_NEWLY_EMPTY_ROW = 9
-
-const CCOLAMD_NEWLY_EMPTY_COL = 10
-
-const CCOLAMD_OK = 0
-
-const CCOLAMD_OK_BUT_JUMBLED = 1
-
-const CCOLAMD_ERROR_A_not_present = -1
-
-const CCOLAMD_ERROR_p_not_present = -2
-
-const CCOLAMD_ERROR_nrow_negative = -3
-
-const CCOLAMD_ERROR_ncol_negative = -4
-
-const CCOLAMD_ERROR_nnz_negative = -5
-
-const CCOLAMD_ERROR_p0_nonzero = -6
-
-const CCOLAMD_ERROR_A_too_small = -7
-
-const CCOLAMD_ERROR_col_length_negative = -8
-
-const CCOLAMD_ERROR_row_index_out_of_bounds = -9
-
-const CCOLAMD_ERROR_out_of_memory = -10
-
-const CCOLAMD_ERROR_invalid_cmember = -11
-
-const CCOLAMD_ERROR_internal_error = -999
-
 const UMFPACK_INFO = 90
 
 const UMFPACK_CONTROL = 20
 
-# Skipping MacroDefinition: UMFPACK_COPYRIGHT \
-#"UMFPACK:  Copyright (c) 2005-2023 by Timothy A. Davis.  All Rights Reserved.\n"
-
-# Skipping MacroDefinition: UMFPACK_LICENSE_PART1 \
-#"\nUMFPACK License: SPDX-License-Identifier: GPL-2.0+\n" \
-#"   UMFPACK is available under alternate licenses,\n" \
-#"   contact T. Davis for details.\n"
-
-const UMFPACK_LICENSE_PART2 = "\n"
-
-# Skipping MacroDefinition: UMFPACK_LICENSE_PART3 \
-#"\n" \
-#"Availability: http://www.suitesparse.com" \
-#"\n"
-
-const UMFPACK_DATE = "Jan 17, 2023"
+const UMFPACK_DATE = "June 16, 2023"
 
 const UMFPACK_MAIN_VERSION = 6
 
 const UMFPACK_SUB_VERSION = 1
 
-const UMFPACK_SUBSUB_VERSION = 0
+const UMFPACK_SUBSUB_VERSION = 1
 
 UMFPACK_VER_CODE(main, sub) = main * 1000 + sub
 
@@ -3169,4 +3849,3 @@ const UMFPACK_Q_Uat = 12
 const UMFPACK_Ut = 13
 
 const UMFPACK_Uat = 14
-
diff --git a/src/solvers/lib/i686-w64-mingw32.jl b/src/solvers/lib/i686-w64-mingw32.jl
index fcf756d2..a5aa4e44 100644
--- a/src/solvers/lib/i686-w64-mingw32.jl
+++ b/src/solvers/lib/i686-w64-mingw32.jl
@@ -1,137 +1,150 @@
 function SuiteSparse_config_printf_func_get()
-    @ccall libcholmod.SuiteSparse_config_printf_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_printf_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_malloc_func_get()
-    @ccall libcholmod.SuiteSparse_config_malloc_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_malloc_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_calloc_func_get()
-    @ccall libcholmod.SuiteSparse_config_calloc_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_calloc_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_realloc_func_get()
-    @ccall libcholmod.SuiteSparse_config_realloc_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_realloc_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_free_func_get()
-    @ccall libcholmod.SuiteSparse_config_free_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_free_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_hypot_func_get()
-    @ccall libcholmod.SuiteSparse_config_hypot_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_hypot_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_divcomplex_func_get()
-    @ccall libcholmod.SuiteSparse_config_divcomplex_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_divcomplex_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_malloc_func_set(malloc_func)
-    @ccall libcholmod.SuiteSparse_config_malloc_func_set(malloc_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_malloc_func_set(malloc_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_calloc_func_set(calloc_func)
-    @ccall libcholmod.SuiteSparse_config_calloc_func_set(calloc_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_calloc_func_set(calloc_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_realloc_func_set(realloc_func)
-    @ccall libcholmod.SuiteSparse_config_realloc_func_set(realloc_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_realloc_func_set(realloc_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_free_func_set(free_func)
-    @ccall libcholmod.SuiteSparse_config_free_func_set(free_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_free_func_set(free_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_printf_func_set(printf_func)
-    @ccall libcholmod.SuiteSparse_config_printf_func_set(printf_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_printf_func_set(printf_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_hypot_func_set(hypot_func)
-    @ccall libcholmod.SuiteSparse_config_hypot_func_set(hypot_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_hypot_func_set(hypot_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_divcomplex_func_set(divcomplex_func)
-    @ccall libcholmod.SuiteSparse_config_divcomplex_func_set(divcomplex_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_divcomplex_func_set(divcomplex_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_malloc(s)
-    @ccall libcholmod.SuiteSparse_config_malloc(s::Csize_t)::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_malloc(s::Csize_t)::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_calloc(n, s)
-    @ccall libcholmod.SuiteSparse_config_calloc(n::Csize_t, s::Csize_t)::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_calloc(n::Csize_t,
+                                                          s::Csize_t)::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_realloc(arg1, s)
-    @ccall libcholmod.SuiteSparse_config_realloc(arg1::Ptr{Cvoid}, s::Csize_t)::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_realloc(arg1::Ptr{Cvoid},
+                                                           s::Csize_t)::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_free(arg1)
-    @ccall libcholmod.SuiteSparse_config_free(arg1::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_free(arg1::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_hypot(x, y)
-    @ccall libcholmod.SuiteSparse_config_hypot(x::Cdouble, y::Cdouble)::Cdouble
+    @ccall libsuitesparseconfig.SuiteSparse_config_hypot(x::Cdouble, y::Cdouble)::Cdouble
 end
 
 function SuiteSparse_config_divcomplex(xr, xi, yr, yi, zr, zi)
-    @ccall libcholmod.SuiteSparse_config_divcomplex(xr::Cdouble, xi::Cdouble, yr::Cdouble, yi::Cdouble, zr::Ptr{Cdouble}, zi::Ptr{Cdouble})::Cint
+    @ccall libsuitesparseconfig.SuiteSparse_config_divcomplex(xr::Cdouble, xi::Cdouble,
+                                                              yr::Cdouble, yi::Cdouble,
+                                                              zr::Ptr{Cdouble},
+                                                              zi::Ptr{Cdouble})::Cint
 end
 
 function SuiteSparse_start()
-    @ccall libcholmod.SuiteSparse_start()::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_start()::Cvoid
 end
 
 function SuiteSparse_finish()
-    @ccall libcholmod.SuiteSparse_finish()::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_finish()::Cvoid
 end
 
 function SuiteSparse_malloc(nitems, size_of_item)
-    @ccall libcholmod.SuiteSparse_malloc(nitems::Csize_t, size_of_item::Csize_t)::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_malloc(nitems::Csize_t,
+                                                   size_of_item::Csize_t)::Ptr{Cvoid}
 end
 
 function SuiteSparse_calloc(nitems, size_of_item)
-    @ccall libcholmod.SuiteSparse_calloc(nitems::Csize_t, size_of_item::Csize_t)::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_calloc(nitems::Csize_t,
+                                                   size_of_item::Csize_t)::Ptr{Cvoid}
 end
 
 function SuiteSparse_realloc(nitems_new, nitems_old, size_of_item, p, ok)
-    @ccall libcholmod.SuiteSparse_realloc(nitems_new::Csize_t, nitems_old::Csize_t, size_of_item::Csize_t, p::Ptr{Cvoid}, ok::Ptr{Cint})::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_realloc(nitems_new::Csize_t,
+                                                    nitems_old::Csize_t,
+                                                    size_of_item::Csize_t, p::Ptr{Cvoid},
+                                                    ok::Ptr{Cint})::Ptr{Cvoid}
 end
 
 function SuiteSparse_free(p)
-    @ccall libcholmod.SuiteSparse_free(p::Ptr{Cvoid})::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_free(p::Ptr{Cvoid})::Ptr{Cvoid}
 end
 
 function SuiteSparse_tic(tic)
-    @ccall libcholmod.SuiteSparse_tic(tic::Ptr{Cdouble})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_tic(tic::Ptr{Cdouble})::Cvoid
 end
 
 function SuiteSparse_toc(tic)
-    @ccall libcholmod.SuiteSparse_toc(tic::Ptr{Cdouble})::Cdouble
+    @ccall libsuitesparseconfig.SuiteSparse_toc(tic::Ptr{Cdouble})::Cdouble
 end
 
 function SuiteSparse_time()
-    @ccall libcholmod.SuiteSparse_time()::Cdouble
+    @ccall libsuitesparseconfig.SuiteSparse_time()::Cdouble
 end
 
 function SuiteSparse_hypot(x, y)
-    @ccall libcholmod.SuiteSparse_hypot(x::Cdouble, y::Cdouble)::Cdouble
+    @ccall libsuitesparseconfig.SuiteSparse_hypot(x::Cdouble, y::Cdouble)::Cdouble
 end
 
 function SuiteSparse_divcomplex(ar, ai, br, bi, cr, ci)
-    @ccall libcholmod.SuiteSparse_divcomplex(ar::Cdouble, ai::Cdouble, br::Cdouble, bi::Cdouble, cr::Ptr{Cdouble}, ci::Ptr{Cdouble})::Cint
+    @ccall libsuitesparseconfig.SuiteSparse_divcomplex(ar::Cdouble, ai::Cdouble,
+                                                       br::Cdouble, bi::Cdouble,
+                                                       cr::Ptr{Cdouble},
+                                                       ci::Ptr{Cdouble})::Cint
 end
 
 function SuiteSparse_version(version)
-    @ccall libcholmod.SuiteSparse_version(version::Ptr{Cint})::Cint
+    @ccall libsuitesparseconfig.SuiteSparse_version(version::Ptr{Cint})::Cint
 end
 
 function SuiteSparse_BLAS_library()
-    @ccall libcholmod.SuiteSparse_BLAS_library()::Ptr{Cchar}
+    @ccall libsuitesparseconfig.SuiteSparse_BLAS_library()::Ptr{Cchar}
 end
 
 function SuiteSparse_BLAS_integer_size()
-    @ccall libcholmod.SuiteSparse_BLAS_integer_size()::Csize_t
+    @ccall libsuitesparseconfig.SuiteSparse_BLAS_integer_size()::Csize_t
 end
 
 struct cholmod_method_struct
@@ -140,16 +153,16 @@ struct cholmod_method_struct
     prune_dense::Cdouble
     prune_dense2::Cdouble
     nd_oksep::Cdouble
-    other_1::NTuple{4, Cdouble}
+    other_1::NTuple{4,Cdouble}
     nd_small::Csize_t
-    other_2::NTuple{4, Csize_t}
+    other_2::NTuple{4,Csize_t}
     aggressive::Cint
     order_for_lu::Cint
     nd_compress::Cint
     nd_camd::Cint
     nd_components::Cint
     ordering::Cint
-    other_3::NTuple{4, Csize_t}
+    other_3::NTuple{4,Csize_t}
 end
 
 mutable struct cholmod_common_struct
@@ -166,8 +179,8 @@ mutable struct cholmod_common_struct
     final_pack::Cint
     final_monotonic::Cint
     final_resymbol::Cint
-    zrelax::NTuple{3, Cdouble}
-    nrelax::NTuple{3, Csize_t}
+    zrelax::NTuple{3,Cdouble}
+    nrelax::NTuple{3,Csize_t}
     prefer_zomplex::Cint
     prefer_upper::Cint
     quick_return_if_not_posdef::Cint
@@ -179,7 +192,7 @@ mutable struct cholmod_common_struct
     nmethods::Cint
     current::Cint
     selected::Cint
-    method::NTuple{10, cholmod_method_struct}
+    method::NTuple{10,cholmod_method_struct}
     postorder::Cint
     default_nesdis::Cint
     metis_memory::Cdouble
@@ -222,7 +235,7 @@ mutable struct cholmod_common_struct
     SPQR_flopcount_bound::Cdouble
     SPQR_tol_used::Cdouble
     SPQR_norm_E_fro::Cdouble
-    SPQR_istat::NTuple{10, Int64}
+    SPQR_istat::NTuple{10,Int64}
     useGPU::Cint
     maxGpuMemBytes::Csize_t
     maxGpuMemFraction::Cdouble
@@ -231,10 +244,10 @@ mutable struct cholmod_common_struct
     gpuFlops::Int64
     gpuNumKernelLaunches::Cint
     cublasHandle::Ptr{Cvoid}
-    gpuStream::NTuple{8, Ptr{Cvoid}}
-    cublasEventPotrf::NTuple{3, Ptr{Cvoid}}
+    gpuStream::NTuple{8,Ptr{Cvoid}}
+    cublasEventPotrf::NTuple{3,Ptr{Cvoid}}
     updateCKernelsComplete::Ptr{Cvoid}
-    updateCBuffersFree::NTuple{8, Ptr{Cvoid}}
+    updateCBuffersFree::NTuple{8,Ptr{Cvoid}}
     dev_mempool::Ptr{Cvoid}
     dev_mempool_size::Csize_t
     host_pinned_mempool::Ptr{Cvoid}
@@ -300,11 +313,14 @@ function cholmod_l_maxrank(arg1, arg2)
 end
 
 function cholmod_allocate_work(nrow, iworksize, xworksize, Common)
-    @ccall libcholmod.cholmod_allocate_work(nrow::Csize_t, iworksize::Csize_t, xworksize::Csize_t, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_allocate_work(nrow::Csize_t, iworksize::Csize_t,
+                                            xworksize::Csize_t,
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_allocate_work(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_allocate_work(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_allocate_work(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t,
+                                              arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_free_work(Common)
@@ -324,11 +340,13 @@ function cholmod_l_clear_flag(arg1)
 end
 
 function cholmod_error(status, file, line, message, Common)
-    @ccall libcholmod.cholmod_error(status::Cint, file::Ptr{Cchar}, line::Cint, message::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_error(status::Cint, file::Ptr{Cchar}, line::Cint,
+                                    message::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_error(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_error(arg1::Cint, arg2::Ptr{Cchar}, arg3::Cint, arg4::Ptr{Cchar}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_error(arg1::Cint, arg2::Ptr{Cchar}, arg3::Cint,
+                                      arg4::Ptr{Cchar}, arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_dbound(dj, Common)
@@ -348,11 +366,14 @@ function cholmod_l_hypot(arg1, arg2)
 end
 
 function cholmod_divcomplex(ar, ai, br, bi, cr, ci)
-    @ccall libcholmod.cholmod_divcomplex(ar::Cdouble, ai::Cdouble, br::Cdouble, bi::Cdouble, cr::Ptr{Cdouble}, ci::Ptr{Cdouble})::Cint
+    @ccall libcholmod.cholmod_divcomplex(ar::Cdouble, ai::Cdouble, br::Cdouble, bi::Cdouble,
+                                         cr::Ptr{Cdouble}, ci::Ptr{Cdouble})::Cint
 end
 
 function cholmod_l_divcomplex(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_divcomplex(arg1::Cdouble, arg2::Cdouble, arg3::Cdouble, arg4::Cdouble, arg5::Ptr{Cdouble}, arg6::Ptr{Cdouble})::Cint
+    @ccall libcholmod.cholmod_l_divcomplex(arg1::Cdouble, arg2::Cdouble, arg3::Cdouble,
+                                           arg4::Cdouble, arg5::Ptr{Cdouble},
+                                           arg6::Ptr{Cdouble})::Cint
 end
 
 mutable struct cholmod_sparse_struct
@@ -384,155 +405,217 @@ end
 const descendantScore = cholmod_descendant_score_t
 
 function cholmod_score_comp(i, j)
-    @ccall libcholmod.cholmod_score_comp(i::Ptr{cholmod_descendant_score_t}, j::Ptr{cholmod_descendant_score_t})::Cint
+    @ccall libcholmod.cholmod_score_comp(i::Ptr{cholmod_descendant_score_t},
+                                         j::Ptr{cholmod_descendant_score_t})::Cint
 end
 
 function cholmod_l_score_comp(i, j)
-    @ccall libcholmod.cholmod_l_score_comp(i::Ptr{cholmod_descendant_score_t}, j::Ptr{cholmod_descendant_score_t})::Cint
+    @ccall libcholmod.cholmod_l_score_comp(i::Ptr{cholmod_descendant_score_t},
+                                           j::Ptr{cholmod_descendant_score_t})::Cint
 end
 
 function cholmod_allocate_sparse(nrow, ncol, nzmax, sorted, packed, stype, xtype, Common)
-    @ccall libcholmod.cholmod_allocate_sparse(nrow::Csize_t, ncol::Csize_t, nzmax::Csize_t, sorted::Cint, packed::Cint, stype::Cint, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_allocate_sparse(nrow::Csize_t, ncol::Csize_t, nzmax::Csize_t,
+                                              sorted::Cint, packed::Cint, stype::Cint,
+                                              xtype::Cint,
+                                              Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_allocate_sparse(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
-    @ccall libcholmod.cholmod_l_allocate_sparse(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t, arg4::Cint, arg5::Cint, arg6::Cint, arg7::Cint, arg8::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_allocate_sparse(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t,
+                                                arg4::Cint, arg5::Cint, arg6::Cint,
+                                                arg7::Cint,
+                                                arg8::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_free_sparse(A, Common)
-    @ccall libcholmod.cholmod_free_sparse(A::Ptr{Ptr{cholmod_sparse}}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_free_sparse(A::Ptr{Ptr{cholmod_sparse}},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_free_sparse(arg1, arg2)
-    @ccall libcholmod.cholmod_l_free_sparse(arg1::Ptr{Ptr{cholmod_sparse}}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_free_sparse(arg1::Ptr{Ptr{cholmod_sparse}},
+                                            arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_reallocate_sparse(nznew, A, Common)
-    @ccall libcholmod.cholmod_reallocate_sparse(nznew::Csize_t, A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_reallocate_sparse(nznew::Csize_t, A::Ptr{cholmod_sparse},
+                                                Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_reallocate_sparse(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_reallocate_sparse(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_reallocate_sparse(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                                  arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_nnz(A, Common)
-    @ccall libcholmod.cholmod_nnz(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_nnz(A::Ptr{cholmod_sparse},
+                                  Common::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_l_nnz(arg1, arg2)
-    @ccall libcholmod.cholmod_l_nnz(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_l_nnz(arg1::Ptr{cholmod_sparse},
+                                    arg2::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_speye(nrow, ncol, xtype, Common)
-    @ccall libcholmod.cholmod_speye(nrow::Csize_t, ncol::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_speye(nrow::Csize_t, ncol::Csize_t, xtype::Cint,
+                                    Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_speye(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_speye(arg1::Csize_t, arg2::Csize_t, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_speye(arg1::Csize_t, arg2::Csize_t, arg3::Cint,
+                                      arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_spzeros(nrow, ncol, nzmax, xtype, Common)
-    @ccall libcholmod.cholmod_spzeros(nrow::Csize_t, ncol::Csize_t, nzmax::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_spzeros(nrow::Csize_t, ncol::Csize_t, nzmax::Csize_t,
+                                      xtype::Cint,
+                                      Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_spzeros(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_spzeros(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t, arg4::Cint, arg5::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_spzeros(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t,
+                                        arg4::Cint,
+                                        arg5::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_transpose(A, values, Common)
-    @ccall libcholmod.cholmod_transpose(A::Ptr{cholmod_sparse}, values::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_transpose(A::Ptr{cholmod_sparse}, values::Cint,
+                                        Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_transpose(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_transpose(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_transpose(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                          arg3::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_transpose_unsym(A, values, Perm, fset, fsize, F, Common)
-    @ccall libcholmod.cholmod_transpose_unsym(A::Ptr{cholmod_sparse}, values::Cint, Perm::Ptr{Int32}, fset::Ptr{Int32}, fsize::Csize_t, F::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_transpose_unsym(A::Ptr{cholmod_sparse}, values::Cint,
+                                              Perm::Ptr{Int32}, fset::Ptr{Int32},
+                                              fsize::Csize_t, F::Ptr{cholmod_sparse},
+                                              Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_transpose_unsym(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_transpose_unsym(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Csize_t, arg6::Ptr{cholmod_sparse}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_transpose_unsym(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                                arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                                arg5::Csize_t, arg6::Ptr{cholmod_sparse},
+                                                arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_transpose_sym(A, values, Perm, F, Common)
-    @ccall libcholmod.cholmod_transpose_sym(A::Ptr{cholmod_sparse}, values::Cint, Perm::Ptr{Int32}, F::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_transpose_sym(A::Ptr{cholmod_sparse}, values::Cint,
+                                            Perm::Ptr{Int32}, F::Ptr{cholmod_sparse},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_transpose_sym(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_transpose_sym(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{Int64}, arg4::Ptr{cholmod_sparse}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_transpose_sym(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                              arg3::Ptr{Int64}, arg4::Ptr{cholmod_sparse},
+                                              arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_ptranspose(A, values, Perm, fset, fsize, Common)
-    @ccall libcholmod.cholmod_ptranspose(A::Ptr{cholmod_sparse}, values::Cint, Perm::Ptr{Int32}, fset::Ptr{Int32}, fsize::Csize_t, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_ptranspose(A::Ptr{cholmod_sparse}, values::Cint,
+                                         Perm::Ptr{Int32}, fset::Ptr{Int32}, fsize::Csize_t,
+                                         Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_ptranspose(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_ptranspose(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Csize_t, arg6::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_ptranspose(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                           arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                           arg5::Csize_t,
+                                           arg6::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_sort(A, Common)
-    @ccall libcholmod.cholmod_sort(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_sort(A::Ptr{cholmod_sparse},
+                                   Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_sort(arg1, arg2)
-    @ccall libcholmod.cholmod_l_sort(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_sort(arg1::Ptr{cholmod_sparse},
+                                     arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_band(A, k1, k2, mode, Common)
-    @ccall libcholmod.cholmod_band(A::Ptr{cholmod_sparse}, k1::Int64, k2::Int64, mode::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_band(A::Ptr{cholmod_sparse}, k1::Int64, k2::Int64, mode::Cint,
+                                   Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_band(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_band(arg1::Ptr{cholmod_sparse}, arg2::Int64, arg3::Int64, arg4::Cint, arg5::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_band(arg1::Ptr{cholmod_sparse}, arg2::Int64, arg3::Int64,
+                                     arg4::Cint,
+                                     arg5::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_band_inplace(k1, k2, mode, A, Common)
-    @ccall libcholmod.cholmod_band_inplace(k1::Int64, k2::Int64, mode::Cint, A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_band_inplace(k1::Int64, k2::Int64, mode::Cint,
+                                           A::Ptr{cholmod_sparse},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_band_inplace(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_band_inplace(arg1::Int64, arg2::Int64, arg3::Cint, arg4::Ptr{cholmod_sparse}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_band_inplace(arg1::Int64, arg2::Int64, arg3::Cint,
+                                             arg4::Ptr{cholmod_sparse},
+                                             arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_aat(A, fset, fsize, mode, Common)
-    @ccall libcholmod.cholmod_aat(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, mode::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_aat(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t,
+                                  mode::Cint,
+                                  Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_aat(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_aat(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Cint, arg5::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_aat(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                    arg3::Csize_t, arg4::Cint,
+                                    arg5::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_copy_sparse(A, Common)
-    @ccall libcholmod.cholmod_copy_sparse(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_copy_sparse(A::Ptr{cholmod_sparse},
+                                          Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_copy_sparse(arg1, arg2)
-    @ccall libcholmod.cholmod_l_copy_sparse(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_copy_sparse(arg1::Ptr{cholmod_sparse},
+                                            arg2::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_copy(A, stype, mode, Common)
-    @ccall libcholmod.cholmod_copy(A::Ptr{cholmod_sparse}, stype::Cint, mode::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_copy(A::Ptr{cholmod_sparse}, stype::Cint, mode::Cint,
+                                   Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_copy(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_copy(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_copy(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Cint,
+                                     arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_add(A, B, alpha, beta, values, sorted, Common)
-    @ccall libcholmod.cholmod_add(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse}, alpha::Ptr{Cdouble}, beta::Ptr{Cdouble}, values::Cint, sorted::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_add(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse},
+                                  alpha::Ptr{Cdouble}, beta::Ptr{Cdouble}, values::Cint,
+                                  sorted::Cint,
+                                  Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_add(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_add(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Ptr{Cdouble}, arg5::Cint, arg6::Cint, arg7::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_add(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse},
+                                    arg3::Ptr{Cdouble}, arg4::Ptr{Cdouble}, arg5::Cint,
+                                    arg6::Cint,
+                                    arg7::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_sparse_xtype(to_xtype, A, Common)
-    @ccall libcholmod.cholmod_sparse_xtype(to_xtype::Cint, A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_sparse_xtype(to_xtype::Cint, A::Ptr{cholmod_sparse},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_sparse_xtype(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_sparse_xtype(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_sparse_xtype(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                             arg3::Ptr{cholmod_common})::Cint
 end
 
 mutable struct cholmod_factor_struct
@@ -572,75 +655,100 @@ end
 const cholmod_factor = cholmod_factor_struct
 
 function cholmod_allocate_factor(n, Common)
-    @ccall libcholmod.cholmod_allocate_factor(n::Csize_t, Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_allocate_factor(n::Csize_t,
+                                              Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_l_allocate_factor(arg1, arg2)
-    @ccall libcholmod.cholmod_l_allocate_factor(arg1::Csize_t, arg2::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_l_allocate_factor(arg1::Csize_t,
+                                                arg2::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_free_factor(L, Common)
-    @ccall libcholmod.cholmod_free_factor(L::Ptr{Ptr{cholmod_factor}}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_free_factor(L::Ptr{Ptr{cholmod_factor}},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_free_factor(arg1, arg2)
-    @ccall libcholmod.cholmod_l_free_factor(arg1::Ptr{Ptr{cholmod_factor}}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_free_factor(arg1::Ptr{Ptr{cholmod_factor}},
+                                            arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_reallocate_factor(nznew, L, Common)
-    @ccall libcholmod.cholmod_reallocate_factor(nznew::Csize_t, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_reallocate_factor(nznew::Csize_t, L::Ptr{cholmod_factor},
+                                                Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_reallocate_factor(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_reallocate_factor(arg1::Csize_t, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_reallocate_factor(arg1::Csize_t, arg2::Ptr{cholmod_factor},
+                                                  arg3::Ptr{cholmod_common})::Cint
 end
 
-function cholmod_change_factor(to_xtype, to_ll, to_super, to_packed, to_monotonic, L, Common)
-    @ccall libcholmod.cholmod_change_factor(to_xtype::Cint, to_ll::Cint, to_super::Cint, to_packed::Cint, to_monotonic::Cint, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+function cholmod_change_factor(to_xtype, to_ll, to_super, to_packed, to_monotonic, L,
+                               Common)
+    @ccall libcholmod.cholmod_change_factor(to_xtype::Cint, to_ll::Cint, to_super::Cint,
+                                            to_packed::Cint, to_monotonic::Cint,
+                                            L::Ptr{cholmod_factor},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_change_factor(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_change_factor(arg1::Cint, arg2::Cint, arg3::Cint, arg4::Cint, arg5::Cint, arg6::Ptr{cholmod_factor}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_change_factor(arg1::Cint, arg2::Cint, arg3::Cint,
+                                              arg4::Cint, arg5::Cint,
+                                              arg6::Ptr{cholmod_factor},
+                                              arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_pack_factor(L, Common)
-    @ccall libcholmod.cholmod_pack_factor(L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_pack_factor(L::Ptr{cholmod_factor},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_pack_factor(arg1, arg2)
-    @ccall libcholmod.cholmod_l_pack_factor(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_pack_factor(arg1::Ptr{cholmod_factor},
+                                            arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_reallocate_column(j, need, L, Common)
-    @ccall libcholmod.cholmod_reallocate_column(j::Csize_t, need::Csize_t, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_reallocate_column(j::Csize_t, need::Csize_t,
+                                                L::Ptr{cholmod_factor},
+                                                Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_reallocate_column(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_reallocate_column(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{cholmod_factor}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_reallocate_column(arg1::Csize_t, arg2::Csize_t,
+                                                  arg3::Ptr{cholmod_factor},
+                                                  arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_factor_to_sparse(L, Common)
-    @ccall libcholmod.cholmod_factor_to_sparse(L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_factor_to_sparse(L::Ptr{cholmod_factor},
+                                               Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_factor_to_sparse(arg1, arg2)
-    @ccall libcholmod.cholmod_l_factor_to_sparse(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_factor_to_sparse(arg1::Ptr{cholmod_factor},
+                                                 arg2::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_copy_factor(L, Common)
-    @ccall libcholmod.cholmod_copy_factor(L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_copy_factor(L::Ptr{cholmod_factor},
+                                          Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_l_copy_factor(arg1, arg2)
-    @ccall libcholmod.cholmod_l_copy_factor(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_l_copy_factor(arg1::Ptr{cholmod_factor},
+                                            arg2::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_factor_xtype(to_xtype, L, Common)
-    @ccall libcholmod.cholmod_factor_xtype(to_xtype::Cint, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_factor_xtype(to_xtype::Cint, L::Ptr{cholmod_factor},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_factor_xtype(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_factor_xtype(arg1::Cint, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_factor_xtype(arg1::Cint, arg2::Ptr{cholmod_factor},
+                                             arg3::Ptr{cholmod_common})::Cint
 end
 
 mutable struct cholmod_dense_struct
@@ -658,91 +766,118 @@ end
 const cholmod_dense = cholmod_dense_struct
 
 function cholmod_allocate_dense(nrow, ncol, d, xtype, Common)
-    @ccall libcholmod.cholmod_allocate_dense(nrow::Csize_t, ncol::Csize_t, d::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_allocate_dense(nrow::Csize_t, ncol::Csize_t, d::Csize_t,
+                                             xtype::Cint,
+                                             Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_allocate_dense(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_allocate_dense(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t, arg4::Cint, arg5::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_allocate_dense(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t,
+                                               arg4::Cint,
+                                               arg5::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_zeros(nrow, ncol, xtype, Common)
-    @ccall libcholmod.cholmod_zeros(nrow::Csize_t, ncol::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_zeros(nrow::Csize_t, ncol::Csize_t, xtype::Cint,
+                                    Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_zeros(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_zeros(arg1::Csize_t, arg2::Csize_t, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_zeros(arg1::Csize_t, arg2::Csize_t, arg3::Cint,
+                                      arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_ones(nrow, ncol, xtype, Common)
-    @ccall libcholmod.cholmod_ones(nrow::Csize_t, ncol::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_ones(nrow::Csize_t, ncol::Csize_t, xtype::Cint,
+                                   Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_ones(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_ones(arg1::Csize_t, arg2::Csize_t, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_ones(arg1::Csize_t, arg2::Csize_t, arg3::Cint,
+                                     arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_eye(nrow, ncol, xtype, Common)
-    @ccall libcholmod.cholmod_eye(nrow::Csize_t, ncol::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_eye(nrow::Csize_t, ncol::Csize_t, xtype::Cint,
+                                  Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_eye(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_eye(arg1::Csize_t, arg2::Csize_t, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_eye(arg1::Csize_t, arg2::Csize_t, arg3::Cint,
+                                    arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_free_dense(X, Common)
-    @ccall libcholmod.cholmod_free_dense(X::Ptr{Ptr{cholmod_dense}}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_free_dense(X::Ptr{Ptr{cholmod_dense}},
+                                         Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_free_dense(arg1, arg2)
-    @ccall libcholmod.cholmod_l_free_dense(arg1::Ptr{Ptr{cholmod_dense}}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_free_dense(arg1::Ptr{Ptr{cholmod_dense}},
+                                           arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_ensure_dense(XHandle, nrow, ncol, d, xtype, Common)
-    @ccall libcholmod.cholmod_ensure_dense(XHandle::Ptr{Ptr{cholmod_dense}}, nrow::Csize_t, ncol::Csize_t, d::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_ensure_dense(XHandle::Ptr{Ptr{cholmod_dense}}, nrow::Csize_t,
+                                           ncol::Csize_t, d::Csize_t, xtype::Cint,
+                                           Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_ensure_dense(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_ensure_dense(arg1::Ptr{Ptr{cholmod_dense}}, arg2::Csize_t, arg3::Csize_t, arg4::Csize_t, arg5::Cint, arg6::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_ensure_dense(arg1::Ptr{Ptr{cholmod_dense}}, arg2::Csize_t,
+                                             arg3::Csize_t, arg4::Csize_t, arg5::Cint,
+                                             arg6::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_sparse_to_dense(A, Common)
-    @ccall libcholmod.cholmod_sparse_to_dense(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_sparse_to_dense(A::Ptr{cholmod_sparse},
+                                              Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_sparse_to_dense(arg1, arg2)
-    @ccall libcholmod.cholmod_l_sparse_to_dense(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_sparse_to_dense(arg1::Ptr{cholmod_sparse},
+                                                arg2::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_dense_to_sparse(X, values, Common)
-    @ccall libcholmod.cholmod_dense_to_sparse(X::Ptr{cholmod_dense}, values::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_dense_to_sparse(X::Ptr{cholmod_dense}, values::Cint,
+                                              Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_dense_to_sparse(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_dense_to_sparse(arg1::Ptr{cholmod_dense}, arg2::Cint, arg3::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_dense_to_sparse(arg1::Ptr{cholmod_dense}, arg2::Cint,
+                                                arg3::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_copy_dense(X, Common)
-    @ccall libcholmod.cholmod_copy_dense(X::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_copy_dense(X::Ptr{cholmod_dense},
+                                         Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_copy_dense(arg1, arg2)
-    @ccall libcholmod.cholmod_l_copy_dense(arg1::Ptr{cholmod_dense}, arg2::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_copy_dense(arg1::Ptr{cholmod_dense},
+                                           arg2::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_copy_dense2(X, Y, Common)
-    @ccall libcholmod.cholmod_copy_dense2(X::Ptr{cholmod_dense}, Y::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_copy_dense2(X::Ptr{cholmod_dense}, Y::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_copy_dense2(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_copy_dense2(arg1::Ptr{cholmod_dense}, arg2::Ptr{cholmod_dense}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_copy_dense2(arg1::Ptr{cholmod_dense},
+                                            arg2::Ptr{cholmod_dense},
+                                            arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_dense_xtype(to_xtype, X, Common)
-    @ccall libcholmod.cholmod_dense_xtype(to_xtype::Cint, X::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_dense_xtype(to_xtype::Cint, X::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_dense_xtype(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_dense_xtype(arg1::Cint, arg2::Ptr{cholmod_dense}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_dense_xtype(arg1::Cint, arg2::Ptr{cholmod_dense},
+                                            arg3::Ptr{cholmod_common})::Cint
 end
 
 mutable struct cholmod_triplet_struct
@@ -764,99 +899,137 @@ end
 const cholmod_triplet = cholmod_triplet_struct
 
 function cholmod_allocate_triplet(nrow, ncol, nzmax, stype, xtype, Common)
-    @ccall libcholmod.cholmod_allocate_triplet(nrow::Csize_t, ncol::Csize_t, nzmax::Csize_t, stype::Cint, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_allocate_triplet(nrow::Csize_t, ncol::Csize_t, nzmax::Csize_t,
+                                               stype::Cint, xtype::Cint,
+                                               Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_l_allocate_triplet(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_allocate_triplet(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t, arg4::Cint, arg5::Cint, arg6::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_l_allocate_triplet(arg1::Csize_t, arg2::Csize_t,
+                                                 arg3::Csize_t, arg4::Cint, arg5::Cint,
+                                                 arg6::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_free_triplet(T, Common)
-    @ccall libcholmod.cholmod_free_triplet(T::Ptr{Ptr{cholmod_triplet}}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_free_triplet(T::Ptr{Ptr{cholmod_triplet}},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_free_triplet(arg1, arg2)
-    @ccall libcholmod.cholmod_l_free_triplet(arg1::Ptr{Ptr{cholmod_triplet}}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_free_triplet(arg1::Ptr{Ptr{cholmod_triplet}},
+                                             arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_reallocate_triplet(nznew, T, Common)
-    @ccall libcholmod.cholmod_reallocate_triplet(nznew::Csize_t, T::Ptr{cholmod_triplet}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_reallocate_triplet(nznew::Csize_t, T::Ptr{cholmod_triplet},
+                                                 Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_reallocate_triplet(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_reallocate_triplet(arg1::Csize_t, arg2::Ptr{cholmod_triplet}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_reallocate_triplet(arg1::Csize_t,
+                                                   arg2::Ptr{cholmod_triplet},
+                                                   arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_sparse_to_triplet(A, Common)
-    @ccall libcholmod.cholmod_sparse_to_triplet(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_sparse_to_triplet(A::Ptr{cholmod_sparse},
+                                                Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_l_sparse_to_triplet(arg1, arg2)
-    @ccall libcholmod.cholmod_l_sparse_to_triplet(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_l_sparse_to_triplet(arg1::Ptr{cholmod_sparse},
+                                                  arg2::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_triplet_to_sparse(T, nzmax, Common)
-    @ccall libcholmod.cholmod_triplet_to_sparse(T::Ptr{cholmod_triplet}, nzmax::Csize_t, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_triplet_to_sparse(T::Ptr{cholmod_triplet}, nzmax::Csize_t,
+                                                Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_triplet_to_sparse(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_triplet_to_sparse(arg1::Ptr{cholmod_triplet}, arg2::Csize_t, arg3::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_triplet_to_sparse(arg1::Ptr{cholmod_triplet}, arg2::Csize_t,
+                                                  arg3::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_copy_triplet(T, Common)
-    @ccall libcholmod.cholmod_copy_triplet(T::Ptr{cholmod_triplet}, Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_copy_triplet(T::Ptr{cholmod_triplet},
+                                           Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_l_copy_triplet(arg1, arg2)
-    @ccall libcholmod.cholmod_l_copy_triplet(arg1::Ptr{cholmod_triplet}, arg2::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_l_copy_triplet(arg1::Ptr{cholmod_triplet},
+                                             arg2::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_triplet_xtype(to_xtype, T, Common)
-    @ccall libcholmod.cholmod_triplet_xtype(to_xtype::Cint, T::Ptr{cholmod_triplet}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_triplet_xtype(to_xtype::Cint, T::Ptr{cholmod_triplet},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_triplet_xtype(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_triplet_xtype(arg1::Cint, arg2::Ptr{cholmod_triplet}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_triplet_xtype(arg1::Cint, arg2::Ptr{cholmod_triplet},
+                                              arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_malloc(n, size, Common)
-    @ccall libcholmod.cholmod_malloc(n::Csize_t, size::Csize_t, Common::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_malloc(n::Csize_t, size::Csize_t,
+                                     Common::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_l_malloc(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_malloc(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_l_malloc(arg1::Csize_t, arg2::Csize_t,
+                                       arg3::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_calloc(n, size, Common)
-    @ccall libcholmod.cholmod_calloc(n::Csize_t, size::Csize_t, Common::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_calloc(n::Csize_t, size::Csize_t,
+                                     Common::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_l_calloc(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_calloc(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_l_calloc(arg1::Csize_t, arg2::Csize_t,
+                                       arg3::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_free(n, size, p, Common)
-    @ccall libcholmod.cholmod_free(n::Csize_t, size::Csize_t, p::Ptr{Cvoid}, Common::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_free(n::Csize_t, size::Csize_t, p::Ptr{Cvoid},
+                                   Common::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_l_free(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_free(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{Cvoid}, arg4::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_l_free(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{Cvoid},
+                                     arg4::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_realloc(nnew, size, p, n, Common)
-    @ccall libcholmod.cholmod_realloc(nnew::Csize_t, size::Csize_t, p::Ptr{Cvoid}, n::Ptr{Csize_t}, Common::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_realloc(nnew::Csize_t, size::Csize_t, p::Ptr{Cvoid},
+                                      n::Ptr{Csize_t},
+                                      Common::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_l_realloc(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_realloc(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{Cvoid}, arg4::Ptr{Csize_t}, arg5::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_l_realloc(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{Cvoid},
+                                        arg4::Ptr{Csize_t},
+                                        arg5::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
-function cholmod_realloc_multiple(nnew, nint, xtype, Iblock, Jblock, Xblock, Zblock, n, Common)
-    @ccall libcholmod.cholmod_realloc_multiple(nnew::Csize_t, nint::Cint, xtype::Cint, Iblock::Ptr{Ptr{Cvoid}}, Jblock::Ptr{Ptr{Cvoid}}, Xblock::Ptr{Ptr{Cvoid}}, Zblock::Ptr{Ptr{Cvoid}}, n::Ptr{Csize_t}, Common::Ptr{cholmod_common})::Cint
+function cholmod_realloc_multiple(nnew, nint, xtype, Iblock, Jblock, Xblock, Zblock, n,
+                                  Common)
+    @ccall libcholmod.cholmod_realloc_multiple(nnew::Csize_t, nint::Cint, xtype::Cint,
+                                               Iblock::Ptr{Ptr{Cvoid}},
+                                               Jblock::Ptr{Ptr{Cvoid}},
+                                               Xblock::Ptr{Ptr{Cvoid}},
+                                               Zblock::Ptr{Ptr{Cvoid}}, n::Ptr{Csize_t},
+                                               Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_realloc_multiple(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
-    @ccall libcholmod.cholmod_l_realloc_multiple(arg1::Csize_t, arg2::Cint, arg3::Cint, arg4::Ptr{Ptr{Cvoid}}, arg5::Ptr{Ptr{Cvoid}}, arg6::Ptr{Ptr{Cvoid}}, arg7::Ptr{Ptr{Cvoid}}, arg8::Ptr{Csize_t}, arg9::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_realloc_multiple(arg1::Csize_t, arg2::Cint, arg3::Cint,
+                                                 arg4::Ptr{Ptr{Cvoid}},
+                                                 arg5::Ptr{Ptr{Cvoid}},
+                                                 arg6::Ptr{Ptr{Cvoid}},
+                                                 arg7::Ptr{Ptr{Cvoid}}, arg8::Ptr{Csize_t},
+                                                 arg9::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_version(version)
@@ -876,11 +1049,13 @@ function cholmod_l_check_common(arg1)
 end
 
 function cholmod_print_common(name, Common)
-    @ccall libcholmod.cholmod_print_common(name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_common(name::Ptr{Cchar},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_common(arg1, arg2)
-    @ccall libcholmod.cholmod_l_print_common(arg1::Ptr{Cchar}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_common(arg1::Ptr{Cchar},
+                                             arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_gpu_stats(arg1)
@@ -892,643 +1067,1047 @@ function cholmod_l_gpu_stats(arg1)
 end
 
 function cholmod_check_sparse(A, Common)
-    @ccall libcholmod.cholmod_check_sparse(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_sparse(A::Ptr{cholmod_sparse},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_sparse(arg1, arg2)
-    @ccall libcholmod.cholmod_l_check_sparse(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_sparse(arg1::Ptr{cholmod_sparse},
+                                             arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_sparse(A, name, Common)
-    @ccall libcholmod.cholmod_print_sparse(A::Ptr{cholmod_sparse}, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_sparse(A::Ptr{cholmod_sparse}, name::Ptr{Cchar},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_sparse(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_print_sparse(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Cchar}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_sparse(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Cchar},
+                                             arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_check_dense(X, Common)
-    @ccall libcholmod.cholmod_check_dense(X::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_dense(X::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_dense(arg1, arg2)
-    @ccall libcholmod.cholmod_l_check_dense(arg1::Ptr{cholmod_dense}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_dense(arg1::Ptr{cholmod_dense},
+                                            arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_dense(X, name, Common)
-    @ccall libcholmod.cholmod_print_dense(X::Ptr{cholmod_dense}, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_dense(X::Ptr{cholmod_dense}, name::Ptr{Cchar},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_dense(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_print_dense(arg1::Ptr{cholmod_dense}, arg2::Ptr{Cchar}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_dense(arg1::Ptr{cholmod_dense}, arg2::Ptr{Cchar},
+                                            arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_check_factor(L, Common)
-    @ccall libcholmod.cholmod_check_factor(L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_factor(L::Ptr{cholmod_factor},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_factor(arg1, arg2)
-    @ccall libcholmod.cholmod_l_check_factor(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_factor(arg1::Ptr{cholmod_factor},
+                                             arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_factor(L, name, Common)
-    @ccall libcholmod.cholmod_print_factor(L::Ptr{cholmod_factor}, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_factor(L::Ptr{cholmod_factor}, name::Ptr{Cchar},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_factor(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_print_factor(arg1::Ptr{cholmod_factor}, arg2::Ptr{Cchar}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_factor(arg1::Ptr{cholmod_factor}, arg2::Ptr{Cchar},
+                                             arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_check_triplet(T, Common)
-    @ccall libcholmod.cholmod_check_triplet(T::Ptr{cholmod_triplet}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_triplet(T::Ptr{cholmod_triplet},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_triplet(arg1, arg2)
-    @ccall libcholmod.cholmod_l_check_triplet(arg1::Ptr{cholmod_triplet}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_triplet(arg1::Ptr{cholmod_triplet},
+                                              arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_triplet(T, name, Common)
-    @ccall libcholmod.cholmod_print_triplet(T::Ptr{cholmod_triplet}, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_triplet(T::Ptr{cholmod_triplet}, name::Ptr{Cchar},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_triplet(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_print_triplet(arg1::Ptr{cholmod_triplet}, arg2::Ptr{Cchar}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_triplet(arg1::Ptr{cholmod_triplet}, arg2::Ptr{Cchar},
+                                              arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_check_subset(Set, len, n, Common)
-    @ccall libcholmod.cholmod_check_subset(Set::Ptr{Int32}, len::Int64, n::Csize_t, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_subset(Set::Ptr{Int32}, len::Int64, n::Csize_t,
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_subset(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_check_subset(arg1::Ptr{Int64}, arg2::Int64, arg3::Csize_t, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_subset(arg1::Ptr{Int64}, arg2::Int64, arg3::Csize_t,
+                                             arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_subset(Set, len, n, name, Common)
-    @ccall libcholmod.cholmod_print_subset(Set::Ptr{Int32}, len::Int64, n::Csize_t, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_subset(Set::Ptr{Int32}, len::Int64, n::Csize_t,
+                                           name::Ptr{Cchar},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_subset(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_print_subset(arg1::Ptr{Int64}, arg2::Int64, arg3::Csize_t, arg4::Ptr{Cchar}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_subset(arg1::Ptr{Int64}, arg2::Int64, arg3::Csize_t,
+                                             arg4::Ptr{Cchar},
+                                             arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_check_perm(Perm, len, n, Common)
-    @ccall libcholmod.cholmod_check_perm(Perm::Ptr{Int32}, len::Csize_t, n::Csize_t, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_perm(Perm::Ptr{Int32}, len::Csize_t, n::Csize_t,
+                                         Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_perm(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_check_perm(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Csize_t, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_perm(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Csize_t,
+                                           arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_perm(Perm, len, n, name, Common)
-    @ccall libcholmod.cholmod_print_perm(Perm::Ptr{Int32}, len::Csize_t, n::Csize_t, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_perm(Perm::Ptr{Int32}, len::Csize_t, n::Csize_t,
+                                         name::Ptr{Cchar},
+                                         Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_perm(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_print_perm(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Csize_t, arg4::Ptr{Cchar}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_perm(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Csize_t,
+                                           arg4::Ptr{Cchar},
+                                           arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_check_parent(Parent, n, Common)
-    @ccall libcholmod.cholmod_check_parent(Parent::Ptr{Int32}, n::Csize_t, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_parent(Parent::Ptr{Int32}, n::Csize_t,
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_parent(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_check_parent(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_parent(arg1::Ptr{Int64}, arg2::Csize_t,
+                                             arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_parent(Parent, n, name, Common)
-    @ccall libcholmod.cholmod_print_parent(Parent::Ptr{Int32}, n::Csize_t, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_parent(Parent::Ptr{Int32}, n::Csize_t, name::Ptr{Cchar},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_parent(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_print_parent(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Ptr{Cchar}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_parent(arg1::Ptr{Int64}, arg2::Csize_t,
+                                             arg3::Ptr{Cchar},
+                                             arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_read_sparse(f, Common)
-    @ccall libcholmod.cholmod_read_sparse(f::Ptr{Libc.FILE}, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_read_sparse(f::Ptr{Libc.FILE},
+                                          Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_read_sparse(arg1, arg2)
-    @ccall libcholmod.cholmod_l_read_sparse(arg1::Ptr{Libc.FILE}, arg2::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_read_sparse(arg1::Ptr{Libc.FILE},
+                                            arg2::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_read_triplet(f, Common)
-    @ccall libcholmod.cholmod_read_triplet(f::Ptr{Libc.FILE}, Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_read_triplet(f::Ptr{Libc.FILE},
+                                           Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_l_read_triplet(arg1, arg2)
-    @ccall libcholmod.cholmod_l_read_triplet(arg1::Ptr{Libc.FILE}, arg2::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_l_read_triplet(arg1::Ptr{Libc.FILE},
+                                             arg2::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_read_dense(f, Common)
-    @ccall libcholmod.cholmod_read_dense(f::Ptr{Libc.FILE}, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_read_dense(f::Ptr{Libc.FILE},
+                                         Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_read_dense(arg1, arg2)
-    @ccall libcholmod.cholmod_l_read_dense(arg1::Ptr{Libc.FILE}, arg2::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_read_dense(arg1::Ptr{Libc.FILE},
+                                           arg2::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_read_matrix(f, prefer, mtype, Common)
-    @ccall libcholmod.cholmod_read_matrix(f::Ptr{Libc.FILE}, prefer::Cint, mtype::Ptr{Cint}, Common::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_read_matrix(f::Ptr{Libc.FILE}, prefer::Cint, mtype::Ptr{Cint},
+                                          Common::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_l_read_matrix(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_read_matrix(arg1::Ptr{Libc.FILE}, arg2::Cint, arg3::Ptr{Cint}, arg4::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_l_read_matrix(arg1::Ptr{Libc.FILE}, arg2::Cint,
+                                            arg3::Ptr{Cint},
+                                            arg4::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_write_sparse(f, A, Z, comments, Common)
-    @ccall libcholmod.cholmod_write_sparse(f::Ptr{Libc.FILE}, A::Ptr{cholmod_sparse}, Z::Ptr{cholmod_sparse}, comments::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_write_sparse(f::Ptr{Libc.FILE}, A::Ptr{cholmod_sparse},
+                                           Z::Ptr{cholmod_sparse}, comments::Ptr{Cchar},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_write_sparse(arg1, arg2, arg3, c, arg5)
-    @ccall libcholmod.cholmod_l_write_sparse(arg1::Ptr{Libc.FILE}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_sparse}, c::Ptr{Cchar}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_write_sparse(arg1::Ptr{Libc.FILE},
+                                             arg2::Ptr{cholmod_sparse},
+                                             arg3::Ptr{cholmod_sparse}, c::Ptr{Cchar},
+                                             arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_write_dense(f, X, comments, Common)
-    @ccall libcholmod.cholmod_write_dense(f::Ptr{Libc.FILE}, X::Ptr{cholmod_dense}, comments::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_write_dense(f::Ptr{Libc.FILE}, X::Ptr{cholmod_dense},
+                                          comments::Ptr{Cchar},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_write_dense(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_write_dense(arg1::Ptr{Libc.FILE}, arg2::Ptr{cholmod_dense}, arg3::Ptr{Cchar}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_write_dense(arg1::Ptr{Libc.FILE}, arg2::Ptr{cholmod_dense},
+                                            arg3::Ptr{Cchar},
+                                            arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_analyze(A, Common)
-    @ccall libcholmod.cholmod_analyze(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_analyze(A::Ptr{cholmod_sparse},
+                                      Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_l_analyze(arg1, arg2)
-    @ccall libcholmod.cholmod_l_analyze(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_l_analyze(arg1::Ptr{cholmod_sparse},
+                                        arg2::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_analyze_p(A, UserPerm, fset, fsize, Common)
-    @ccall libcholmod.cholmod_analyze_p(A::Ptr{cholmod_sparse}, UserPerm::Ptr{Int32}, fset::Ptr{Int32}, fsize::Csize_t, Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_analyze_p(A::Ptr{cholmod_sparse}, UserPerm::Ptr{Int32},
+                                        fset::Ptr{Int32}, fsize::Csize_t,
+                                        Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_l_analyze_p(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_analyze_p(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Ptr{Int64}, arg4::Csize_t, arg5::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_l_analyze_p(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                          arg3::Ptr{Int64}, arg4::Csize_t,
+                                          arg5::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_analyze_p2(for_whom, A, UserPerm, fset, fsize, Common)
-    @ccall libcholmod.cholmod_analyze_p2(for_whom::Cint, A::Ptr{cholmod_sparse}, UserPerm::Ptr{Int32}, fset::Ptr{Int32}, fsize::Csize_t, Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_analyze_p2(for_whom::Cint, A::Ptr{cholmod_sparse},
+                                         UserPerm::Ptr{Int32}, fset::Ptr{Int32},
+                                         fsize::Csize_t,
+                                         Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_l_analyze_p2(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_analyze_p2(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Csize_t, arg6::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_l_analyze_p2(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                           arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                           arg5::Csize_t,
+                                           arg6::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_factorize(A, L, Common)
-    @ccall libcholmod.cholmod_factorize(A::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_factorize(A::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor},
+                                        Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_factorize(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_factorize(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_factorize(arg1::Ptr{cholmod_sparse},
+                                          arg2::Ptr{cholmod_factor},
+                                          arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_factorize_p(A, beta, fset, fsize, L, Common)
-    @ccall libcholmod.cholmod_factorize_p(A::Ptr{cholmod_sparse}, beta::Ptr{Cdouble}, fset::Ptr{Int32}, fsize::Csize_t, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_factorize_p(A::Ptr{cholmod_sparse}, beta::Ptr{Cdouble},
+                                          fset::Ptr{Int32}, fsize::Csize_t,
+                                          L::Ptr{cholmod_factor},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_factorize_p(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_factorize_p(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Cdouble}, arg3::Ptr{Int64}, arg4::Csize_t, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_factorize_p(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Cdouble},
+                                            arg3::Ptr{Int64}, arg4::Csize_t,
+                                            arg5::Ptr{cholmod_factor},
+                                            arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_solve(sys, L, B, Common)
-    @ccall libcholmod.cholmod_solve(sys::Cint, L::Ptr{cholmod_factor}, B::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_solve(sys::Cint, L::Ptr{cholmod_factor},
+                                    B::Ptr{cholmod_dense},
+                                    Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_solve(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_solve(arg1::Cint, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_dense}, arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_solve(arg1::Cint, arg2::Ptr{cholmod_factor},
+                                      arg3::Ptr{cholmod_dense},
+                                      arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_solve2(sys, L, B, Bset, X_Handle, Xset_Handle, Y_Handle, E_Handle, Common)
-    @ccall libcholmod.cholmod_solve2(sys::Cint, L::Ptr{cholmod_factor}, B::Ptr{cholmod_dense}, Bset::Ptr{cholmod_sparse}, X_Handle::Ptr{Ptr{cholmod_dense}}, Xset_Handle::Ptr{Ptr{cholmod_sparse}}, Y_Handle::Ptr{Ptr{cholmod_dense}}, E_Handle::Ptr{Ptr{cholmod_dense}}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_solve2(sys::Cint, L::Ptr{cholmod_factor},
+                                     B::Ptr{cholmod_dense}, Bset::Ptr{cholmod_sparse},
+                                     X_Handle::Ptr{Ptr{cholmod_dense}},
+                                     Xset_Handle::Ptr{Ptr{cholmod_sparse}},
+                                     Y_Handle::Ptr{Ptr{cholmod_dense}},
+                                     E_Handle::Ptr{Ptr{cholmod_dense}},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_solve2(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
-    @ccall libcholmod.cholmod_l_solve2(arg1::Cint, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_dense}, arg4::Ptr{cholmod_sparse}, arg5::Ptr{Ptr{cholmod_dense}}, arg6::Ptr{Ptr{cholmod_sparse}}, arg7::Ptr{Ptr{cholmod_dense}}, arg8::Ptr{Ptr{cholmod_dense}}, arg9::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_solve2(arg1::Cint, arg2::Ptr{cholmod_factor},
+                                       arg3::Ptr{cholmod_dense}, arg4::Ptr{cholmod_sparse},
+                                       arg5::Ptr{Ptr{cholmod_dense}},
+                                       arg6::Ptr{Ptr{cholmod_sparse}},
+                                       arg7::Ptr{Ptr{cholmod_dense}},
+                                       arg8::Ptr{Ptr{cholmod_dense}},
+                                       arg9::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_spsolve(sys, L, B, Common)
-    @ccall libcholmod.cholmod_spsolve(sys::Cint, L::Ptr{cholmod_factor}, B::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_spsolve(sys::Cint, L::Ptr{cholmod_factor},
+                                      B::Ptr{cholmod_sparse},
+                                      Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_spsolve(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_spsolve(arg1::Cint, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_sparse}, arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_spsolve(arg1::Cint, arg2::Ptr{cholmod_factor},
+                                        arg3::Ptr{cholmod_sparse},
+                                        arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_etree(A, Parent, Common)
-    @ccall libcholmod.cholmod_etree(A::Ptr{cholmod_sparse}, Parent::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_etree(A::Ptr{cholmod_sparse}, Parent::Ptr{Int32},
+                                    Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_etree(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_etree(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_etree(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                      arg3::Ptr{cholmod_common})::Cint
 end
 
-function cholmod_rowcolcounts(A, fset, fsize, Parent, Post, RowCount, ColCount, First, Level, Common)
-    @ccall libcholmod.cholmod_rowcolcounts(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, Parent::Ptr{Int32}, Post::Ptr{Int32}, RowCount::Ptr{Int32}, ColCount::Ptr{Int32}, First::Ptr{Int32}, Level::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+function cholmod_rowcolcounts(A, fset, fsize, Parent, Post, RowCount, ColCount, First,
+                              Level, Common)
+    @ccall libcholmod.cholmod_rowcolcounts(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                           fsize::Csize_t, Parent::Ptr{Int32},
+                                           Post::Ptr{Int32}, RowCount::Ptr{Int32},
+                                           ColCount::Ptr{Int32}, First::Ptr{Int32},
+                                           Level::Ptr{Int32},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowcolcounts(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)
-    @ccall libcholmod.cholmod_l_rowcolcounts(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{Int64}, arg6::Ptr{Int64}, arg7::Ptr{Int64}, arg8::Ptr{Int64}, arg9::Ptr{Int64}, arg10::Ptr{cholmod_common})::Cint
-end
-
-function cholmod_analyze_ordering(A, ordering, Perm, fset, fsize, Parent, Post, ColCount, First, Level, Common)
-    @ccall libcholmod.cholmod_analyze_ordering(A::Ptr{cholmod_sparse}, ordering::Cint, Perm::Ptr{Int32}, fset::Ptr{Int32}, fsize::Csize_t, Parent::Ptr{Int32}, Post::Ptr{Int32}, ColCount::Ptr{Int32}, First::Ptr{Int32}, Level::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
-end
-
-function cholmod_l_analyze_ordering(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11)
-    @ccall libcholmod.cholmod_l_analyze_ordering(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Csize_t, arg6::Ptr{Int64}, arg7::Ptr{Int64}, arg8::Ptr{Int64}, arg9::Ptr{Int64}, arg10::Ptr{Int64}, arg11::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowcolcounts(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                             arg3::Csize_t, arg4::Ptr{Int64},
+                                             arg5::Ptr{Int64}, arg6::Ptr{Int64},
+                                             arg7::Ptr{Int64}, arg8::Ptr{Int64},
+                                             arg9::Ptr{Int64},
+                                             arg10::Ptr{cholmod_common})::Cint
+end
+
+function cholmod_analyze_ordering(A, ordering, Perm, fset, fsize, Parent, Post, ColCount,
+                                  First, Level, Common)
+    @ccall libcholmod.cholmod_analyze_ordering(A::Ptr{cholmod_sparse}, ordering::Cint,
+                                               Perm::Ptr{Int32}, fset::Ptr{Int32},
+                                               fsize::Csize_t, Parent::Ptr{Int32},
+                                               Post::Ptr{Int32}, ColCount::Ptr{Int32},
+                                               First::Ptr{Int32}, Level::Ptr{Int32},
+                                               Common::Ptr{cholmod_common})::Cint
+end
+
+function cholmod_l_analyze_ordering(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9,
+                                    arg10, arg11)
+    @ccall libcholmod.cholmod_l_analyze_ordering(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                                 arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                                 arg5::Csize_t, arg6::Ptr{Int64},
+                                                 arg7::Ptr{Int64}, arg8::Ptr{Int64},
+                                                 arg9::Ptr{Int64}, arg10::Ptr{Int64},
+                                                 arg11::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_amd(A, fset, fsize, Perm, Common)
-    @ccall libcholmod.cholmod_amd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_amd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t,
+                                  Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_amd(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_amd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_amd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                    arg3::Csize_t, arg4::Ptr{Int64},
+                                    arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_colamd(A, fset, fsize, postorder, Perm, Common)
-    @ccall libcholmod.cholmod_colamd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, postorder::Cint, Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_colamd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                     fsize::Csize_t, postorder::Cint, Perm::Ptr{Int32},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_colamd(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_colamd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Cint, arg5::Ptr{Int64}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_colamd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                       arg3::Csize_t, arg4::Cint, arg5::Ptr{Int64},
+                                       arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowfac(A, F, beta, kstart, kend, L, Common)
-    @ccall libcholmod.cholmod_rowfac(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, beta::Ptr{Cdouble}, kstart::Csize_t, kend::Csize_t, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowfac(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse},
+                                     beta::Ptr{Cdouble}, kstart::Csize_t, kend::Csize_t,
+                                     L::Ptr{cholmod_factor},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowfac(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_rowfac(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Csize_t, arg5::Csize_t, arg6::Ptr{cholmod_factor}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowfac(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse},
+                                       arg3::Ptr{Cdouble}, arg4::Csize_t, arg5::Csize_t,
+                                       arg6::Ptr{cholmod_factor},
+                                       arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowfac_mask(A, F, beta, kstart, kend, mask, RLinkUp, L, Common)
-    @ccall libcholmod.cholmod_rowfac_mask(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, beta::Ptr{Cdouble}, kstart::Csize_t, kend::Csize_t, mask::Ptr{Int32}, RLinkUp::Ptr{Int32}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowfac_mask(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse},
+                                          beta::Ptr{Cdouble}, kstart::Csize_t,
+                                          kend::Csize_t, mask::Ptr{Int32},
+                                          RLinkUp::Ptr{Int32}, L::Ptr{cholmod_factor},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowfac_mask(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
-    @ccall libcholmod.cholmod_l_rowfac_mask(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Csize_t, arg5::Csize_t, arg6::Ptr{Int64}, arg7::Ptr{Int64}, arg8::Ptr{cholmod_factor}, arg9::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowfac_mask(arg1::Ptr{cholmod_sparse},
+                                            arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble},
+                                            arg4::Csize_t, arg5::Csize_t, arg6::Ptr{Int64},
+                                            arg7::Ptr{Int64}, arg8::Ptr{cholmod_factor},
+                                            arg9::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowfac_mask2(A, F, beta, kstart, kend, mask, maskmark, RLinkUp, L, Common)
-    @ccall libcholmod.cholmod_rowfac_mask2(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, beta::Ptr{Cdouble}, kstart::Csize_t, kend::Csize_t, mask::Ptr{Int32}, maskmark::Int32, RLinkUp::Ptr{Int32}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowfac_mask2(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse},
+                                           beta::Ptr{Cdouble}, kstart::Csize_t,
+                                           kend::Csize_t, mask::Ptr{Int32}, maskmark::Int32,
+                                           RLinkUp::Ptr{Int32}, L::Ptr{cholmod_factor},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowfac_mask2(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)
-    @ccall libcholmod.cholmod_l_rowfac_mask2(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Csize_t, arg5::Csize_t, arg6::Ptr{Int64}, arg7::Int64, arg8::Ptr{Int64}, arg9::Ptr{cholmod_factor}, arg10::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowfac_mask2(arg1::Ptr{cholmod_sparse},
+                                             arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble},
+                                             arg4::Csize_t, arg5::Csize_t, arg6::Ptr{Int64},
+                                             arg7::Int64, arg8::Ptr{Int64},
+                                             arg9::Ptr{cholmod_factor},
+                                             arg10::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_row_subtree(A, F, k, Parent, R, Common)
-    @ccall libcholmod.cholmod_row_subtree(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, k::Csize_t, Parent::Ptr{Int32}, R::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_row_subtree(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse},
+                                          k::Csize_t, Parent::Ptr{Int32},
+                                          R::Ptr{cholmod_sparse},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_row_subtree(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_row_subtree(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{cholmod_sparse}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_row_subtree(arg1::Ptr{cholmod_sparse},
+                                            arg2::Ptr{cholmod_sparse}, arg3::Csize_t,
+                                            arg4::Ptr{Int64}, arg5::Ptr{cholmod_sparse},
+                                            arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_lsolve_pattern(B, L, X, Common)
-    @ccall libcholmod.cholmod_lsolve_pattern(B::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_lsolve_pattern(B::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor},
+                                             X::Ptr{cholmod_sparse},
+                                             Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_lsolve_pattern(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_lsolve_pattern(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_sparse}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_lsolve_pattern(arg1::Ptr{cholmod_sparse},
+                                               arg2::Ptr{cholmod_factor},
+                                               arg3::Ptr{cholmod_sparse},
+                                               arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_row_lsubtree(A, Fi, fnz, k, L, R, Common)
-    @ccall libcholmod.cholmod_row_lsubtree(A::Ptr{cholmod_sparse}, Fi::Ptr{Int32}, fnz::Csize_t, k::Csize_t, L::Ptr{cholmod_factor}, R::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_row_lsubtree(A::Ptr{cholmod_sparse}, Fi::Ptr{Int32},
+                                           fnz::Csize_t, k::Csize_t, L::Ptr{cholmod_factor},
+                                           R::Ptr{cholmod_sparse},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_row_lsubtree(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_row_lsubtree(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Csize_t, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_sparse}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_row_lsubtree(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                             arg3::Csize_t, arg4::Csize_t,
+                                             arg5::Ptr{cholmod_factor},
+                                             arg6::Ptr{cholmod_sparse},
+                                             arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_resymbol(A, fset, fsize, pack, L, Common)
-    @ccall libcholmod.cholmod_resymbol(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, pack::Cint, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_resymbol(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                       fsize::Csize_t, pack::Cint, L::Ptr{cholmod_factor},
+                                       Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_resymbol(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_resymbol(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Cint, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_resymbol(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                         arg3::Csize_t, arg4::Cint,
+                                         arg5::Ptr{cholmod_factor},
+                                         arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_resymbol_noperm(A, fset, fsize, pack, L, Common)
-    @ccall libcholmod.cholmod_resymbol_noperm(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, pack::Cint, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_resymbol_noperm(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                              fsize::Csize_t, pack::Cint,
+                                              L::Ptr{cholmod_factor},
+                                              Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_resymbol_noperm(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_resymbol_noperm(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Cint, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_resymbol_noperm(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                                arg3::Csize_t, arg4::Cint,
+                                                arg5::Ptr{cholmod_factor},
+                                                arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rcond(L, Common)
-    @ccall libcholmod.cholmod_rcond(L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cdouble
+    @ccall libcholmod.cholmod_rcond(L::Ptr{cholmod_factor},
+                                    Common::Ptr{cholmod_common})::Cdouble
 end
 
 function cholmod_l_rcond(arg1, arg2)
-    @ccall libcholmod.cholmod_l_rcond(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_common})::Cdouble
+    @ccall libcholmod.cholmod_l_rcond(arg1::Ptr{cholmod_factor},
+                                      arg2::Ptr{cholmod_common})::Cdouble
 end
 
 function cholmod_postorder(Parent, n, Weight_p, Post, Common)
-    @ccall libcholmod.cholmod_postorder(Parent::Ptr{Int32}, n::Csize_t, Weight_p::Ptr{Int32}, Post::Ptr{Int32}, Common::Ptr{cholmod_common})::Int32
+    @ccall libcholmod.cholmod_postorder(Parent::Ptr{Int32}, n::Csize_t,
+                                        Weight_p::Ptr{Int32}, Post::Ptr{Int32},
+                                        Common::Ptr{cholmod_common})::Int32
 end
 
 function cholmod_l_postorder(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_postorder(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_l_postorder(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Ptr{Int64},
+                                          arg4::Ptr{Int64},
+                                          arg5::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_drop(tol, A, Common)
-    @ccall libcholmod.cholmod_drop(tol::Cdouble, A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_drop(tol::Cdouble, A::Ptr{cholmod_sparse},
+                                   Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_drop(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_drop(arg1::Cdouble, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_drop(arg1::Cdouble, arg2::Ptr{cholmod_sparse},
+                                     arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_norm_dense(X, norm, Common)
-    @ccall libcholmod.cholmod_norm_dense(X::Ptr{cholmod_dense}, norm::Cint, Common::Ptr{cholmod_common})::Cdouble
+    @ccall libcholmod.cholmod_norm_dense(X::Ptr{cholmod_dense}, norm::Cint,
+                                         Common::Ptr{cholmod_common})::Cdouble
 end
 
 function cholmod_l_norm_dense(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_norm_dense(arg1::Ptr{cholmod_dense}, arg2::Cint, arg3::Ptr{cholmod_common})::Cdouble
+    @ccall libcholmod.cholmod_l_norm_dense(arg1::Ptr{cholmod_dense}, arg2::Cint,
+                                           arg3::Ptr{cholmod_common})::Cdouble
 end
 
 function cholmod_norm_sparse(A, norm, Common)
-    @ccall libcholmod.cholmod_norm_sparse(A::Ptr{cholmod_sparse}, norm::Cint, Common::Ptr{cholmod_common})::Cdouble
+    @ccall libcholmod.cholmod_norm_sparse(A::Ptr{cholmod_sparse}, norm::Cint,
+                                          Common::Ptr{cholmod_common})::Cdouble
 end
 
 function cholmod_l_norm_sparse(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_norm_sparse(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{cholmod_common})::Cdouble
+    @ccall libcholmod.cholmod_l_norm_sparse(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                            arg3::Ptr{cholmod_common})::Cdouble
 end
 
 function cholmod_horzcat(A, B, values, Common)
-    @ccall libcholmod.cholmod_horzcat(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse}, values::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_horzcat(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse},
+                                      values::Cint,
+                                      Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_horzcat(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_horzcat(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_horzcat(arg1::Ptr{cholmod_sparse},
+                                        arg2::Ptr{cholmod_sparse}, arg3::Cint,
+                                        arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_scale(S, scale, A, Common)
-    @ccall libcholmod.cholmod_scale(S::Ptr{cholmod_dense}, scale::Cint, A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_scale(S::Ptr{cholmod_dense}, scale::Cint,
+                                    A::Ptr{cholmod_sparse},
+                                    Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_scale(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_scale(arg1::Ptr{cholmod_dense}, arg2::Cint, arg3::Ptr{cholmod_sparse}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_scale(arg1::Ptr{cholmod_dense}, arg2::Cint,
+                                      arg3::Ptr{cholmod_sparse},
+                                      arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_sdmult(A, transpose, alpha, beta, X, Y, Common)
-    @ccall libcholmod.cholmod_sdmult(A::Ptr{cholmod_sparse}, transpose::Cint, alpha::Ptr{Cdouble}, beta::Ptr{Cdouble}, X::Ptr{cholmod_dense}, Y::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_sdmult(A::Ptr{cholmod_sparse}, transpose::Cint,
+                                     alpha::Ptr{Cdouble}, beta::Ptr{Cdouble},
+                                     X::Ptr{cholmod_dense}, Y::Ptr{cholmod_dense},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_sdmult(arg1, arg2, arg3, arg4, arg5, Y, arg7)
-    @ccall libcholmod.cholmod_l_sdmult(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{Cdouble}, arg4::Ptr{Cdouble}, arg5::Ptr{cholmod_dense}, Y::Ptr{cholmod_dense}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_sdmult(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                       arg3::Ptr{Cdouble}, arg4::Ptr{Cdouble},
+                                       arg5::Ptr{cholmod_dense}, Y::Ptr{cholmod_dense},
+                                       arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_ssmult(A, B, stype, values, sorted, Common)
-    @ccall libcholmod.cholmod_ssmult(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse}, stype::Cint, values::Cint, sorted::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_ssmult(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse},
+                                     stype::Cint, values::Cint, sorted::Cint,
+                                     Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_ssmult(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_ssmult(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Cint, arg4::Cint, arg5::Cint, arg6::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_ssmult(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse},
+                                       arg3::Cint, arg4::Cint, arg5::Cint,
+                                       arg6::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_submatrix(A, rset, rsize, cset, csize, values, sorted, Common)
-    @ccall libcholmod.cholmod_submatrix(A::Ptr{cholmod_sparse}, rset::Ptr{Int32}, rsize::Int64, cset::Ptr{Int32}, csize::Int64, values::Cint, sorted::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_submatrix(A::Ptr{cholmod_sparse}, rset::Ptr{Int32},
+                                        rsize::Int64, cset::Ptr{Int32}, csize::Int64,
+                                        values::Cint, sorted::Cint,
+                                        Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_submatrix(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
-    @ccall libcholmod.cholmod_l_submatrix(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Int64, arg4::Ptr{Int64}, arg5::Int64, arg6::Cint, arg7::Cint, arg8::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_submatrix(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                          arg3::Int64, arg4::Ptr{Int64}, arg5::Int64,
+                                          arg6::Cint, arg7::Cint,
+                                          arg8::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_vertcat(A, B, values, Common)
-    @ccall libcholmod.cholmod_vertcat(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse}, values::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_vertcat(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse},
+                                      values::Cint,
+                                      Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_vertcat(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_vertcat(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_vertcat(arg1::Ptr{cholmod_sparse},
+                                        arg2::Ptr{cholmod_sparse}, arg3::Cint,
+                                        arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_symmetry(A, option, xmatched, pmatched, nzoffdiag, nzdiag, Common)
-    @ccall libcholmod.cholmod_symmetry(A::Ptr{cholmod_sparse}, option::Cint, xmatched::Ptr{Int32}, pmatched::Ptr{Int32}, nzoffdiag::Ptr{Int32}, nzdiag::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_symmetry(A::Ptr{cholmod_sparse}, option::Cint,
+                                       xmatched::Ptr{Int32}, pmatched::Ptr{Int32},
+                                       nzoffdiag::Ptr{Int32}, nzdiag::Ptr{Int32},
+                                       Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_symmetry(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_symmetry(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Ptr{Int64}, arg6::Ptr{Int64}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_symmetry(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                         arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                         arg5::Ptr{Int64}, arg6::Ptr{Int64},
+                                         arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_updown(update, C, L, Common)
-    @ccall libcholmod.cholmod_updown(update::Cint, C::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_updown(update::Cint, C::Ptr{cholmod_sparse},
+                                     L::Ptr{cholmod_factor},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_updown(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_updown(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_factor}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_updown(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                       arg3::Ptr{cholmod_factor},
+                                       arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_updown_solve(update, C, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_updown_solve(update::Cint, C::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_updown_solve(update::Cint, C::Ptr{cholmod_sparse},
+                                           L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense},
+                                           DeltaB::Ptr{cholmod_dense},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_updown_solve(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_updown_solve(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_factor}, arg4::Ptr{cholmod_dense}, arg5::Ptr{cholmod_dense}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_updown_solve(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                             arg3::Ptr{cholmod_factor},
+                                             arg4::Ptr{cholmod_dense},
+                                             arg5::Ptr{cholmod_dense},
+                                             arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_updown_mark(update, C, colmark, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_updown_mark(update::Cint, C::Ptr{cholmod_sparse}, colmark::Ptr{Int32}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_updown_mark(update::Cint, C::Ptr{cholmod_sparse},
+                                          colmark::Ptr{Int32}, L::Ptr{cholmod_factor},
+                                          X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_updown_mark(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_updown_mark(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Int64}, arg4::Ptr{cholmod_factor}, arg5::Ptr{cholmod_dense}, arg6::Ptr{cholmod_dense}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_updown_mark(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                            arg3::Ptr{Int64}, arg4::Ptr{cholmod_factor},
+                                            arg5::Ptr{cholmod_dense},
+                                            arg6::Ptr{cholmod_dense},
+                                            arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_updown_mask(update, C, colmark, mask, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_updown_mask(update::Cint, C::Ptr{cholmod_sparse}, colmark::Ptr{Int32}, mask::Ptr{Int32}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_updown_mask(update::Cint, C::Ptr{cholmod_sparse},
+                                          colmark::Ptr{Int32}, mask::Ptr{Int32},
+                                          L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense},
+                                          DeltaB::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_updown_mask(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
-    @ccall libcholmod.cholmod_l_updown_mask(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_dense}, arg7::Ptr{cholmod_dense}, arg8::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_updown_mask(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                            arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                            arg5::Ptr{cholmod_factor},
+                                            arg6::Ptr{cholmod_dense},
+                                            arg7::Ptr{cholmod_dense},
+                                            arg8::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_updown_mask2(update, C, colmark, mask, maskmark, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_updown_mask2(update::Cint, C::Ptr{cholmod_sparse}, colmark::Ptr{Int32}, mask::Ptr{Int32}, maskmark::Int32, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_updown_mask2(update::Cint, C::Ptr{cholmod_sparse},
+                                           colmark::Ptr{Int32}, mask::Ptr{Int32},
+                                           maskmark::Int32, L::Ptr{cholmod_factor},
+                                           X::Ptr{cholmod_dense},
+                                           DeltaB::Ptr{cholmod_dense},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_updown_mask2(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
-    @ccall libcholmod.cholmod_l_updown_mask2(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Int64, arg6::Ptr{cholmod_factor}, arg7::Ptr{cholmod_dense}, arg8::Ptr{cholmod_dense}, arg9::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_updown_mask2(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                             arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                             arg5::Int64, arg6::Ptr{cholmod_factor},
+                                             arg7::Ptr{cholmod_dense},
+                                             arg8::Ptr{cholmod_dense},
+                                             arg9::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowadd(k, R, L, Common)
-    @ccall libcholmod.cholmod_rowadd(k::Csize_t, R::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowadd(k::Csize_t, R::Ptr{cholmod_sparse},
+                                     L::Ptr{cholmod_factor},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowadd(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_rowadd(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_factor}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowadd(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                       arg3::Ptr{cholmod_factor},
+                                       arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowadd_solve(k, R, bk, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_rowadd_solve(k::Csize_t, R::Ptr{cholmod_sparse}, bk::Ptr{Cdouble}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowadd_solve(k::Csize_t, R::Ptr{cholmod_sparse},
+                                           bk::Ptr{Cdouble}, L::Ptr{cholmod_factor},
+                                           X::Ptr{cholmod_dense},
+                                           DeltaB::Ptr{cholmod_dense},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowadd_solve(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_rowadd_solve(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Ptr{cholmod_factor}, arg5::Ptr{cholmod_dense}, arg6::Ptr{cholmod_dense}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowadd_solve(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                             arg3::Ptr{Cdouble}, arg4::Ptr{cholmod_factor},
+                                             arg5::Ptr{cholmod_dense},
+                                             arg6::Ptr{cholmod_dense},
+                                             arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowadd_mark(k, R, bk, colmark, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_rowadd_mark(k::Csize_t, R::Ptr{cholmod_sparse}, bk::Ptr{Cdouble}, colmark::Ptr{Int32}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowadd_mark(k::Csize_t, R::Ptr{cholmod_sparse},
+                                          bk::Ptr{Cdouble}, colmark::Ptr{Int32},
+                                          L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense},
+                                          DeltaB::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowadd_mark(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
-    @ccall libcholmod.cholmod_l_rowadd_mark(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Ptr{Int64}, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_dense}, arg7::Ptr{cholmod_dense}, arg8::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowadd_mark(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                            arg3::Ptr{Cdouble}, arg4::Ptr{Int64},
+                                            arg5::Ptr{cholmod_factor},
+                                            arg6::Ptr{cholmod_dense},
+                                            arg7::Ptr{cholmod_dense},
+                                            arg8::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowdel(k, R, L, Common)
-    @ccall libcholmod.cholmod_rowdel(k::Csize_t, R::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowdel(k::Csize_t, R::Ptr{cholmod_sparse},
+                                     L::Ptr{cholmod_factor},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowdel(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_rowdel(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_factor}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowdel(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                       arg3::Ptr{cholmod_factor},
+                                       arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowdel_solve(k, R, yk, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_rowdel_solve(k::Csize_t, R::Ptr{cholmod_sparse}, yk::Ptr{Cdouble}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowdel_solve(k::Csize_t, R::Ptr{cholmod_sparse},
+                                           yk::Ptr{Cdouble}, L::Ptr{cholmod_factor},
+                                           X::Ptr{cholmod_dense},
+                                           DeltaB::Ptr{cholmod_dense},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowdel_solve(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_rowdel_solve(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Ptr{cholmod_factor}, arg5::Ptr{cholmod_dense}, arg6::Ptr{cholmod_dense}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowdel_solve(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                             arg3::Ptr{Cdouble}, arg4::Ptr{cholmod_factor},
+                                             arg5::Ptr{cholmod_dense},
+                                             arg6::Ptr{cholmod_dense},
+                                             arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowdel_mark(k, R, yk, colmark, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_rowdel_mark(k::Csize_t, R::Ptr{cholmod_sparse}, yk::Ptr{Cdouble}, colmark::Ptr{Int32}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowdel_mark(k::Csize_t, R::Ptr{cholmod_sparse},
+                                          yk::Ptr{Cdouble}, colmark::Ptr{Int32},
+                                          L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense},
+                                          DeltaB::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowdel_mark(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
-    @ccall libcholmod.cholmod_l_rowdel_mark(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Ptr{Int64}, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_dense}, arg7::Ptr{cholmod_dense}, arg8::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowdel_mark(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                            arg3::Ptr{Cdouble}, arg4::Ptr{Int64},
+                                            arg5::Ptr{cholmod_factor},
+                                            arg6::Ptr{cholmod_dense},
+                                            arg7::Ptr{cholmod_dense},
+                                            arg8::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_ccolamd(A, fset, fsize, Cmember, Perm, Common)
-    @ccall libcholmod.cholmod_ccolamd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, Cmember::Ptr{Int32}, Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_ccolamd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                      fsize::Csize_t, Cmember::Ptr{Int32}, Perm::Ptr{Int32},
+                                      Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_ccolamd(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_ccolamd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{Int64}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_ccolamd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                        arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{Int64},
+                                        arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_csymamd(A, Cmember, Perm, Common)
-    @ccall libcholmod.cholmod_csymamd(A::Ptr{cholmod_sparse}, Cmember::Ptr{Int32}, Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_csymamd(A::Ptr{cholmod_sparse}, Cmember::Ptr{Int32},
+                                      Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_csymamd(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_csymamd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Ptr{Int64}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_csymamd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                        arg3::Ptr{Int64}, arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_camd(A, fset, fsize, Cmember, Perm, Common)
-    @ccall libcholmod.cholmod_camd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, Cmember::Ptr{Int32}, Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_camd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t,
+                                   Cmember::Ptr{Int32}, Perm::Ptr{Int32},
+                                   Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_camd(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_camd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{Int64}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_camd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                     arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{Int64},
+                                     arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_nested_dissection(A, fset, fsize, Perm, CParent, Cmember, Common)
-    @ccall libcholmod.cholmod_nested_dissection(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, Perm::Ptr{Int32}, CParent::Ptr{Int32}, Cmember::Ptr{Int32}, Common::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_nested_dissection(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                                fsize::Csize_t, Perm::Ptr{Int32},
+                                                CParent::Ptr{Int32}, Cmember::Ptr{Int32},
+                                                Common::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_l_nested_dissection(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_nested_dissection(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{Int64}, arg6::Ptr{Int64}, arg7::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_l_nested_dissection(arg1::Ptr{cholmod_sparse},
+                                                  arg2::Ptr{Int64}, arg3::Csize_t,
+                                                  arg4::Ptr{Int64}, arg5::Ptr{Int64},
+                                                  arg6::Ptr{Int64},
+                                                  arg7::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_metis(A, fset, fsize, postorder, Perm, Common)
-    @ccall libcholmod.cholmod_metis(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, postorder::Cint, Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_metis(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                    fsize::Csize_t, postorder::Cint, Perm::Ptr{Int32},
+                                    Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_metis(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_metis(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Cint, arg5::Ptr{Int64}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_metis(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                      arg3::Csize_t, arg4::Cint, arg5::Ptr{Int64},
+                                      arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_bisect(A, fset, fsize, compress, Partition, Common)
-    @ccall libcholmod.cholmod_bisect(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, compress::Cint, Partition::Ptr{Int32}, Common::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_bisect(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                     fsize::Csize_t, compress::Cint, Partition::Ptr{Int32},
+                                     Common::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_l_bisect(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_bisect(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Cint, arg5::Ptr{Int64}, arg6::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_l_bisect(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                       arg3::Csize_t, arg4::Cint, arg5::Ptr{Int64},
+                                       arg6::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_metis_bisector(A, Anw, Aew, Partition, Common)
-    @ccall libcholmod.cholmod_metis_bisector(A::Ptr{cholmod_sparse}, Anw::Ptr{Int32}, Aew::Ptr{Int32}, Partition::Ptr{Int32}, Common::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_metis_bisector(A::Ptr{cholmod_sparse}, Anw::Ptr{Int32},
+                                             Aew::Ptr{Int32}, Partition::Ptr{Int32},
+                                             Common::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_l_metis_bisector(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_metis_bisector(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_l_metis_bisector(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                               arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                               arg5::Ptr{cholmod_common})::Int64
 end
 
-function cholmod_collapse_septree(n, ncomponents, nd_oksep, nd_small, CParent, Cmember, Common)
-    @ccall libcholmod.cholmod_collapse_septree(n::Csize_t, ncomponents::Csize_t, nd_oksep::Cdouble, nd_small::Csize_t, CParent::Ptr{Int32}, Cmember::Ptr{Int32}, Common::Ptr{cholmod_common})::Int64
+function cholmod_collapse_septree(n, ncomponents, nd_oksep, nd_small, CParent, Cmember,
+                                  Common)
+    @ccall libcholmod.cholmod_collapse_septree(n::Csize_t, ncomponents::Csize_t,
+                                               nd_oksep::Cdouble, nd_small::Csize_t,
+                                               CParent::Ptr{Int32}, Cmember::Ptr{Int32},
+                                               Common::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_l_collapse_septree(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_collapse_septree(arg1::Csize_t, arg2::Csize_t, arg3::Cdouble, arg4::Csize_t, arg5::Ptr{Int64}, arg6::Ptr{Int64}, arg7::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_l_collapse_septree(arg1::Csize_t, arg2::Csize_t,
+                                                 arg3::Cdouble, arg4::Csize_t,
+                                                 arg5::Ptr{Int64}, arg6::Ptr{Int64},
+                                                 arg7::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_super_symbolic(A, F, Parent, L, Common)
-    @ccall libcholmod.cholmod_super_symbolic(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, Parent::Ptr{Int32}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_super_symbolic(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse},
+                                             Parent::Ptr{Int32}, L::Ptr{cholmod_factor},
+                                             Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_super_symbolic(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_super_symbolic(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Int64}, arg4::Ptr{cholmod_factor}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_super_symbolic(arg1::Ptr{cholmod_sparse},
+                                               arg2::Ptr{cholmod_sparse}, arg3::Ptr{Int64},
+                                               arg4::Ptr{cholmod_factor},
+                                               arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_super_symbolic2(for_whom, A, F, Parent, L, Common)
-    @ccall libcholmod.cholmod_super_symbolic2(for_whom::Cint, A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, Parent::Ptr{Int32}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_super_symbolic2(for_whom::Cint, A::Ptr{cholmod_sparse},
+                                              F::Ptr{cholmod_sparse}, Parent::Ptr{Int32},
+                                              L::Ptr{cholmod_factor},
+                                              Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_super_symbolic2(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_super_symbolic2(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_sparse}, arg4::Ptr{Int64}, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_super_symbolic2(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                                arg3::Ptr{cholmod_sparse}, arg4::Ptr{Int64},
+                                                arg5::Ptr{cholmod_factor},
+                                                arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_super_numeric(A, F, beta, L, Common)
-    @ccall libcholmod.cholmod_super_numeric(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, beta::Ptr{Cdouble}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_super_numeric(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse},
+                                            beta::Ptr{Cdouble}, L::Ptr{cholmod_factor},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_super_numeric(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_super_numeric(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Ptr{cholmod_factor}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_super_numeric(arg1::Ptr{cholmod_sparse},
+                                              arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble},
+                                              arg4::Ptr{cholmod_factor},
+                                              arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_super_lsolve(L, X, E, Common)
-    @ccall libcholmod.cholmod_super_lsolve(L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, E::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_super_lsolve(L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense},
+                                           E::Ptr{cholmod_dense},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_super_lsolve(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_super_lsolve(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_dense}, arg3::Ptr{cholmod_dense}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_super_lsolve(arg1::Ptr{cholmod_factor},
+                                             arg2::Ptr{cholmod_dense},
+                                             arg3::Ptr{cholmod_dense},
+                                             arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_super_ltsolve(L, X, E, Common)
-    @ccall libcholmod.cholmod_super_ltsolve(L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, E::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_super_ltsolve(L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense},
+                                            E::Ptr{cholmod_dense},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_super_ltsolve(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_super_ltsolve(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_dense}, arg3::Ptr{cholmod_dense}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_super_ltsolve(arg1::Ptr{cholmod_factor},
+                                              arg2::Ptr{cholmod_dense},
+                                              arg3::Ptr{cholmod_dense},
+                                              arg4::Ptr{cholmod_common})::Cint
+end
+
+function SuiteSparseQR_C(ordering, tol, econ, getCTX, A, Bsparse, Bdense, Zsparse, Zdense,
+                         R, E, H, HPinv, HTau, cc)
+    @ccall libspqr.SuiteSparseQR_C(ordering::Cint, tol::Cdouble, econ::Int64, getCTX::Cint,
+                                   A::Ptr{cholmod_sparse}, Bsparse::Ptr{cholmod_sparse},
+                                   Bdense::Ptr{cholmod_dense},
+                                   Zsparse::Ptr{Ptr{cholmod_sparse}},
+                                   Zdense::Ptr{Ptr{cholmod_dense}},
+                                   R::Ptr{Ptr{cholmod_sparse}}, E::Ptr{Ptr{Int64}},
+                                   H::Ptr{Ptr{cholmod_sparse}}, HPinv::Ptr{Ptr{Int64}},
+                                   HTau::Ptr{Ptr{cholmod_dense}},
+                                   cc::Ptr{cholmod_common})::Int64
+end
+
+function SuiteSparseQR_i_C(ordering, tol, econ, getCTX, A, Bsparse, Bdense, Zsparse, Zdense,
+                           R, E, H, HPinv, HTau, cc)
+    @ccall libspqr.SuiteSparseQR_i_C(ordering::Cint, tol::Cdouble, econ::Int32,
+                                     getCTX::Cint, A::Ptr{cholmod_sparse},
+                                     Bsparse::Ptr{cholmod_sparse},
+                                     Bdense::Ptr{cholmod_dense},
+                                     Zsparse::Ptr{Ptr{cholmod_sparse}},
+                                     Zdense::Ptr{Ptr{cholmod_dense}},
+                                     R::Ptr{Ptr{cholmod_sparse}}, E::Ptr{Ptr{Int32}},
+                                     H::Ptr{Ptr{cholmod_sparse}}, HPinv::Ptr{Ptr{Int32}},
+                                     HTau::Ptr{Ptr{cholmod_dense}},
+                                     cc::Ptr{cholmod_common})::Int32
 end
 
-function SuiteSparseQR_C(ordering, tol, econ, getCTX, A, Bsparse, Bdense, Zsparse, Zdense, R, E, H, HPinv, HTau, cc)
-    @ccall libspqr.SuiteSparseQR_C(ordering::Cint, tol::Cdouble, econ::Int64, getCTX::Cint, A::Ptr{cholmod_sparse}, Bsparse::Ptr{cholmod_sparse}, Bdense::Ptr{cholmod_dense}, Zsparse::Ptr{Ptr{cholmod_sparse}}, Zdense::Ptr{Ptr{cholmod_dense}}, R::Ptr{Ptr{cholmod_sparse}}, E::Ptr{Ptr{Int64}}, H::Ptr{Ptr{cholmod_sparse}}, HPinv::Ptr{Ptr{Int64}}, HTau::Ptr{Ptr{cholmod_dense}}, cc::Ptr{cholmod_common})::Int64
+function SuiteSparseQR_C_QR(ordering, tol, econ, A, Q, R, E, cc)
+    @ccall libspqr.SuiteSparseQR_C_QR(ordering::Cint, tol::Cdouble, econ::Int64,
+                                      A::Ptr{cholmod_sparse}, Q::Ptr{Ptr{cholmod_sparse}},
+                                      R::Ptr{Ptr{cholmod_sparse}}, E::Ptr{Ptr{Int64}},
+                                      cc::Ptr{cholmod_common})::Int64
 end
 
-function SuiteSparseQR_C_QR(ordering, tol, econ, A, Q, R, E, cc)
-    @ccall libspqr.SuiteSparseQR_C_QR(ordering::Cint, tol::Cdouble, econ::Int64, A::Ptr{cholmod_sparse}, Q::Ptr{Ptr{cholmod_sparse}}, R::Ptr{Ptr{cholmod_sparse}}, E::Ptr{Ptr{Int64}}, cc::Ptr{cholmod_common})::Int64
+function SuiteSparseQR_i_C_QR(ordering, tol, econ, A, Q, R, E, cc)
+    @ccall libspqr.SuiteSparseQR_i_C_QR(ordering::Cint, tol::Cdouble, econ::Int32,
+                                        A::Ptr{cholmod_sparse}, Q::Ptr{Ptr{cholmod_sparse}},
+                                        R::Ptr{Ptr{cholmod_sparse}}, E::Ptr{Ptr{Int32}},
+                                        cc::Ptr{cholmod_common})::Int32
 end
 
 function SuiteSparseQR_C_backslash(ordering, tol, A, B, cc)
-    @ccall libspqr.SuiteSparseQR_C_backslash(ordering::Cint, tol::Cdouble, A::Ptr{cholmod_sparse}, B::Ptr{cholmod_dense}, cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libspqr.SuiteSparseQR_C_backslash(ordering::Cint, tol::Cdouble,
+                                             A::Ptr{cholmod_sparse}, B::Ptr{cholmod_dense},
+                                             cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function SuiteSparseQR_C_backslash_default(A, B, cc)
-    @ccall libspqr.SuiteSparseQR_C_backslash_default(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_dense}, cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libspqr.SuiteSparseQR_C_backslash_default(A::Ptr{cholmod_sparse},
+                                                     B::Ptr{cholmod_dense},
+                                                     cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function SuiteSparseQR_C_backslash_sparse(ordering, tol, A, B, cc)
-    @ccall libspqr.SuiteSparseQR_C_backslash_sparse(ordering::Cint, tol::Cdouble, A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse}, cc::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libspqr.SuiteSparseQR_C_backslash_sparse(ordering::Cint, tol::Cdouble,
+                                                    A::Ptr{cholmod_sparse},
+                                                    B::Ptr{cholmod_sparse},
+                                                    cc::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 mutable struct SuiteSparseQR_C_factorization_struct
     xtype::Cint
+    itype::Cint
     factors::Ptr{Cvoid}
     SuiteSparseQR_C_factorization_struct() = new()
 end
@@ -1536,51 +2115,78 @@ end
 const SuiteSparseQR_C_factorization = SuiteSparseQR_C_factorization_struct
 
 function SuiteSparseQR_C_factorize(ordering, tol, A, cc)
-    @ccall libspqr.SuiteSparseQR_C_factorize(ordering::Cint, tol::Cdouble, A::Ptr{cholmod_sparse}, cc::Ptr{cholmod_common})::Ptr{SuiteSparseQR_C_factorization}
+    @ccall libspqr.SuiteSparseQR_C_factorize(ordering::Cint, tol::Cdouble,
+                                             A::Ptr{cholmod_sparse},
+                                             cc::Ptr{cholmod_common})::Ptr{SuiteSparseQR_C_factorization}
 end
 
 function SuiteSparseQR_C_symbolic(ordering, allow_tol, A, cc)
-    @ccall libspqr.SuiteSparseQR_C_symbolic(ordering::Cint, allow_tol::Cint, A::Ptr{cholmod_sparse}, cc::Ptr{cholmod_common})::Ptr{SuiteSparseQR_C_factorization}
+    @ccall libspqr.SuiteSparseQR_C_symbolic(ordering::Cint, allow_tol::Cint,
+                                            A::Ptr{cholmod_sparse},
+                                            cc::Ptr{cholmod_common})::Ptr{SuiteSparseQR_C_factorization}
 end
 
 function SuiteSparseQR_C_numeric(tol, A, QR, cc)
-    @ccall libspqr.SuiteSparseQR_C_numeric(tol::Cdouble, A::Ptr{cholmod_sparse}, QR::Ptr{SuiteSparseQR_C_factorization}, cc::Ptr{cholmod_common})::Cint
+    @ccall libspqr.SuiteSparseQR_C_numeric(tol::Cdouble, A::Ptr{cholmod_sparse},
+                                           QR::Ptr{SuiteSparseQR_C_factorization},
+                                           cc::Ptr{cholmod_common})::Cint
 end
 
 function SuiteSparseQR_C_free(QR, cc)
-    @ccall libspqr.SuiteSparseQR_C_free(QR::Ptr{Ptr{SuiteSparseQR_C_factorization}}, cc::Ptr{cholmod_common})::Cint
+    @ccall libspqr.SuiteSparseQR_C_free(QR::Ptr{Ptr{SuiteSparseQR_C_factorization}},
+                                        cc::Ptr{cholmod_common})::Cint
 end
 
 function SuiteSparseQR_C_solve(system, QR, B, cc)
-    @ccall libspqr.SuiteSparseQR_C_solve(system::Cint, QR::Ptr{SuiteSparseQR_C_factorization}, B::Ptr{cholmod_dense}, cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libspqr.SuiteSparseQR_C_solve(system::Cint,
+                                         QR::Ptr{SuiteSparseQR_C_factorization},
+                                         B::Ptr{cholmod_dense},
+                                         cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function SuiteSparseQR_C_qmult(method, QR, X, cc)
-    @ccall libspqr.SuiteSparseQR_C_qmult(method::Cint, QR::Ptr{SuiteSparseQR_C_factorization}, X::Ptr{cholmod_dense}, cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libspqr.SuiteSparseQR_C_qmult(method::Cint,
+                                         QR::Ptr{SuiteSparseQR_C_factorization},
+                                         X::Ptr{cholmod_dense},
+                                         cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function amd_order(n, Ap, Ai, P, Control, Info)
-    @ccall libamd.amd_order(n::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, P::Ptr{Int32}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libamd.amd_order(n::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, P::Ptr{Int32},
+                            Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function amd_l_order(n, Ap, Ai, P, Control, Info)
-    @ccall libamd.amd_l_order(n::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, P::Ptr{Int64}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libamd.amd_l_order(n::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, P::Ptr{Int64},
+                              Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
-function amd_2(n, Pe, Iw, Len, iwlen, pfree, Nv, Next, Last, Head, Elen, Degree, W, Control, Info)
-    @ccall libamd.amd_2(n::Int32, Pe::Ptr{Int32}, Iw::Ptr{Int32}, Len::Ptr{Int32}, iwlen::Int32, pfree::Int32, Nv::Ptr{Int32}, Next::Ptr{Int32}, Last::Ptr{Int32}, Head::Ptr{Int32}, Elen::Ptr{Int32}, Degree::Ptr{Int32}, W::Ptr{Int32}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cvoid
+function amd_2(n, Pe, Iw, Len, iwlen, pfree, Nv, Next, Last, Head, Elen, Degree, W, Control,
+               Info)
+    @ccall libamd.amd_2(n::Int32, Pe::Ptr{Int32}, Iw::Ptr{Int32}, Len::Ptr{Int32},
+                        iwlen::Int32, pfree::Int32, Nv::Ptr{Int32}, Next::Ptr{Int32},
+                        Last::Ptr{Int32}, Head::Ptr{Int32}, Elen::Ptr{Int32},
+                        Degree::Ptr{Int32}, W::Ptr{Int32}, Control::Ptr{Cdouble},
+                        Info::Ptr{Cdouble})::Cvoid
 end
 
-function amd_l2(n, Pe, Iw, Len, iwlen, pfree, Nv, Next, Last, Head, Elen, Degree, W, Control, Info)
-    @ccall libamd.amd_l2(n::Int64, Pe::Ptr{Int64}, Iw::Ptr{Int64}, Len::Ptr{Int64}, iwlen::Int64, pfree::Int64, Nv::Ptr{Int64}, Next::Ptr{Int64}, Last::Ptr{Int64}, Head::Ptr{Int64}, Elen::Ptr{Int64}, Degree::Ptr{Int64}, W::Ptr{Int64}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cvoid
+function amd_l2(n, Pe, Iw, Len, iwlen, pfree, Nv, Next, Last, Head, Elen, Degree, W,
+                Control, Info)
+    @ccall libamd.amd_l2(n::Int64, Pe::Ptr{Int64}, Iw::Ptr{Int64}, Len::Ptr{Int64},
+                         iwlen::Int64, pfree::Int64, Nv::Ptr{Int64}, Next::Ptr{Int64},
+                         Last::Ptr{Int64}, Head::Ptr{Int64}, Elen::Ptr{Int64},
+                         Degree::Ptr{Int64}, W::Ptr{Int64}, Control::Ptr{Cdouble},
+                         Info::Ptr{Cdouble})::Cvoid
 end
 
 function amd_valid(n_row, n_col, Ap, Ai)
-    @ccall libamd.amd_valid(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32})::Cint
+    @ccall libamd.amd_valid(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                            Ai::Ptr{Int32})::Cint
 end
 
 function amd_l_valid(n_row, n_col, Ap, Ai)
-    @ccall libamd.amd_l_valid(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64})::Cint
+    @ccall libamd.amd_l_valid(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                              Ai::Ptr{Int64})::Cint
 end
 
 function amd_defaults(Control)
@@ -1607,188 +2213,88 @@ function amd_l_info(Info)
     @ccall libamd.amd_l_info(Info::Ptr{Cdouble})::Cvoid
 end
 
-function colamd_recommended(nnz, n_row, n_col)
-    @ccall libcolamd.colamd_recommended(nnz::Int32, n_row::Int32, n_col::Int32)::Csize_t
-end
-
-function colamd_l_recommended(nnz, n_row, n_col)
-    @ccall libcolamd.colamd_l_recommended(nnz::Int64, n_row::Int64, n_col::Int64)::Csize_t
-end
-
-function colamd_set_defaults(knobs)
-    @ccall libcolamd.colamd_set_defaults(knobs::Ptr{Cdouble})::Cvoid
-end
-
-function colamd_l_set_defaults(knobs)
-    @ccall libcolamd.colamd_l_set_defaults(knobs::Ptr{Cdouble})::Cvoid
-end
-
-function colamd(n_row, n_col, Alen, A, p, knobs, stats)
-    @ccall libcolamd.colamd(n_row::Int32, n_col::Int32, Alen::Int32, A::Ptr{Int32}, p::Ptr{Int32}, knobs::Ptr{Cdouble}, stats::Ptr{Int32})::Cint
-end
-
-function colamd_l(n_row, n_col, Alen, A, p, knobs, stats)
-    @ccall libcolamd.colamd_l(n_row::Int64, n_col::Int64, Alen::Int64, A::Ptr{Int64}, p::Ptr{Int64}, knobs::Ptr{Cdouble}, stats::Ptr{Int64})::Cint
-end
-
-function symamd(n, A, p, perm, knobs, stats, allocate, release)
-    @ccall libcolamd.symamd(n::Int32, A::Ptr{Int32}, p::Ptr{Int32}, perm::Ptr{Int32}, knobs::Ptr{Cdouble}, stats::Ptr{Int32}, allocate::Ptr{Cvoid}, release::Ptr{Cvoid})::Cint
-end
-
-function symamd_l(n, A, p, perm, knobs, stats, allocate, release)
-    @ccall libcolamd.symamd_l(n::Int64, A::Ptr{Int64}, p::Ptr{Int64}, perm::Ptr{Int64}, knobs::Ptr{Cdouble}, stats::Ptr{Int64}, allocate::Ptr{Cvoid}, release::Ptr{Cvoid})::Cint
-end
-
-function colamd_report(stats)
-    @ccall libcolamd.colamd_report(stats::Ptr{Int32})::Cvoid
-end
-
-function colamd_l_report(stats)
-    @ccall libcolamd.colamd_l_report(stats::Ptr{Int64})::Cvoid
-end
-
-function symamd_report(stats)
-    @ccall libcolamd.symamd_report(stats::Ptr{Int32})::Cvoid
-end
-
-function symamd_l_report(stats)
-    @ccall libcolamd.symamd_l_report(stats::Ptr{Int64})::Cvoid
-end
-
-function ccolamd_recommended(nnz, n_row, n_col)
-    @ccall libcolamd.ccolamd_recommended(nnz::Cint, n_row::Cint, n_col::Cint)::Csize_t
-end
-
-function ccolamd_l_recommended(nnz, n_row, n_col)
-    @ccall libcolamd.ccolamd_l_recommended(nnz::Int64, n_row::Int64, n_col::Int64)::Csize_t
-end
-
-function ccolamd_set_defaults(knobs)
-    @ccall libcolamd.ccolamd_set_defaults(knobs::Ptr{Cdouble})::Cvoid
-end
-
-function ccolamd_l_set_defaults(knobs)
-    @ccall libcolamd.ccolamd_l_set_defaults(knobs::Ptr{Cdouble})::Cvoid
-end
-
-function ccolamd(n_row, n_col, Alen, A, p, knobs, stats, cmember)
-    @ccall libcolamd.ccolamd(n_row::Cint, n_col::Cint, Alen::Cint, A::Ptr{Cint}, p::Ptr{Cint}, knobs::Ptr{Cdouble}, stats::Ptr{Cint}, cmember::Ptr{Cint})::Cint
-end
-
-function ccolamd_l(n_row, n_col, Alen, A, p, knobs, stats, cmember)
-    @ccall libcolamd.ccolamd_l(n_row::Int64, n_col::Int64, Alen::Int64, A::Ptr{Int64}, p::Ptr{Int64}, knobs::Ptr{Cdouble}, stats::Ptr{Int64}, cmember::Ptr{Int64})::Cint
-end
-
-function csymamd(n, A, p, perm, knobs, stats, allocate, release, cmember, stype)
-    @ccall libcolamd.csymamd(n::Cint, A::Ptr{Cint}, p::Ptr{Cint}, perm::Ptr{Cint}, knobs::Ptr{Cdouble}, stats::Ptr{Cint}, allocate::Ptr{Cvoid}, release::Ptr{Cvoid}, cmember::Ptr{Cint}, stype::Cint)::Cint
-end
-
-function csymamd_l(n, A, p, perm, knobs, stats, allocate, release, cmember, stype)
-    @ccall libcolamd.csymamd_l(n::Int64, A::Ptr{Int64}, p::Ptr{Int64}, perm::Ptr{Int64}, knobs::Ptr{Cdouble}, stats::Ptr{Int64}, allocate::Ptr{Cvoid}, release::Ptr{Cvoid}, cmember::Ptr{Int64}, stype::Int64)::Cint
-end
-
-function ccolamd_report(stats)
-    @ccall libcolamd.ccolamd_report(stats::Ptr{Cint})::Cvoid
-end
-
-function ccolamd_l_report(stats)
-    @ccall libcolamd.ccolamd_l_report(stats::Ptr{Int64})::Cvoid
-end
-
-function csymamd_report(stats)
-    @ccall libcolamd.csymamd_report(stats::Ptr{Cint})::Cvoid
-end
-
-function csymamd_l_report(stats)
-    @ccall libcolamd.csymamd_l_report(stats::Ptr{Int64})::Cvoid
-end
-
-function ccolamd2(n_row, n_col, Alen, A, p, knobs, stats, Front_npivcol, Front_nrows, Front_ncols, Front_parent, Front_cols, p_nfr, InFront, cmember)
-    @ccall libcolamd.ccolamd2(n_row::Cint, n_col::Cint, Alen::Cint, A::Ptr{Cint}, p::Ptr{Cint}, knobs::Ptr{Cdouble}, stats::Ptr{Cint}, Front_npivcol::Ptr{Cint}, Front_nrows::Ptr{Cint}, Front_ncols::Ptr{Cint}, Front_parent::Ptr{Cint}, Front_cols::Ptr{Cint}, p_nfr::Ptr{Cint}, InFront::Ptr{Cint}, cmember::Ptr{Cint})::Cint
-end
-
-function ccolamd2_l(n_row, n_col, Alen, A, p, knobs, stats, Front_npivcol, Front_nrows, Front_ncols, Front_parent, Front_cols, p_nfr, InFront, cmember)
-    @ccall libcolamd.ccolamd2_l(n_row::Int64, n_col::Int64, Alen::Int64, A::Ptr{Int64}, p::Ptr{Int64}, knobs::Ptr{Cdouble}, stats::Ptr{Int64}, Front_npivcol::Ptr{Int64}, Front_nrows::Ptr{Int64}, Front_ncols::Ptr{Int64}, Front_parent::Ptr{Int64}, Front_cols::Ptr{Int64}, p_nfr::Ptr{Int64}, InFront::Ptr{Int64}, cmember::Ptr{Int64})::Cint
-end
-
-function ccolamd_apply_order(Front, Order, Temp, nn, nfr)
-    @ccall libcolamd.ccolamd_apply_order(Front::Ptr{Cint}, Order::Ptr{Cint}, Temp::Ptr{Cint}, nn::Cint, nfr::Cint)::Cvoid
-end
-
-function ccolamd_l_apply_order(Front, Order, Temp, nn, nfr)
-    @ccall libcolamd.ccolamd_l_apply_order(Front::Ptr{Int64}, Order::Ptr{Int64}, Temp::Ptr{Int64}, nn::Int64, nfr::Int64)::Cvoid
-end
-
-function ccolamd_fsize(nn, MaxFsize, Fnrows, Fncols, Parent, Npiv)
-    @ccall libcolamd.ccolamd_fsize(nn::Cint, MaxFsize::Ptr{Cint}, Fnrows::Ptr{Cint}, Fncols::Ptr{Cint}, Parent::Ptr{Cint}, Npiv::Ptr{Cint})::Cvoid
-end
-
-function ccolamd_l_fsize(nn, MaxFsize, Fnrows, Fncols, Parent, Npiv)
-    @ccall libcolamd.ccolamd_l_fsize(nn::Int64, MaxFsize::Ptr{Int64}, Fnrows::Ptr{Int64}, Fncols::Ptr{Int64}, Parent::Ptr{Int64}, Npiv::Ptr{Int64})::Cvoid
-end
-
-function ccolamd_postorder(nn, Parent, Npiv, Fsize, Order, Child, Sibling, Stack, Front_cols, cmember)
-    @ccall libcolamd.ccolamd_postorder(nn::Cint, Parent::Ptr{Cint}, Npiv::Ptr{Cint}, Fsize::Ptr{Cint}, Order::Ptr{Cint}, Child::Ptr{Cint}, Sibling::Ptr{Cint}, Stack::Ptr{Cint}, Front_cols::Ptr{Cint}, cmember::Ptr{Cint})::Cvoid
-end
-
-function ccolamd_l_postorder(nn, Parent, Npiv, Fsize, Order, Child, Sibling, Stack, Front_cols, cmember)
-    @ccall libcolamd.ccolamd_l_postorder(nn::Int64, Parent::Ptr{Int64}, Npiv::Ptr{Int64}, Fsize::Ptr{Int64}, Order::Ptr{Int64}, Child::Ptr{Int64}, Sibling::Ptr{Int64}, Stack::Ptr{Int64}, Front_cols::Ptr{Int64}, cmember::Ptr{Int64})::Cvoid
-end
-
-function ccolamd_post_tree(root, k, Child, Sibling, Order, Stack)
-    @ccall libcolamd.ccolamd_post_tree(root::Cint, k::Cint, Child::Ptr{Cint}, Sibling::Ptr{Cint}, Order::Ptr{Cint}, Stack::Ptr{Cint})::Cint
-end
-
-function ccolamd_l_post_tree(root, k, Child, Sibling, Order, Stack)
-    @ccall libcolamd.ccolamd_l_post_tree(root::Int64, k::Int64, Child::Ptr{Int64}, Sibling::Ptr{Int64}, Order::Ptr{Int64}, Stack::Ptr{Int64})::Int64
-end
-
 function umfpack_di_symbolic(n_row, n_col, Ap, Ai, Ax, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_di_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                          Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                          Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                          Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_symbolic(n_row, n_col, Ap, Ai, Ax, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_dl_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                          Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                          Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                          Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_symbolic(n_row, n_col, Ap, Ai, Ax, Az, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_zi_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                          Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                          Az::Ptr{Cdouble}, Symbolic::Ptr{Ptr{Cvoid}},
+                                          Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_symbolic(n_row, n_col, Ap, Ai, Ax, Az, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_zl_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                          Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                          Az::Ptr{Cdouble}, Symbolic::Ptr{Ptr{Cvoid}},
+                                          Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_numeric(Ap, Ai, Ax, Symbolic, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_di_numeric(Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Symbolic::Ptr{Cvoid}, Numeric::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_numeric(Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                         Symbolic::Ptr{Cvoid}, Numeric::Ptr{Ptr{Cvoid}},
+                                         Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_numeric(Ap, Ai, Ax, Symbolic, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_dl_numeric(Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Symbolic::Ptr{Cvoid}, Numeric::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_numeric(Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                         Symbolic::Ptr{Cvoid}, Numeric::Ptr{Ptr{Cvoid}},
+                                         Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_numeric(Ap, Ai, Ax, Az, Symbolic, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_zi_numeric(Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Symbolic::Ptr{Cvoid}, Numeric::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_numeric(Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                         Az::Ptr{Cdouble}, Symbolic::Ptr{Cvoid},
+                                         Numeric::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                         Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_numeric(Ap, Ai, Ax, Az, Symbolic, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_zl_numeric(Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Symbolic::Ptr{Cvoid}, Numeric::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_numeric(Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                         Az::Ptr{Cdouble}, Symbolic::Ptr{Cvoid},
+                                         Numeric::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                         Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_solve(sys, Ap, Ai, Ax, X, B, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_di_solve(sys::Cint, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_solve(sys::Cint, Ap::Ptr{Int32}, Ai::Ptr{Int32},
+                                       Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble},
+                                       Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                       Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_solve(sys, Ap, Ai, Ax, X, B, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_dl_solve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_solve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64},
+                                       Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble},
+                                       Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                       Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_solve(sys, Ap, Ai, Ax, Az, Xx, Xz, Bx, Bz, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_zi_solve(sys::Cint, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_solve(sys::Cint, Ap::Ptr{Int32}, Ai::Ptr{Int32},
+                                       Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Xx::Ptr{Cdouble},
+                                       Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble},
+                                       Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                       Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_solve(sys, Ap, Ai, Ax, Az, Xx, Xz, Bx, Bz, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_zl_solve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_solve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64},
+                                       Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Xx::Ptr{Cdouble},
+                                       Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble},
+                                       Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                       Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_free_symbolic(Symbolic)
@@ -1840,51 +2346,119 @@ function umfpack_zl_defaults(Control)
 end
 
 function umfpack_di_qsymbolic(n_row, n_col, Ap, Ai, Ax, Qinit, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_di_qsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Qinit::Ptr{Int32}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_qsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                           Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                           Qinit::Ptr{Int32}, Symbolic::Ptr{Ptr{Cvoid}},
+                                           Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_qsymbolic(n_row, n_col, Ap, Ai, Ax, Qinit, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_dl_qsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Qinit::Ptr{Int64}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_qsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                           Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                           Qinit::Ptr{Int64}, Symbolic::Ptr{Ptr{Cvoid}},
+                                           Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_qsymbolic(n_row, n_col, Ap, Ai, Ax, Az, Qinit, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_zi_qsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Qinit::Ptr{Int32}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_qsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                           Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                           Az::Ptr{Cdouble}, Qinit::Ptr{Int32},
+                                           Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                           Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_qsymbolic(n_row, n_col, Ap, Ai, Ax, Az, Qinit, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_zl_qsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Qinit::Ptr{Int64}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_di_fsymbolic(n_row, n_col, Ap, Ai, Ax, user_ordering, user_params, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_di_fsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_dl_fsymbolic(n_row, n_col, Ap, Ai, Ax, user_ordering, user_params, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_dl_fsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_zi_fsymbolic(n_row, n_col, Ap, Ai, Ax, Az, user_ordering, user_params, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_zi_fsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_zl_fsymbolic(n_row, n_col, Ap, Ai, Ax, Az, user_ordering, user_params, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_zl_fsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_di_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Qinit, user_ordering, user_params, Symbolic, SW, Control, Info)
-    @ccall libumfpack.umfpack_di_paru_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Qinit::Ptr{Int32}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_dl_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Qinit, user_ordering, user_params, Symbolic, SW, Control, Info)
-    @ccall libumfpack.umfpack_dl_paru_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Qinit::Ptr{Int64}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_zi_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Az, Qinit, user_ordering, user_params, Symbolic, SW, Control, Info)
-    @ccall libumfpack.umfpack_zi_paru_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Qinit::Ptr{Int32}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_zl_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Az, Qinit, user_ordering, user_params, Symbolic, SW, Control, Info)
-    @ccall libumfpack.umfpack_zl_paru_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Qinit::Ptr{Int64}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_qsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                           Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                           Az::Ptr{Cdouble}, Qinit::Ptr{Int64},
+                                           Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                           Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_di_fsymbolic(n_row, n_col, Ap, Ai, Ax, user_ordering, user_params,
+                              Symbolic, Control, Info)
+    @ccall libumfpack.umfpack_di_fsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                           Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                           user_ordering::Ptr{Cvoid},
+                                           user_params::Ptr{Cvoid},
+                                           Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                           Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_dl_fsymbolic(n_row, n_col, Ap, Ai, Ax, user_ordering, user_params,
+                              Symbolic, Control, Info)
+    @ccall libumfpack.umfpack_dl_fsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                           Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                           user_ordering::Ptr{Cvoid},
+                                           user_params::Ptr{Cvoid},
+                                           Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                           Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_zi_fsymbolic(n_row, n_col, Ap, Ai, Ax, Az, user_ordering, user_params,
+                              Symbolic, Control, Info)
+    @ccall libumfpack.umfpack_zi_fsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                           Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                           Az::Ptr{Cdouble}, user_ordering::Ptr{Cvoid},
+                                           user_params::Ptr{Cvoid},
+                                           Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                           Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_zl_fsymbolic(n_row, n_col, Ap, Ai, Ax, Az, user_ordering, user_params,
+                              Symbolic, Control, Info)
+    @ccall libumfpack.umfpack_zl_fsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                           Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                           Az::Ptr{Cdouble}, user_ordering::Ptr{Cvoid},
+                                           user_params::Ptr{Cvoid},
+                                           Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                           Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_di_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Qinit, user_ordering,
+                                  user_params, Symbolic, SW, Control, Info)
+    @ccall libumfpack.umfpack_di_paru_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                               Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                               Qinit::Ptr{Int32}, user_ordering::Ptr{Cvoid},
+                                               user_params::Ptr{Cvoid},
+                                               Symbolic::Ptr{Ptr{Cvoid}},
+                                               SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                               Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_dl_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Qinit, user_ordering,
+                                  user_params, Symbolic, SW, Control, Info)
+    @ccall libumfpack.umfpack_dl_paru_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                               Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                               Qinit::Ptr{Int64}, user_ordering::Ptr{Cvoid},
+                                               user_params::Ptr{Cvoid},
+                                               Symbolic::Ptr{Ptr{Cvoid}},
+                                               SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                               Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_zi_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Az, Qinit, user_ordering,
+                                  user_params, Symbolic, SW, Control, Info)
+    @ccall libumfpack.umfpack_zi_paru_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                               Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                               Az::Ptr{Cdouble}, Qinit::Ptr{Int32},
+                                               user_ordering::Ptr{Cvoid},
+                                               user_params::Ptr{Cvoid},
+                                               Symbolic::Ptr{Ptr{Cvoid}},
+                                               SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                               Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_zl_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Az, Qinit, user_ordering,
+                                  user_params, Symbolic, SW, Control, Info)
+    @ccall libumfpack.umfpack_zl_paru_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                               Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                               Az::Ptr{Cdouble}, Qinit::Ptr{Int64},
+                                               user_ordering::Ptr{Cvoid},
+                                               user_params::Ptr{Cvoid},
+                                               Symbolic::Ptr{Ptr{Cvoid}},
+                                               SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                               Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_paru_free_sw(SW)
@@ -1904,339 +2478,547 @@ function umfpack_zl_paru_free_sw(SW)
 end
 
 function umfpack_di_wsolve(sys, Ap, Ai, Ax, X, B, Numeric, Control, Info, Wi, W)
-    @ccall libumfpack.umfpack_di_wsolve(sys::Cint, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble}, Wi::Ptr{Int32}, W::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_wsolve(sys::Cint, Ap::Ptr{Int32}, Ai::Ptr{Int32},
+                                        Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble},
+                                        Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                        Info::Ptr{Cdouble}, Wi::Ptr{Int32},
+                                        W::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_wsolve(sys, Ap, Ai, Ax, X, B, Numeric, Control, Info, Wi, W)
-    @ccall libumfpack.umfpack_dl_wsolve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble}, Wi::Ptr{Int64}, W::Ptr{Cdouble})::Cint
-end
-
-function umfpack_zi_wsolve(sys, Ap, Ai, Ax, Az, Xx, Xz, Bx, Bz, Numeric, Control, Info, Wi, W)
-    @ccall libumfpack.umfpack_zi_wsolve(sys::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble}, Wi::Ptr{Int32}, W::Ptr{Cdouble})::Cint
-end
-
-function umfpack_zl_wsolve(sys, Ap, Ai, Ax, Az, Xx, Xz, Bx, Bz, Numeric, Control, Info, Wi, W)
-    @ccall libumfpack.umfpack_zl_wsolve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble}, Wi::Ptr{Int64}, W::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_wsolve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64},
+                                        Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble},
+                                        Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                        Info::Ptr{Cdouble}, Wi::Ptr{Int64},
+                                        W::Ptr{Cdouble})::Cint
+end
+
+function umfpack_zi_wsolve(sys, Ap, Ai, Ax, Az, Xx, Xz, Bx, Bz, Numeric, Control, Info, Wi,
+                           W)
+    @ccall libumfpack.umfpack_zi_wsolve(sys::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32},
+                                        Ax::Ptr{Cdouble}, Az::Ptr{Cdouble},
+                                        Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble},
+                                        Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble},
+                                        Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                        Info::Ptr{Cdouble}, Wi::Ptr{Int32},
+                                        W::Ptr{Cdouble})::Cint
+end
+
+function umfpack_zl_wsolve(sys, Ap, Ai, Ax, Az, Xx, Xz, Bx, Bz, Numeric, Control, Info, Wi,
+                           W)
+    @ccall libumfpack.umfpack_zl_wsolve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64},
+                                        Ax::Ptr{Cdouble}, Az::Ptr{Cdouble},
+                                        Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble},
+                                        Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble},
+                                        Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                        Info::Ptr{Cdouble}, Wi::Ptr{Int64},
+                                        W::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_triplet_to_col(n_row, n_col, nz, Ti, Tj, Tx, Ap, Ai, Ax, Map)
-    @ccall libumfpack.umfpack_di_triplet_to_col(n_row::Int32, n_col::Int32, nz::Int32, Ti::Ptr{Int32}, Tj::Ptr{Int32}, Tx::Ptr{Cdouble}, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Map::Ptr{Int32})::Cint
+    @ccall libumfpack.umfpack_di_triplet_to_col(n_row::Int32, n_col::Int32, nz::Int32,
+                                                Ti::Ptr{Int32}, Tj::Ptr{Int32},
+                                                Tx::Ptr{Cdouble}, Ap::Ptr{Int32},
+                                                Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                                Map::Ptr{Int32})::Cint
 end
 
 function umfpack_dl_triplet_to_col(n_row, n_col, nz, Ti, Tj, Tx, Ap, Ai, Ax, Map)
-    @ccall libumfpack.umfpack_dl_triplet_to_col(n_row::Int64, n_col::Int64, nz::Int64, Ti::Ptr{Int64}, Tj::Ptr{Int64}, Tx::Ptr{Cdouble}, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Map::Ptr{Int64})::Cint
+    @ccall libumfpack.umfpack_dl_triplet_to_col(n_row::Int64, n_col::Int64, nz::Int64,
+                                                Ti::Ptr{Int64}, Tj::Ptr{Int64},
+                                                Tx::Ptr{Cdouble}, Ap::Ptr{Int64},
+                                                Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                                Map::Ptr{Int64})::Cint
 end
 
 function umfpack_zi_triplet_to_col(n_row, n_col, nz, Ti, Tj, Tx, Tz, Ap, Ai, Ax, Az, Map)
-    @ccall libumfpack.umfpack_zi_triplet_to_col(n_row::Int32, n_col::Int32, nz::Int32, Ti::Ptr{Int32}, Tj::Ptr{Int32}, Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble}, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Map::Ptr{Int32})::Cint
+    @ccall libumfpack.umfpack_zi_triplet_to_col(n_row::Int32, n_col::Int32, nz::Int32,
+                                                Ti::Ptr{Int32}, Tj::Ptr{Int32},
+                                                Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble},
+                                                Ap::Ptr{Int32}, Ai::Ptr{Int32},
+                                                Ax::Ptr{Cdouble}, Az::Ptr{Cdouble},
+                                                Map::Ptr{Int32})::Cint
 end
 
 function umfpack_zl_triplet_to_col(n_row, n_col, nz, Ti, Tj, Tx, Tz, Ap, Ai, Ax, Az, Map)
-    @ccall libumfpack.umfpack_zl_triplet_to_col(n_row::Int64, n_col::Int64, nz::Int64, Ti::Ptr{Int64}, Tj::Ptr{Int64}, Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble}, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Map::Ptr{Int64})::Cint
+    @ccall libumfpack.umfpack_zl_triplet_to_col(n_row::Int64, n_col::Int64, nz::Int64,
+                                                Ti::Ptr{Int64}, Tj::Ptr{Int64},
+                                                Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble},
+                                                Ap::Ptr{Int64}, Ai::Ptr{Int64},
+                                                Ax::Ptr{Cdouble}, Az::Ptr{Cdouble},
+                                                Map::Ptr{Int64})::Cint
 end
 
 function umfpack_di_col_to_triplet(n_col, Ap, Tj)
-    @ccall libumfpack.umfpack_di_col_to_triplet(n_col::Int32, Ap::Ptr{Int32}, Tj::Ptr{Int32})::Cint
+    @ccall libumfpack.umfpack_di_col_to_triplet(n_col::Int32, Ap::Ptr{Int32},
+                                                Tj::Ptr{Int32})::Cint
 end
 
 function umfpack_dl_col_to_triplet(n_col, Ap, Tj)
-    @ccall libumfpack.umfpack_dl_col_to_triplet(n_col::Int64, Ap::Ptr{Int64}, Tj::Ptr{Int64})::Cint
+    @ccall libumfpack.umfpack_dl_col_to_triplet(n_col::Int64, Ap::Ptr{Int64},
+                                                Tj::Ptr{Int64})::Cint
 end
 
 function umfpack_zi_col_to_triplet(n_col, Ap, Tj)
-    @ccall libumfpack.umfpack_zi_col_to_triplet(n_col::Int32, Ap::Ptr{Int32}, Tj::Ptr{Int32})::Cint
+    @ccall libumfpack.umfpack_zi_col_to_triplet(n_col::Int32, Ap::Ptr{Int32},
+                                                Tj::Ptr{Int32})::Cint
 end
 
 function umfpack_zl_col_to_triplet(n_col, Ap, Tj)
-    @ccall libumfpack.umfpack_zl_col_to_triplet(n_col::Int64, Ap::Ptr{Int64}, Tj::Ptr{Int64})::Cint
+    @ccall libumfpack.umfpack_zl_col_to_triplet(n_col::Int64, Ap::Ptr{Int64},
+                                                Tj::Ptr{Int64})::Cint
 end
 
 function umfpack_di_transpose(n_row, n_col, Ap, Ai, Ax, P, Q, Rp, Ri, Rx)
-    @ccall libumfpack.umfpack_di_transpose(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, P::Ptr{Int32}, Q::Ptr{Int32}, Rp::Ptr{Int32}, Ri::Ptr{Int32}, Rx::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_transpose(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                           Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, P::Ptr{Int32},
+                                           Q::Ptr{Int32}, Rp::Ptr{Int32}, Ri::Ptr{Int32},
+                                           Rx::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_transpose(n_row, n_col, Ap, Ai, Ax, P, Q, Rp, Ri, Rx)
-    @ccall libumfpack.umfpack_dl_transpose(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, P::Ptr{Int64}, Q::Ptr{Int64}, Rp::Ptr{Int64}, Ri::Ptr{Int64}, Rx::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_transpose(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                           Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, P::Ptr{Int64},
+                                           Q::Ptr{Int64}, Rp::Ptr{Int64}, Ri::Ptr{Int64},
+                                           Rx::Ptr{Cdouble})::Cint
 end
 
-function umfpack_zi_transpose(n_row, n_col, Ap, Ai, Ax, Az, P, Q, Rp, Ri, Rx, Rz, do_conjugate)
-    @ccall libumfpack.umfpack_zi_transpose(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, P::Ptr{Int32}, Q::Ptr{Int32}, Rp::Ptr{Int32}, Ri::Ptr{Int32}, Rx::Ptr{Cdouble}, Rz::Ptr{Cdouble}, do_conjugate::Cint)::Cint
+function umfpack_zi_transpose(n_row, n_col, Ap, Ai, Ax, Az, P, Q, Rp, Ri, Rx, Rz,
+                              do_conjugate)
+    @ccall libumfpack.umfpack_zi_transpose(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                           Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                           Az::Ptr{Cdouble}, P::Ptr{Int32}, Q::Ptr{Int32},
+                                           Rp::Ptr{Int32}, Ri::Ptr{Int32}, Rx::Ptr{Cdouble},
+                                           Rz::Ptr{Cdouble}, do_conjugate::Cint)::Cint
 end
 
-function umfpack_zl_transpose(n_row, n_col, Ap, Ai, Ax, Az, P, Q, Rp, Ri, Rx, Rz, do_conjugate)
-    @ccall libumfpack.umfpack_zl_transpose(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, P::Ptr{Int64}, Q::Ptr{Int64}, Rp::Ptr{Int64}, Ri::Ptr{Int64}, Rx::Ptr{Cdouble}, Rz::Ptr{Cdouble}, do_conjugate::Cint)::Cint
+function umfpack_zl_transpose(n_row, n_col, Ap, Ai, Ax, Az, P, Q, Rp, Ri, Rx, Rz,
+                              do_conjugate)
+    @ccall libumfpack.umfpack_zl_transpose(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                           Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                           Az::Ptr{Cdouble}, P::Ptr{Int64}, Q::Ptr{Int64},
+                                           Rp::Ptr{Int64}, Ri::Ptr{Int64}, Rx::Ptr{Cdouble},
+                                           Rz::Ptr{Cdouble}, do_conjugate::Cint)::Cint
 end
 
 function umfpack_di_scale(X, B, Numeric)
-    @ccall libumfpack.umfpack_di_scale(X::Ptr{Cdouble}, B::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_scale(X::Ptr{Cdouble}, B::Ptr{Cdouble},
+                                       Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_scale(X, B, Numeric)
-    @ccall libumfpack.umfpack_dl_scale(X::Ptr{Cdouble}, B::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_scale(X::Ptr{Cdouble}, B::Ptr{Cdouble},
+                                       Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_scale(Xx, Xz, Bx, Bz, Numeric)
-    @ccall libumfpack.umfpack_zi_scale(Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_scale(Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble},
+                                       Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_scale(Xx, Xz, Bx, Bz, Numeric)
-    @ccall libumfpack.umfpack_zl_scale(Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_scale(Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble},
+                                       Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_get_lunz(lnz, unz, n_row, n_col, nz_udiag, Numeric)
-    @ccall libumfpack.umfpack_di_get_lunz(lnz::Ptr{Int32}, unz::Ptr{Int32}, n_row::Ptr{Int32}, n_col::Ptr{Int32}, nz_udiag::Ptr{Int32}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_get_lunz(lnz::Ptr{Int32}, unz::Ptr{Int32},
+                                          n_row::Ptr{Int32}, n_col::Ptr{Int32},
+                                          nz_udiag::Ptr{Int32}, Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_get_lunz(lnz, unz, n_row, n_col, nz_udiag, Numeric)
-    @ccall libumfpack.umfpack_dl_get_lunz(lnz::Ptr{Int64}, unz::Ptr{Int64}, n_row::Ptr{Int64}, n_col::Ptr{Int64}, nz_udiag::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_get_lunz(lnz::Ptr{Int64}, unz::Ptr{Int64},
+                                          n_row::Ptr{Int64}, n_col::Ptr{Int64},
+                                          nz_udiag::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_get_lunz(lnz, unz, n_row, n_col, nz_udiag, Numeric)
-    @ccall libumfpack.umfpack_zi_get_lunz(lnz::Ptr{Int32}, unz::Ptr{Int32}, n_row::Ptr{Int32}, n_col::Ptr{Int32}, nz_udiag::Ptr{Int32}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_get_lunz(lnz::Ptr{Int32}, unz::Ptr{Int32},
+                                          n_row::Ptr{Int32}, n_col::Ptr{Int32},
+                                          nz_udiag::Ptr{Int32}, Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_get_lunz(lnz, unz, n_row, n_col, nz_udiag, Numeric)
-    @ccall libumfpack.umfpack_zl_get_lunz(lnz::Ptr{Int64}, unz::Ptr{Int64}, n_row::Ptr{Int64}, n_col::Ptr{Int64}, nz_udiag::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_get_lunz(lnz::Ptr{Int64}, unz::Ptr{Int64},
+                                          n_row::Ptr{Int64}, n_col::Ptr{Int64},
+                                          nz_udiag::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_get_numeric(Lp, Lj, Lx, Up, Ui, Ux, P, Q, Dx, do_recip, Rs, Numeric)
-    @ccall libumfpack.umfpack_di_get_numeric(Lp::Ptr{Int32}, Lj::Ptr{Int32}, Lx::Ptr{Cdouble}, Up::Ptr{Int32}, Ui::Ptr{Int32}, Ux::Ptr{Cdouble}, P::Ptr{Int32}, Q::Ptr{Int32}, Dx::Ptr{Cdouble}, do_recip::Ptr{Int32}, Rs::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_get_numeric(Lp::Ptr{Int32}, Lj::Ptr{Int32},
+                                             Lx::Ptr{Cdouble}, Up::Ptr{Int32},
+                                             Ui::Ptr{Int32}, Ux::Ptr{Cdouble},
+                                             P::Ptr{Int32}, Q::Ptr{Int32}, Dx::Ptr{Cdouble},
+                                             do_recip::Ptr{Int32}, Rs::Ptr{Cdouble},
+                                             Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_get_numeric(Lp, Lj, Lx, Up, Ui, Ux, P, Q, Dx, do_recip, Rs, Numeric)
-    @ccall libumfpack.umfpack_dl_get_numeric(Lp::Ptr{Int64}, Lj::Ptr{Int64}, Lx::Ptr{Cdouble}, Up::Ptr{Int64}, Ui::Ptr{Int64}, Ux::Ptr{Cdouble}, P::Ptr{Int64}, Q::Ptr{Int64}, Dx::Ptr{Cdouble}, do_recip::Ptr{Int64}, Rs::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
-end
-
-function umfpack_zi_get_numeric(Lp, Lj, Lx, Lz, Up, Ui, Ux, Uz, P, Q, Dx, Dz, do_recip, Rs, Numeric)
-    @ccall libumfpack.umfpack_zi_get_numeric(Lp::Ptr{Int32}, Lj::Ptr{Int32}, Lx::Ptr{Cdouble}, Lz::Ptr{Cdouble}, Up::Ptr{Int32}, Ui::Ptr{Int32}, Ux::Ptr{Cdouble}, Uz::Ptr{Cdouble}, P::Ptr{Int32}, Q::Ptr{Int32}, Dx::Ptr{Cdouble}, Dz::Ptr{Cdouble}, do_recip::Ptr{Int32}, Rs::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
-end
-
-function umfpack_zl_get_numeric(Lp, Lj, Lx, Lz, Up, Ui, Ux, Uz, P, Q, Dx, Dz, do_recip, Rs, Numeric)
-    @ccall libumfpack.umfpack_zl_get_numeric(Lp::Ptr{Int64}, Lj::Ptr{Int64}, Lx::Ptr{Cdouble}, Lz::Ptr{Cdouble}, Up::Ptr{Int64}, Ui::Ptr{Int64}, Ux::Ptr{Cdouble}, Uz::Ptr{Cdouble}, P::Ptr{Int64}, Q::Ptr{Int64}, Dx::Ptr{Cdouble}, Dz::Ptr{Cdouble}, do_recip::Ptr{Int64}, Rs::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
-end
-
-function umfpack_di_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol, Front_parent, Front_1strow, Front_leftmostdesc, Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
-    @ccall libumfpack.umfpack_di_get_symbolic(n_row::Ptr{Int32}, n_col::Ptr{Int32}, n1::Ptr{Int32}, nz::Ptr{Int32}, nfr::Ptr{Int32}, nchains::Ptr{Int32}, P::Ptr{Int32}, Q::Ptr{Int32}, Front_npivcol::Ptr{Int32}, Front_parent::Ptr{Int32}, Front_1strow::Ptr{Int32}, Front_leftmostdesc::Ptr{Int32}, Chain_start::Ptr{Int32}, Chain_maxrows::Ptr{Int32}, Chain_maxcols::Ptr{Int32}, Dmap::Ptr{Int32}, Symbolic::Ptr{Cvoid})::Cint
-end
-
-function umfpack_dl_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol, Front_parent, Front_1strow, Front_leftmostdesc, Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
-    @ccall libumfpack.umfpack_dl_get_symbolic(n_row::Ptr{Int64}, n_col::Ptr{Int64}, n1::Ptr{Int64}, nz::Ptr{Int64}, nfr::Ptr{Int64}, nchains::Ptr{Int64}, P::Ptr{Int64}, Q::Ptr{Int64}, Front_npivcol::Ptr{Int64}, Front_parent::Ptr{Int64}, Front_1strow::Ptr{Int64}, Front_leftmostdesc::Ptr{Int64}, Chain_start::Ptr{Int64}, Chain_maxrows::Ptr{Int64}, Chain_maxcols::Ptr{Int64}, Dmap::Ptr{Int64}, Symbolic::Ptr{Cvoid})::Cint
-end
-
-function umfpack_zi_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol, Front_parent, Front_1strow, Front_leftmostdesc, Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
-    @ccall libumfpack.umfpack_zi_get_symbolic(n_row::Ptr{Int32}, n_col::Ptr{Int32}, n1::Ptr{Int32}, nz::Ptr{Int32}, nfr::Ptr{Int32}, nchains::Ptr{Int32}, P::Ptr{Int32}, Q::Ptr{Int32}, Front_npivcol::Ptr{Int32}, Front_parent::Ptr{Int32}, Front_1strow::Ptr{Int32}, Front_leftmostdesc::Ptr{Int32}, Chain_start::Ptr{Int32}, Chain_maxrows::Ptr{Int32}, Chain_maxcols::Ptr{Int32}, Dmap::Ptr{Int32}, Symbolic::Ptr{Cvoid})::Cint
-end
-
-function umfpack_zl_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol, Front_parent, Front_1strow, Front_leftmostdesc, Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
-    @ccall libumfpack.umfpack_zl_get_symbolic(n_row::Ptr{Int64}, n_col::Ptr{Int64}, n1::Ptr{Int64}, nz::Ptr{Int64}, nfr::Ptr{Int64}, nchains::Ptr{Int64}, P::Ptr{Int64}, Q::Ptr{Int64}, Front_npivcol::Ptr{Int64}, Front_parent::Ptr{Int64}, Front_1strow::Ptr{Int64}, Front_leftmostdesc::Ptr{Int64}, Chain_start::Ptr{Int64}, Chain_maxrows::Ptr{Int64}, Chain_maxcols::Ptr{Int64}, Dmap::Ptr{Int64}, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_get_numeric(Lp::Ptr{Int64}, Lj::Ptr{Int64},
+                                             Lx::Ptr{Cdouble}, Up::Ptr{Int64},
+                                             Ui::Ptr{Int64}, Ux::Ptr{Cdouble},
+                                             P::Ptr{Int64}, Q::Ptr{Int64}, Dx::Ptr{Cdouble},
+                                             do_recip::Ptr{Int64}, Rs::Ptr{Cdouble},
+                                             Numeric::Ptr{Cvoid})::Cint
+end
+
+function umfpack_zi_get_numeric(Lp, Lj, Lx, Lz, Up, Ui, Ux, Uz, P, Q, Dx, Dz, do_recip, Rs,
+                                Numeric)
+    @ccall libumfpack.umfpack_zi_get_numeric(Lp::Ptr{Int32}, Lj::Ptr{Int32},
+                                             Lx::Ptr{Cdouble}, Lz::Ptr{Cdouble},
+                                             Up::Ptr{Int32}, Ui::Ptr{Int32},
+                                             Ux::Ptr{Cdouble}, Uz::Ptr{Cdouble},
+                                             P::Ptr{Int32}, Q::Ptr{Int32}, Dx::Ptr{Cdouble},
+                                             Dz::Ptr{Cdouble}, do_recip::Ptr{Int32},
+                                             Rs::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+end
+
+function umfpack_zl_get_numeric(Lp, Lj, Lx, Lz, Up, Ui, Ux, Uz, P, Q, Dx, Dz, do_recip, Rs,
+                                Numeric)
+    @ccall libumfpack.umfpack_zl_get_numeric(Lp::Ptr{Int64}, Lj::Ptr{Int64},
+                                             Lx::Ptr{Cdouble}, Lz::Ptr{Cdouble},
+                                             Up::Ptr{Int64}, Ui::Ptr{Int64},
+                                             Ux::Ptr{Cdouble}, Uz::Ptr{Cdouble},
+                                             P::Ptr{Int64}, Q::Ptr{Int64}, Dx::Ptr{Cdouble},
+                                             Dz::Ptr{Cdouble}, do_recip::Ptr{Int64},
+                                             Rs::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+end
+
+function umfpack_di_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol,
+                                 Front_parent, Front_1strow, Front_leftmostdesc,
+                                 Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
+    @ccall libumfpack.umfpack_di_get_symbolic(n_row::Ptr{Int32}, n_col::Ptr{Int32},
+                                              n1::Ptr{Int32}, nz::Ptr{Int32},
+                                              nfr::Ptr{Int32}, nchains::Ptr{Int32},
+                                              P::Ptr{Int32}, Q::Ptr{Int32},
+                                              Front_npivcol::Ptr{Int32},
+                                              Front_parent::Ptr{Int32},
+                                              Front_1strow::Ptr{Int32},
+                                              Front_leftmostdesc::Ptr{Int32},
+                                              Chain_start::Ptr{Int32},
+                                              Chain_maxrows::Ptr{Int32},
+                                              Chain_maxcols::Ptr{Int32}, Dmap::Ptr{Int32},
+                                              Symbolic::Ptr{Cvoid})::Cint
+end
+
+function umfpack_dl_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol,
+                                 Front_parent, Front_1strow, Front_leftmostdesc,
+                                 Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
+    @ccall libumfpack.umfpack_dl_get_symbolic(n_row::Ptr{Int64}, n_col::Ptr{Int64},
+                                              n1::Ptr{Int64}, nz::Ptr{Int64},
+                                              nfr::Ptr{Int64}, nchains::Ptr{Int64},
+                                              P::Ptr{Int64}, Q::Ptr{Int64},
+                                              Front_npivcol::Ptr{Int64},
+                                              Front_parent::Ptr{Int64},
+                                              Front_1strow::Ptr{Int64},
+                                              Front_leftmostdesc::Ptr{Int64},
+                                              Chain_start::Ptr{Int64},
+                                              Chain_maxrows::Ptr{Int64},
+                                              Chain_maxcols::Ptr{Int64}, Dmap::Ptr{Int64},
+                                              Symbolic::Ptr{Cvoid})::Cint
+end
+
+function umfpack_zi_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol,
+                                 Front_parent, Front_1strow, Front_leftmostdesc,
+                                 Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
+    @ccall libumfpack.umfpack_zi_get_symbolic(n_row::Ptr{Int32}, n_col::Ptr{Int32},
+                                              n1::Ptr{Int32}, nz::Ptr{Int32},
+                                              nfr::Ptr{Int32}, nchains::Ptr{Int32},
+                                              P::Ptr{Int32}, Q::Ptr{Int32},
+                                              Front_npivcol::Ptr{Int32},
+                                              Front_parent::Ptr{Int32},
+                                              Front_1strow::Ptr{Int32},
+                                              Front_leftmostdesc::Ptr{Int32},
+                                              Chain_start::Ptr{Int32},
+                                              Chain_maxrows::Ptr{Int32},
+                                              Chain_maxcols::Ptr{Int32}, Dmap::Ptr{Int32},
+                                              Symbolic::Ptr{Cvoid})::Cint
+end
+
+function umfpack_zl_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol,
+                                 Front_parent, Front_1strow, Front_leftmostdesc,
+                                 Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
+    @ccall libumfpack.umfpack_zl_get_symbolic(n_row::Ptr{Int64}, n_col::Ptr{Int64},
+                                              n1::Ptr{Int64}, nz::Ptr{Int64},
+                                              nfr::Ptr{Int64}, nchains::Ptr{Int64},
+                                              P::Ptr{Int64}, Q::Ptr{Int64},
+                                              Front_npivcol::Ptr{Int64},
+                                              Front_parent::Ptr{Int64},
+                                              Front_1strow::Ptr{Int64},
+                                              Front_leftmostdesc::Ptr{Int64},
+                                              Chain_start::Ptr{Int64},
+                                              Chain_maxrows::Ptr{Int64},
+                                              Chain_maxcols::Ptr{Int64}, Dmap::Ptr{Int64},
+                                              Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_save_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_di_save_numeric(Numeric::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_di_save_numeric(Numeric::Ptr{Cvoid},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_dl_save_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_dl_save_numeric(Numeric::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_dl_save_numeric(Numeric::Ptr{Cvoid},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zi_save_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_zi_save_numeric(Numeric::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zi_save_numeric(Numeric::Ptr{Cvoid},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zl_save_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_zl_save_numeric(Numeric::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zl_save_numeric(Numeric::Ptr{Cvoid},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_di_load_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_di_load_numeric(Numeric::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_di_load_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_dl_load_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_dl_load_numeric(Numeric::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_dl_load_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zi_load_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_zi_load_numeric(Numeric::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zi_load_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zl_load_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_zl_load_numeric(Numeric::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zl_load_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_di_copy_numeric(Numeric, Original)
-    @ccall libumfpack.umfpack_di_copy_numeric(Numeric::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_copy_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_copy_numeric(Numeric, Original)
-    @ccall libumfpack.umfpack_dl_copy_numeric(Numeric::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_copy_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_copy_numeric(Numeric, Original)
-    @ccall libumfpack.umfpack_zi_copy_numeric(Numeric::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_copy_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_copy_numeric(Numeric, Original)
-    @ccall libumfpack.umfpack_zl_copy_numeric(Numeric::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_copy_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_serialize_numeric_size(blobsize, Numeric)
-    @ccall libumfpack.umfpack_di_serialize_numeric_size(blobsize::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_serialize_numeric_size(blobsize::Ptr{Int64},
+                                                        Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_serialize_numeric_size(blobsize, Numeric)
-    @ccall libumfpack.umfpack_dl_serialize_numeric_size(blobsize::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_serialize_numeric_size(blobsize::Ptr{Int64},
+                                                        Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_serialize_numeric_size(blobsize, Numeric)
-    @ccall libumfpack.umfpack_zi_serialize_numeric_size(blobsize::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_serialize_numeric_size(blobsize::Ptr{Int64},
+                                                        Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_serialize_numeric_size(blobsize, Numeric)
-    @ccall libumfpack.umfpack_zl_serialize_numeric_size(blobsize::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_serialize_numeric_size(blobsize::Ptr{Int64},
+                                                        Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_serialize_numeric(blob, blobsize, Numeric)
-    @ccall libumfpack.umfpack_di_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64,
+                                                   Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_serialize_numeric(blob, blobsize, Numeric)
-    @ccall libumfpack.umfpack_dl_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64,
+                                                   Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_serialize_numeric(blob, blobsize, Numeric)
-    @ccall libumfpack.umfpack_zi_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64,
+                                                   Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_serialize_numeric(blob, blobsize, Numeric)
-    @ccall libumfpack.umfpack_zl_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64,
+                                                   Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_deserialize_numeric(Numeric, blob, blobsize)
-    @ccall libumfpack.umfpack_di_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_di_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                                     blob::Ptr{Int8}, blobsize::Int64)::Cint
 end
 
 function umfpack_dl_deserialize_numeric(Numeric, blob, blobsize)
-    @ccall libumfpack.umfpack_dl_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_dl_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                                     blob::Ptr{Int8}, blobsize::Int64)::Cint
 end
 
 function umfpack_zi_deserialize_numeric(Numeric, blob, blobsize)
-    @ccall libumfpack.umfpack_zi_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_zi_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                                     blob::Ptr{Int8}, blobsize::Int64)::Cint
 end
 
 function umfpack_zl_deserialize_numeric(Numeric, blob, blobsize)
-    @ccall libumfpack.umfpack_zl_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_zl_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                                     blob::Ptr{Int8}, blobsize::Int64)::Cint
 end
 
 function umfpack_di_save_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_di_save_symbolic(Symbolic::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_di_save_symbolic(Symbolic::Ptr{Cvoid},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_dl_save_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_dl_save_symbolic(Symbolic::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_dl_save_symbolic(Symbolic::Ptr{Cvoid},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zi_save_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_zi_save_symbolic(Symbolic::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zi_save_symbolic(Symbolic::Ptr{Cvoid},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zl_save_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_zl_save_symbolic(Symbolic::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zl_save_symbolic(Symbolic::Ptr{Cvoid},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_di_load_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_di_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_di_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_dl_load_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_dl_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_dl_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zi_load_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_zi_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zi_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zl_load_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_zl_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zl_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_di_copy_symbolic(Symbolic, Original)
-    @ccall libumfpack.umfpack_di_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_copy_symbolic(Symbolic, Original)
-    @ccall libumfpack.umfpack_dl_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_copy_symbolic(Symbolic, Original)
-    @ccall libumfpack.umfpack_zi_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_copy_symbolic(Symbolic, Original)
-    @ccall libumfpack.umfpack_zl_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_serialize_symbolic_size(blobsize, Symbolic)
-    @ccall libumfpack.umfpack_di_serialize_symbolic_size(blobsize::Ptr{Int64}, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_serialize_symbolic_size(blobsize::Ptr{Int64},
+                                                         Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_serialize_symbolic_size(blobsize, Symbolic)
-    @ccall libumfpack.umfpack_dl_serialize_symbolic_size(blobsize::Ptr{Int64}, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_serialize_symbolic_size(blobsize::Ptr{Int64},
+                                                         Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_serialize_symbolic_size(blobsize, Symbolic)
-    @ccall libumfpack.umfpack_zi_serialize_symbolic_size(blobsize::Ptr{Int64}, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_serialize_symbolic_size(blobsize::Ptr{Int64},
+                                                         Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_serialize_symbolic_size(blobsize, Symbolic)
-    @ccall libumfpack.umfpack_zl_serialize_symbolic_size(blobsize::Ptr{Int64}, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_serialize_symbolic_size(blobsize::Ptr{Int64},
+                                                         Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_serialize_symbolic(blob, blobsize, Symbolic)
-    @ccall libumfpack.umfpack_di_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64,
+                                                    Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_serialize_symbolic(blob, blobsize, Symbolic)
-    @ccall libumfpack.umfpack_dl_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64,
+                                                    Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_serialize_symbolic(blob, blobsize, Symbolic)
-    @ccall libumfpack.umfpack_zi_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64,
+                                                    Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_serialize_symbolic(blob, blobsize, Symbolic)
-    @ccall libumfpack.umfpack_zl_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64,
+                                                    Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_deserialize_symbolic(Symbolic, blob, blobsize)
-    @ccall libumfpack.umfpack_di_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_di_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                                      blob::Ptr{Int8},
+                                                      blobsize::Int64)::Cint
 end
 
 function umfpack_dl_deserialize_symbolic(Symbolic, blob, blobsize)
-    @ccall libumfpack.umfpack_dl_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_dl_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                                      blob::Ptr{Int8},
+                                                      blobsize::Int64)::Cint
 end
 
 function umfpack_zi_deserialize_symbolic(Symbolic, blob, blobsize)
-    @ccall libumfpack.umfpack_zi_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_zi_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                                      blob::Ptr{Int8},
+                                                      blobsize::Int64)::Cint
 end
 
 function umfpack_zl_deserialize_symbolic(Symbolic, blob, blobsize)
-    @ccall libumfpack.umfpack_zl_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_zl_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                                      blob::Ptr{Int8},
+                                                      blobsize::Int64)::Cint
 end
 
 function umfpack_di_get_determinant(Mx, Ex, Numeric, User_Info)
-    @ccall libumfpack.umfpack_di_get_determinant(Mx::Ptr{Cdouble}, Ex::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, User_Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_get_determinant(Mx::Ptr{Cdouble}, Ex::Ptr{Cdouble},
+                                                 Numeric::Ptr{Cvoid},
+                                                 User_Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_get_determinant(Mx, Ex, Numeric, User_Info)
-    @ccall libumfpack.umfpack_dl_get_determinant(Mx::Ptr{Cdouble}, Ex::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, User_Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_get_determinant(Mx::Ptr{Cdouble}, Ex::Ptr{Cdouble},
+                                                 Numeric::Ptr{Cvoid},
+                                                 User_Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_get_determinant(Mx, Mz, Ex, Numeric, User_Info)
-    @ccall libumfpack.umfpack_zi_get_determinant(Mx::Ptr{Cdouble}, Mz::Ptr{Cdouble}, Ex::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, User_Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_get_determinant(Mx::Ptr{Cdouble}, Mz::Ptr{Cdouble},
+                                                 Ex::Ptr{Cdouble}, Numeric::Ptr{Cvoid},
+                                                 User_Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_get_determinant(Mx, Mz, Ex, Numeric, User_Info)
-    @ccall libumfpack.umfpack_zl_get_determinant(Mx::Ptr{Cdouble}, Mz::Ptr{Cdouble}, Ex::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, User_Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_get_determinant(Mx::Ptr{Cdouble}, Mz::Ptr{Cdouble},
+                                                 Ex::Ptr{Cdouble}, Numeric::Ptr{Cvoid},
+                                                 User_Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_report_status(Control, status)
@@ -2256,19 +3038,23 @@ function umfpack_zl_report_status(Control, status)
 end
 
 function umfpack_di_report_info(Control, Info)
-    @ccall libumfpack.umfpack_di_report_info(Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cvoid
+    @ccall libumfpack.umfpack_di_report_info(Control::Ptr{Cdouble},
+                                             Info::Ptr{Cdouble})::Cvoid
 end
 
 function umfpack_dl_report_info(Control, Info)
-    @ccall libumfpack.umfpack_dl_report_info(Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cvoid
+    @ccall libumfpack.umfpack_dl_report_info(Control::Ptr{Cdouble},
+                                             Info::Ptr{Cdouble})::Cvoid
 end
 
 function umfpack_zi_report_info(Control, Info)
-    @ccall libumfpack.umfpack_zi_report_info(Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cvoid
+    @ccall libumfpack.umfpack_zi_report_info(Control::Ptr{Cdouble},
+                                             Info::Ptr{Cdouble})::Cvoid
 end
 
 function umfpack_zl_report_info(Control, Info)
-    @ccall libumfpack.umfpack_zl_report_info(Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cvoid
+    @ccall libumfpack.umfpack_zl_report_info(Control::Ptr{Cdouble},
+                                             Info::Ptr{Cdouble})::Cvoid
 end
 
 function umfpack_di_report_control(Control)
@@ -2288,99 +3074,137 @@ function umfpack_zl_report_control(Control)
 end
 
 function umfpack_di_report_matrix(n_row, n_col, Ap, Ai, Ax, col_form, Control)
-    @ccall libumfpack.umfpack_di_report_matrix(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, col_form::Cint, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_report_matrix(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                               Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                               col_form::Cint, Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_report_matrix(n_row, n_col, Ap, Ai, Ax, col_form, Control)
-    @ccall libumfpack.umfpack_dl_report_matrix(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, col_form::Cint, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_report_matrix(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                               Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                               col_form::Cint, Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_report_matrix(n_row, n_col, Ap, Ai, Ax, Az, col_form, Control)
-    @ccall libumfpack.umfpack_zi_report_matrix(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, col_form::Cint, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_report_matrix(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                               Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                               Az::Ptr{Cdouble}, col_form::Cint,
+                                               Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_report_matrix(n_row, n_col, Ap, Ai, Ax, Az, col_form, Control)
-    @ccall libumfpack.umfpack_zl_report_matrix(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, col_form::Cint, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_report_matrix(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                               Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                               Az::Ptr{Cdouble}, col_form::Cint,
+                                               Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_report_triplet(n_row, n_col, nz, Ti, Tj, Tx, Control)
-    @ccall libumfpack.umfpack_di_report_triplet(n_row::Int32, n_col::Int32, nz::Int32, Ti::Ptr{Int32}, Tj::Ptr{Int32}, Tx::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_report_triplet(n_row::Int32, n_col::Int32, nz::Int32,
+                                                Ti::Ptr{Int32}, Tj::Ptr{Int32},
+                                                Tx::Ptr{Cdouble},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_report_triplet(n_row, n_col, nz, Ti, Tj, Tx, Control)
-    @ccall libumfpack.umfpack_dl_report_triplet(n_row::Int64, n_col::Int64, nz::Int64, Ti::Ptr{Int64}, Tj::Ptr{Int64}, Tx::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_report_triplet(n_row::Int64, n_col::Int64, nz::Int64,
+                                                Ti::Ptr{Int64}, Tj::Ptr{Int64},
+                                                Tx::Ptr{Cdouble},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_report_triplet(n_row, n_col, nz, Ti, Tj, Tx, Tz, Control)
-    @ccall libumfpack.umfpack_zi_report_triplet(n_row::Int32, n_col::Int32, nz::Int32, Ti::Ptr{Int32}, Tj::Ptr{Int32}, Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_report_triplet(n_row::Int32, n_col::Int32, nz::Int32,
+                                                Ti::Ptr{Int32}, Tj::Ptr{Int32},
+                                                Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_report_triplet(n_row, n_col, nz, Ti, Tj, Tx, Tz, Control)
-    @ccall libumfpack.umfpack_zl_report_triplet(n_row::Int64, n_col::Int64, nz::Int64, Ti::Ptr{Int64}, Tj::Ptr{Int64}, Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_report_triplet(n_row::Int64, n_col::Int64, nz::Int64,
+                                                Ti::Ptr{Int64}, Tj::Ptr{Int64},
+                                                Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_report_vector(n, X, Control)
-    @ccall libumfpack.umfpack_di_report_vector(n::Int32, X::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_report_vector(n::Int32, X::Ptr{Cdouble},
+                                               Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_report_vector(n, X, Control)
-    @ccall libumfpack.umfpack_dl_report_vector(n::Int64, X::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_report_vector(n::Int64, X::Ptr{Cdouble},
+                                               Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_report_vector(n, Xx, Xz, Control)
-    @ccall libumfpack.umfpack_zi_report_vector(n::Int32, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_report_vector(n::Int32, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble},
+                                               Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_report_vector(n, Xx, Xz, Control)
-    @ccall libumfpack.umfpack_zl_report_vector(n::Int64, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_report_vector(n::Int64, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble},
+                                               Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_report_symbolic(Symbolic, Control)
-    @ccall libumfpack.umfpack_di_report_symbolic(Symbolic::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_report_symbolic(Symbolic::Ptr{Cvoid},
+                                                 Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_report_symbolic(Symbolic, Control)
-    @ccall libumfpack.umfpack_dl_report_symbolic(Symbolic::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_report_symbolic(Symbolic::Ptr{Cvoid},
+                                                 Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_report_symbolic(Symbolic, Control)
-    @ccall libumfpack.umfpack_zi_report_symbolic(Symbolic::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_report_symbolic(Symbolic::Ptr{Cvoid},
+                                                 Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_report_symbolic(Symbolic, Control)
-    @ccall libumfpack.umfpack_zl_report_symbolic(Symbolic::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_report_symbolic(Symbolic::Ptr{Cvoid},
+                                                 Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_report_numeric(Numeric, Control)
-    @ccall libumfpack.umfpack_di_report_numeric(Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_report_numeric(Numeric::Ptr{Cvoid},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_report_numeric(Numeric, Control)
-    @ccall libumfpack.umfpack_dl_report_numeric(Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_report_numeric(Numeric::Ptr{Cvoid},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_report_numeric(Numeric, Control)
-    @ccall libumfpack.umfpack_zi_report_numeric(Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_report_numeric(Numeric::Ptr{Cvoid},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_report_numeric(Numeric, Control)
-    @ccall libumfpack.umfpack_zl_report_numeric(Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_report_numeric(Numeric::Ptr{Cvoid},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_report_perm(np, Perm, Control)
-    @ccall libumfpack.umfpack_di_report_perm(np::Int32, Perm::Ptr{Int32}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_report_perm(np::Int32, Perm::Ptr{Int32},
+                                             Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_report_perm(np, Perm, Control)
-    @ccall libumfpack.umfpack_dl_report_perm(np::Int64, Perm::Ptr{Int64}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_report_perm(np::Int64, Perm::Ptr{Int64},
+                                             Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_report_perm(np, Perm, Control)
-    @ccall libumfpack.umfpack_zi_report_perm(np::Int32, Perm::Ptr{Int32}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_report_perm(np::Int32, Perm::Ptr{Int32},
+                                             Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_report_perm(np, Perm, Control)
-    @ccall libumfpack.umfpack_zl_report_perm(np::Int64, Perm::Ptr{Int64}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_report_perm(np::Int64, Perm::Ptr{Int64},
+                                             Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_timer()
@@ -2395,13 +3219,13 @@ function umfpack_toc(stats)
     @ccall libumfpack.umfpack_toc(stats::Ptr{Cdouble})::Cvoid
 end
 
-const CHOLMOD_DATE = "Jan 17, 2023"
+const CHOLMOD_DATE = "June 16, 2023"
 
 const CHOLMOD_MAIN_VERSION = 4
 
 const CHOLMOD_SUB_VERSION = 0
 
-const CHOLMOD_SUBSUB_VERSION = 3
+const CHOLMOD_SUBSUB_VERSION = 4
 
 const _FILE_OFFSET_BITS = 64
 
@@ -2427,17 +3251,18 @@ const SUITESPARSE_COMPILER_MSC = 0
 
 const SUITESPARSE_COMPILER_XLC = 0
 
-const SUITESPARSE_DATE = "Jan 20, 2023"
+const SUITESPARSE_DATE = "June 29, 2023"
 
 const SUITESPARSE_MAIN_VERSION = 7
 
-const SUITESPARSE_SUB_VERSION = 0
+const SUITESPARSE_SUB_VERSION = 1
 
-const SUITESPARSE_SUBSUB_VERSION = 1
+const SUITESPARSE_SUBSUB_VERSION = 0
 
 SUITESPARSE_VER_CODE(main, sub) = main * 1000 + sub
 
-const SUITESPARSE_VERSION = SUITESPARSE_VER_CODE(SUITESPARSE_MAIN_VERSION, SUITESPARSE_SUB_VERSION)
+const SUITESPARSE_VERSION = SUITESPARSE_VER_CODE(SUITESPARSE_MAIN_VERSION,
+                                                 SUITESPARSE_SUB_VERSION)
 
 CHOLMOD_VER_CODE(main, sub) = main * 1000 + sub
 
@@ -2601,20 +3426,18 @@ const SPQR_RTX_EQUALS_B = 2
 
 const SPQR_RTX_EQUALS_ETB = 3
 
-const SPQR_DATE = "Jan 17, 2023"
+const SPQR_DATE = "July FIXME, 2023"
 
-const SPQR_MAIN_VERSION = 3
+const SPQR_MAIN_VERSION = 4
 
 const SPQR_SUB_VERSION = 0
 
-const SPQR_SUBSUB_VERSION = 3
+const SPQR_SUBSUB_VERSION = 0
 
 SPQR_VER_CODE(main, sub) = main * 1000 + sub
 
 const SPQR_VERSION = SPQR_VER_CODE(SPQR_MAIN_VERSION, SPQR_SUB_VERSION)
 
-const Complex = Float64
-
 const AMD_CONTROL = 5
 
 const AMD_INFO = 20
@@ -2663,172 +3486,29 @@ const AMD_INVALID = -2
 
 const AMD_OK_BUT_JUMBLED = 1
 
-const AMD_DATE = "Jan 17, 2023"
+const AMD_DATE = "June 16, 2023"
 
 const AMD_MAIN_VERSION = 3
 
 const AMD_SUB_VERSION = 0
 
-const AMD_SUBSUB_VERSION = 3
+const AMD_SUBSUB_VERSION = 4
 
 AMD_VERSION_CODE(main, sub) = main * 1000 + sub
 
 const AMD_VERSION = AMD_VERSION_CODE(AMD_MAIN_VERSION, AMD_SUB_VERSION)
 
-const COLAMD_DATE = "Jan 17, 2023"
-
-const COLAMD_MAIN_VERSION = 3
-
-const COLAMD_SUB_VERSION = 0
-
-const COLAMD_SUBSUB_VERSION = 3
-
-COLAMD_VERSION_CODE(main, sub) = main * 1000 + sub
-
-const COLAMD_VERSION = COLAMD_VERSION_CODE(COLAMD_MAIN_VERSION, COLAMD_SUB_VERSION)
-
-const COLAMD_KNOBS = 20
-
-const COLAMD_STATS = 20
-
-const COLAMD_DENSE_ROW = 0
-
-const COLAMD_DENSE_COL = 1
-
-const COLAMD_AGGRESSIVE = 2
-
-const COLAMD_DEFRAG_COUNT = 2
-
-const COLAMD_STATUS = 3
-
-const COLAMD_INFO1 = 4
-
-const COLAMD_INFO2 = 5
-
-const COLAMD_INFO3 = 6
-
-const COLAMD_OK = 0
-
-const COLAMD_OK_BUT_JUMBLED = 1
-
-const COLAMD_ERROR_A_not_present = -1
-
-const COLAMD_ERROR_p_not_present = -2
-
-const COLAMD_ERROR_nrow_negative = -3
-
-const COLAMD_ERROR_ncol_negative = -4
-
-const COLAMD_ERROR_nnz_negative = -5
-
-const COLAMD_ERROR_p0_nonzero = -6
-
-const COLAMD_ERROR_A_too_small = -7
-
-const COLAMD_ERROR_col_length_negative = -8
-
-const COLAMD_ERROR_row_index_out_of_bounds = -9
-
-const COLAMD_ERROR_out_of_memory = -10
-
-const COLAMD_ERROR_internal_error = -999
-
-const CCOLAMD_DATE = "Jan 17, 2023"
-
-const CCOLAMD_MAIN_VERSION = 3
-
-const CCOLAMD_SUB_VERSION = 0
-
-const CCOLAMD_SUBSUB_VERSION = 3
-
-CCOLAMD_VERSION_CODE(main, sub) = main * 1000 + sub
-
-const CCOLAMD_VERSION = CCOLAMD_VERSION_CODE(CCOLAMD_MAIN_VERSION, CCOLAMD_SUB_VERSION)
-
-const CCOLAMD_KNOBS = 20
-
-const CCOLAMD_STATS = 20
-
-const CCOLAMD_DENSE_ROW = 0
-
-const CCOLAMD_DENSE_COL = 1
-
-const CCOLAMD_AGGRESSIVE = 2
-
-const CCOLAMD_LU = 3
-
-const CCOLAMD_DEFRAG_COUNT = 2
-
-const CCOLAMD_STATUS = 3
-
-const CCOLAMD_INFO1 = 4
-
-const CCOLAMD_INFO2 = 5
-
-const CCOLAMD_INFO3 = 6
-
-const CCOLAMD_EMPTY_ROW = 7
-
-const CCOLAMD_EMPTY_COL = 8
-
-const CCOLAMD_NEWLY_EMPTY_ROW = 9
-
-const CCOLAMD_NEWLY_EMPTY_COL = 10
-
-const CCOLAMD_OK = 0
-
-const CCOLAMD_OK_BUT_JUMBLED = 1
-
-const CCOLAMD_ERROR_A_not_present = -1
-
-const CCOLAMD_ERROR_p_not_present = -2
-
-const CCOLAMD_ERROR_nrow_negative = -3
-
-const CCOLAMD_ERROR_ncol_negative = -4
-
-const CCOLAMD_ERROR_nnz_negative = -5
-
-const CCOLAMD_ERROR_p0_nonzero = -6
-
-const CCOLAMD_ERROR_A_too_small = -7
-
-const CCOLAMD_ERROR_col_length_negative = -8
-
-const CCOLAMD_ERROR_row_index_out_of_bounds = -9
-
-const CCOLAMD_ERROR_out_of_memory = -10
-
-const CCOLAMD_ERROR_invalid_cmember = -11
-
-const CCOLAMD_ERROR_internal_error = -999
-
 const UMFPACK_INFO = 90
 
 const UMFPACK_CONTROL = 20
 
-# Skipping MacroDefinition: UMFPACK_COPYRIGHT \
-#"UMFPACK:  Copyright (c) 2005-2023 by Timothy A. Davis.  All Rights Reserved.\n"
-
-# Skipping MacroDefinition: UMFPACK_LICENSE_PART1 \
-#"\nUMFPACK License: SPDX-License-Identifier: GPL-2.0+\n" \
-#"   UMFPACK is available under alternate licenses,\n" \
-#"   contact T. Davis for details.\n"
-
-const UMFPACK_LICENSE_PART2 = "\n"
-
-# Skipping MacroDefinition: UMFPACK_LICENSE_PART3 \
-#"\n" \
-#"Availability: http://www.suitesparse.com" \
-#"\n"
-
-const UMFPACK_DATE = "Jan 17, 2023"
+const UMFPACK_DATE = "June 16, 2023"
 
 const UMFPACK_MAIN_VERSION = 6
 
 const UMFPACK_SUB_VERSION = 1
 
-const UMFPACK_SUBSUB_VERSION = 0
+const UMFPACK_SUBSUB_VERSION = 1
 
 UMFPACK_VER_CODE(main, sub) = main * 1000 + sub
 
@@ -3169,4 +3849,3 @@ const UMFPACK_Q_Uat = 12
 const UMFPACK_Ut = 13
 
 const UMFPACK_Uat = 14
-
diff --git a/src/solvers/lib/powerpc64le-linux-gnu.jl b/src/solvers/lib/powerpc64le-linux-gnu.jl
index fcf756d2..a5aa4e44 100644
--- a/src/solvers/lib/powerpc64le-linux-gnu.jl
+++ b/src/solvers/lib/powerpc64le-linux-gnu.jl
@@ -1,137 +1,150 @@
 function SuiteSparse_config_printf_func_get()
-    @ccall libcholmod.SuiteSparse_config_printf_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_printf_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_malloc_func_get()
-    @ccall libcholmod.SuiteSparse_config_malloc_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_malloc_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_calloc_func_get()
-    @ccall libcholmod.SuiteSparse_config_calloc_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_calloc_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_realloc_func_get()
-    @ccall libcholmod.SuiteSparse_config_realloc_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_realloc_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_free_func_get()
-    @ccall libcholmod.SuiteSparse_config_free_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_free_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_hypot_func_get()
-    @ccall libcholmod.SuiteSparse_config_hypot_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_hypot_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_divcomplex_func_get()
-    @ccall libcholmod.SuiteSparse_config_divcomplex_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_divcomplex_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_malloc_func_set(malloc_func)
-    @ccall libcholmod.SuiteSparse_config_malloc_func_set(malloc_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_malloc_func_set(malloc_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_calloc_func_set(calloc_func)
-    @ccall libcholmod.SuiteSparse_config_calloc_func_set(calloc_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_calloc_func_set(calloc_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_realloc_func_set(realloc_func)
-    @ccall libcholmod.SuiteSparse_config_realloc_func_set(realloc_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_realloc_func_set(realloc_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_free_func_set(free_func)
-    @ccall libcholmod.SuiteSparse_config_free_func_set(free_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_free_func_set(free_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_printf_func_set(printf_func)
-    @ccall libcholmod.SuiteSparse_config_printf_func_set(printf_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_printf_func_set(printf_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_hypot_func_set(hypot_func)
-    @ccall libcholmod.SuiteSparse_config_hypot_func_set(hypot_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_hypot_func_set(hypot_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_divcomplex_func_set(divcomplex_func)
-    @ccall libcholmod.SuiteSparse_config_divcomplex_func_set(divcomplex_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_divcomplex_func_set(divcomplex_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_malloc(s)
-    @ccall libcholmod.SuiteSparse_config_malloc(s::Csize_t)::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_malloc(s::Csize_t)::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_calloc(n, s)
-    @ccall libcholmod.SuiteSparse_config_calloc(n::Csize_t, s::Csize_t)::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_calloc(n::Csize_t,
+                                                          s::Csize_t)::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_realloc(arg1, s)
-    @ccall libcholmod.SuiteSparse_config_realloc(arg1::Ptr{Cvoid}, s::Csize_t)::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_realloc(arg1::Ptr{Cvoid},
+                                                           s::Csize_t)::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_free(arg1)
-    @ccall libcholmod.SuiteSparse_config_free(arg1::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_free(arg1::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_hypot(x, y)
-    @ccall libcholmod.SuiteSparse_config_hypot(x::Cdouble, y::Cdouble)::Cdouble
+    @ccall libsuitesparseconfig.SuiteSparse_config_hypot(x::Cdouble, y::Cdouble)::Cdouble
 end
 
 function SuiteSparse_config_divcomplex(xr, xi, yr, yi, zr, zi)
-    @ccall libcholmod.SuiteSparse_config_divcomplex(xr::Cdouble, xi::Cdouble, yr::Cdouble, yi::Cdouble, zr::Ptr{Cdouble}, zi::Ptr{Cdouble})::Cint
+    @ccall libsuitesparseconfig.SuiteSparse_config_divcomplex(xr::Cdouble, xi::Cdouble,
+                                                              yr::Cdouble, yi::Cdouble,
+                                                              zr::Ptr{Cdouble},
+                                                              zi::Ptr{Cdouble})::Cint
 end
 
 function SuiteSparse_start()
-    @ccall libcholmod.SuiteSparse_start()::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_start()::Cvoid
 end
 
 function SuiteSparse_finish()
-    @ccall libcholmod.SuiteSparse_finish()::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_finish()::Cvoid
 end
 
 function SuiteSparse_malloc(nitems, size_of_item)
-    @ccall libcholmod.SuiteSparse_malloc(nitems::Csize_t, size_of_item::Csize_t)::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_malloc(nitems::Csize_t,
+                                                   size_of_item::Csize_t)::Ptr{Cvoid}
 end
 
 function SuiteSparse_calloc(nitems, size_of_item)
-    @ccall libcholmod.SuiteSparse_calloc(nitems::Csize_t, size_of_item::Csize_t)::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_calloc(nitems::Csize_t,
+                                                   size_of_item::Csize_t)::Ptr{Cvoid}
 end
 
 function SuiteSparse_realloc(nitems_new, nitems_old, size_of_item, p, ok)
-    @ccall libcholmod.SuiteSparse_realloc(nitems_new::Csize_t, nitems_old::Csize_t, size_of_item::Csize_t, p::Ptr{Cvoid}, ok::Ptr{Cint})::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_realloc(nitems_new::Csize_t,
+                                                    nitems_old::Csize_t,
+                                                    size_of_item::Csize_t, p::Ptr{Cvoid},
+                                                    ok::Ptr{Cint})::Ptr{Cvoid}
 end
 
 function SuiteSparse_free(p)
-    @ccall libcholmod.SuiteSparse_free(p::Ptr{Cvoid})::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_free(p::Ptr{Cvoid})::Ptr{Cvoid}
 end
 
 function SuiteSparse_tic(tic)
-    @ccall libcholmod.SuiteSparse_tic(tic::Ptr{Cdouble})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_tic(tic::Ptr{Cdouble})::Cvoid
 end
 
 function SuiteSparse_toc(tic)
-    @ccall libcholmod.SuiteSparse_toc(tic::Ptr{Cdouble})::Cdouble
+    @ccall libsuitesparseconfig.SuiteSparse_toc(tic::Ptr{Cdouble})::Cdouble
 end
 
 function SuiteSparse_time()
-    @ccall libcholmod.SuiteSparse_time()::Cdouble
+    @ccall libsuitesparseconfig.SuiteSparse_time()::Cdouble
 end
 
 function SuiteSparse_hypot(x, y)
-    @ccall libcholmod.SuiteSparse_hypot(x::Cdouble, y::Cdouble)::Cdouble
+    @ccall libsuitesparseconfig.SuiteSparse_hypot(x::Cdouble, y::Cdouble)::Cdouble
 end
 
 function SuiteSparse_divcomplex(ar, ai, br, bi, cr, ci)
-    @ccall libcholmod.SuiteSparse_divcomplex(ar::Cdouble, ai::Cdouble, br::Cdouble, bi::Cdouble, cr::Ptr{Cdouble}, ci::Ptr{Cdouble})::Cint
+    @ccall libsuitesparseconfig.SuiteSparse_divcomplex(ar::Cdouble, ai::Cdouble,
+                                                       br::Cdouble, bi::Cdouble,
+                                                       cr::Ptr{Cdouble},
+                                                       ci::Ptr{Cdouble})::Cint
 end
 
 function SuiteSparse_version(version)
-    @ccall libcholmod.SuiteSparse_version(version::Ptr{Cint})::Cint
+    @ccall libsuitesparseconfig.SuiteSparse_version(version::Ptr{Cint})::Cint
 end
 
 function SuiteSparse_BLAS_library()
-    @ccall libcholmod.SuiteSparse_BLAS_library()::Ptr{Cchar}
+    @ccall libsuitesparseconfig.SuiteSparse_BLAS_library()::Ptr{Cchar}
 end
 
 function SuiteSparse_BLAS_integer_size()
-    @ccall libcholmod.SuiteSparse_BLAS_integer_size()::Csize_t
+    @ccall libsuitesparseconfig.SuiteSparse_BLAS_integer_size()::Csize_t
 end
 
 struct cholmod_method_struct
@@ -140,16 +153,16 @@ struct cholmod_method_struct
     prune_dense::Cdouble
     prune_dense2::Cdouble
     nd_oksep::Cdouble
-    other_1::NTuple{4, Cdouble}
+    other_1::NTuple{4,Cdouble}
     nd_small::Csize_t
-    other_2::NTuple{4, Csize_t}
+    other_2::NTuple{4,Csize_t}
     aggressive::Cint
     order_for_lu::Cint
     nd_compress::Cint
     nd_camd::Cint
     nd_components::Cint
     ordering::Cint
-    other_3::NTuple{4, Csize_t}
+    other_3::NTuple{4,Csize_t}
 end
 
 mutable struct cholmod_common_struct
@@ -166,8 +179,8 @@ mutable struct cholmod_common_struct
     final_pack::Cint
     final_monotonic::Cint
     final_resymbol::Cint
-    zrelax::NTuple{3, Cdouble}
-    nrelax::NTuple{3, Csize_t}
+    zrelax::NTuple{3,Cdouble}
+    nrelax::NTuple{3,Csize_t}
     prefer_zomplex::Cint
     prefer_upper::Cint
     quick_return_if_not_posdef::Cint
@@ -179,7 +192,7 @@ mutable struct cholmod_common_struct
     nmethods::Cint
     current::Cint
     selected::Cint
-    method::NTuple{10, cholmod_method_struct}
+    method::NTuple{10,cholmod_method_struct}
     postorder::Cint
     default_nesdis::Cint
     metis_memory::Cdouble
@@ -222,7 +235,7 @@ mutable struct cholmod_common_struct
     SPQR_flopcount_bound::Cdouble
     SPQR_tol_used::Cdouble
     SPQR_norm_E_fro::Cdouble
-    SPQR_istat::NTuple{10, Int64}
+    SPQR_istat::NTuple{10,Int64}
     useGPU::Cint
     maxGpuMemBytes::Csize_t
     maxGpuMemFraction::Cdouble
@@ -231,10 +244,10 @@ mutable struct cholmod_common_struct
     gpuFlops::Int64
     gpuNumKernelLaunches::Cint
     cublasHandle::Ptr{Cvoid}
-    gpuStream::NTuple{8, Ptr{Cvoid}}
-    cublasEventPotrf::NTuple{3, Ptr{Cvoid}}
+    gpuStream::NTuple{8,Ptr{Cvoid}}
+    cublasEventPotrf::NTuple{3,Ptr{Cvoid}}
     updateCKernelsComplete::Ptr{Cvoid}
-    updateCBuffersFree::NTuple{8, Ptr{Cvoid}}
+    updateCBuffersFree::NTuple{8,Ptr{Cvoid}}
     dev_mempool::Ptr{Cvoid}
     dev_mempool_size::Csize_t
     host_pinned_mempool::Ptr{Cvoid}
@@ -300,11 +313,14 @@ function cholmod_l_maxrank(arg1, arg2)
 end
 
 function cholmod_allocate_work(nrow, iworksize, xworksize, Common)
-    @ccall libcholmod.cholmod_allocate_work(nrow::Csize_t, iworksize::Csize_t, xworksize::Csize_t, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_allocate_work(nrow::Csize_t, iworksize::Csize_t,
+                                            xworksize::Csize_t,
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_allocate_work(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_allocate_work(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_allocate_work(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t,
+                                              arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_free_work(Common)
@@ -324,11 +340,13 @@ function cholmod_l_clear_flag(arg1)
 end
 
 function cholmod_error(status, file, line, message, Common)
-    @ccall libcholmod.cholmod_error(status::Cint, file::Ptr{Cchar}, line::Cint, message::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_error(status::Cint, file::Ptr{Cchar}, line::Cint,
+                                    message::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_error(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_error(arg1::Cint, arg2::Ptr{Cchar}, arg3::Cint, arg4::Ptr{Cchar}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_error(arg1::Cint, arg2::Ptr{Cchar}, arg3::Cint,
+                                      arg4::Ptr{Cchar}, arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_dbound(dj, Common)
@@ -348,11 +366,14 @@ function cholmod_l_hypot(arg1, arg2)
 end
 
 function cholmod_divcomplex(ar, ai, br, bi, cr, ci)
-    @ccall libcholmod.cholmod_divcomplex(ar::Cdouble, ai::Cdouble, br::Cdouble, bi::Cdouble, cr::Ptr{Cdouble}, ci::Ptr{Cdouble})::Cint
+    @ccall libcholmod.cholmod_divcomplex(ar::Cdouble, ai::Cdouble, br::Cdouble, bi::Cdouble,
+                                         cr::Ptr{Cdouble}, ci::Ptr{Cdouble})::Cint
 end
 
 function cholmod_l_divcomplex(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_divcomplex(arg1::Cdouble, arg2::Cdouble, arg3::Cdouble, arg4::Cdouble, arg5::Ptr{Cdouble}, arg6::Ptr{Cdouble})::Cint
+    @ccall libcholmod.cholmod_l_divcomplex(arg1::Cdouble, arg2::Cdouble, arg3::Cdouble,
+                                           arg4::Cdouble, arg5::Ptr{Cdouble},
+                                           arg6::Ptr{Cdouble})::Cint
 end
 
 mutable struct cholmod_sparse_struct
@@ -384,155 +405,217 @@ end
 const descendantScore = cholmod_descendant_score_t
 
 function cholmod_score_comp(i, j)
-    @ccall libcholmod.cholmod_score_comp(i::Ptr{cholmod_descendant_score_t}, j::Ptr{cholmod_descendant_score_t})::Cint
+    @ccall libcholmod.cholmod_score_comp(i::Ptr{cholmod_descendant_score_t},
+                                         j::Ptr{cholmod_descendant_score_t})::Cint
 end
 
 function cholmod_l_score_comp(i, j)
-    @ccall libcholmod.cholmod_l_score_comp(i::Ptr{cholmod_descendant_score_t}, j::Ptr{cholmod_descendant_score_t})::Cint
+    @ccall libcholmod.cholmod_l_score_comp(i::Ptr{cholmod_descendant_score_t},
+                                           j::Ptr{cholmod_descendant_score_t})::Cint
 end
 
 function cholmod_allocate_sparse(nrow, ncol, nzmax, sorted, packed, stype, xtype, Common)
-    @ccall libcholmod.cholmod_allocate_sparse(nrow::Csize_t, ncol::Csize_t, nzmax::Csize_t, sorted::Cint, packed::Cint, stype::Cint, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_allocate_sparse(nrow::Csize_t, ncol::Csize_t, nzmax::Csize_t,
+                                              sorted::Cint, packed::Cint, stype::Cint,
+                                              xtype::Cint,
+                                              Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_allocate_sparse(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
-    @ccall libcholmod.cholmod_l_allocate_sparse(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t, arg4::Cint, arg5::Cint, arg6::Cint, arg7::Cint, arg8::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_allocate_sparse(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t,
+                                                arg4::Cint, arg5::Cint, arg6::Cint,
+                                                arg7::Cint,
+                                                arg8::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_free_sparse(A, Common)
-    @ccall libcholmod.cholmod_free_sparse(A::Ptr{Ptr{cholmod_sparse}}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_free_sparse(A::Ptr{Ptr{cholmod_sparse}},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_free_sparse(arg1, arg2)
-    @ccall libcholmod.cholmod_l_free_sparse(arg1::Ptr{Ptr{cholmod_sparse}}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_free_sparse(arg1::Ptr{Ptr{cholmod_sparse}},
+                                            arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_reallocate_sparse(nznew, A, Common)
-    @ccall libcholmod.cholmod_reallocate_sparse(nznew::Csize_t, A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_reallocate_sparse(nznew::Csize_t, A::Ptr{cholmod_sparse},
+                                                Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_reallocate_sparse(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_reallocate_sparse(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_reallocate_sparse(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                                  arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_nnz(A, Common)
-    @ccall libcholmod.cholmod_nnz(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_nnz(A::Ptr{cholmod_sparse},
+                                  Common::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_l_nnz(arg1, arg2)
-    @ccall libcholmod.cholmod_l_nnz(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_l_nnz(arg1::Ptr{cholmod_sparse},
+                                    arg2::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_speye(nrow, ncol, xtype, Common)
-    @ccall libcholmod.cholmod_speye(nrow::Csize_t, ncol::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_speye(nrow::Csize_t, ncol::Csize_t, xtype::Cint,
+                                    Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_speye(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_speye(arg1::Csize_t, arg2::Csize_t, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_speye(arg1::Csize_t, arg2::Csize_t, arg3::Cint,
+                                      arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_spzeros(nrow, ncol, nzmax, xtype, Common)
-    @ccall libcholmod.cholmod_spzeros(nrow::Csize_t, ncol::Csize_t, nzmax::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_spzeros(nrow::Csize_t, ncol::Csize_t, nzmax::Csize_t,
+                                      xtype::Cint,
+                                      Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_spzeros(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_spzeros(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t, arg4::Cint, arg5::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_spzeros(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t,
+                                        arg4::Cint,
+                                        arg5::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_transpose(A, values, Common)
-    @ccall libcholmod.cholmod_transpose(A::Ptr{cholmod_sparse}, values::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_transpose(A::Ptr{cholmod_sparse}, values::Cint,
+                                        Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_transpose(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_transpose(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_transpose(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                          arg3::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_transpose_unsym(A, values, Perm, fset, fsize, F, Common)
-    @ccall libcholmod.cholmod_transpose_unsym(A::Ptr{cholmod_sparse}, values::Cint, Perm::Ptr{Int32}, fset::Ptr{Int32}, fsize::Csize_t, F::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_transpose_unsym(A::Ptr{cholmod_sparse}, values::Cint,
+                                              Perm::Ptr{Int32}, fset::Ptr{Int32},
+                                              fsize::Csize_t, F::Ptr{cholmod_sparse},
+                                              Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_transpose_unsym(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_transpose_unsym(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Csize_t, arg6::Ptr{cholmod_sparse}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_transpose_unsym(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                                arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                                arg5::Csize_t, arg6::Ptr{cholmod_sparse},
+                                                arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_transpose_sym(A, values, Perm, F, Common)
-    @ccall libcholmod.cholmod_transpose_sym(A::Ptr{cholmod_sparse}, values::Cint, Perm::Ptr{Int32}, F::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_transpose_sym(A::Ptr{cholmod_sparse}, values::Cint,
+                                            Perm::Ptr{Int32}, F::Ptr{cholmod_sparse},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_transpose_sym(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_transpose_sym(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{Int64}, arg4::Ptr{cholmod_sparse}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_transpose_sym(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                              arg3::Ptr{Int64}, arg4::Ptr{cholmod_sparse},
+                                              arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_ptranspose(A, values, Perm, fset, fsize, Common)
-    @ccall libcholmod.cholmod_ptranspose(A::Ptr{cholmod_sparse}, values::Cint, Perm::Ptr{Int32}, fset::Ptr{Int32}, fsize::Csize_t, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_ptranspose(A::Ptr{cholmod_sparse}, values::Cint,
+                                         Perm::Ptr{Int32}, fset::Ptr{Int32}, fsize::Csize_t,
+                                         Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_ptranspose(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_ptranspose(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Csize_t, arg6::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_ptranspose(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                           arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                           arg5::Csize_t,
+                                           arg6::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_sort(A, Common)
-    @ccall libcholmod.cholmod_sort(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_sort(A::Ptr{cholmod_sparse},
+                                   Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_sort(arg1, arg2)
-    @ccall libcholmod.cholmod_l_sort(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_sort(arg1::Ptr{cholmod_sparse},
+                                     arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_band(A, k1, k2, mode, Common)
-    @ccall libcholmod.cholmod_band(A::Ptr{cholmod_sparse}, k1::Int64, k2::Int64, mode::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_band(A::Ptr{cholmod_sparse}, k1::Int64, k2::Int64, mode::Cint,
+                                   Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_band(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_band(arg1::Ptr{cholmod_sparse}, arg2::Int64, arg3::Int64, arg4::Cint, arg5::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_band(arg1::Ptr{cholmod_sparse}, arg2::Int64, arg3::Int64,
+                                     arg4::Cint,
+                                     arg5::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_band_inplace(k1, k2, mode, A, Common)
-    @ccall libcholmod.cholmod_band_inplace(k1::Int64, k2::Int64, mode::Cint, A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_band_inplace(k1::Int64, k2::Int64, mode::Cint,
+                                           A::Ptr{cholmod_sparse},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_band_inplace(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_band_inplace(arg1::Int64, arg2::Int64, arg3::Cint, arg4::Ptr{cholmod_sparse}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_band_inplace(arg1::Int64, arg2::Int64, arg3::Cint,
+                                             arg4::Ptr{cholmod_sparse},
+                                             arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_aat(A, fset, fsize, mode, Common)
-    @ccall libcholmod.cholmod_aat(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, mode::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_aat(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t,
+                                  mode::Cint,
+                                  Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_aat(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_aat(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Cint, arg5::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_aat(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                    arg3::Csize_t, arg4::Cint,
+                                    arg5::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_copy_sparse(A, Common)
-    @ccall libcholmod.cholmod_copy_sparse(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_copy_sparse(A::Ptr{cholmod_sparse},
+                                          Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_copy_sparse(arg1, arg2)
-    @ccall libcholmod.cholmod_l_copy_sparse(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_copy_sparse(arg1::Ptr{cholmod_sparse},
+                                            arg2::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_copy(A, stype, mode, Common)
-    @ccall libcholmod.cholmod_copy(A::Ptr{cholmod_sparse}, stype::Cint, mode::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_copy(A::Ptr{cholmod_sparse}, stype::Cint, mode::Cint,
+                                   Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_copy(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_copy(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_copy(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Cint,
+                                     arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_add(A, B, alpha, beta, values, sorted, Common)
-    @ccall libcholmod.cholmod_add(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse}, alpha::Ptr{Cdouble}, beta::Ptr{Cdouble}, values::Cint, sorted::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_add(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse},
+                                  alpha::Ptr{Cdouble}, beta::Ptr{Cdouble}, values::Cint,
+                                  sorted::Cint,
+                                  Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_add(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_add(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Ptr{Cdouble}, arg5::Cint, arg6::Cint, arg7::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_add(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse},
+                                    arg3::Ptr{Cdouble}, arg4::Ptr{Cdouble}, arg5::Cint,
+                                    arg6::Cint,
+                                    arg7::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_sparse_xtype(to_xtype, A, Common)
-    @ccall libcholmod.cholmod_sparse_xtype(to_xtype::Cint, A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_sparse_xtype(to_xtype::Cint, A::Ptr{cholmod_sparse},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_sparse_xtype(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_sparse_xtype(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_sparse_xtype(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                             arg3::Ptr{cholmod_common})::Cint
 end
 
 mutable struct cholmod_factor_struct
@@ -572,75 +655,100 @@ end
 const cholmod_factor = cholmod_factor_struct
 
 function cholmod_allocate_factor(n, Common)
-    @ccall libcholmod.cholmod_allocate_factor(n::Csize_t, Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_allocate_factor(n::Csize_t,
+                                              Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_l_allocate_factor(arg1, arg2)
-    @ccall libcholmod.cholmod_l_allocate_factor(arg1::Csize_t, arg2::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_l_allocate_factor(arg1::Csize_t,
+                                                arg2::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_free_factor(L, Common)
-    @ccall libcholmod.cholmod_free_factor(L::Ptr{Ptr{cholmod_factor}}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_free_factor(L::Ptr{Ptr{cholmod_factor}},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_free_factor(arg1, arg2)
-    @ccall libcholmod.cholmod_l_free_factor(arg1::Ptr{Ptr{cholmod_factor}}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_free_factor(arg1::Ptr{Ptr{cholmod_factor}},
+                                            arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_reallocate_factor(nznew, L, Common)
-    @ccall libcholmod.cholmod_reallocate_factor(nznew::Csize_t, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_reallocate_factor(nznew::Csize_t, L::Ptr{cholmod_factor},
+                                                Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_reallocate_factor(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_reallocate_factor(arg1::Csize_t, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_reallocate_factor(arg1::Csize_t, arg2::Ptr{cholmod_factor},
+                                                  arg3::Ptr{cholmod_common})::Cint
 end
 
-function cholmod_change_factor(to_xtype, to_ll, to_super, to_packed, to_monotonic, L, Common)
-    @ccall libcholmod.cholmod_change_factor(to_xtype::Cint, to_ll::Cint, to_super::Cint, to_packed::Cint, to_monotonic::Cint, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+function cholmod_change_factor(to_xtype, to_ll, to_super, to_packed, to_monotonic, L,
+                               Common)
+    @ccall libcholmod.cholmod_change_factor(to_xtype::Cint, to_ll::Cint, to_super::Cint,
+                                            to_packed::Cint, to_monotonic::Cint,
+                                            L::Ptr{cholmod_factor},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_change_factor(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_change_factor(arg1::Cint, arg2::Cint, arg3::Cint, arg4::Cint, arg5::Cint, arg6::Ptr{cholmod_factor}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_change_factor(arg1::Cint, arg2::Cint, arg3::Cint,
+                                              arg4::Cint, arg5::Cint,
+                                              arg6::Ptr{cholmod_factor},
+                                              arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_pack_factor(L, Common)
-    @ccall libcholmod.cholmod_pack_factor(L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_pack_factor(L::Ptr{cholmod_factor},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_pack_factor(arg1, arg2)
-    @ccall libcholmod.cholmod_l_pack_factor(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_pack_factor(arg1::Ptr{cholmod_factor},
+                                            arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_reallocate_column(j, need, L, Common)
-    @ccall libcholmod.cholmod_reallocate_column(j::Csize_t, need::Csize_t, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_reallocate_column(j::Csize_t, need::Csize_t,
+                                                L::Ptr{cholmod_factor},
+                                                Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_reallocate_column(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_reallocate_column(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{cholmod_factor}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_reallocate_column(arg1::Csize_t, arg2::Csize_t,
+                                                  arg3::Ptr{cholmod_factor},
+                                                  arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_factor_to_sparse(L, Common)
-    @ccall libcholmod.cholmod_factor_to_sparse(L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_factor_to_sparse(L::Ptr{cholmod_factor},
+                                               Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_factor_to_sparse(arg1, arg2)
-    @ccall libcholmod.cholmod_l_factor_to_sparse(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_factor_to_sparse(arg1::Ptr{cholmod_factor},
+                                                 arg2::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_copy_factor(L, Common)
-    @ccall libcholmod.cholmod_copy_factor(L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_copy_factor(L::Ptr{cholmod_factor},
+                                          Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_l_copy_factor(arg1, arg2)
-    @ccall libcholmod.cholmod_l_copy_factor(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_l_copy_factor(arg1::Ptr{cholmod_factor},
+                                            arg2::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_factor_xtype(to_xtype, L, Common)
-    @ccall libcholmod.cholmod_factor_xtype(to_xtype::Cint, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_factor_xtype(to_xtype::Cint, L::Ptr{cholmod_factor},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_factor_xtype(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_factor_xtype(arg1::Cint, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_factor_xtype(arg1::Cint, arg2::Ptr{cholmod_factor},
+                                             arg3::Ptr{cholmod_common})::Cint
 end
 
 mutable struct cholmod_dense_struct
@@ -658,91 +766,118 @@ end
 const cholmod_dense = cholmod_dense_struct
 
 function cholmod_allocate_dense(nrow, ncol, d, xtype, Common)
-    @ccall libcholmod.cholmod_allocate_dense(nrow::Csize_t, ncol::Csize_t, d::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_allocate_dense(nrow::Csize_t, ncol::Csize_t, d::Csize_t,
+                                             xtype::Cint,
+                                             Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_allocate_dense(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_allocate_dense(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t, arg4::Cint, arg5::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_allocate_dense(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t,
+                                               arg4::Cint,
+                                               arg5::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_zeros(nrow, ncol, xtype, Common)
-    @ccall libcholmod.cholmod_zeros(nrow::Csize_t, ncol::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_zeros(nrow::Csize_t, ncol::Csize_t, xtype::Cint,
+                                    Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_zeros(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_zeros(arg1::Csize_t, arg2::Csize_t, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_zeros(arg1::Csize_t, arg2::Csize_t, arg3::Cint,
+                                      arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_ones(nrow, ncol, xtype, Common)
-    @ccall libcholmod.cholmod_ones(nrow::Csize_t, ncol::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_ones(nrow::Csize_t, ncol::Csize_t, xtype::Cint,
+                                   Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_ones(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_ones(arg1::Csize_t, arg2::Csize_t, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_ones(arg1::Csize_t, arg2::Csize_t, arg3::Cint,
+                                     arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_eye(nrow, ncol, xtype, Common)
-    @ccall libcholmod.cholmod_eye(nrow::Csize_t, ncol::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_eye(nrow::Csize_t, ncol::Csize_t, xtype::Cint,
+                                  Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_eye(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_eye(arg1::Csize_t, arg2::Csize_t, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_eye(arg1::Csize_t, arg2::Csize_t, arg3::Cint,
+                                    arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_free_dense(X, Common)
-    @ccall libcholmod.cholmod_free_dense(X::Ptr{Ptr{cholmod_dense}}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_free_dense(X::Ptr{Ptr{cholmod_dense}},
+                                         Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_free_dense(arg1, arg2)
-    @ccall libcholmod.cholmod_l_free_dense(arg1::Ptr{Ptr{cholmod_dense}}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_free_dense(arg1::Ptr{Ptr{cholmod_dense}},
+                                           arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_ensure_dense(XHandle, nrow, ncol, d, xtype, Common)
-    @ccall libcholmod.cholmod_ensure_dense(XHandle::Ptr{Ptr{cholmod_dense}}, nrow::Csize_t, ncol::Csize_t, d::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_ensure_dense(XHandle::Ptr{Ptr{cholmod_dense}}, nrow::Csize_t,
+                                           ncol::Csize_t, d::Csize_t, xtype::Cint,
+                                           Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_ensure_dense(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_ensure_dense(arg1::Ptr{Ptr{cholmod_dense}}, arg2::Csize_t, arg3::Csize_t, arg4::Csize_t, arg5::Cint, arg6::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_ensure_dense(arg1::Ptr{Ptr{cholmod_dense}}, arg2::Csize_t,
+                                             arg3::Csize_t, arg4::Csize_t, arg5::Cint,
+                                             arg6::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_sparse_to_dense(A, Common)
-    @ccall libcholmod.cholmod_sparse_to_dense(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_sparse_to_dense(A::Ptr{cholmod_sparse},
+                                              Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_sparse_to_dense(arg1, arg2)
-    @ccall libcholmod.cholmod_l_sparse_to_dense(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_sparse_to_dense(arg1::Ptr{cholmod_sparse},
+                                                arg2::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_dense_to_sparse(X, values, Common)
-    @ccall libcholmod.cholmod_dense_to_sparse(X::Ptr{cholmod_dense}, values::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_dense_to_sparse(X::Ptr{cholmod_dense}, values::Cint,
+                                              Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_dense_to_sparse(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_dense_to_sparse(arg1::Ptr{cholmod_dense}, arg2::Cint, arg3::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_dense_to_sparse(arg1::Ptr{cholmod_dense}, arg2::Cint,
+                                                arg3::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_copy_dense(X, Common)
-    @ccall libcholmod.cholmod_copy_dense(X::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_copy_dense(X::Ptr{cholmod_dense},
+                                         Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_copy_dense(arg1, arg2)
-    @ccall libcholmod.cholmod_l_copy_dense(arg1::Ptr{cholmod_dense}, arg2::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_copy_dense(arg1::Ptr{cholmod_dense},
+                                           arg2::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_copy_dense2(X, Y, Common)
-    @ccall libcholmod.cholmod_copy_dense2(X::Ptr{cholmod_dense}, Y::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_copy_dense2(X::Ptr{cholmod_dense}, Y::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_copy_dense2(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_copy_dense2(arg1::Ptr{cholmod_dense}, arg2::Ptr{cholmod_dense}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_copy_dense2(arg1::Ptr{cholmod_dense},
+                                            arg2::Ptr{cholmod_dense},
+                                            arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_dense_xtype(to_xtype, X, Common)
-    @ccall libcholmod.cholmod_dense_xtype(to_xtype::Cint, X::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_dense_xtype(to_xtype::Cint, X::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_dense_xtype(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_dense_xtype(arg1::Cint, arg2::Ptr{cholmod_dense}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_dense_xtype(arg1::Cint, arg2::Ptr{cholmod_dense},
+                                            arg3::Ptr{cholmod_common})::Cint
 end
 
 mutable struct cholmod_triplet_struct
@@ -764,99 +899,137 @@ end
 const cholmod_triplet = cholmod_triplet_struct
 
 function cholmod_allocate_triplet(nrow, ncol, nzmax, stype, xtype, Common)
-    @ccall libcholmod.cholmod_allocate_triplet(nrow::Csize_t, ncol::Csize_t, nzmax::Csize_t, stype::Cint, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_allocate_triplet(nrow::Csize_t, ncol::Csize_t, nzmax::Csize_t,
+                                               stype::Cint, xtype::Cint,
+                                               Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_l_allocate_triplet(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_allocate_triplet(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t, arg4::Cint, arg5::Cint, arg6::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_l_allocate_triplet(arg1::Csize_t, arg2::Csize_t,
+                                                 arg3::Csize_t, arg4::Cint, arg5::Cint,
+                                                 arg6::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_free_triplet(T, Common)
-    @ccall libcholmod.cholmod_free_triplet(T::Ptr{Ptr{cholmod_triplet}}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_free_triplet(T::Ptr{Ptr{cholmod_triplet}},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_free_triplet(arg1, arg2)
-    @ccall libcholmod.cholmod_l_free_triplet(arg1::Ptr{Ptr{cholmod_triplet}}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_free_triplet(arg1::Ptr{Ptr{cholmod_triplet}},
+                                             arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_reallocate_triplet(nznew, T, Common)
-    @ccall libcholmod.cholmod_reallocate_triplet(nznew::Csize_t, T::Ptr{cholmod_triplet}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_reallocate_triplet(nznew::Csize_t, T::Ptr{cholmod_triplet},
+                                                 Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_reallocate_triplet(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_reallocate_triplet(arg1::Csize_t, arg2::Ptr{cholmod_triplet}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_reallocate_triplet(arg1::Csize_t,
+                                                   arg2::Ptr{cholmod_triplet},
+                                                   arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_sparse_to_triplet(A, Common)
-    @ccall libcholmod.cholmod_sparse_to_triplet(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_sparse_to_triplet(A::Ptr{cholmod_sparse},
+                                                Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_l_sparse_to_triplet(arg1, arg2)
-    @ccall libcholmod.cholmod_l_sparse_to_triplet(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_l_sparse_to_triplet(arg1::Ptr{cholmod_sparse},
+                                                  arg2::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_triplet_to_sparse(T, nzmax, Common)
-    @ccall libcholmod.cholmod_triplet_to_sparse(T::Ptr{cholmod_triplet}, nzmax::Csize_t, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_triplet_to_sparse(T::Ptr{cholmod_triplet}, nzmax::Csize_t,
+                                                Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_triplet_to_sparse(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_triplet_to_sparse(arg1::Ptr{cholmod_triplet}, arg2::Csize_t, arg3::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_triplet_to_sparse(arg1::Ptr{cholmod_triplet}, arg2::Csize_t,
+                                                  arg3::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_copy_triplet(T, Common)
-    @ccall libcholmod.cholmod_copy_triplet(T::Ptr{cholmod_triplet}, Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_copy_triplet(T::Ptr{cholmod_triplet},
+                                           Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_l_copy_triplet(arg1, arg2)
-    @ccall libcholmod.cholmod_l_copy_triplet(arg1::Ptr{cholmod_triplet}, arg2::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_l_copy_triplet(arg1::Ptr{cholmod_triplet},
+                                             arg2::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_triplet_xtype(to_xtype, T, Common)
-    @ccall libcholmod.cholmod_triplet_xtype(to_xtype::Cint, T::Ptr{cholmod_triplet}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_triplet_xtype(to_xtype::Cint, T::Ptr{cholmod_triplet},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_triplet_xtype(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_triplet_xtype(arg1::Cint, arg2::Ptr{cholmod_triplet}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_triplet_xtype(arg1::Cint, arg2::Ptr{cholmod_triplet},
+                                              arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_malloc(n, size, Common)
-    @ccall libcholmod.cholmod_malloc(n::Csize_t, size::Csize_t, Common::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_malloc(n::Csize_t, size::Csize_t,
+                                     Common::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_l_malloc(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_malloc(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_l_malloc(arg1::Csize_t, arg2::Csize_t,
+                                       arg3::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_calloc(n, size, Common)
-    @ccall libcholmod.cholmod_calloc(n::Csize_t, size::Csize_t, Common::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_calloc(n::Csize_t, size::Csize_t,
+                                     Common::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_l_calloc(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_calloc(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_l_calloc(arg1::Csize_t, arg2::Csize_t,
+                                       arg3::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_free(n, size, p, Common)
-    @ccall libcholmod.cholmod_free(n::Csize_t, size::Csize_t, p::Ptr{Cvoid}, Common::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_free(n::Csize_t, size::Csize_t, p::Ptr{Cvoid},
+                                   Common::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_l_free(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_free(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{Cvoid}, arg4::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_l_free(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{Cvoid},
+                                     arg4::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_realloc(nnew, size, p, n, Common)
-    @ccall libcholmod.cholmod_realloc(nnew::Csize_t, size::Csize_t, p::Ptr{Cvoid}, n::Ptr{Csize_t}, Common::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_realloc(nnew::Csize_t, size::Csize_t, p::Ptr{Cvoid},
+                                      n::Ptr{Csize_t},
+                                      Common::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_l_realloc(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_realloc(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{Cvoid}, arg4::Ptr{Csize_t}, arg5::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_l_realloc(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{Cvoid},
+                                        arg4::Ptr{Csize_t},
+                                        arg5::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
-function cholmod_realloc_multiple(nnew, nint, xtype, Iblock, Jblock, Xblock, Zblock, n, Common)
-    @ccall libcholmod.cholmod_realloc_multiple(nnew::Csize_t, nint::Cint, xtype::Cint, Iblock::Ptr{Ptr{Cvoid}}, Jblock::Ptr{Ptr{Cvoid}}, Xblock::Ptr{Ptr{Cvoid}}, Zblock::Ptr{Ptr{Cvoid}}, n::Ptr{Csize_t}, Common::Ptr{cholmod_common})::Cint
+function cholmod_realloc_multiple(nnew, nint, xtype, Iblock, Jblock, Xblock, Zblock, n,
+                                  Common)
+    @ccall libcholmod.cholmod_realloc_multiple(nnew::Csize_t, nint::Cint, xtype::Cint,
+                                               Iblock::Ptr{Ptr{Cvoid}},
+                                               Jblock::Ptr{Ptr{Cvoid}},
+                                               Xblock::Ptr{Ptr{Cvoid}},
+                                               Zblock::Ptr{Ptr{Cvoid}}, n::Ptr{Csize_t},
+                                               Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_realloc_multiple(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
-    @ccall libcholmod.cholmod_l_realloc_multiple(arg1::Csize_t, arg2::Cint, arg3::Cint, arg4::Ptr{Ptr{Cvoid}}, arg5::Ptr{Ptr{Cvoid}}, arg6::Ptr{Ptr{Cvoid}}, arg7::Ptr{Ptr{Cvoid}}, arg8::Ptr{Csize_t}, arg9::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_realloc_multiple(arg1::Csize_t, arg2::Cint, arg3::Cint,
+                                                 arg4::Ptr{Ptr{Cvoid}},
+                                                 arg5::Ptr{Ptr{Cvoid}},
+                                                 arg6::Ptr{Ptr{Cvoid}},
+                                                 arg7::Ptr{Ptr{Cvoid}}, arg8::Ptr{Csize_t},
+                                                 arg9::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_version(version)
@@ -876,11 +1049,13 @@ function cholmod_l_check_common(arg1)
 end
 
 function cholmod_print_common(name, Common)
-    @ccall libcholmod.cholmod_print_common(name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_common(name::Ptr{Cchar},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_common(arg1, arg2)
-    @ccall libcholmod.cholmod_l_print_common(arg1::Ptr{Cchar}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_common(arg1::Ptr{Cchar},
+                                             arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_gpu_stats(arg1)
@@ -892,643 +1067,1047 @@ function cholmod_l_gpu_stats(arg1)
 end
 
 function cholmod_check_sparse(A, Common)
-    @ccall libcholmod.cholmod_check_sparse(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_sparse(A::Ptr{cholmod_sparse},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_sparse(arg1, arg2)
-    @ccall libcholmod.cholmod_l_check_sparse(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_sparse(arg1::Ptr{cholmod_sparse},
+                                             arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_sparse(A, name, Common)
-    @ccall libcholmod.cholmod_print_sparse(A::Ptr{cholmod_sparse}, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_sparse(A::Ptr{cholmod_sparse}, name::Ptr{Cchar},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_sparse(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_print_sparse(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Cchar}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_sparse(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Cchar},
+                                             arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_check_dense(X, Common)
-    @ccall libcholmod.cholmod_check_dense(X::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_dense(X::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_dense(arg1, arg2)
-    @ccall libcholmod.cholmod_l_check_dense(arg1::Ptr{cholmod_dense}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_dense(arg1::Ptr{cholmod_dense},
+                                            arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_dense(X, name, Common)
-    @ccall libcholmod.cholmod_print_dense(X::Ptr{cholmod_dense}, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_dense(X::Ptr{cholmod_dense}, name::Ptr{Cchar},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_dense(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_print_dense(arg1::Ptr{cholmod_dense}, arg2::Ptr{Cchar}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_dense(arg1::Ptr{cholmod_dense}, arg2::Ptr{Cchar},
+                                            arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_check_factor(L, Common)
-    @ccall libcholmod.cholmod_check_factor(L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_factor(L::Ptr{cholmod_factor},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_factor(arg1, arg2)
-    @ccall libcholmod.cholmod_l_check_factor(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_factor(arg1::Ptr{cholmod_factor},
+                                             arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_factor(L, name, Common)
-    @ccall libcholmod.cholmod_print_factor(L::Ptr{cholmod_factor}, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_factor(L::Ptr{cholmod_factor}, name::Ptr{Cchar},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_factor(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_print_factor(arg1::Ptr{cholmod_factor}, arg2::Ptr{Cchar}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_factor(arg1::Ptr{cholmod_factor}, arg2::Ptr{Cchar},
+                                             arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_check_triplet(T, Common)
-    @ccall libcholmod.cholmod_check_triplet(T::Ptr{cholmod_triplet}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_triplet(T::Ptr{cholmod_triplet},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_triplet(arg1, arg2)
-    @ccall libcholmod.cholmod_l_check_triplet(arg1::Ptr{cholmod_triplet}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_triplet(arg1::Ptr{cholmod_triplet},
+                                              arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_triplet(T, name, Common)
-    @ccall libcholmod.cholmod_print_triplet(T::Ptr{cholmod_triplet}, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_triplet(T::Ptr{cholmod_triplet}, name::Ptr{Cchar},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_triplet(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_print_triplet(arg1::Ptr{cholmod_triplet}, arg2::Ptr{Cchar}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_triplet(arg1::Ptr{cholmod_triplet}, arg2::Ptr{Cchar},
+                                              arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_check_subset(Set, len, n, Common)
-    @ccall libcholmod.cholmod_check_subset(Set::Ptr{Int32}, len::Int64, n::Csize_t, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_subset(Set::Ptr{Int32}, len::Int64, n::Csize_t,
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_subset(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_check_subset(arg1::Ptr{Int64}, arg2::Int64, arg3::Csize_t, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_subset(arg1::Ptr{Int64}, arg2::Int64, arg3::Csize_t,
+                                             arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_subset(Set, len, n, name, Common)
-    @ccall libcholmod.cholmod_print_subset(Set::Ptr{Int32}, len::Int64, n::Csize_t, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_subset(Set::Ptr{Int32}, len::Int64, n::Csize_t,
+                                           name::Ptr{Cchar},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_subset(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_print_subset(arg1::Ptr{Int64}, arg2::Int64, arg3::Csize_t, arg4::Ptr{Cchar}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_subset(arg1::Ptr{Int64}, arg2::Int64, arg3::Csize_t,
+                                             arg4::Ptr{Cchar},
+                                             arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_check_perm(Perm, len, n, Common)
-    @ccall libcholmod.cholmod_check_perm(Perm::Ptr{Int32}, len::Csize_t, n::Csize_t, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_perm(Perm::Ptr{Int32}, len::Csize_t, n::Csize_t,
+                                         Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_perm(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_check_perm(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Csize_t, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_perm(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Csize_t,
+                                           arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_perm(Perm, len, n, name, Common)
-    @ccall libcholmod.cholmod_print_perm(Perm::Ptr{Int32}, len::Csize_t, n::Csize_t, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_perm(Perm::Ptr{Int32}, len::Csize_t, n::Csize_t,
+                                         name::Ptr{Cchar},
+                                         Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_perm(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_print_perm(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Csize_t, arg4::Ptr{Cchar}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_perm(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Csize_t,
+                                           arg4::Ptr{Cchar},
+                                           arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_check_parent(Parent, n, Common)
-    @ccall libcholmod.cholmod_check_parent(Parent::Ptr{Int32}, n::Csize_t, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_parent(Parent::Ptr{Int32}, n::Csize_t,
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_parent(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_check_parent(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_parent(arg1::Ptr{Int64}, arg2::Csize_t,
+                                             arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_parent(Parent, n, name, Common)
-    @ccall libcholmod.cholmod_print_parent(Parent::Ptr{Int32}, n::Csize_t, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_parent(Parent::Ptr{Int32}, n::Csize_t, name::Ptr{Cchar},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_parent(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_print_parent(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Ptr{Cchar}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_parent(arg1::Ptr{Int64}, arg2::Csize_t,
+                                             arg3::Ptr{Cchar},
+                                             arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_read_sparse(f, Common)
-    @ccall libcholmod.cholmod_read_sparse(f::Ptr{Libc.FILE}, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_read_sparse(f::Ptr{Libc.FILE},
+                                          Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_read_sparse(arg1, arg2)
-    @ccall libcholmod.cholmod_l_read_sparse(arg1::Ptr{Libc.FILE}, arg2::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_read_sparse(arg1::Ptr{Libc.FILE},
+                                            arg2::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_read_triplet(f, Common)
-    @ccall libcholmod.cholmod_read_triplet(f::Ptr{Libc.FILE}, Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_read_triplet(f::Ptr{Libc.FILE},
+                                           Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_l_read_triplet(arg1, arg2)
-    @ccall libcholmod.cholmod_l_read_triplet(arg1::Ptr{Libc.FILE}, arg2::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_l_read_triplet(arg1::Ptr{Libc.FILE},
+                                             arg2::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_read_dense(f, Common)
-    @ccall libcholmod.cholmod_read_dense(f::Ptr{Libc.FILE}, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_read_dense(f::Ptr{Libc.FILE},
+                                         Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_read_dense(arg1, arg2)
-    @ccall libcholmod.cholmod_l_read_dense(arg1::Ptr{Libc.FILE}, arg2::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_read_dense(arg1::Ptr{Libc.FILE},
+                                           arg2::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_read_matrix(f, prefer, mtype, Common)
-    @ccall libcholmod.cholmod_read_matrix(f::Ptr{Libc.FILE}, prefer::Cint, mtype::Ptr{Cint}, Common::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_read_matrix(f::Ptr{Libc.FILE}, prefer::Cint, mtype::Ptr{Cint},
+                                          Common::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_l_read_matrix(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_read_matrix(arg1::Ptr{Libc.FILE}, arg2::Cint, arg3::Ptr{Cint}, arg4::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_l_read_matrix(arg1::Ptr{Libc.FILE}, arg2::Cint,
+                                            arg3::Ptr{Cint},
+                                            arg4::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_write_sparse(f, A, Z, comments, Common)
-    @ccall libcholmod.cholmod_write_sparse(f::Ptr{Libc.FILE}, A::Ptr{cholmod_sparse}, Z::Ptr{cholmod_sparse}, comments::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_write_sparse(f::Ptr{Libc.FILE}, A::Ptr{cholmod_sparse},
+                                           Z::Ptr{cholmod_sparse}, comments::Ptr{Cchar},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_write_sparse(arg1, arg2, arg3, c, arg5)
-    @ccall libcholmod.cholmod_l_write_sparse(arg1::Ptr{Libc.FILE}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_sparse}, c::Ptr{Cchar}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_write_sparse(arg1::Ptr{Libc.FILE},
+                                             arg2::Ptr{cholmod_sparse},
+                                             arg3::Ptr{cholmod_sparse}, c::Ptr{Cchar},
+                                             arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_write_dense(f, X, comments, Common)
-    @ccall libcholmod.cholmod_write_dense(f::Ptr{Libc.FILE}, X::Ptr{cholmod_dense}, comments::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_write_dense(f::Ptr{Libc.FILE}, X::Ptr{cholmod_dense},
+                                          comments::Ptr{Cchar},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_write_dense(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_write_dense(arg1::Ptr{Libc.FILE}, arg2::Ptr{cholmod_dense}, arg3::Ptr{Cchar}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_write_dense(arg1::Ptr{Libc.FILE}, arg2::Ptr{cholmod_dense},
+                                            arg3::Ptr{Cchar},
+                                            arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_analyze(A, Common)
-    @ccall libcholmod.cholmod_analyze(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_analyze(A::Ptr{cholmod_sparse},
+                                      Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_l_analyze(arg1, arg2)
-    @ccall libcholmod.cholmod_l_analyze(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_l_analyze(arg1::Ptr{cholmod_sparse},
+                                        arg2::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_analyze_p(A, UserPerm, fset, fsize, Common)
-    @ccall libcholmod.cholmod_analyze_p(A::Ptr{cholmod_sparse}, UserPerm::Ptr{Int32}, fset::Ptr{Int32}, fsize::Csize_t, Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_analyze_p(A::Ptr{cholmod_sparse}, UserPerm::Ptr{Int32},
+                                        fset::Ptr{Int32}, fsize::Csize_t,
+                                        Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_l_analyze_p(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_analyze_p(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Ptr{Int64}, arg4::Csize_t, arg5::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_l_analyze_p(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                          arg3::Ptr{Int64}, arg4::Csize_t,
+                                          arg5::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_analyze_p2(for_whom, A, UserPerm, fset, fsize, Common)
-    @ccall libcholmod.cholmod_analyze_p2(for_whom::Cint, A::Ptr{cholmod_sparse}, UserPerm::Ptr{Int32}, fset::Ptr{Int32}, fsize::Csize_t, Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_analyze_p2(for_whom::Cint, A::Ptr{cholmod_sparse},
+                                         UserPerm::Ptr{Int32}, fset::Ptr{Int32},
+                                         fsize::Csize_t,
+                                         Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_l_analyze_p2(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_analyze_p2(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Csize_t, arg6::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_l_analyze_p2(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                           arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                           arg5::Csize_t,
+                                           arg6::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_factorize(A, L, Common)
-    @ccall libcholmod.cholmod_factorize(A::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_factorize(A::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor},
+                                        Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_factorize(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_factorize(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_factorize(arg1::Ptr{cholmod_sparse},
+                                          arg2::Ptr{cholmod_factor},
+                                          arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_factorize_p(A, beta, fset, fsize, L, Common)
-    @ccall libcholmod.cholmod_factorize_p(A::Ptr{cholmod_sparse}, beta::Ptr{Cdouble}, fset::Ptr{Int32}, fsize::Csize_t, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_factorize_p(A::Ptr{cholmod_sparse}, beta::Ptr{Cdouble},
+                                          fset::Ptr{Int32}, fsize::Csize_t,
+                                          L::Ptr{cholmod_factor},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_factorize_p(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_factorize_p(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Cdouble}, arg3::Ptr{Int64}, arg4::Csize_t, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_factorize_p(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Cdouble},
+                                            arg3::Ptr{Int64}, arg4::Csize_t,
+                                            arg5::Ptr{cholmod_factor},
+                                            arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_solve(sys, L, B, Common)
-    @ccall libcholmod.cholmod_solve(sys::Cint, L::Ptr{cholmod_factor}, B::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_solve(sys::Cint, L::Ptr{cholmod_factor},
+                                    B::Ptr{cholmod_dense},
+                                    Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_solve(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_solve(arg1::Cint, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_dense}, arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_solve(arg1::Cint, arg2::Ptr{cholmod_factor},
+                                      arg3::Ptr{cholmod_dense},
+                                      arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_solve2(sys, L, B, Bset, X_Handle, Xset_Handle, Y_Handle, E_Handle, Common)
-    @ccall libcholmod.cholmod_solve2(sys::Cint, L::Ptr{cholmod_factor}, B::Ptr{cholmod_dense}, Bset::Ptr{cholmod_sparse}, X_Handle::Ptr{Ptr{cholmod_dense}}, Xset_Handle::Ptr{Ptr{cholmod_sparse}}, Y_Handle::Ptr{Ptr{cholmod_dense}}, E_Handle::Ptr{Ptr{cholmod_dense}}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_solve2(sys::Cint, L::Ptr{cholmod_factor},
+                                     B::Ptr{cholmod_dense}, Bset::Ptr{cholmod_sparse},
+                                     X_Handle::Ptr{Ptr{cholmod_dense}},
+                                     Xset_Handle::Ptr{Ptr{cholmod_sparse}},
+                                     Y_Handle::Ptr{Ptr{cholmod_dense}},
+                                     E_Handle::Ptr{Ptr{cholmod_dense}},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_solve2(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
-    @ccall libcholmod.cholmod_l_solve2(arg1::Cint, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_dense}, arg4::Ptr{cholmod_sparse}, arg5::Ptr{Ptr{cholmod_dense}}, arg6::Ptr{Ptr{cholmod_sparse}}, arg7::Ptr{Ptr{cholmod_dense}}, arg8::Ptr{Ptr{cholmod_dense}}, arg9::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_solve2(arg1::Cint, arg2::Ptr{cholmod_factor},
+                                       arg3::Ptr{cholmod_dense}, arg4::Ptr{cholmod_sparse},
+                                       arg5::Ptr{Ptr{cholmod_dense}},
+                                       arg6::Ptr{Ptr{cholmod_sparse}},
+                                       arg7::Ptr{Ptr{cholmod_dense}},
+                                       arg8::Ptr{Ptr{cholmod_dense}},
+                                       arg9::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_spsolve(sys, L, B, Common)
-    @ccall libcholmod.cholmod_spsolve(sys::Cint, L::Ptr{cholmod_factor}, B::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_spsolve(sys::Cint, L::Ptr{cholmod_factor},
+                                      B::Ptr{cholmod_sparse},
+                                      Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_spsolve(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_spsolve(arg1::Cint, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_sparse}, arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_spsolve(arg1::Cint, arg2::Ptr{cholmod_factor},
+                                        arg3::Ptr{cholmod_sparse},
+                                        arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_etree(A, Parent, Common)
-    @ccall libcholmod.cholmod_etree(A::Ptr{cholmod_sparse}, Parent::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_etree(A::Ptr{cholmod_sparse}, Parent::Ptr{Int32},
+                                    Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_etree(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_etree(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_etree(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                      arg3::Ptr{cholmod_common})::Cint
 end
 
-function cholmod_rowcolcounts(A, fset, fsize, Parent, Post, RowCount, ColCount, First, Level, Common)
-    @ccall libcholmod.cholmod_rowcolcounts(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, Parent::Ptr{Int32}, Post::Ptr{Int32}, RowCount::Ptr{Int32}, ColCount::Ptr{Int32}, First::Ptr{Int32}, Level::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+function cholmod_rowcolcounts(A, fset, fsize, Parent, Post, RowCount, ColCount, First,
+                              Level, Common)
+    @ccall libcholmod.cholmod_rowcolcounts(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                           fsize::Csize_t, Parent::Ptr{Int32},
+                                           Post::Ptr{Int32}, RowCount::Ptr{Int32},
+                                           ColCount::Ptr{Int32}, First::Ptr{Int32},
+                                           Level::Ptr{Int32},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowcolcounts(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)
-    @ccall libcholmod.cholmod_l_rowcolcounts(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{Int64}, arg6::Ptr{Int64}, arg7::Ptr{Int64}, arg8::Ptr{Int64}, arg9::Ptr{Int64}, arg10::Ptr{cholmod_common})::Cint
-end
-
-function cholmod_analyze_ordering(A, ordering, Perm, fset, fsize, Parent, Post, ColCount, First, Level, Common)
-    @ccall libcholmod.cholmod_analyze_ordering(A::Ptr{cholmod_sparse}, ordering::Cint, Perm::Ptr{Int32}, fset::Ptr{Int32}, fsize::Csize_t, Parent::Ptr{Int32}, Post::Ptr{Int32}, ColCount::Ptr{Int32}, First::Ptr{Int32}, Level::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
-end
-
-function cholmod_l_analyze_ordering(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11)
-    @ccall libcholmod.cholmod_l_analyze_ordering(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Csize_t, arg6::Ptr{Int64}, arg7::Ptr{Int64}, arg8::Ptr{Int64}, arg9::Ptr{Int64}, arg10::Ptr{Int64}, arg11::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowcolcounts(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                             arg3::Csize_t, arg4::Ptr{Int64},
+                                             arg5::Ptr{Int64}, arg6::Ptr{Int64},
+                                             arg7::Ptr{Int64}, arg8::Ptr{Int64},
+                                             arg9::Ptr{Int64},
+                                             arg10::Ptr{cholmod_common})::Cint
+end
+
+function cholmod_analyze_ordering(A, ordering, Perm, fset, fsize, Parent, Post, ColCount,
+                                  First, Level, Common)
+    @ccall libcholmod.cholmod_analyze_ordering(A::Ptr{cholmod_sparse}, ordering::Cint,
+                                               Perm::Ptr{Int32}, fset::Ptr{Int32},
+                                               fsize::Csize_t, Parent::Ptr{Int32},
+                                               Post::Ptr{Int32}, ColCount::Ptr{Int32},
+                                               First::Ptr{Int32}, Level::Ptr{Int32},
+                                               Common::Ptr{cholmod_common})::Cint
+end
+
+function cholmod_l_analyze_ordering(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9,
+                                    arg10, arg11)
+    @ccall libcholmod.cholmod_l_analyze_ordering(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                                 arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                                 arg5::Csize_t, arg6::Ptr{Int64},
+                                                 arg7::Ptr{Int64}, arg8::Ptr{Int64},
+                                                 arg9::Ptr{Int64}, arg10::Ptr{Int64},
+                                                 arg11::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_amd(A, fset, fsize, Perm, Common)
-    @ccall libcholmod.cholmod_amd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_amd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t,
+                                  Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_amd(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_amd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_amd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                    arg3::Csize_t, arg4::Ptr{Int64},
+                                    arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_colamd(A, fset, fsize, postorder, Perm, Common)
-    @ccall libcholmod.cholmod_colamd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, postorder::Cint, Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_colamd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                     fsize::Csize_t, postorder::Cint, Perm::Ptr{Int32},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_colamd(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_colamd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Cint, arg5::Ptr{Int64}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_colamd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                       arg3::Csize_t, arg4::Cint, arg5::Ptr{Int64},
+                                       arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowfac(A, F, beta, kstart, kend, L, Common)
-    @ccall libcholmod.cholmod_rowfac(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, beta::Ptr{Cdouble}, kstart::Csize_t, kend::Csize_t, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowfac(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse},
+                                     beta::Ptr{Cdouble}, kstart::Csize_t, kend::Csize_t,
+                                     L::Ptr{cholmod_factor},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowfac(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_rowfac(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Csize_t, arg5::Csize_t, arg6::Ptr{cholmod_factor}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowfac(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse},
+                                       arg3::Ptr{Cdouble}, arg4::Csize_t, arg5::Csize_t,
+                                       arg6::Ptr{cholmod_factor},
+                                       arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowfac_mask(A, F, beta, kstart, kend, mask, RLinkUp, L, Common)
-    @ccall libcholmod.cholmod_rowfac_mask(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, beta::Ptr{Cdouble}, kstart::Csize_t, kend::Csize_t, mask::Ptr{Int32}, RLinkUp::Ptr{Int32}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowfac_mask(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse},
+                                          beta::Ptr{Cdouble}, kstart::Csize_t,
+                                          kend::Csize_t, mask::Ptr{Int32},
+                                          RLinkUp::Ptr{Int32}, L::Ptr{cholmod_factor},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowfac_mask(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
-    @ccall libcholmod.cholmod_l_rowfac_mask(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Csize_t, arg5::Csize_t, arg6::Ptr{Int64}, arg7::Ptr{Int64}, arg8::Ptr{cholmod_factor}, arg9::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowfac_mask(arg1::Ptr{cholmod_sparse},
+                                            arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble},
+                                            arg4::Csize_t, arg5::Csize_t, arg6::Ptr{Int64},
+                                            arg7::Ptr{Int64}, arg8::Ptr{cholmod_factor},
+                                            arg9::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowfac_mask2(A, F, beta, kstart, kend, mask, maskmark, RLinkUp, L, Common)
-    @ccall libcholmod.cholmod_rowfac_mask2(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, beta::Ptr{Cdouble}, kstart::Csize_t, kend::Csize_t, mask::Ptr{Int32}, maskmark::Int32, RLinkUp::Ptr{Int32}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowfac_mask2(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse},
+                                           beta::Ptr{Cdouble}, kstart::Csize_t,
+                                           kend::Csize_t, mask::Ptr{Int32}, maskmark::Int32,
+                                           RLinkUp::Ptr{Int32}, L::Ptr{cholmod_factor},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowfac_mask2(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)
-    @ccall libcholmod.cholmod_l_rowfac_mask2(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Csize_t, arg5::Csize_t, arg6::Ptr{Int64}, arg7::Int64, arg8::Ptr{Int64}, arg9::Ptr{cholmod_factor}, arg10::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowfac_mask2(arg1::Ptr{cholmod_sparse},
+                                             arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble},
+                                             arg4::Csize_t, arg5::Csize_t, arg6::Ptr{Int64},
+                                             arg7::Int64, arg8::Ptr{Int64},
+                                             arg9::Ptr{cholmod_factor},
+                                             arg10::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_row_subtree(A, F, k, Parent, R, Common)
-    @ccall libcholmod.cholmod_row_subtree(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, k::Csize_t, Parent::Ptr{Int32}, R::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_row_subtree(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse},
+                                          k::Csize_t, Parent::Ptr{Int32},
+                                          R::Ptr{cholmod_sparse},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_row_subtree(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_row_subtree(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{cholmod_sparse}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_row_subtree(arg1::Ptr{cholmod_sparse},
+                                            arg2::Ptr{cholmod_sparse}, arg3::Csize_t,
+                                            arg4::Ptr{Int64}, arg5::Ptr{cholmod_sparse},
+                                            arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_lsolve_pattern(B, L, X, Common)
-    @ccall libcholmod.cholmod_lsolve_pattern(B::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_lsolve_pattern(B::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor},
+                                             X::Ptr{cholmod_sparse},
+                                             Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_lsolve_pattern(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_lsolve_pattern(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_sparse}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_lsolve_pattern(arg1::Ptr{cholmod_sparse},
+                                               arg2::Ptr{cholmod_factor},
+                                               arg3::Ptr{cholmod_sparse},
+                                               arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_row_lsubtree(A, Fi, fnz, k, L, R, Common)
-    @ccall libcholmod.cholmod_row_lsubtree(A::Ptr{cholmod_sparse}, Fi::Ptr{Int32}, fnz::Csize_t, k::Csize_t, L::Ptr{cholmod_factor}, R::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_row_lsubtree(A::Ptr{cholmod_sparse}, Fi::Ptr{Int32},
+                                           fnz::Csize_t, k::Csize_t, L::Ptr{cholmod_factor},
+                                           R::Ptr{cholmod_sparse},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_row_lsubtree(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_row_lsubtree(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Csize_t, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_sparse}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_row_lsubtree(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                             arg3::Csize_t, arg4::Csize_t,
+                                             arg5::Ptr{cholmod_factor},
+                                             arg6::Ptr{cholmod_sparse},
+                                             arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_resymbol(A, fset, fsize, pack, L, Common)
-    @ccall libcholmod.cholmod_resymbol(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, pack::Cint, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_resymbol(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                       fsize::Csize_t, pack::Cint, L::Ptr{cholmod_factor},
+                                       Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_resymbol(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_resymbol(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Cint, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_resymbol(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                         arg3::Csize_t, arg4::Cint,
+                                         arg5::Ptr{cholmod_factor},
+                                         arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_resymbol_noperm(A, fset, fsize, pack, L, Common)
-    @ccall libcholmod.cholmod_resymbol_noperm(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, pack::Cint, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_resymbol_noperm(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                              fsize::Csize_t, pack::Cint,
+                                              L::Ptr{cholmod_factor},
+                                              Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_resymbol_noperm(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_resymbol_noperm(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Cint, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_resymbol_noperm(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                                arg3::Csize_t, arg4::Cint,
+                                                arg5::Ptr{cholmod_factor},
+                                                arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rcond(L, Common)
-    @ccall libcholmod.cholmod_rcond(L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cdouble
+    @ccall libcholmod.cholmod_rcond(L::Ptr{cholmod_factor},
+                                    Common::Ptr{cholmod_common})::Cdouble
 end
 
 function cholmod_l_rcond(arg1, arg2)
-    @ccall libcholmod.cholmod_l_rcond(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_common})::Cdouble
+    @ccall libcholmod.cholmod_l_rcond(arg1::Ptr{cholmod_factor},
+                                      arg2::Ptr{cholmod_common})::Cdouble
 end
 
 function cholmod_postorder(Parent, n, Weight_p, Post, Common)
-    @ccall libcholmod.cholmod_postorder(Parent::Ptr{Int32}, n::Csize_t, Weight_p::Ptr{Int32}, Post::Ptr{Int32}, Common::Ptr{cholmod_common})::Int32
+    @ccall libcholmod.cholmod_postorder(Parent::Ptr{Int32}, n::Csize_t,
+                                        Weight_p::Ptr{Int32}, Post::Ptr{Int32},
+                                        Common::Ptr{cholmod_common})::Int32
 end
 
 function cholmod_l_postorder(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_postorder(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_l_postorder(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Ptr{Int64},
+                                          arg4::Ptr{Int64},
+                                          arg5::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_drop(tol, A, Common)
-    @ccall libcholmod.cholmod_drop(tol::Cdouble, A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_drop(tol::Cdouble, A::Ptr{cholmod_sparse},
+                                   Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_drop(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_drop(arg1::Cdouble, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_drop(arg1::Cdouble, arg2::Ptr{cholmod_sparse},
+                                     arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_norm_dense(X, norm, Common)
-    @ccall libcholmod.cholmod_norm_dense(X::Ptr{cholmod_dense}, norm::Cint, Common::Ptr{cholmod_common})::Cdouble
+    @ccall libcholmod.cholmod_norm_dense(X::Ptr{cholmod_dense}, norm::Cint,
+                                         Common::Ptr{cholmod_common})::Cdouble
 end
 
 function cholmod_l_norm_dense(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_norm_dense(arg1::Ptr{cholmod_dense}, arg2::Cint, arg3::Ptr{cholmod_common})::Cdouble
+    @ccall libcholmod.cholmod_l_norm_dense(arg1::Ptr{cholmod_dense}, arg2::Cint,
+                                           arg3::Ptr{cholmod_common})::Cdouble
 end
 
 function cholmod_norm_sparse(A, norm, Common)
-    @ccall libcholmod.cholmod_norm_sparse(A::Ptr{cholmod_sparse}, norm::Cint, Common::Ptr{cholmod_common})::Cdouble
+    @ccall libcholmod.cholmod_norm_sparse(A::Ptr{cholmod_sparse}, norm::Cint,
+                                          Common::Ptr{cholmod_common})::Cdouble
 end
 
 function cholmod_l_norm_sparse(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_norm_sparse(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{cholmod_common})::Cdouble
+    @ccall libcholmod.cholmod_l_norm_sparse(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                            arg3::Ptr{cholmod_common})::Cdouble
 end
 
 function cholmod_horzcat(A, B, values, Common)
-    @ccall libcholmod.cholmod_horzcat(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse}, values::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_horzcat(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse},
+                                      values::Cint,
+                                      Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_horzcat(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_horzcat(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_horzcat(arg1::Ptr{cholmod_sparse},
+                                        arg2::Ptr{cholmod_sparse}, arg3::Cint,
+                                        arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_scale(S, scale, A, Common)
-    @ccall libcholmod.cholmod_scale(S::Ptr{cholmod_dense}, scale::Cint, A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_scale(S::Ptr{cholmod_dense}, scale::Cint,
+                                    A::Ptr{cholmod_sparse},
+                                    Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_scale(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_scale(arg1::Ptr{cholmod_dense}, arg2::Cint, arg3::Ptr{cholmod_sparse}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_scale(arg1::Ptr{cholmod_dense}, arg2::Cint,
+                                      arg3::Ptr{cholmod_sparse},
+                                      arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_sdmult(A, transpose, alpha, beta, X, Y, Common)
-    @ccall libcholmod.cholmod_sdmult(A::Ptr{cholmod_sparse}, transpose::Cint, alpha::Ptr{Cdouble}, beta::Ptr{Cdouble}, X::Ptr{cholmod_dense}, Y::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_sdmult(A::Ptr{cholmod_sparse}, transpose::Cint,
+                                     alpha::Ptr{Cdouble}, beta::Ptr{Cdouble},
+                                     X::Ptr{cholmod_dense}, Y::Ptr{cholmod_dense},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_sdmult(arg1, arg2, arg3, arg4, arg5, Y, arg7)
-    @ccall libcholmod.cholmod_l_sdmult(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{Cdouble}, arg4::Ptr{Cdouble}, arg5::Ptr{cholmod_dense}, Y::Ptr{cholmod_dense}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_sdmult(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                       arg3::Ptr{Cdouble}, arg4::Ptr{Cdouble},
+                                       arg5::Ptr{cholmod_dense}, Y::Ptr{cholmod_dense},
+                                       arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_ssmult(A, B, stype, values, sorted, Common)
-    @ccall libcholmod.cholmod_ssmult(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse}, stype::Cint, values::Cint, sorted::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_ssmult(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse},
+                                     stype::Cint, values::Cint, sorted::Cint,
+                                     Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_ssmult(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_ssmult(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Cint, arg4::Cint, arg5::Cint, arg6::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_ssmult(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse},
+                                       arg3::Cint, arg4::Cint, arg5::Cint,
+                                       arg6::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_submatrix(A, rset, rsize, cset, csize, values, sorted, Common)
-    @ccall libcholmod.cholmod_submatrix(A::Ptr{cholmod_sparse}, rset::Ptr{Int32}, rsize::Int64, cset::Ptr{Int32}, csize::Int64, values::Cint, sorted::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_submatrix(A::Ptr{cholmod_sparse}, rset::Ptr{Int32},
+                                        rsize::Int64, cset::Ptr{Int32}, csize::Int64,
+                                        values::Cint, sorted::Cint,
+                                        Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_submatrix(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
-    @ccall libcholmod.cholmod_l_submatrix(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Int64, arg4::Ptr{Int64}, arg5::Int64, arg6::Cint, arg7::Cint, arg8::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_submatrix(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                          arg3::Int64, arg4::Ptr{Int64}, arg5::Int64,
+                                          arg6::Cint, arg7::Cint,
+                                          arg8::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_vertcat(A, B, values, Common)
-    @ccall libcholmod.cholmod_vertcat(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse}, values::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_vertcat(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse},
+                                      values::Cint,
+                                      Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_vertcat(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_vertcat(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_vertcat(arg1::Ptr{cholmod_sparse},
+                                        arg2::Ptr{cholmod_sparse}, arg3::Cint,
+                                        arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_symmetry(A, option, xmatched, pmatched, nzoffdiag, nzdiag, Common)
-    @ccall libcholmod.cholmod_symmetry(A::Ptr{cholmod_sparse}, option::Cint, xmatched::Ptr{Int32}, pmatched::Ptr{Int32}, nzoffdiag::Ptr{Int32}, nzdiag::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_symmetry(A::Ptr{cholmod_sparse}, option::Cint,
+                                       xmatched::Ptr{Int32}, pmatched::Ptr{Int32},
+                                       nzoffdiag::Ptr{Int32}, nzdiag::Ptr{Int32},
+                                       Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_symmetry(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_symmetry(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Ptr{Int64}, arg6::Ptr{Int64}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_symmetry(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                         arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                         arg5::Ptr{Int64}, arg6::Ptr{Int64},
+                                         arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_updown(update, C, L, Common)
-    @ccall libcholmod.cholmod_updown(update::Cint, C::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_updown(update::Cint, C::Ptr{cholmod_sparse},
+                                     L::Ptr{cholmod_factor},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_updown(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_updown(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_factor}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_updown(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                       arg3::Ptr{cholmod_factor},
+                                       arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_updown_solve(update, C, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_updown_solve(update::Cint, C::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_updown_solve(update::Cint, C::Ptr{cholmod_sparse},
+                                           L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense},
+                                           DeltaB::Ptr{cholmod_dense},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_updown_solve(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_updown_solve(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_factor}, arg4::Ptr{cholmod_dense}, arg5::Ptr{cholmod_dense}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_updown_solve(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                             arg3::Ptr{cholmod_factor},
+                                             arg4::Ptr{cholmod_dense},
+                                             arg5::Ptr{cholmod_dense},
+                                             arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_updown_mark(update, C, colmark, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_updown_mark(update::Cint, C::Ptr{cholmod_sparse}, colmark::Ptr{Int32}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_updown_mark(update::Cint, C::Ptr{cholmod_sparse},
+                                          colmark::Ptr{Int32}, L::Ptr{cholmod_factor},
+                                          X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_updown_mark(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_updown_mark(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Int64}, arg4::Ptr{cholmod_factor}, arg5::Ptr{cholmod_dense}, arg6::Ptr{cholmod_dense}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_updown_mark(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                            arg3::Ptr{Int64}, arg4::Ptr{cholmod_factor},
+                                            arg5::Ptr{cholmod_dense},
+                                            arg6::Ptr{cholmod_dense},
+                                            arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_updown_mask(update, C, colmark, mask, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_updown_mask(update::Cint, C::Ptr{cholmod_sparse}, colmark::Ptr{Int32}, mask::Ptr{Int32}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_updown_mask(update::Cint, C::Ptr{cholmod_sparse},
+                                          colmark::Ptr{Int32}, mask::Ptr{Int32},
+                                          L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense},
+                                          DeltaB::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_updown_mask(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
-    @ccall libcholmod.cholmod_l_updown_mask(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_dense}, arg7::Ptr{cholmod_dense}, arg8::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_updown_mask(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                            arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                            arg5::Ptr{cholmod_factor},
+                                            arg6::Ptr{cholmod_dense},
+                                            arg7::Ptr{cholmod_dense},
+                                            arg8::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_updown_mask2(update, C, colmark, mask, maskmark, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_updown_mask2(update::Cint, C::Ptr{cholmod_sparse}, colmark::Ptr{Int32}, mask::Ptr{Int32}, maskmark::Int32, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_updown_mask2(update::Cint, C::Ptr{cholmod_sparse},
+                                           colmark::Ptr{Int32}, mask::Ptr{Int32},
+                                           maskmark::Int32, L::Ptr{cholmod_factor},
+                                           X::Ptr{cholmod_dense},
+                                           DeltaB::Ptr{cholmod_dense},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_updown_mask2(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
-    @ccall libcholmod.cholmod_l_updown_mask2(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Int64, arg6::Ptr{cholmod_factor}, arg7::Ptr{cholmod_dense}, arg8::Ptr{cholmod_dense}, arg9::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_updown_mask2(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                             arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                             arg5::Int64, arg6::Ptr{cholmod_factor},
+                                             arg7::Ptr{cholmod_dense},
+                                             arg8::Ptr{cholmod_dense},
+                                             arg9::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowadd(k, R, L, Common)
-    @ccall libcholmod.cholmod_rowadd(k::Csize_t, R::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowadd(k::Csize_t, R::Ptr{cholmod_sparse},
+                                     L::Ptr{cholmod_factor},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowadd(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_rowadd(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_factor}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowadd(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                       arg3::Ptr{cholmod_factor},
+                                       arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowadd_solve(k, R, bk, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_rowadd_solve(k::Csize_t, R::Ptr{cholmod_sparse}, bk::Ptr{Cdouble}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowadd_solve(k::Csize_t, R::Ptr{cholmod_sparse},
+                                           bk::Ptr{Cdouble}, L::Ptr{cholmod_factor},
+                                           X::Ptr{cholmod_dense},
+                                           DeltaB::Ptr{cholmod_dense},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowadd_solve(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_rowadd_solve(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Ptr{cholmod_factor}, arg5::Ptr{cholmod_dense}, arg6::Ptr{cholmod_dense}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowadd_solve(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                             arg3::Ptr{Cdouble}, arg4::Ptr{cholmod_factor},
+                                             arg5::Ptr{cholmod_dense},
+                                             arg6::Ptr{cholmod_dense},
+                                             arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowadd_mark(k, R, bk, colmark, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_rowadd_mark(k::Csize_t, R::Ptr{cholmod_sparse}, bk::Ptr{Cdouble}, colmark::Ptr{Int32}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowadd_mark(k::Csize_t, R::Ptr{cholmod_sparse},
+                                          bk::Ptr{Cdouble}, colmark::Ptr{Int32},
+                                          L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense},
+                                          DeltaB::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowadd_mark(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
-    @ccall libcholmod.cholmod_l_rowadd_mark(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Ptr{Int64}, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_dense}, arg7::Ptr{cholmod_dense}, arg8::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowadd_mark(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                            arg3::Ptr{Cdouble}, arg4::Ptr{Int64},
+                                            arg5::Ptr{cholmod_factor},
+                                            arg6::Ptr{cholmod_dense},
+                                            arg7::Ptr{cholmod_dense},
+                                            arg8::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowdel(k, R, L, Common)
-    @ccall libcholmod.cholmod_rowdel(k::Csize_t, R::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowdel(k::Csize_t, R::Ptr{cholmod_sparse},
+                                     L::Ptr{cholmod_factor},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowdel(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_rowdel(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_factor}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowdel(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                       arg3::Ptr{cholmod_factor},
+                                       arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowdel_solve(k, R, yk, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_rowdel_solve(k::Csize_t, R::Ptr{cholmod_sparse}, yk::Ptr{Cdouble}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowdel_solve(k::Csize_t, R::Ptr{cholmod_sparse},
+                                           yk::Ptr{Cdouble}, L::Ptr{cholmod_factor},
+                                           X::Ptr{cholmod_dense},
+                                           DeltaB::Ptr{cholmod_dense},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowdel_solve(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_rowdel_solve(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Ptr{cholmod_factor}, arg5::Ptr{cholmod_dense}, arg6::Ptr{cholmod_dense}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowdel_solve(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                             arg3::Ptr{Cdouble}, arg4::Ptr{cholmod_factor},
+                                             arg5::Ptr{cholmod_dense},
+                                             arg6::Ptr{cholmod_dense},
+                                             arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowdel_mark(k, R, yk, colmark, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_rowdel_mark(k::Csize_t, R::Ptr{cholmod_sparse}, yk::Ptr{Cdouble}, colmark::Ptr{Int32}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowdel_mark(k::Csize_t, R::Ptr{cholmod_sparse},
+                                          yk::Ptr{Cdouble}, colmark::Ptr{Int32},
+                                          L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense},
+                                          DeltaB::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowdel_mark(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
-    @ccall libcholmod.cholmod_l_rowdel_mark(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Ptr{Int64}, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_dense}, arg7::Ptr{cholmod_dense}, arg8::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowdel_mark(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                            arg3::Ptr{Cdouble}, arg4::Ptr{Int64},
+                                            arg5::Ptr{cholmod_factor},
+                                            arg6::Ptr{cholmod_dense},
+                                            arg7::Ptr{cholmod_dense},
+                                            arg8::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_ccolamd(A, fset, fsize, Cmember, Perm, Common)
-    @ccall libcholmod.cholmod_ccolamd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, Cmember::Ptr{Int32}, Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_ccolamd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                      fsize::Csize_t, Cmember::Ptr{Int32}, Perm::Ptr{Int32},
+                                      Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_ccolamd(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_ccolamd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{Int64}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_ccolamd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                        arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{Int64},
+                                        arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_csymamd(A, Cmember, Perm, Common)
-    @ccall libcholmod.cholmod_csymamd(A::Ptr{cholmod_sparse}, Cmember::Ptr{Int32}, Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_csymamd(A::Ptr{cholmod_sparse}, Cmember::Ptr{Int32},
+                                      Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_csymamd(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_csymamd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Ptr{Int64}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_csymamd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                        arg3::Ptr{Int64}, arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_camd(A, fset, fsize, Cmember, Perm, Common)
-    @ccall libcholmod.cholmod_camd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, Cmember::Ptr{Int32}, Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_camd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t,
+                                   Cmember::Ptr{Int32}, Perm::Ptr{Int32},
+                                   Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_camd(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_camd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{Int64}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_camd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                     arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{Int64},
+                                     arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_nested_dissection(A, fset, fsize, Perm, CParent, Cmember, Common)
-    @ccall libcholmod.cholmod_nested_dissection(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, Perm::Ptr{Int32}, CParent::Ptr{Int32}, Cmember::Ptr{Int32}, Common::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_nested_dissection(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                                fsize::Csize_t, Perm::Ptr{Int32},
+                                                CParent::Ptr{Int32}, Cmember::Ptr{Int32},
+                                                Common::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_l_nested_dissection(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_nested_dissection(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{Int64}, arg6::Ptr{Int64}, arg7::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_l_nested_dissection(arg1::Ptr{cholmod_sparse},
+                                                  arg2::Ptr{Int64}, arg3::Csize_t,
+                                                  arg4::Ptr{Int64}, arg5::Ptr{Int64},
+                                                  arg6::Ptr{Int64},
+                                                  arg7::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_metis(A, fset, fsize, postorder, Perm, Common)
-    @ccall libcholmod.cholmod_metis(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, postorder::Cint, Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_metis(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                    fsize::Csize_t, postorder::Cint, Perm::Ptr{Int32},
+                                    Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_metis(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_metis(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Cint, arg5::Ptr{Int64}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_metis(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                      arg3::Csize_t, arg4::Cint, arg5::Ptr{Int64},
+                                      arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_bisect(A, fset, fsize, compress, Partition, Common)
-    @ccall libcholmod.cholmod_bisect(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, compress::Cint, Partition::Ptr{Int32}, Common::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_bisect(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                     fsize::Csize_t, compress::Cint, Partition::Ptr{Int32},
+                                     Common::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_l_bisect(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_bisect(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Cint, arg5::Ptr{Int64}, arg6::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_l_bisect(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                       arg3::Csize_t, arg4::Cint, arg5::Ptr{Int64},
+                                       arg6::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_metis_bisector(A, Anw, Aew, Partition, Common)
-    @ccall libcholmod.cholmod_metis_bisector(A::Ptr{cholmod_sparse}, Anw::Ptr{Int32}, Aew::Ptr{Int32}, Partition::Ptr{Int32}, Common::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_metis_bisector(A::Ptr{cholmod_sparse}, Anw::Ptr{Int32},
+                                             Aew::Ptr{Int32}, Partition::Ptr{Int32},
+                                             Common::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_l_metis_bisector(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_metis_bisector(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_l_metis_bisector(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                               arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                               arg5::Ptr{cholmod_common})::Int64
 end
 
-function cholmod_collapse_septree(n, ncomponents, nd_oksep, nd_small, CParent, Cmember, Common)
-    @ccall libcholmod.cholmod_collapse_septree(n::Csize_t, ncomponents::Csize_t, nd_oksep::Cdouble, nd_small::Csize_t, CParent::Ptr{Int32}, Cmember::Ptr{Int32}, Common::Ptr{cholmod_common})::Int64
+function cholmod_collapse_septree(n, ncomponents, nd_oksep, nd_small, CParent, Cmember,
+                                  Common)
+    @ccall libcholmod.cholmod_collapse_septree(n::Csize_t, ncomponents::Csize_t,
+                                               nd_oksep::Cdouble, nd_small::Csize_t,
+                                               CParent::Ptr{Int32}, Cmember::Ptr{Int32},
+                                               Common::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_l_collapse_septree(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_collapse_septree(arg1::Csize_t, arg2::Csize_t, arg3::Cdouble, arg4::Csize_t, arg5::Ptr{Int64}, arg6::Ptr{Int64}, arg7::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_l_collapse_septree(arg1::Csize_t, arg2::Csize_t,
+                                                 arg3::Cdouble, arg4::Csize_t,
+                                                 arg5::Ptr{Int64}, arg6::Ptr{Int64},
+                                                 arg7::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_super_symbolic(A, F, Parent, L, Common)
-    @ccall libcholmod.cholmod_super_symbolic(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, Parent::Ptr{Int32}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_super_symbolic(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse},
+                                             Parent::Ptr{Int32}, L::Ptr{cholmod_factor},
+                                             Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_super_symbolic(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_super_symbolic(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Int64}, arg4::Ptr{cholmod_factor}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_super_symbolic(arg1::Ptr{cholmod_sparse},
+                                               arg2::Ptr{cholmod_sparse}, arg3::Ptr{Int64},
+                                               arg4::Ptr{cholmod_factor},
+                                               arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_super_symbolic2(for_whom, A, F, Parent, L, Common)
-    @ccall libcholmod.cholmod_super_symbolic2(for_whom::Cint, A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, Parent::Ptr{Int32}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_super_symbolic2(for_whom::Cint, A::Ptr{cholmod_sparse},
+                                              F::Ptr{cholmod_sparse}, Parent::Ptr{Int32},
+                                              L::Ptr{cholmod_factor},
+                                              Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_super_symbolic2(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_super_symbolic2(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_sparse}, arg4::Ptr{Int64}, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_super_symbolic2(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                                arg3::Ptr{cholmod_sparse}, arg4::Ptr{Int64},
+                                                arg5::Ptr{cholmod_factor},
+                                                arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_super_numeric(A, F, beta, L, Common)
-    @ccall libcholmod.cholmod_super_numeric(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, beta::Ptr{Cdouble}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_super_numeric(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse},
+                                            beta::Ptr{Cdouble}, L::Ptr{cholmod_factor},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_super_numeric(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_super_numeric(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Ptr{cholmod_factor}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_super_numeric(arg1::Ptr{cholmod_sparse},
+                                              arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble},
+                                              arg4::Ptr{cholmod_factor},
+                                              arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_super_lsolve(L, X, E, Common)
-    @ccall libcholmod.cholmod_super_lsolve(L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, E::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_super_lsolve(L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense},
+                                           E::Ptr{cholmod_dense},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_super_lsolve(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_super_lsolve(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_dense}, arg3::Ptr{cholmod_dense}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_super_lsolve(arg1::Ptr{cholmod_factor},
+                                             arg2::Ptr{cholmod_dense},
+                                             arg3::Ptr{cholmod_dense},
+                                             arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_super_ltsolve(L, X, E, Common)
-    @ccall libcholmod.cholmod_super_ltsolve(L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, E::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_super_ltsolve(L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense},
+                                            E::Ptr{cholmod_dense},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_super_ltsolve(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_super_ltsolve(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_dense}, arg3::Ptr{cholmod_dense}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_super_ltsolve(arg1::Ptr{cholmod_factor},
+                                              arg2::Ptr{cholmod_dense},
+                                              arg3::Ptr{cholmod_dense},
+                                              arg4::Ptr{cholmod_common})::Cint
+end
+
+function SuiteSparseQR_C(ordering, tol, econ, getCTX, A, Bsparse, Bdense, Zsparse, Zdense,
+                         R, E, H, HPinv, HTau, cc)
+    @ccall libspqr.SuiteSparseQR_C(ordering::Cint, tol::Cdouble, econ::Int64, getCTX::Cint,
+                                   A::Ptr{cholmod_sparse}, Bsparse::Ptr{cholmod_sparse},
+                                   Bdense::Ptr{cholmod_dense},
+                                   Zsparse::Ptr{Ptr{cholmod_sparse}},
+                                   Zdense::Ptr{Ptr{cholmod_dense}},
+                                   R::Ptr{Ptr{cholmod_sparse}}, E::Ptr{Ptr{Int64}},
+                                   H::Ptr{Ptr{cholmod_sparse}}, HPinv::Ptr{Ptr{Int64}},
+                                   HTau::Ptr{Ptr{cholmod_dense}},
+                                   cc::Ptr{cholmod_common})::Int64
+end
+
+function SuiteSparseQR_i_C(ordering, tol, econ, getCTX, A, Bsparse, Bdense, Zsparse, Zdense,
+                           R, E, H, HPinv, HTau, cc)
+    @ccall libspqr.SuiteSparseQR_i_C(ordering::Cint, tol::Cdouble, econ::Int32,
+                                     getCTX::Cint, A::Ptr{cholmod_sparse},
+                                     Bsparse::Ptr{cholmod_sparse},
+                                     Bdense::Ptr{cholmod_dense},
+                                     Zsparse::Ptr{Ptr{cholmod_sparse}},
+                                     Zdense::Ptr{Ptr{cholmod_dense}},
+                                     R::Ptr{Ptr{cholmod_sparse}}, E::Ptr{Ptr{Int32}},
+                                     H::Ptr{Ptr{cholmod_sparse}}, HPinv::Ptr{Ptr{Int32}},
+                                     HTau::Ptr{Ptr{cholmod_dense}},
+                                     cc::Ptr{cholmod_common})::Int32
 end
 
-function SuiteSparseQR_C(ordering, tol, econ, getCTX, A, Bsparse, Bdense, Zsparse, Zdense, R, E, H, HPinv, HTau, cc)
-    @ccall libspqr.SuiteSparseQR_C(ordering::Cint, tol::Cdouble, econ::Int64, getCTX::Cint, A::Ptr{cholmod_sparse}, Bsparse::Ptr{cholmod_sparse}, Bdense::Ptr{cholmod_dense}, Zsparse::Ptr{Ptr{cholmod_sparse}}, Zdense::Ptr{Ptr{cholmod_dense}}, R::Ptr{Ptr{cholmod_sparse}}, E::Ptr{Ptr{Int64}}, H::Ptr{Ptr{cholmod_sparse}}, HPinv::Ptr{Ptr{Int64}}, HTau::Ptr{Ptr{cholmod_dense}}, cc::Ptr{cholmod_common})::Int64
+function SuiteSparseQR_C_QR(ordering, tol, econ, A, Q, R, E, cc)
+    @ccall libspqr.SuiteSparseQR_C_QR(ordering::Cint, tol::Cdouble, econ::Int64,
+                                      A::Ptr{cholmod_sparse}, Q::Ptr{Ptr{cholmod_sparse}},
+                                      R::Ptr{Ptr{cholmod_sparse}}, E::Ptr{Ptr{Int64}},
+                                      cc::Ptr{cholmod_common})::Int64
 end
 
-function SuiteSparseQR_C_QR(ordering, tol, econ, A, Q, R, E, cc)
-    @ccall libspqr.SuiteSparseQR_C_QR(ordering::Cint, tol::Cdouble, econ::Int64, A::Ptr{cholmod_sparse}, Q::Ptr{Ptr{cholmod_sparse}}, R::Ptr{Ptr{cholmod_sparse}}, E::Ptr{Ptr{Int64}}, cc::Ptr{cholmod_common})::Int64
+function SuiteSparseQR_i_C_QR(ordering, tol, econ, A, Q, R, E, cc)
+    @ccall libspqr.SuiteSparseQR_i_C_QR(ordering::Cint, tol::Cdouble, econ::Int32,
+                                        A::Ptr{cholmod_sparse}, Q::Ptr{Ptr{cholmod_sparse}},
+                                        R::Ptr{Ptr{cholmod_sparse}}, E::Ptr{Ptr{Int32}},
+                                        cc::Ptr{cholmod_common})::Int32
 end
 
 function SuiteSparseQR_C_backslash(ordering, tol, A, B, cc)
-    @ccall libspqr.SuiteSparseQR_C_backslash(ordering::Cint, tol::Cdouble, A::Ptr{cholmod_sparse}, B::Ptr{cholmod_dense}, cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libspqr.SuiteSparseQR_C_backslash(ordering::Cint, tol::Cdouble,
+                                             A::Ptr{cholmod_sparse}, B::Ptr{cholmod_dense},
+                                             cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function SuiteSparseQR_C_backslash_default(A, B, cc)
-    @ccall libspqr.SuiteSparseQR_C_backslash_default(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_dense}, cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libspqr.SuiteSparseQR_C_backslash_default(A::Ptr{cholmod_sparse},
+                                                     B::Ptr{cholmod_dense},
+                                                     cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function SuiteSparseQR_C_backslash_sparse(ordering, tol, A, B, cc)
-    @ccall libspqr.SuiteSparseQR_C_backslash_sparse(ordering::Cint, tol::Cdouble, A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse}, cc::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libspqr.SuiteSparseQR_C_backslash_sparse(ordering::Cint, tol::Cdouble,
+                                                    A::Ptr{cholmod_sparse},
+                                                    B::Ptr{cholmod_sparse},
+                                                    cc::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 mutable struct SuiteSparseQR_C_factorization_struct
     xtype::Cint
+    itype::Cint
     factors::Ptr{Cvoid}
     SuiteSparseQR_C_factorization_struct() = new()
 end
@@ -1536,51 +2115,78 @@ end
 const SuiteSparseQR_C_factorization = SuiteSparseQR_C_factorization_struct
 
 function SuiteSparseQR_C_factorize(ordering, tol, A, cc)
-    @ccall libspqr.SuiteSparseQR_C_factorize(ordering::Cint, tol::Cdouble, A::Ptr{cholmod_sparse}, cc::Ptr{cholmod_common})::Ptr{SuiteSparseQR_C_factorization}
+    @ccall libspqr.SuiteSparseQR_C_factorize(ordering::Cint, tol::Cdouble,
+                                             A::Ptr{cholmod_sparse},
+                                             cc::Ptr{cholmod_common})::Ptr{SuiteSparseQR_C_factorization}
 end
 
 function SuiteSparseQR_C_symbolic(ordering, allow_tol, A, cc)
-    @ccall libspqr.SuiteSparseQR_C_symbolic(ordering::Cint, allow_tol::Cint, A::Ptr{cholmod_sparse}, cc::Ptr{cholmod_common})::Ptr{SuiteSparseQR_C_factorization}
+    @ccall libspqr.SuiteSparseQR_C_symbolic(ordering::Cint, allow_tol::Cint,
+                                            A::Ptr{cholmod_sparse},
+                                            cc::Ptr{cholmod_common})::Ptr{SuiteSparseQR_C_factorization}
 end
 
 function SuiteSparseQR_C_numeric(tol, A, QR, cc)
-    @ccall libspqr.SuiteSparseQR_C_numeric(tol::Cdouble, A::Ptr{cholmod_sparse}, QR::Ptr{SuiteSparseQR_C_factorization}, cc::Ptr{cholmod_common})::Cint
+    @ccall libspqr.SuiteSparseQR_C_numeric(tol::Cdouble, A::Ptr{cholmod_sparse},
+                                           QR::Ptr{SuiteSparseQR_C_factorization},
+                                           cc::Ptr{cholmod_common})::Cint
 end
 
 function SuiteSparseQR_C_free(QR, cc)
-    @ccall libspqr.SuiteSparseQR_C_free(QR::Ptr{Ptr{SuiteSparseQR_C_factorization}}, cc::Ptr{cholmod_common})::Cint
+    @ccall libspqr.SuiteSparseQR_C_free(QR::Ptr{Ptr{SuiteSparseQR_C_factorization}},
+                                        cc::Ptr{cholmod_common})::Cint
 end
 
 function SuiteSparseQR_C_solve(system, QR, B, cc)
-    @ccall libspqr.SuiteSparseQR_C_solve(system::Cint, QR::Ptr{SuiteSparseQR_C_factorization}, B::Ptr{cholmod_dense}, cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libspqr.SuiteSparseQR_C_solve(system::Cint,
+                                         QR::Ptr{SuiteSparseQR_C_factorization},
+                                         B::Ptr{cholmod_dense},
+                                         cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function SuiteSparseQR_C_qmult(method, QR, X, cc)
-    @ccall libspqr.SuiteSparseQR_C_qmult(method::Cint, QR::Ptr{SuiteSparseQR_C_factorization}, X::Ptr{cholmod_dense}, cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libspqr.SuiteSparseQR_C_qmult(method::Cint,
+                                         QR::Ptr{SuiteSparseQR_C_factorization},
+                                         X::Ptr{cholmod_dense},
+                                         cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function amd_order(n, Ap, Ai, P, Control, Info)
-    @ccall libamd.amd_order(n::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, P::Ptr{Int32}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libamd.amd_order(n::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, P::Ptr{Int32},
+                            Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function amd_l_order(n, Ap, Ai, P, Control, Info)
-    @ccall libamd.amd_l_order(n::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, P::Ptr{Int64}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libamd.amd_l_order(n::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, P::Ptr{Int64},
+                              Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
-function amd_2(n, Pe, Iw, Len, iwlen, pfree, Nv, Next, Last, Head, Elen, Degree, W, Control, Info)
-    @ccall libamd.amd_2(n::Int32, Pe::Ptr{Int32}, Iw::Ptr{Int32}, Len::Ptr{Int32}, iwlen::Int32, pfree::Int32, Nv::Ptr{Int32}, Next::Ptr{Int32}, Last::Ptr{Int32}, Head::Ptr{Int32}, Elen::Ptr{Int32}, Degree::Ptr{Int32}, W::Ptr{Int32}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cvoid
+function amd_2(n, Pe, Iw, Len, iwlen, pfree, Nv, Next, Last, Head, Elen, Degree, W, Control,
+               Info)
+    @ccall libamd.amd_2(n::Int32, Pe::Ptr{Int32}, Iw::Ptr{Int32}, Len::Ptr{Int32},
+                        iwlen::Int32, pfree::Int32, Nv::Ptr{Int32}, Next::Ptr{Int32},
+                        Last::Ptr{Int32}, Head::Ptr{Int32}, Elen::Ptr{Int32},
+                        Degree::Ptr{Int32}, W::Ptr{Int32}, Control::Ptr{Cdouble},
+                        Info::Ptr{Cdouble})::Cvoid
 end
 
-function amd_l2(n, Pe, Iw, Len, iwlen, pfree, Nv, Next, Last, Head, Elen, Degree, W, Control, Info)
-    @ccall libamd.amd_l2(n::Int64, Pe::Ptr{Int64}, Iw::Ptr{Int64}, Len::Ptr{Int64}, iwlen::Int64, pfree::Int64, Nv::Ptr{Int64}, Next::Ptr{Int64}, Last::Ptr{Int64}, Head::Ptr{Int64}, Elen::Ptr{Int64}, Degree::Ptr{Int64}, W::Ptr{Int64}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cvoid
+function amd_l2(n, Pe, Iw, Len, iwlen, pfree, Nv, Next, Last, Head, Elen, Degree, W,
+                Control, Info)
+    @ccall libamd.amd_l2(n::Int64, Pe::Ptr{Int64}, Iw::Ptr{Int64}, Len::Ptr{Int64},
+                         iwlen::Int64, pfree::Int64, Nv::Ptr{Int64}, Next::Ptr{Int64},
+                         Last::Ptr{Int64}, Head::Ptr{Int64}, Elen::Ptr{Int64},
+                         Degree::Ptr{Int64}, W::Ptr{Int64}, Control::Ptr{Cdouble},
+                         Info::Ptr{Cdouble})::Cvoid
 end
 
 function amd_valid(n_row, n_col, Ap, Ai)
-    @ccall libamd.amd_valid(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32})::Cint
+    @ccall libamd.amd_valid(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                            Ai::Ptr{Int32})::Cint
 end
 
 function amd_l_valid(n_row, n_col, Ap, Ai)
-    @ccall libamd.amd_l_valid(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64})::Cint
+    @ccall libamd.amd_l_valid(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                              Ai::Ptr{Int64})::Cint
 end
 
 function amd_defaults(Control)
@@ -1607,188 +2213,88 @@ function amd_l_info(Info)
     @ccall libamd.amd_l_info(Info::Ptr{Cdouble})::Cvoid
 end
 
-function colamd_recommended(nnz, n_row, n_col)
-    @ccall libcolamd.colamd_recommended(nnz::Int32, n_row::Int32, n_col::Int32)::Csize_t
-end
-
-function colamd_l_recommended(nnz, n_row, n_col)
-    @ccall libcolamd.colamd_l_recommended(nnz::Int64, n_row::Int64, n_col::Int64)::Csize_t
-end
-
-function colamd_set_defaults(knobs)
-    @ccall libcolamd.colamd_set_defaults(knobs::Ptr{Cdouble})::Cvoid
-end
-
-function colamd_l_set_defaults(knobs)
-    @ccall libcolamd.colamd_l_set_defaults(knobs::Ptr{Cdouble})::Cvoid
-end
-
-function colamd(n_row, n_col, Alen, A, p, knobs, stats)
-    @ccall libcolamd.colamd(n_row::Int32, n_col::Int32, Alen::Int32, A::Ptr{Int32}, p::Ptr{Int32}, knobs::Ptr{Cdouble}, stats::Ptr{Int32})::Cint
-end
-
-function colamd_l(n_row, n_col, Alen, A, p, knobs, stats)
-    @ccall libcolamd.colamd_l(n_row::Int64, n_col::Int64, Alen::Int64, A::Ptr{Int64}, p::Ptr{Int64}, knobs::Ptr{Cdouble}, stats::Ptr{Int64})::Cint
-end
-
-function symamd(n, A, p, perm, knobs, stats, allocate, release)
-    @ccall libcolamd.symamd(n::Int32, A::Ptr{Int32}, p::Ptr{Int32}, perm::Ptr{Int32}, knobs::Ptr{Cdouble}, stats::Ptr{Int32}, allocate::Ptr{Cvoid}, release::Ptr{Cvoid})::Cint
-end
-
-function symamd_l(n, A, p, perm, knobs, stats, allocate, release)
-    @ccall libcolamd.symamd_l(n::Int64, A::Ptr{Int64}, p::Ptr{Int64}, perm::Ptr{Int64}, knobs::Ptr{Cdouble}, stats::Ptr{Int64}, allocate::Ptr{Cvoid}, release::Ptr{Cvoid})::Cint
-end
-
-function colamd_report(stats)
-    @ccall libcolamd.colamd_report(stats::Ptr{Int32})::Cvoid
-end
-
-function colamd_l_report(stats)
-    @ccall libcolamd.colamd_l_report(stats::Ptr{Int64})::Cvoid
-end
-
-function symamd_report(stats)
-    @ccall libcolamd.symamd_report(stats::Ptr{Int32})::Cvoid
-end
-
-function symamd_l_report(stats)
-    @ccall libcolamd.symamd_l_report(stats::Ptr{Int64})::Cvoid
-end
-
-function ccolamd_recommended(nnz, n_row, n_col)
-    @ccall libcolamd.ccolamd_recommended(nnz::Cint, n_row::Cint, n_col::Cint)::Csize_t
-end
-
-function ccolamd_l_recommended(nnz, n_row, n_col)
-    @ccall libcolamd.ccolamd_l_recommended(nnz::Int64, n_row::Int64, n_col::Int64)::Csize_t
-end
-
-function ccolamd_set_defaults(knobs)
-    @ccall libcolamd.ccolamd_set_defaults(knobs::Ptr{Cdouble})::Cvoid
-end
-
-function ccolamd_l_set_defaults(knobs)
-    @ccall libcolamd.ccolamd_l_set_defaults(knobs::Ptr{Cdouble})::Cvoid
-end
-
-function ccolamd(n_row, n_col, Alen, A, p, knobs, stats, cmember)
-    @ccall libcolamd.ccolamd(n_row::Cint, n_col::Cint, Alen::Cint, A::Ptr{Cint}, p::Ptr{Cint}, knobs::Ptr{Cdouble}, stats::Ptr{Cint}, cmember::Ptr{Cint})::Cint
-end
-
-function ccolamd_l(n_row, n_col, Alen, A, p, knobs, stats, cmember)
-    @ccall libcolamd.ccolamd_l(n_row::Int64, n_col::Int64, Alen::Int64, A::Ptr{Int64}, p::Ptr{Int64}, knobs::Ptr{Cdouble}, stats::Ptr{Int64}, cmember::Ptr{Int64})::Cint
-end
-
-function csymamd(n, A, p, perm, knobs, stats, allocate, release, cmember, stype)
-    @ccall libcolamd.csymamd(n::Cint, A::Ptr{Cint}, p::Ptr{Cint}, perm::Ptr{Cint}, knobs::Ptr{Cdouble}, stats::Ptr{Cint}, allocate::Ptr{Cvoid}, release::Ptr{Cvoid}, cmember::Ptr{Cint}, stype::Cint)::Cint
-end
-
-function csymamd_l(n, A, p, perm, knobs, stats, allocate, release, cmember, stype)
-    @ccall libcolamd.csymamd_l(n::Int64, A::Ptr{Int64}, p::Ptr{Int64}, perm::Ptr{Int64}, knobs::Ptr{Cdouble}, stats::Ptr{Int64}, allocate::Ptr{Cvoid}, release::Ptr{Cvoid}, cmember::Ptr{Int64}, stype::Int64)::Cint
-end
-
-function ccolamd_report(stats)
-    @ccall libcolamd.ccolamd_report(stats::Ptr{Cint})::Cvoid
-end
-
-function ccolamd_l_report(stats)
-    @ccall libcolamd.ccolamd_l_report(stats::Ptr{Int64})::Cvoid
-end
-
-function csymamd_report(stats)
-    @ccall libcolamd.csymamd_report(stats::Ptr{Cint})::Cvoid
-end
-
-function csymamd_l_report(stats)
-    @ccall libcolamd.csymamd_l_report(stats::Ptr{Int64})::Cvoid
-end
-
-function ccolamd2(n_row, n_col, Alen, A, p, knobs, stats, Front_npivcol, Front_nrows, Front_ncols, Front_parent, Front_cols, p_nfr, InFront, cmember)
-    @ccall libcolamd.ccolamd2(n_row::Cint, n_col::Cint, Alen::Cint, A::Ptr{Cint}, p::Ptr{Cint}, knobs::Ptr{Cdouble}, stats::Ptr{Cint}, Front_npivcol::Ptr{Cint}, Front_nrows::Ptr{Cint}, Front_ncols::Ptr{Cint}, Front_parent::Ptr{Cint}, Front_cols::Ptr{Cint}, p_nfr::Ptr{Cint}, InFront::Ptr{Cint}, cmember::Ptr{Cint})::Cint
-end
-
-function ccolamd2_l(n_row, n_col, Alen, A, p, knobs, stats, Front_npivcol, Front_nrows, Front_ncols, Front_parent, Front_cols, p_nfr, InFront, cmember)
-    @ccall libcolamd.ccolamd2_l(n_row::Int64, n_col::Int64, Alen::Int64, A::Ptr{Int64}, p::Ptr{Int64}, knobs::Ptr{Cdouble}, stats::Ptr{Int64}, Front_npivcol::Ptr{Int64}, Front_nrows::Ptr{Int64}, Front_ncols::Ptr{Int64}, Front_parent::Ptr{Int64}, Front_cols::Ptr{Int64}, p_nfr::Ptr{Int64}, InFront::Ptr{Int64}, cmember::Ptr{Int64})::Cint
-end
-
-function ccolamd_apply_order(Front, Order, Temp, nn, nfr)
-    @ccall libcolamd.ccolamd_apply_order(Front::Ptr{Cint}, Order::Ptr{Cint}, Temp::Ptr{Cint}, nn::Cint, nfr::Cint)::Cvoid
-end
-
-function ccolamd_l_apply_order(Front, Order, Temp, nn, nfr)
-    @ccall libcolamd.ccolamd_l_apply_order(Front::Ptr{Int64}, Order::Ptr{Int64}, Temp::Ptr{Int64}, nn::Int64, nfr::Int64)::Cvoid
-end
-
-function ccolamd_fsize(nn, MaxFsize, Fnrows, Fncols, Parent, Npiv)
-    @ccall libcolamd.ccolamd_fsize(nn::Cint, MaxFsize::Ptr{Cint}, Fnrows::Ptr{Cint}, Fncols::Ptr{Cint}, Parent::Ptr{Cint}, Npiv::Ptr{Cint})::Cvoid
-end
-
-function ccolamd_l_fsize(nn, MaxFsize, Fnrows, Fncols, Parent, Npiv)
-    @ccall libcolamd.ccolamd_l_fsize(nn::Int64, MaxFsize::Ptr{Int64}, Fnrows::Ptr{Int64}, Fncols::Ptr{Int64}, Parent::Ptr{Int64}, Npiv::Ptr{Int64})::Cvoid
-end
-
-function ccolamd_postorder(nn, Parent, Npiv, Fsize, Order, Child, Sibling, Stack, Front_cols, cmember)
-    @ccall libcolamd.ccolamd_postorder(nn::Cint, Parent::Ptr{Cint}, Npiv::Ptr{Cint}, Fsize::Ptr{Cint}, Order::Ptr{Cint}, Child::Ptr{Cint}, Sibling::Ptr{Cint}, Stack::Ptr{Cint}, Front_cols::Ptr{Cint}, cmember::Ptr{Cint})::Cvoid
-end
-
-function ccolamd_l_postorder(nn, Parent, Npiv, Fsize, Order, Child, Sibling, Stack, Front_cols, cmember)
-    @ccall libcolamd.ccolamd_l_postorder(nn::Int64, Parent::Ptr{Int64}, Npiv::Ptr{Int64}, Fsize::Ptr{Int64}, Order::Ptr{Int64}, Child::Ptr{Int64}, Sibling::Ptr{Int64}, Stack::Ptr{Int64}, Front_cols::Ptr{Int64}, cmember::Ptr{Int64})::Cvoid
-end
-
-function ccolamd_post_tree(root, k, Child, Sibling, Order, Stack)
-    @ccall libcolamd.ccolamd_post_tree(root::Cint, k::Cint, Child::Ptr{Cint}, Sibling::Ptr{Cint}, Order::Ptr{Cint}, Stack::Ptr{Cint})::Cint
-end
-
-function ccolamd_l_post_tree(root, k, Child, Sibling, Order, Stack)
-    @ccall libcolamd.ccolamd_l_post_tree(root::Int64, k::Int64, Child::Ptr{Int64}, Sibling::Ptr{Int64}, Order::Ptr{Int64}, Stack::Ptr{Int64})::Int64
-end
-
 function umfpack_di_symbolic(n_row, n_col, Ap, Ai, Ax, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_di_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                          Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                          Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                          Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_symbolic(n_row, n_col, Ap, Ai, Ax, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_dl_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                          Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                          Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                          Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_symbolic(n_row, n_col, Ap, Ai, Ax, Az, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_zi_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                          Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                          Az::Ptr{Cdouble}, Symbolic::Ptr{Ptr{Cvoid}},
+                                          Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_symbolic(n_row, n_col, Ap, Ai, Ax, Az, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_zl_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                          Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                          Az::Ptr{Cdouble}, Symbolic::Ptr{Ptr{Cvoid}},
+                                          Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_numeric(Ap, Ai, Ax, Symbolic, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_di_numeric(Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Symbolic::Ptr{Cvoid}, Numeric::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_numeric(Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                         Symbolic::Ptr{Cvoid}, Numeric::Ptr{Ptr{Cvoid}},
+                                         Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_numeric(Ap, Ai, Ax, Symbolic, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_dl_numeric(Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Symbolic::Ptr{Cvoid}, Numeric::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_numeric(Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                         Symbolic::Ptr{Cvoid}, Numeric::Ptr{Ptr{Cvoid}},
+                                         Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_numeric(Ap, Ai, Ax, Az, Symbolic, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_zi_numeric(Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Symbolic::Ptr{Cvoid}, Numeric::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_numeric(Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                         Az::Ptr{Cdouble}, Symbolic::Ptr{Cvoid},
+                                         Numeric::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                         Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_numeric(Ap, Ai, Ax, Az, Symbolic, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_zl_numeric(Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Symbolic::Ptr{Cvoid}, Numeric::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_numeric(Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                         Az::Ptr{Cdouble}, Symbolic::Ptr{Cvoid},
+                                         Numeric::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                         Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_solve(sys, Ap, Ai, Ax, X, B, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_di_solve(sys::Cint, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_solve(sys::Cint, Ap::Ptr{Int32}, Ai::Ptr{Int32},
+                                       Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble},
+                                       Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                       Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_solve(sys, Ap, Ai, Ax, X, B, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_dl_solve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_solve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64},
+                                       Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble},
+                                       Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                       Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_solve(sys, Ap, Ai, Ax, Az, Xx, Xz, Bx, Bz, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_zi_solve(sys::Cint, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_solve(sys::Cint, Ap::Ptr{Int32}, Ai::Ptr{Int32},
+                                       Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Xx::Ptr{Cdouble},
+                                       Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble},
+                                       Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                       Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_solve(sys, Ap, Ai, Ax, Az, Xx, Xz, Bx, Bz, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_zl_solve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_solve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64},
+                                       Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Xx::Ptr{Cdouble},
+                                       Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble},
+                                       Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                       Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_free_symbolic(Symbolic)
@@ -1840,51 +2346,119 @@ function umfpack_zl_defaults(Control)
 end
 
 function umfpack_di_qsymbolic(n_row, n_col, Ap, Ai, Ax, Qinit, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_di_qsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Qinit::Ptr{Int32}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_qsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                           Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                           Qinit::Ptr{Int32}, Symbolic::Ptr{Ptr{Cvoid}},
+                                           Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_qsymbolic(n_row, n_col, Ap, Ai, Ax, Qinit, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_dl_qsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Qinit::Ptr{Int64}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_qsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                           Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                           Qinit::Ptr{Int64}, Symbolic::Ptr{Ptr{Cvoid}},
+                                           Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_qsymbolic(n_row, n_col, Ap, Ai, Ax, Az, Qinit, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_zi_qsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Qinit::Ptr{Int32}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_qsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                           Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                           Az::Ptr{Cdouble}, Qinit::Ptr{Int32},
+                                           Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                           Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_qsymbolic(n_row, n_col, Ap, Ai, Ax, Az, Qinit, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_zl_qsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Qinit::Ptr{Int64}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_di_fsymbolic(n_row, n_col, Ap, Ai, Ax, user_ordering, user_params, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_di_fsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_dl_fsymbolic(n_row, n_col, Ap, Ai, Ax, user_ordering, user_params, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_dl_fsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_zi_fsymbolic(n_row, n_col, Ap, Ai, Ax, Az, user_ordering, user_params, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_zi_fsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_zl_fsymbolic(n_row, n_col, Ap, Ai, Ax, Az, user_ordering, user_params, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_zl_fsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_di_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Qinit, user_ordering, user_params, Symbolic, SW, Control, Info)
-    @ccall libumfpack.umfpack_di_paru_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Qinit::Ptr{Int32}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_dl_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Qinit, user_ordering, user_params, Symbolic, SW, Control, Info)
-    @ccall libumfpack.umfpack_dl_paru_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Qinit::Ptr{Int64}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_zi_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Az, Qinit, user_ordering, user_params, Symbolic, SW, Control, Info)
-    @ccall libumfpack.umfpack_zi_paru_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Qinit::Ptr{Int32}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_zl_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Az, Qinit, user_ordering, user_params, Symbolic, SW, Control, Info)
-    @ccall libumfpack.umfpack_zl_paru_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Qinit::Ptr{Int64}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_qsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                           Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                           Az::Ptr{Cdouble}, Qinit::Ptr{Int64},
+                                           Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                           Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_di_fsymbolic(n_row, n_col, Ap, Ai, Ax, user_ordering, user_params,
+                              Symbolic, Control, Info)
+    @ccall libumfpack.umfpack_di_fsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                           Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                           user_ordering::Ptr{Cvoid},
+                                           user_params::Ptr{Cvoid},
+                                           Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                           Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_dl_fsymbolic(n_row, n_col, Ap, Ai, Ax, user_ordering, user_params,
+                              Symbolic, Control, Info)
+    @ccall libumfpack.umfpack_dl_fsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                           Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                           user_ordering::Ptr{Cvoid},
+                                           user_params::Ptr{Cvoid},
+                                           Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                           Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_zi_fsymbolic(n_row, n_col, Ap, Ai, Ax, Az, user_ordering, user_params,
+                              Symbolic, Control, Info)
+    @ccall libumfpack.umfpack_zi_fsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                           Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                           Az::Ptr{Cdouble}, user_ordering::Ptr{Cvoid},
+                                           user_params::Ptr{Cvoid},
+                                           Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                           Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_zl_fsymbolic(n_row, n_col, Ap, Ai, Ax, Az, user_ordering, user_params,
+                              Symbolic, Control, Info)
+    @ccall libumfpack.umfpack_zl_fsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                           Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                           Az::Ptr{Cdouble}, user_ordering::Ptr{Cvoid},
+                                           user_params::Ptr{Cvoid},
+                                           Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                           Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_di_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Qinit, user_ordering,
+                                  user_params, Symbolic, SW, Control, Info)
+    @ccall libumfpack.umfpack_di_paru_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                               Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                               Qinit::Ptr{Int32}, user_ordering::Ptr{Cvoid},
+                                               user_params::Ptr{Cvoid},
+                                               Symbolic::Ptr{Ptr{Cvoid}},
+                                               SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                               Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_dl_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Qinit, user_ordering,
+                                  user_params, Symbolic, SW, Control, Info)
+    @ccall libumfpack.umfpack_dl_paru_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                               Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                               Qinit::Ptr{Int64}, user_ordering::Ptr{Cvoid},
+                                               user_params::Ptr{Cvoid},
+                                               Symbolic::Ptr{Ptr{Cvoid}},
+                                               SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                               Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_zi_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Az, Qinit, user_ordering,
+                                  user_params, Symbolic, SW, Control, Info)
+    @ccall libumfpack.umfpack_zi_paru_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                               Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                               Az::Ptr{Cdouble}, Qinit::Ptr{Int32},
+                                               user_ordering::Ptr{Cvoid},
+                                               user_params::Ptr{Cvoid},
+                                               Symbolic::Ptr{Ptr{Cvoid}},
+                                               SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                               Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_zl_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Az, Qinit, user_ordering,
+                                  user_params, Symbolic, SW, Control, Info)
+    @ccall libumfpack.umfpack_zl_paru_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                               Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                               Az::Ptr{Cdouble}, Qinit::Ptr{Int64},
+                                               user_ordering::Ptr{Cvoid},
+                                               user_params::Ptr{Cvoid},
+                                               Symbolic::Ptr{Ptr{Cvoid}},
+                                               SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                               Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_paru_free_sw(SW)
@@ -1904,339 +2478,547 @@ function umfpack_zl_paru_free_sw(SW)
 end
 
 function umfpack_di_wsolve(sys, Ap, Ai, Ax, X, B, Numeric, Control, Info, Wi, W)
-    @ccall libumfpack.umfpack_di_wsolve(sys::Cint, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble}, Wi::Ptr{Int32}, W::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_wsolve(sys::Cint, Ap::Ptr{Int32}, Ai::Ptr{Int32},
+                                        Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble},
+                                        Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                        Info::Ptr{Cdouble}, Wi::Ptr{Int32},
+                                        W::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_wsolve(sys, Ap, Ai, Ax, X, B, Numeric, Control, Info, Wi, W)
-    @ccall libumfpack.umfpack_dl_wsolve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble}, Wi::Ptr{Int64}, W::Ptr{Cdouble})::Cint
-end
-
-function umfpack_zi_wsolve(sys, Ap, Ai, Ax, Az, Xx, Xz, Bx, Bz, Numeric, Control, Info, Wi, W)
-    @ccall libumfpack.umfpack_zi_wsolve(sys::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble}, Wi::Ptr{Int32}, W::Ptr{Cdouble})::Cint
-end
-
-function umfpack_zl_wsolve(sys, Ap, Ai, Ax, Az, Xx, Xz, Bx, Bz, Numeric, Control, Info, Wi, W)
-    @ccall libumfpack.umfpack_zl_wsolve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble}, Wi::Ptr{Int64}, W::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_wsolve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64},
+                                        Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble},
+                                        Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                        Info::Ptr{Cdouble}, Wi::Ptr{Int64},
+                                        W::Ptr{Cdouble})::Cint
+end
+
+function umfpack_zi_wsolve(sys, Ap, Ai, Ax, Az, Xx, Xz, Bx, Bz, Numeric, Control, Info, Wi,
+                           W)
+    @ccall libumfpack.umfpack_zi_wsolve(sys::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32},
+                                        Ax::Ptr{Cdouble}, Az::Ptr{Cdouble},
+                                        Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble},
+                                        Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble},
+                                        Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                        Info::Ptr{Cdouble}, Wi::Ptr{Int32},
+                                        W::Ptr{Cdouble})::Cint
+end
+
+function umfpack_zl_wsolve(sys, Ap, Ai, Ax, Az, Xx, Xz, Bx, Bz, Numeric, Control, Info, Wi,
+                           W)
+    @ccall libumfpack.umfpack_zl_wsolve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64},
+                                        Ax::Ptr{Cdouble}, Az::Ptr{Cdouble},
+                                        Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble},
+                                        Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble},
+                                        Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                        Info::Ptr{Cdouble}, Wi::Ptr{Int64},
+                                        W::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_triplet_to_col(n_row, n_col, nz, Ti, Tj, Tx, Ap, Ai, Ax, Map)
-    @ccall libumfpack.umfpack_di_triplet_to_col(n_row::Int32, n_col::Int32, nz::Int32, Ti::Ptr{Int32}, Tj::Ptr{Int32}, Tx::Ptr{Cdouble}, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Map::Ptr{Int32})::Cint
+    @ccall libumfpack.umfpack_di_triplet_to_col(n_row::Int32, n_col::Int32, nz::Int32,
+                                                Ti::Ptr{Int32}, Tj::Ptr{Int32},
+                                                Tx::Ptr{Cdouble}, Ap::Ptr{Int32},
+                                                Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                                Map::Ptr{Int32})::Cint
 end
 
 function umfpack_dl_triplet_to_col(n_row, n_col, nz, Ti, Tj, Tx, Ap, Ai, Ax, Map)
-    @ccall libumfpack.umfpack_dl_triplet_to_col(n_row::Int64, n_col::Int64, nz::Int64, Ti::Ptr{Int64}, Tj::Ptr{Int64}, Tx::Ptr{Cdouble}, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Map::Ptr{Int64})::Cint
+    @ccall libumfpack.umfpack_dl_triplet_to_col(n_row::Int64, n_col::Int64, nz::Int64,
+                                                Ti::Ptr{Int64}, Tj::Ptr{Int64},
+                                                Tx::Ptr{Cdouble}, Ap::Ptr{Int64},
+                                                Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                                Map::Ptr{Int64})::Cint
 end
 
 function umfpack_zi_triplet_to_col(n_row, n_col, nz, Ti, Tj, Tx, Tz, Ap, Ai, Ax, Az, Map)
-    @ccall libumfpack.umfpack_zi_triplet_to_col(n_row::Int32, n_col::Int32, nz::Int32, Ti::Ptr{Int32}, Tj::Ptr{Int32}, Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble}, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Map::Ptr{Int32})::Cint
+    @ccall libumfpack.umfpack_zi_triplet_to_col(n_row::Int32, n_col::Int32, nz::Int32,
+                                                Ti::Ptr{Int32}, Tj::Ptr{Int32},
+                                                Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble},
+                                                Ap::Ptr{Int32}, Ai::Ptr{Int32},
+                                                Ax::Ptr{Cdouble}, Az::Ptr{Cdouble},
+                                                Map::Ptr{Int32})::Cint
 end
 
 function umfpack_zl_triplet_to_col(n_row, n_col, nz, Ti, Tj, Tx, Tz, Ap, Ai, Ax, Az, Map)
-    @ccall libumfpack.umfpack_zl_triplet_to_col(n_row::Int64, n_col::Int64, nz::Int64, Ti::Ptr{Int64}, Tj::Ptr{Int64}, Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble}, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Map::Ptr{Int64})::Cint
+    @ccall libumfpack.umfpack_zl_triplet_to_col(n_row::Int64, n_col::Int64, nz::Int64,
+                                                Ti::Ptr{Int64}, Tj::Ptr{Int64},
+                                                Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble},
+                                                Ap::Ptr{Int64}, Ai::Ptr{Int64},
+                                                Ax::Ptr{Cdouble}, Az::Ptr{Cdouble},
+                                                Map::Ptr{Int64})::Cint
 end
 
 function umfpack_di_col_to_triplet(n_col, Ap, Tj)
-    @ccall libumfpack.umfpack_di_col_to_triplet(n_col::Int32, Ap::Ptr{Int32}, Tj::Ptr{Int32})::Cint
+    @ccall libumfpack.umfpack_di_col_to_triplet(n_col::Int32, Ap::Ptr{Int32},
+                                                Tj::Ptr{Int32})::Cint
 end
 
 function umfpack_dl_col_to_triplet(n_col, Ap, Tj)
-    @ccall libumfpack.umfpack_dl_col_to_triplet(n_col::Int64, Ap::Ptr{Int64}, Tj::Ptr{Int64})::Cint
+    @ccall libumfpack.umfpack_dl_col_to_triplet(n_col::Int64, Ap::Ptr{Int64},
+                                                Tj::Ptr{Int64})::Cint
 end
 
 function umfpack_zi_col_to_triplet(n_col, Ap, Tj)
-    @ccall libumfpack.umfpack_zi_col_to_triplet(n_col::Int32, Ap::Ptr{Int32}, Tj::Ptr{Int32})::Cint
+    @ccall libumfpack.umfpack_zi_col_to_triplet(n_col::Int32, Ap::Ptr{Int32},
+                                                Tj::Ptr{Int32})::Cint
 end
 
 function umfpack_zl_col_to_triplet(n_col, Ap, Tj)
-    @ccall libumfpack.umfpack_zl_col_to_triplet(n_col::Int64, Ap::Ptr{Int64}, Tj::Ptr{Int64})::Cint
+    @ccall libumfpack.umfpack_zl_col_to_triplet(n_col::Int64, Ap::Ptr{Int64},
+                                                Tj::Ptr{Int64})::Cint
 end
 
 function umfpack_di_transpose(n_row, n_col, Ap, Ai, Ax, P, Q, Rp, Ri, Rx)
-    @ccall libumfpack.umfpack_di_transpose(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, P::Ptr{Int32}, Q::Ptr{Int32}, Rp::Ptr{Int32}, Ri::Ptr{Int32}, Rx::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_transpose(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                           Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, P::Ptr{Int32},
+                                           Q::Ptr{Int32}, Rp::Ptr{Int32}, Ri::Ptr{Int32},
+                                           Rx::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_transpose(n_row, n_col, Ap, Ai, Ax, P, Q, Rp, Ri, Rx)
-    @ccall libumfpack.umfpack_dl_transpose(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, P::Ptr{Int64}, Q::Ptr{Int64}, Rp::Ptr{Int64}, Ri::Ptr{Int64}, Rx::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_transpose(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                           Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, P::Ptr{Int64},
+                                           Q::Ptr{Int64}, Rp::Ptr{Int64}, Ri::Ptr{Int64},
+                                           Rx::Ptr{Cdouble})::Cint
 end
 
-function umfpack_zi_transpose(n_row, n_col, Ap, Ai, Ax, Az, P, Q, Rp, Ri, Rx, Rz, do_conjugate)
-    @ccall libumfpack.umfpack_zi_transpose(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, P::Ptr{Int32}, Q::Ptr{Int32}, Rp::Ptr{Int32}, Ri::Ptr{Int32}, Rx::Ptr{Cdouble}, Rz::Ptr{Cdouble}, do_conjugate::Cint)::Cint
+function umfpack_zi_transpose(n_row, n_col, Ap, Ai, Ax, Az, P, Q, Rp, Ri, Rx, Rz,
+                              do_conjugate)
+    @ccall libumfpack.umfpack_zi_transpose(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                           Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                           Az::Ptr{Cdouble}, P::Ptr{Int32}, Q::Ptr{Int32},
+                                           Rp::Ptr{Int32}, Ri::Ptr{Int32}, Rx::Ptr{Cdouble},
+                                           Rz::Ptr{Cdouble}, do_conjugate::Cint)::Cint
 end
 
-function umfpack_zl_transpose(n_row, n_col, Ap, Ai, Ax, Az, P, Q, Rp, Ri, Rx, Rz, do_conjugate)
-    @ccall libumfpack.umfpack_zl_transpose(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, P::Ptr{Int64}, Q::Ptr{Int64}, Rp::Ptr{Int64}, Ri::Ptr{Int64}, Rx::Ptr{Cdouble}, Rz::Ptr{Cdouble}, do_conjugate::Cint)::Cint
+function umfpack_zl_transpose(n_row, n_col, Ap, Ai, Ax, Az, P, Q, Rp, Ri, Rx, Rz,
+                              do_conjugate)
+    @ccall libumfpack.umfpack_zl_transpose(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                           Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                           Az::Ptr{Cdouble}, P::Ptr{Int64}, Q::Ptr{Int64},
+                                           Rp::Ptr{Int64}, Ri::Ptr{Int64}, Rx::Ptr{Cdouble},
+                                           Rz::Ptr{Cdouble}, do_conjugate::Cint)::Cint
 end
 
 function umfpack_di_scale(X, B, Numeric)
-    @ccall libumfpack.umfpack_di_scale(X::Ptr{Cdouble}, B::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_scale(X::Ptr{Cdouble}, B::Ptr{Cdouble},
+                                       Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_scale(X, B, Numeric)
-    @ccall libumfpack.umfpack_dl_scale(X::Ptr{Cdouble}, B::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_scale(X::Ptr{Cdouble}, B::Ptr{Cdouble},
+                                       Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_scale(Xx, Xz, Bx, Bz, Numeric)
-    @ccall libumfpack.umfpack_zi_scale(Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_scale(Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble},
+                                       Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_scale(Xx, Xz, Bx, Bz, Numeric)
-    @ccall libumfpack.umfpack_zl_scale(Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_scale(Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble},
+                                       Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_get_lunz(lnz, unz, n_row, n_col, nz_udiag, Numeric)
-    @ccall libumfpack.umfpack_di_get_lunz(lnz::Ptr{Int32}, unz::Ptr{Int32}, n_row::Ptr{Int32}, n_col::Ptr{Int32}, nz_udiag::Ptr{Int32}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_get_lunz(lnz::Ptr{Int32}, unz::Ptr{Int32},
+                                          n_row::Ptr{Int32}, n_col::Ptr{Int32},
+                                          nz_udiag::Ptr{Int32}, Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_get_lunz(lnz, unz, n_row, n_col, nz_udiag, Numeric)
-    @ccall libumfpack.umfpack_dl_get_lunz(lnz::Ptr{Int64}, unz::Ptr{Int64}, n_row::Ptr{Int64}, n_col::Ptr{Int64}, nz_udiag::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_get_lunz(lnz::Ptr{Int64}, unz::Ptr{Int64},
+                                          n_row::Ptr{Int64}, n_col::Ptr{Int64},
+                                          nz_udiag::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_get_lunz(lnz, unz, n_row, n_col, nz_udiag, Numeric)
-    @ccall libumfpack.umfpack_zi_get_lunz(lnz::Ptr{Int32}, unz::Ptr{Int32}, n_row::Ptr{Int32}, n_col::Ptr{Int32}, nz_udiag::Ptr{Int32}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_get_lunz(lnz::Ptr{Int32}, unz::Ptr{Int32},
+                                          n_row::Ptr{Int32}, n_col::Ptr{Int32},
+                                          nz_udiag::Ptr{Int32}, Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_get_lunz(lnz, unz, n_row, n_col, nz_udiag, Numeric)
-    @ccall libumfpack.umfpack_zl_get_lunz(lnz::Ptr{Int64}, unz::Ptr{Int64}, n_row::Ptr{Int64}, n_col::Ptr{Int64}, nz_udiag::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_get_lunz(lnz::Ptr{Int64}, unz::Ptr{Int64},
+                                          n_row::Ptr{Int64}, n_col::Ptr{Int64},
+                                          nz_udiag::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_get_numeric(Lp, Lj, Lx, Up, Ui, Ux, P, Q, Dx, do_recip, Rs, Numeric)
-    @ccall libumfpack.umfpack_di_get_numeric(Lp::Ptr{Int32}, Lj::Ptr{Int32}, Lx::Ptr{Cdouble}, Up::Ptr{Int32}, Ui::Ptr{Int32}, Ux::Ptr{Cdouble}, P::Ptr{Int32}, Q::Ptr{Int32}, Dx::Ptr{Cdouble}, do_recip::Ptr{Int32}, Rs::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_get_numeric(Lp::Ptr{Int32}, Lj::Ptr{Int32},
+                                             Lx::Ptr{Cdouble}, Up::Ptr{Int32},
+                                             Ui::Ptr{Int32}, Ux::Ptr{Cdouble},
+                                             P::Ptr{Int32}, Q::Ptr{Int32}, Dx::Ptr{Cdouble},
+                                             do_recip::Ptr{Int32}, Rs::Ptr{Cdouble},
+                                             Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_get_numeric(Lp, Lj, Lx, Up, Ui, Ux, P, Q, Dx, do_recip, Rs, Numeric)
-    @ccall libumfpack.umfpack_dl_get_numeric(Lp::Ptr{Int64}, Lj::Ptr{Int64}, Lx::Ptr{Cdouble}, Up::Ptr{Int64}, Ui::Ptr{Int64}, Ux::Ptr{Cdouble}, P::Ptr{Int64}, Q::Ptr{Int64}, Dx::Ptr{Cdouble}, do_recip::Ptr{Int64}, Rs::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
-end
-
-function umfpack_zi_get_numeric(Lp, Lj, Lx, Lz, Up, Ui, Ux, Uz, P, Q, Dx, Dz, do_recip, Rs, Numeric)
-    @ccall libumfpack.umfpack_zi_get_numeric(Lp::Ptr{Int32}, Lj::Ptr{Int32}, Lx::Ptr{Cdouble}, Lz::Ptr{Cdouble}, Up::Ptr{Int32}, Ui::Ptr{Int32}, Ux::Ptr{Cdouble}, Uz::Ptr{Cdouble}, P::Ptr{Int32}, Q::Ptr{Int32}, Dx::Ptr{Cdouble}, Dz::Ptr{Cdouble}, do_recip::Ptr{Int32}, Rs::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
-end
-
-function umfpack_zl_get_numeric(Lp, Lj, Lx, Lz, Up, Ui, Ux, Uz, P, Q, Dx, Dz, do_recip, Rs, Numeric)
-    @ccall libumfpack.umfpack_zl_get_numeric(Lp::Ptr{Int64}, Lj::Ptr{Int64}, Lx::Ptr{Cdouble}, Lz::Ptr{Cdouble}, Up::Ptr{Int64}, Ui::Ptr{Int64}, Ux::Ptr{Cdouble}, Uz::Ptr{Cdouble}, P::Ptr{Int64}, Q::Ptr{Int64}, Dx::Ptr{Cdouble}, Dz::Ptr{Cdouble}, do_recip::Ptr{Int64}, Rs::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
-end
-
-function umfpack_di_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol, Front_parent, Front_1strow, Front_leftmostdesc, Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
-    @ccall libumfpack.umfpack_di_get_symbolic(n_row::Ptr{Int32}, n_col::Ptr{Int32}, n1::Ptr{Int32}, nz::Ptr{Int32}, nfr::Ptr{Int32}, nchains::Ptr{Int32}, P::Ptr{Int32}, Q::Ptr{Int32}, Front_npivcol::Ptr{Int32}, Front_parent::Ptr{Int32}, Front_1strow::Ptr{Int32}, Front_leftmostdesc::Ptr{Int32}, Chain_start::Ptr{Int32}, Chain_maxrows::Ptr{Int32}, Chain_maxcols::Ptr{Int32}, Dmap::Ptr{Int32}, Symbolic::Ptr{Cvoid})::Cint
-end
-
-function umfpack_dl_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol, Front_parent, Front_1strow, Front_leftmostdesc, Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
-    @ccall libumfpack.umfpack_dl_get_symbolic(n_row::Ptr{Int64}, n_col::Ptr{Int64}, n1::Ptr{Int64}, nz::Ptr{Int64}, nfr::Ptr{Int64}, nchains::Ptr{Int64}, P::Ptr{Int64}, Q::Ptr{Int64}, Front_npivcol::Ptr{Int64}, Front_parent::Ptr{Int64}, Front_1strow::Ptr{Int64}, Front_leftmostdesc::Ptr{Int64}, Chain_start::Ptr{Int64}, Chain_maxrows::Ptr{Int64}, Chain_maxcols::Ptr{Int64}, Dmap::Ptr{Int64}, Symbolic::Ptr{Cvoid})::Cint
-end
-
-function umfpack_zi_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol, Front_parent, Front_1strow, Front_leftmostdesc, Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
-    @ccall libumfpack.umfpack_zi_get_symbolic(n_row::Ptr{Int32}, n_col::Ptr{Int32}, n1::Ptr{Int32}, nz::Ptr{Int32}, nfr::Ptr{Int32}, nchains::Ptr{Int32}, P::Ptr{Int32}, Q::Ptr{Int32}, Front_npivcol::Ptr{Int32}, Front_parent::Ptr{Int32}, Front_1strow::Ptr{Int32}, Front_leftmostdesc::Ptr{Int32}, Chain_start::Ptr{Int32}, Chain_maxrows::Ptr{Int32}, Chain_maxcols::Ptr{Int32}, Dmap::Ptr{Int32}, Symbolic::Ptr{Cvoid})::Cint
-end
-
-function umfpack_zl_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol, Front_parent, Front_1strow, Front_leftmostdesc, Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
-    @ccall libumfpack.umfpack_zl_get_symbolic(n_row::Ptr{Int64}, n_col::Ptr{Int64}, n1::Ptr{Int64}, nz::Ptr{Int64}, nfr::Ptr{Int64}, nchains::Ptr{Int64}, P::Ptr{Int64}, Q::Ptr{Int64}, Front_npivcol::Ptr{Int64}, Front_parent::Ptr{Int64}, Front_1strow::Ptr{Int64}, Front_leftmostdesc::Ptr{Int64}, Chain_start::Ptr{Int64}, Chain_maxrows::Ptr{Int64}, Chain_maxcols::Ptr{Int64}, Dmap::Ptr{Int64}, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_get_numeric(Lp::Ptr{Int64}, Lj::Ptr{Int64},
+                                             Lx::Ptr{Cdouble}, Up::Ptr{Int64},
+                                             Ui::Ptr{Int64}, Ux::Ptr{Cdouble},
+                                             P::Ptr{Int64}, Q::Ptr{Int64}, Dx::Ptr{Cdouble},
+                                             do_recip::Ptr{Int64}, Rs::Ptr{Cdouble},
+                                             Numeric::Ptr{Cvoid})::Cint
+end
+
+function umfpack_zi_get_numeric(Lp, Lj, Lx, Lz, Up, Ui, Ux, Uz, P, Q, Dx, Dz, do_recip, Rs,
+                                Numeric)
+    @ccall libumfpack.umfpack_zi_get_numeric(Lp::Ptr{Int32}, Lj::Ptr{Int32},
+                                             Lx::Ptr{Cdouble}, Lz::Ptr{Cdouble},
+                                             Up::Ptr{Int32}, Ui::Ptr{Int32},
+                                             Ux::Ptr{Cdouble}, Uz::Ptr{Cdouble},
+                                             P::Ptr{Int32}, Q::Ptr{Int32}, Dx::Ptr{Cdouble},
+                                             Dz::Ptr{Cdouble}, do_recip::Ptr{Int32},
+                                             Rs::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+end
+
+function umfpack_zl_get_numeric(Lp, Lj, Lx, Lz, Up, Ui, Ux, Uz, P, Q, Dx, Dz, do_recip, Rs,
+                                Numeric)
+    @ccall libumfpack.umfpack_zl_get_numeric(Lp::Ptr{Int64}, Lj::Ptr{Int64},
+                                             Lx::Ptr{Cdouble}, Lz::Ptr{Cdouble},
+                                             Up::Ptr{Int64}, Ui::Ptr{Int64},
+                                             Ux::Ptr{Cdouble}, Uz::Ptr{Cdouble},
+                                             P::Ptr{Int64}, Q::Ptr{Int64}, Dx::Ptr{Cdouble},
+                                             Dz::Ptr{Cdouble}, do_recip::Ptr{Int64},
+                                             Rs::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+end
+
+function umfpack_di_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol,
+                                 Front_parent, Front_1strow, Front_leftmostdesc,
+                                 Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
+    @ccall libumfpack.umfpack_di_get_symbolic(n_row::Ptr{Int32}, n_col::Ptr{Int32},
+                                              n1::Ptr{Int32}, nz::Ptr{Int32},
+                                              nfr::Ptr{Int32}, nchains::Ptr{Int32},
+                                              P::Ptr{Int32}, Q::Ptr{Int32},
+                                              Front_npivcol::Ptr{Int32},
+                                              Front_parent::Ptr{Int32},
+                                              Front_1strow::Ptr{Int32},
+                                              Front_leftmostdesc::Ptr{Int32},
+                                              Chain_start::Ptr{Int32},
+                                              Chain_maxrows::Ptr{Int32},
+                                              Chain_maxcols::Ptr{Int32}, Dmap::Ptr{Int32},
+                                              Symbolic::Ptr{Cvoid})::Cint
+end
+
+function umfpack_dl_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol,
+                                 Front_parent, Front_1strow, Front_leftmostdesc,
+                                 Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
+    @ccall libumfpack.umfpack_dl_get_symbolic(n_row::Ptr{Int64}, n_col::Ptr{Int64},
+                                              n1::Ptr{Int64}, nz::Ptr{Int64},
+                                              nfr::Ptr{Int64}, nchains::Ptr{Int64},
+                                              P::Ptr{Int64}, Q::Ptr{Int64},
+                                              Front_npivcol::Ptr{Int64},
+                                              Front_parent::Ptr{Int64},
+                                              Front_1strow::Ptr{Int64},
+                                              Front_leftmostdesc::Ptr{Int64},
+                                              Chain_start::Ptr{Int64},
+                                              Chain_maxrows::Ptr{Int64},
+                                              Chain_maxcols::Ptr{Int64}, Dmap::Ptr{Int64},
+                                              Symbolic::Ptr{Cvoid})::Cint
+end
+
+function umfpack_zi_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol,
+                                 Front_parent, Front_1strow, Front_leftmostdesc,
+                                 Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
+    @ccall libumfpack.umfpack_zi_get_symbolic(n_row::Ptr{Int32}, n_col::Ptr{Int32},
+                                              n1::Ptr{Int32}, nz::Ptr{Int32},
+                                              nfr::Ptr{Int32}, nchains::Ptr{Int32},
+                                              P::Ptr{Int32}, Q::Ptr{Int32},
+                                              Front_npivcol::Ptr{Int32},
+                                              Front_parent::Ptr{Int32},
+                                              Front_1strow::Ptr{Int32},
+                                              Front_leftmostdesc::Ptr{Int32},
+                                              Chain_start::Ptr{Int32},
+                                              Chain_maxrows::Ptr{Int32},
+                                              Chain_maxcols::Ptr{Int32}, Dmap::Ptr{Int32},
+                                              Symbolic::Ptr{Cvoid})::Cint
+end
+
+function umfpack_zl_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol,
+                                 Front_parent, Front_1strow, Front_leftmostdesc,
+                                 Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
+    @ccall libumfpack.umfpack_zl_get_symbolic(n_row::Ptr{Int64}, n_col::Ptr{Int64},
+                                              n1::Ptr{Int64}, nz::Ptr{Int64},
+                                              nfr::Ptr{Int64}, nchains::Ptr{Int64},
+                                              P::Ptr{Int64}, Q::Ptr{Int64},
+                                              Front_npivcol::Ptr{Int64},
+                                              Front_parent::Ptr{Int64},
+                                              Front_1strow::Ptr{Int64},
+                                              Front_leftmostdesc::Ptr{Int64},
+                                              Chain_start::Ptr{Int64},
+                                              Chain_maxrows::Ptr{Int64},
+                                              Chain_maxcols::Ptr{Int64}, Dmap::Ptr{Int64},
+                                              Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_save_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_di_save_numeric(Numeric::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_di_save_numeric(Numeric::Ptr{Cvoid},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_dl_save_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_dl_save_numeric(Numeric::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_dl_save_numeric(Numeric::Ptr{Cvoid},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zi_save_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_zi_save_numeric(Numeric::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zi_save_numeric(Numeric::Ptr{Cvoid},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zl_save_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_zl_save_numeric(Numeric::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zl_save_numeric(Numeric::Ptr{Cvoid},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_di_load_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_di_load_numeric(Numeric::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_di_load_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_dl_load_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_dl_load_numeric(Numeric::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_dl_load_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zi_load_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_zi_load_numeric(Numeric::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zi_load_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zl_load_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_zl_load_numeric(Numeric::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zl_load_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_di_copy_numeric(Numeric, Original)
-    @ccall libumfpack.umfpack_di_copy_numeric(Numeric::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_copy_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_copy_numeric(Numeric, Original)
-    @ccall libumfpack.umfpack_dl_copy_numeric(Numeric::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_copy_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_copy_numeric(Numeric, Original)
-    @ccall libumfpack.umfpack_zi_copy_numeric(Numeric::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_copy_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_copy_numeric(Numeric, Original)
-    @ccall libumfpack.umfpack_zl_copy_numeric(Numeric::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_copy_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_serialize_numeric_size(blobsize, Numeric)
-    @ccall libumfpack.umfpack_di_serialize_numeric_size(blobsize::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_serialize_numeric_size(blobsize::Ptr{Int64},
+                                                        Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_serialize_numeric_size(blobsize, Numeric)
-    @ccall libumfpack.umfpack_dl_serialize_numeric_size(blobsize::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_serialize_numeric_size(blobsize::Ptr{Int64},
+                                                        Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_serialize_numeric_size(blobsize, Numeric)
-    @ccall libumfpack.umfpack_zi_serialize_numeric_size(blobsize::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_serialize_numeric_size(blobsize::Ptr{Int64},
+                                                        Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_serialize_numeric_size(blobsize, Numeric)
-    @ccall libumfpack.umfpack_zl_serialize_numeric_size(blobsize::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_serialize_numeric_size(blobsize::Ptr{Int64},
+                                                        Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_serialize_numeric(blob, blobsize, Numeric)
-    @ccall libumfpack.umfpack_di_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64,
+                                                   Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_serialize_numeric(blob, blobsize, Numeric)
-    @ccall libumfpack.umfpack_dl_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64,
+                                                   Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_serialize_numeric(blob, blobsize, Numeric)
-    @ccall libumfpack.umfpack_zi_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64,
+                                                   Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_serialize_numeric(blob, blobsize, Numeric)
-    @ccall libumfpack.umfpack_zl_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64,
+                                                   Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_deserialize_numeric(Numeric, blob, blobsize)
-    @ccall libumfpack.umfpack_di_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_di_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                                     blob::Ptr{Int8}, blobsize::Int64)::Cint
 end
 
 function umfpack_dl_deserialize_numeric(Numeric, blob, blobsize)
-    @ccall libumfpack.umfpack_dl_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_dl_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                                     blob::Ptr{Int8}, blobsize::Int64)::Cint
 end
 
 function umfpack_zi_deserialize_numeric(Numeric, blob, blobsize)
-    @ccall libumfpack.umfpack_zi_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_zi_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                                     blob::Ptr{Int8}, blobsize::Int64)::Cint
 end
 
 function umfpack_zl_deserialize_numeric(Numeric, blob, blobsize)
-    @ccall libumfpack.umfpack_zl_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_zl_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                                     blob::Ptr{Int8}, blobsize::Int64)::Cint
 end
 
 function umfpack_di_save_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_di_save_symbolic(Symbolic::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_di_save_symbolic(Symbolic::Ptr{Cvoid},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_dl_save_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_dl_save_symbolic(Symbolic::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_dl_save_symbolic(Symbolic::Ptr{Cvoid},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zi_save_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_zi_save_symbolic(Symbolic::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zi_save_symbolic(Symbolic::Ptr{Cvoid},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zl_save_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_zl_save_symbolic(Symbolic::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zl_save_symbolic(Symbolic::Ptr{Cvoid},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_di_load_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_di_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_di_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_dl_load_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_dl_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_dl_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zi_load_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_zi_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zi_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zl_load_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_zl_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zl_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_di_copy_symbolic(Symbolic, Original)
-    @ccall libumfpack.umfpack_di_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_copy_symbolic(Symbolic, Original)
-    @ccall libumfpack.umfpack_dl_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_copy_symbolic(Symbolic, Original)
-    @ccall libumfpack.umfpack_zi_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_copy_symbolic(Symbolic, Original)
-    @ccall libumfpack.umfpack_zl_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_serialize_symbolic_size(blobsize, Symbolic)
-    @ccall libumfpack.umfpack_di_serialize_symbolic_size(blobsize::Ptr{Int64}, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_serialize_symbolic_size(blobsize::Ptr{Int64},
+                                                         Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_serialize_symbolic_size(blobsize, Symbolic)
-    @ccall libumfpack.umfpack_dl_serialize_symbolic_size(blobsize::Ptr{Int64}, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_serialize_symbolic_size(blobsize::Ptr{Int64},
+                                                         Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_serialize_symbolic_size(blobsize, Symbolic)
-    @ccall libumfpack.umfpack_zi_serialize_symbolic_size(blobsize::Ptr{Int64}, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_serialize_symbolic_size(blobsize::Ptr{Int64},
+                                                         Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_serialize_symbolic_size(blobsize, Symbolic)
-    @ccall libumfpack.umfpack_zl_serialize_symbolic_size(blobsize::Ptr{Int64}, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_serialize_symbolic_size(blobsize::Ptr{Int64},
+                                                         Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_serialize_symbolic(blob, blobsize, Symbolic)
-    @ccall libumfpack.umfpack_di_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64,
+                                                    Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_serialize_symbolic(blob, blobsize, Symbolic)
-    @ccall libumfpack.umfpack_dl_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64,
+                                                    Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_serialize_symbolic(blob, blobsize, Symbolic)
-    @ccall libumfpack.umfpack_zi_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64,
+                                                    Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_serialize_symbolic(blob, blobsize, Symbolic)
-    @ccall libumfpack.umfpack_zl_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64,
+                                                    Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_deserialize_symbolic(Symbolic, blob, blobsize)
-    @ccall libumfpack.umfpack_di_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_di_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                                      blob::Ptr{Int8},
+                                                      blobsize::Int64)::Cint
 end
 
 function umfpack_dl_deserialize_symbolic(Symbolic, blob, blobsize)
-    @ccall libumfpack.umfpack_dl_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_dl_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                                      blob::Ptr{Int8},
+                                                      blobsize::Int64)::Cint
 end
 
 function umfpack_zi_deserialize_symbolic(Symbolic, blob, blobsize)
-    @ccall libumfpack.umfpack_zi_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_zi_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                                      blob::Ptr{Int8},
+                                                      blobsize::Int64)::Cint
 end
 
 function umfpack_zl_deserialize_symbolic(Symbolic, blob, blobsize)
-    @ccall libumfpack.umfpack_zl_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_zl_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                                      blob::Ptr{Int8},
+                                                      blobsize::Int64)::Cint
 end
 
 function umfpack_di_get_determinant(Mx, Ex, Numeric, User_Info)
-    @ccall libumfpack.umfpack_di_get_determinant(Mx::Ptr{Cdouble}, Ex::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, User_Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_get_determinant(Mx::Ptr{Cdouble}, Ex::Ptr{Cdouble},
+                                                 Numeric::Ptr{Cvoid},
+                                                 User_Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_get_determinant(Mx, Ex, Numeric, User_Info)
-    @ccall libumfpack.umfpack_dl_get_determinant(Mx::Ptr{Cdouble}, Ex::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, User_Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_get_determinant(Mx::Ptr{Cdouble}, Ex::Ptr{Cdouble},
+                                                 Numeric::Ptr{Cvoid},
+                                                 User_Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_get_determinant(Mx, Mz, Ex, Numeric, User_Info)
-    @ccall libumfpack.umfpack_zi_get_determinant(Mx::Ptr{Cdouble}, Mz::Ptr{Cdouble}, Ex::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, User_Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_get_determinant(Mx::Ptr{Cdouble}, Mz::Ptr{Cdouble},
+                                                 Ex::Ptr{Cdouble}, Numeric::Ptr{Cvoid},
+                                                 User_Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_get_determinant(Mx, Mz, Ex, Numeric, User_Info)
-    @ccall libumfpack.umfpack_zl_get_determinant(Mx::Ptr{Cdouble}, Mz::Ptr{Cdouble}, Ex::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, User_Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_get_determinant(Mx::Ptr{Cdouble}, Mz::Ptr{Cdouble},
+                                                 Ex::Ptr{Cdouble}, Numeric::Ptr{Cvoid},
+                                                 User_Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_report_status(Control, status)
@@ -2256,19 +3038,23 @@ function umfpack_zl_report_status(Control, status)
 end
 
 function umfpack_di_report_info(Control, Info)
-    @ccall libumfpack.umfpack_di_report_info(Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cvoid
+    @ccall libumfpack.umfpack_di_report_info(Control::Ptr{Cdouble},
+                                             Info::Ptr{Cdouble})::Cvoid
 end
 
 function umfpack_dl_report_info(Control, Info)
-    @ccall libumfpack.umfpack_dl_report_info(Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cvoid
+    @ccall libumfpack.umfpack_dl_report_info(Control::Ptr{Cdouble},
+                                             Info::Ptr{Cdouble})::Cvoid
 end
 
 function umfpack_zi_report_info(Control, Info)
-    @ccall libumfpack.umfpack_zi_report_info(Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cvoid
+    @ccall libumfpack.umfpack_zi_report_info(Control::Ptr{Cdouble},
+                                             Info::Ptr{Cdouble})::Cvoid
 end
 
 function umfpack_zl_report_info(Control, Info)
-    @ccall libumfpack.umfpack_zl_report_info(Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cvoid
+    @ccall libumfpack.umfpack_zl_report_info(Control::Ptr{Cdouble},
+                                             Info::Ptr{Cdouble})::Cvoid
 end
 
 function umfpack_di_report_control(Control)
@@ -2288,99 +3074,137 @@ function umfpack_zl_report_control(Control)
 end
 
 function umfpack_di_report_matrix(n_row, n_col, Ap, Ai, Ax, col_form, Control)
-    @ccall libumfpack.umfpack_di_report_matrix(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, col_form::Cint, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_report_matrix(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                               Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                               col_form::Cint, Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_report_matrix(n_row, n_col, Ap, Ai, Ax, col_form, Control)
-    @ccall libumfpack.umfpack_dl_report_matrix(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, col_form::Cint, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_report_matrix(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                               Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                               col_form::Cint, Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_report_matrix(n_row, n_col, Ap, Ai, Ax, Az, col_form, Control)
-    @ccall libumfpack.umfpack_zi_report_matrix(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, col_form::Cint, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_report_matrix(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                               Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                               Az::Ptr{Cdouble}, col_form::Cint,
+                                               Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_report_matrix(n_row, n_col, Ap, Ai, Ax, Az, col_form, Control)
-    @ccall libumfpack.umfpack_zl_report_matrix(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, col_form::Cint, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_report_matrix(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                               Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                               Az::Ptr{Cdouble}, col_form::Cint,
+                                               Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_report_triplet(n_row, n_col, nz, Ti, Tj, Tx, Control)
-    @ccall libumfpack.umfpack_di_report_triplet(n_row::Int32, n_col::Int32, nz::Int32, Ti::Ptr{Int32}, Tj::Ptr{Int32}, Tx::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_report_triplet(n_row::Int32, n_col::Int32, nz::Int32,
+                                                Ti::Ptr{Int32}, Tj::Ptr{Int32},
+                                                Tx::Ptr{Cdouble},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_report_triplet(n_row, n_col, nz, Ti, Tj, Tx, Control)
-    @ccall libumfpack.umfpack_dl_report_triplet(n_row::Int64, n_col::Int64, nz::Int64, Ti::Ptr{Int64}, Tj::Ptr{Int64}, Tx::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_report_triplet(n_row::Int64, n_col::Int64, nz::Int64,
+                                                Ti::Ptr{Int64}, Tj::Ptr{Int64},
+                                                Tx::Ptr{Cdouble},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_report_triplet(n_row, n_col, nz, Ti, Tj, Tx, Tz, Control)
-    @ccall libumfpack.umfpack_zi_report_triplet(n_row::Int32, n_col::Int32, nz::Int32, Ti::Ptr{Int32}, Tj::Ptr{Int32}, Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_report_triplet(n_row::Int32, n_col::Int32, nz::Int32,
+                                                Ti::Ptr{Int32}, Tj::Ptr{Int32},
+                                                Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_report_triplet(n_row, n_col, nz, Ti, Tj, Tx, Tz, Control)
-    @ccall libumfpack.umfpack_zl_report_triplet(n_row::Int64, n_col::Int64, nz::Int64, Ti::Ptr{Int64}, Tj::Ptr{Int64}, Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_report_triplet(n_row::Int64, n_col::Int64, nz::Int64,
+                                                Ti::Ptr{Int64}, Tj::Ptr{Int64},
+                                                Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_report_vector(n, X, Control)
-    @ccall libumfpack.umfpack_di_report_vector(n::Int32, X::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_report_vector(n::Int32, X::Ptr{Cdouble},
+                                               Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_report_vector(n, X, Control)
-    @ccall libumfpack.umfpack_dl_report_vector(n::Int64, X::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_report_vector(n::Int64, X::Ptr{Cdouble},
+                                               Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_report_vector(n, Xx, Xz, Control)
-    @ccall libumfpack.umfpack_zi_report_vector(n::Int32, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_report_vector(n::Int32, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble},
+                                               Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_report_vector(n, Xx, Xz, Control)
-    @ccall libumfpack.umfpack_zl_report_vector(n::Int64, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_report_vector(n::Int64, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble},
+                                               Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_report_symbolic(Symbolic, Control)
-    @ccall libumfpack.umfpack_di_report_symbolic(Symbolic::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_report_symbolic(Symbolic::Ptr{Cvoid},
+                                                 Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_report_symbolic(Symbolic, Control)
-    @ccall libumfpack.umfpack_dl_report_symbolic(Symbolic::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_report_symbolic(Symbolic::Ptr{Cvoid},
+                                                 Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_report_symbolic(Symbolic, Control)
-    @ccall libumfpack.umfpack_zi_report_symbolic(Symbolic::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_report_symbolic(Symbolic::Ptr{Cvoid},
+                                                 Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_report_symbolic(Symbolic, Control)
-    @ccall libumfpack.umfpack_zl_report_symbolic(Symbolic::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_report_symbolic(Symbolic::Ptr{Cvoid},
+                                                 Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_report_numeric(Numeric, Control)
-    @ccall libumfpack.umfpack_di_report_numeric(Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_report_numeric(Numeric::Ptr{Cvoid},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_report_numeric(Numeric, Control)
-    @ccall libumfpack.umfpack_dl_report_numeric(Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_report_numeric(Numeric::Ptr{Cvoid},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_report_numeric(Numeric, Control)
-    @ccall libumfpack.umfpack_zi_report_numeric(Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_report_numeric(Numeric::Ptr{Cvoid},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_report_numeric(Numeric, Control)
-    @ccall libumfpack.umfpack_zl_report_numeric(Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_report_numeric(Numeric::Ptr{Cvoid},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_report_perm(np, Perm, Control)
-    @ccall libumfpack.umfpack_di_report_perm(np::Int32, Perm::Ptr{Int32}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_report_perm(np::Int32, Perm::Ptr{Int32},
+                                             Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_report_perm(np, Perm, Control)
-    @ccall libumfpack.umfpack_dl_report_perm(np::Int64, Perm::Ptr{Int64}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_report_perm(np::Int64, Perm::Ptr{Int64},
+                                             Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_report_perm(np, Perm, Control)
-    @ccall libumfpack.umfpack_zi_report_perm(np::Int32, Perm::Ptr{Int32}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_report_perm(np::Int32, Perm::Ptr{Int32},
+                                             Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_report_perm(np, Perm, Control)
-    @ccall libumfpack.umfpack_zl_report_perm(np::Int64, Perm::Ptr{Int64}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_report_perm(np::Int64, Perm::Ptr{Int64},
+                                             Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_timer()
@@ -2395,13 +3219,13 @@ function umfpack_toc(stats)
     @ccall libumfpack.umfpack_toc(stats::Ptr{Cdouble})::Cvoid
 end
 
-const CHOLMOD_DATE = "Jan 17, 2023"
+const CHOLMOD_DATE = "June 16, 2023"
 
 const CHOLMOD_MAIN_VERSION = 4
 
 const CHOLMOD_SUB_VERSION = 0
 
-const CHOLMOD_SUBSUB_VERSION = 3
+const CHOLMOD_SUBSUB_VERSION = 4
 
 const _FILE_OFFSET_BITS = 64
 
@@ -2427,17 +3251,18 @@ const SUITESPARSE_COMPILER_MSC = 0
 
 const SUITESPARSE_COMPILER_XLC = 0
 
-const SUITESPARSE_DATE = "Jan 20, 2023"
+const SUITESPARSE_DATE = "June 29, 2023"
 
 const SUITESPARSE_MAIN_VERSION = 7
 
-const SUITESPARSE_SUB_VERSION = 0
+const SUITESPARSE_SUB_VERSION = 1
 
-const SUITESPARSE_SUBSUB_VERSION = 1
+const SUITESPARSE_SUBSUB_VERSION = 0
 
 SUITESPARSE_VER_CODE(main, sub) = main * 1000 + sub
 
-const SUITESPARSE_VERSION = SUITESPARSE_VER_CODE(SUITESPARSE_MAIN_VERSION, SUITESPARSE_SUB_VERSION)
+const SUITESPARSE_VERSION = SUITESPARSE_VER_CODE(SUITESPARSE_MAIN_VERSION,
+                                                 SUITESPARSE_SUB_VERSION)
 
 CHOLMOD_VER_CODE(main, sub) = main * 1000 + sub
 
@@ -2601,20 +3426,18 @@ const SPQR_RTX_EQUALS_B = 2
 
 const SPQR_RTX_EQUALS_ETB = 3
 
-const SPQR_DATE = "Jan 17, 2023"
+const SPQR_DATE = "July FIXME, 2023"
 
-const SPQR_MAIN_VERSION = 3
+const SPQR_MAIN_VERSION = 4
 
 const SPQR_SUB_VERSION = 0
 
-const SPQR_SUBSUB_VERSION = 3
+const SPQR_SUBSUB_VERSION = 0
 
 SPQR_VER_CODE(main, sub) = main * 1000 + sub
 
 const SPQR_VERSION = SPQR_VER_CODE(SPQR_MAIN_VERSION, SPQR_SUB_VERSION)
 
-const Complex = Float64
-
 const AMD_CONTROL = 5
 
 const AMD_INFO = 20
@@ -2663,172 +3486,29 @@ const AMD_INVALID = -2
 
 const AMD_OK_BUT_JUMBLED = 1
 
-const AMD_DATE = "Jan 17, 2023"
+const AMD_DATE = "June 16, 2023"
 
 const AMD_MAIN_VERSION = 3
 
 const AMD_SUB_VERSION = 0
 
-const AMD_SUBSUB_VERSION = 3
+const AMD_SUBSUB_VERSION = 4
 
 AMD_VERSION_CODE(main, sub) = main * 1000 + sub
 
 const AMD_VERSION = AMD_VERSION_CODE(AMD_MAIN_VERSION, AMD_SUB_VERSION)
 
-const COLAMD_DATE = "Jan 17, 2023"
-
-const COLAMD_MAIN_VERSION = 3
-
-const COLAMD_SUB_VERSION = 0
-
-const COLAMD_SUBSUB_VERSION = 3
-
-COLAMD_VERSION_CODE(main, sub) = main * 1000 + sub
-
-const COLAMD_VERSION = COLAMD_VERSION_CODE(COLAMD_MAIN_VERSION, COLAMD_SUB_VERSION)
-
-const COLAMD_KNOBS = 20
-
-const COLAMD_STATS = 20
-
-const COLAMD_DENSE_ROW = 0
-
-const COLAMD_DENSE_COL = 1
-
-const COLAMD_AGGRESSIVE = 2
-
-const COLAMD_DEFRAG_COUNT = 2
-
-const COLAMD_STATUS = 3
-
-const COLAMD_INFO1 = 4
-
-const COLAMD_INFO2 = 5
-
-const COLAMD_INFO3 = 6
-
-const COLAMD_OK = 0
-
-const COLAMD_OK_BUT_JUMBLED = 1
-
-const COLAMD_ERROR_A_not_present = -1
-
-const COLAMD_ERROR_p_not_present = -2
-
-const COLAMD_ERROR_nrow_negative = -3
-
-const COLAMD_ERROR_ncol_negative = -4
-
-const COLAMD_ERROR_nnz_negative = -5
-
-const COLAMD_ERROR_p0_nonzero = -6
-
-const COLAMD_ERROR_A_too_small = -7
-
-const COLAMD_ERROR_col_length_negative = -8
-
-const COLAMD_ERROR_row_index_out_of_bounds = -9
-
-const COLAMD_ERROR_out_of_memory = -10
-
-const COLAMD_ERROR_internal_error = -999
-
-const CCOLAMD_DATE = "Jan 17, 2023"
-
-const CCOLAMD_MAIN_VERSION = 3
-
-const CCOLAMD_SUB_VERSION = 0
-
-const CCOLAMD_SUBSUB_VERSION = 3
-
-CCOLAMD_VERSION_CODE(main, sub) = main * 1000 + sub
-
-const CCOLAMD_VERSION = CCOLAMD_VERSION_CODE(CCOLAMD_MAIN_VERSION, CCOLAMD_SUB_VERSION)
-
-const CCOLAMD_KNOBS = 20
-
-const CCOLAMD_STATS = 20
-
-const CCOLAMD_DENSE_ROW = 0
-
-const CCOLAMD_DENSE_COL = 1
-
-const CCOLAMD_AGGRESSIVE = 2
-
-const CCOLAMD_LU = 3
-
-const CCOLAMD_DEFRAG_COUNT = 2
-
-const CCOLAMD_STATUS = 3
-
-const CCOLAMD_INFO1 = 4
-
-const CCOLAMD_INFO2 = 5
-
-const CCOLAMD_INFO3 = 6
-
-const CCOLAMD_EMPTY_ROW = 7
-
-const CCOLAMD_EMPTY_COL = 8
-
-const CCOLAMD_NEWLY_EMPTY_ROW = 9
-
-const CCOLAMD_NEWLY_EMPTY_COL = 10
-
-const CCOLAMD_OK = 0
-
-const CCOLAMD_OK_BUT_JUMBLED = 1
-
-const CCOLAMD_ERROR_A_not_present = -1
-
-const CCOLAMD_ERROR_p_not_present = -2
-
-const CCOLAMD_ERROR_nrow_negative = -3
-
-const CCOLAMD_ERROR_ncol_negative = -4
-
-const CCOLAMD_ERROR_nnz_negative = -5
-
-const CCOLAMD_ERROR_p0_nonzero = -6
-
-const CCOLAMD_ERROR_A_too_small = -7
-
-const CCOLAMD_ERROR_col_length_negative = -8
-
-const CCOLAMD_ERROR_row_index_out_of_bounds = -9
-
-const CCOLAMD_ERROR_out_of_memory = -10
-
-const CCOLAMD_ERROR_invalid_cmember = -11
-
-const CCOLAMD_ERROR_internal_error = -999
-
 const UMFPACK_INFO = 90
 
 const UMFPACK_CONTROL = 20
 
-# Skipping MacroDefinition: UMFPACK_COPYRIGHT \
-#"UMFPACK:  Copyright (c) 2005-2023 by Timothy A. Davis.  All Rights Reserved.\n"
-
-# Skipping MacroDefinition: UMFPACK_LICENSE_PART1 \
-#"\nUMFPACK License: SPDX-License-Identifier: GPL-2.0+\n" \
-#"   UMFPACK is available under alternate licenses,\n" \
-#"   contact T. Davis for details.\n"
-
-const UMFPACK_LICENSE_PART2 = "\n"
-
-# Skipping MacroDefinition: UMFPACK_LICENSE_PART3 \
-#"\n" \
-#"Availability: http://www.suitesparse.com" \
-#"\n"
-
-const UMFPACK_DATE = "Jan 17, 2023"
+const UMFPACK_DATE = "June 16, 2023"
 
 const UMFPACK_MAIN_VERSION = 6
 
 const UMFPACK_SUB_VERSION = 1
 
-const UMFPACK_SUBSUB_VERSION = 0
+const UMFPACK_SUBSUB_VERSION = 1
 
 UMFPACK_VER_CODE(main, sub) = main * 1000 + sub
 
@@ -3169,4 +3849,3 @@ const UMFPACK_Q_Uat = 12
 const UMFPACK_Ut = 13
 
 const UMFPACK_Uat = 14
-
diff --git a/src/solvers/lib/x86_64-apple-darwin14.jl b/src/solvers/lib/x86_64-apple-darwin14.jl
index fcf756d2..a5aa4e44 100644
--- a/src/solvers/lib/x86_64-apple-darwin14.jl
+++ b/src/solvers/lib/x86_64-apple-darwin14.jl
@@ -1,137 +1,150 @@
 function SuiteSparse_config_printf_func_get()
-    @ccall libcholmod.SuiteSparse_config_printf_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_printf_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_malloc_func_get()
-    @ccall libcholmod.SuiteSparse_config_malloc_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_malloc_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_calloc_func_get()
-    @ccall libcholmod.SuiteSparse_config_calloc_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_calloc_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_realloc_func_get()
-    @ccall libcholmod.SuiteSparse_config_realloc_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_realloc_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_free_func_get()
-    @ccall libcholmod.SuiteSparse_config_free_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_free_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_hypot_func_get()
-    @ccall libcholmod.SuiteSparse_config_hypot_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_hypot_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_divcomplex_func_get()
-    @ccall libcholmod.SuiteSparse_config_divcomplex_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_divcomplex_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_malloc_func_set(malloc_func)
-    @ccall libcholmod.SuiteSparse_config_malloc_func_set(malloc_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_malloc_func_set(malloc_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_calloc_func_set(calloc_func)
-    @ccall libcholmod.SuiteSparse_config_calloc_func_set(calloc_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_calloc_func_set(calloc_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_realloc_func_set(realloc_func)
-    @ccall libcholmod.SuiteSparse_config_realloc_func_set(realloc_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_realloc_func_set(realloc_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_free_func_set(free_func)
-    @ccall libcholmod.SuiteSparse_config_free_func_set(free_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_free_func_set(free_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_printf_func_set(printf_func)
-    @ccall libcholmod.SuiteSparse_config_printf_func_set(printf_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_printf_func_set(printf_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_hypot_func_set(hypot_func)
-    @ccall libcholmod.SuiteSparse_config_hypot_func_set(hypot_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_hypot_func_set(hypot_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_divcomplex_func_set(divcomplex_func)
-    @ccall libcholmod.SuiteSparse_config_divcomplex_func_set(divcomplex_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_divcomplex_func_set(divcomplex_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_malloc(s)
-    @ccall libcholmod.SuiteSparse_config_malloc(s::Csize_t)::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_malloc(s::Csize_t)::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_calloc(n, s)
-    @ccall libcholmod.SuiteSparse_config_calloc(n::Csize_t, s::Csize_t)::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_calloc(n::Csize_t,
+                                                          s::Csize_t)::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_realloc(arg1, s)
-    @ccall libcholmod.SuiteSparse_config_realloc(arg1::Ptr{Cvoid}, s::Csize_t)::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_realloc(arg1::Ptr{Cvoid},
+                                                           s::Csize_t)::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_free(arg1)
-    @ccall libcholmod.SuiteSparse_config_free(arg1::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_free(arg1::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_hypot(x, y)
-    @ccall libcholmod.SuiteSparse_config_hypot(x::Cdouble, y::Cdouble)::Cdouble
+    @ccall libsuitesparseconfig.SuiteSparse_config_hypot(x::Cdouble, y::Cdouble)::Cdouble
 end
 
 function SuiteSparse_config_divcomplex(xr, xi, yr, yi, zr, zi)
-    @ccall libcholmod.SuiteSparse_config_divcomplex(xr::Cdouble, xi::Cdouble, yr::Cdouble, yi::Cdouble, zr::Ptr{Cdouble}, zi::Ptr{Cdouble})::Cint
+    @ccall libsuitesparseconfig.SuiteSparse_config_divcomplex(xr::Cdouble, xi::Cdouble,
+                                                              yr::Cdouble, yi::Cdouble,
+                                                              zr::Ptr{Cdouble},
+                                                              zi::Ptr{Cdouble})::Cint
 end
 
 function SuiteSparse_start()
-    @ccall libcholmod.SuiteSparse_start()::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_start()::Cvoid
 end
 
 function SuiteSparse_finish()
-    @ccall libcholmod.SuiteSparse_finish()::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_finish()::Cvoid
 end
 
 function SuiteSparse_malloc(nitems, size_of_item)
-    @ccall libcholmod.SuiteSparse_malloc(nitems::Csize_t, size_of_item::Csize_t)::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_malloc(nitems::Csize_t,
+                                                   size_of_item::Csize_t)::Ptr{Cvoid}
 end
 
 function SuiteSparse_calloc(nitems, size_of_item)
-    @ccall libcholmod.SuiteSparse_calloc(nitems::Csize_t, size_of_item::Csize_t)::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_calloc(nitems::Csize_t,
+                                                   size_of_item::Csize_t)::Ptr{Cvoid}
 end
 
 function SuiteSparse_realloc(nitems_new, nitems_old, size_of_item, p, ok)
-    @ccall libcholmod.SuiteSparse_realloc(nitems_new::Csize_t, nitems_old::Csize_t, size_of_item::Csize_t, p::Ptr{Cvoid}, ok::Ptr{Cint})::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_realloc(nitems_new::Csize_t,
+                                                    nitems_old::Csize_t,
+                                                    size_of_item::Csize_t, p::Ptr{Cvoid},
+                                                    ok::Ptr{Cint})::Ptr{Cvoid}
 end
 
 function SuiteSparse_free(p)
-    @ccall libcholmod.SuiteSparse_free(p::Ptr{Cvoid})::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_free(p::Ptr{Cvoid})::Ptr{Cvoid}
 end
 
 function SuiteSparse_tic(tic)
-    @ccall libcholmod.SuiteSparse_tic(tic::Ptr{Cdouble})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_tic(tic::Ptr{Cdouble})::Cvoid
 end
 
 function SuiteSparse_toc(tic)
-    @ccall libcholmod.SuiteSparse_toc(tic::Ptr{Cdouble})::Cdouble
+    @ccall libsuitesparseconfig.SuiteSparse_toc(tic::Ptr{Cdouble})::Cdouble
 end
 
 function SuiteSparse_time()
-    @ccall libcholmod.SuiteSparse_time()::Cdouble
+    @ccall libsuitesparseconfig.SuiteSparse_time()::Cdouble
 end
 
 function SuiteSparse_hypot(x, y)
-    @ccall libcholmod.SuiteSparse_hypot(x::Cdouble, y::Cdouble)::Cdouble
+    @ccall libsuitesparseconfig.SuiteSparse_hypot(x::Cdouble, y::Cdouble)::Cdouble
 end
 
 function SuiteSparse_divcomplex(ar, ai, br, bi, cr, ci)
-    @ccall libcholmod.SuiteSparse_divcomplex(ar::Cdouble, ai::Cdouble, br::Cdouble, bi::Cdouble, cr::Ptr{Cdouble}, ci::Ptr{Cdouble})::Cint
+    @ccall libsuitesparseconfig.SuiteSparse_divcomplex(ar::Cdouble, ai::Cdouble,
+                                                       br::Cdouble, bi::Cdouble,
+                                                       cr::Ptr{Cdouble},
+                                                       ci::Ptr{Cdouble})::Cint
 end
 
 function SuiteSparse_version(version)
-    @ccall libcholmod.SuiteSparse_version(version::Ptr{Cint})::Cint
+    @ccall libsuitesparseconfig.SuiteSparse_version(version::Ptr{Cint})::Cint
 end
 
 function SuiteSparse_BLAS_library()
-    @ccall libcholmod.SuiteSparse_BLAS_library()::Ptr{Cchar}
+    @ccall libsuitesparseconfig.SuiteSparse_BLAS_library()::Ptr{Cchar}
 end
 
 function SuiteSparse_BLAS_integer_size()
-    @ccall libcholmod.SuiteSparse_BLAS_integer_size()::Csize_t
+    @ccall libsuitesparseconfig.SuiteSparse_BLAS_integer_size()::Csize_t
 end
 
 struct cholmod_method_struct
@@ -140,16 +153,16 @@ struct cholmod_method_struct
     prune_dense::Cdouble
     prune_dense2::Cdouble
     nd_oksep::Cdouble
-    other_1::NTuple{4, Cdouble}
+    other_1::NTuple{4,Cdouble}
     nd_small::Csize_t
-    other_2::NTuple{4, Csize_t}
+    other_2::NTuple{4,Csize_t}
     aggressive::Cint
     order_for_lu::Cint
     nd_compress::Cint
     nd_camd::Cint
     nd_components::Cint
     ordering::Cint
-    other_3::NTuple{4, Csize_t}
+    other_3::NTuple{4,Csize_t}
 end
 
 mutable struct cholmod_common_struct
@@ -166,8 +179,8 @@ mutable struct cholmod_common_struct
     final_pack::Cint
     final_monotonic::Cint
     final_resymbol::Cint
-    zrelax::NTuple{3, Cdouble}
-    nrelax::NTuple{3, Csize_t}
+    zrelax::NTuple{3,Cdouble}
+    nrelax::NTuple{3,Csize_t}
     prefer_zomplex::Cint
     prefer_upper::Cint
     quick_return_if_not_posdef::Cint
@@ -179,7 +192,7 @@ mutable struct cholmod_common_struct
     nmethods::Cint
     current::Cint
     selected::Cint
-    method::NTuple{10, cholmod_method_struct}
+    method::NTuple{10,cholmod_method_struct}
     postorder::Cint
     default_nesdis::Cint
     metis_memory::Cdouble
@@ -222,7 +235,7 @@ mutable struct cholmod_common_struct
     SPQR_flopcount_bound::Cdouble
     SPQR_tol_used::Cdouble
     SPQR_norm_E_fro::Cdouble
-    SPQR_istat::NTuple{10, Int64}
+    SPQR_istat::NTuple{10,Int64}
     useGPU::Cint
     maxGpuMemBytes::Csize_t
     maxGpuMemFraction::Cdouble
@@ -231,10 +244,10 @@ mutable struct cholmod_common_struct
     gpuFlops::Int64
     gpuNumKernelLaunches::Cint
     cublasHandle::Ptr{Cvoid}
-    gpuStream::NTuple{8, Ptr{Cvoid}}
-    cublasEventPotrf::NTuple{3, Ptr{Cvoid}}
+    gpuStream::NTuple{8,Ptr{Cvoid}}
+    cublasEventPotrf::NTuple{3,Ptr{Cvoid}}
     updateCKernelsComplete::Ptr{Cvoid}
-    updateCBuffersFree::NTuple{8, Ptr{Cvoid}}
+    updateCBuffersFree::NTuple{8,Ptr{Cvoid}}
     dev_mempool::Ptr{Cvoid}
     dev_mempool_size::Csize_t
     host_pinned_mempool::Ptr{Cvoid}
@@ -300,11 +313,14 @@ function cholmod_l_maxrank(arg1, arg2)
 end
 
 function cholmod_allocate_work(nrow, iworksize, xworksize, Common)
-    @ccall libcholmod.cholmod_allocate_work(nrow::Csize_t, iworksize::Csize_t, xworksize::Csize_t, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_allocate_work(nrow::Csize_t, iworksize::Csize_t,
+                                            xworksize::Csize_t,
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_allocate_work(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_allocate_work(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_allocate_work(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t,
+                                              arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_free_work(Common)
@@ -324,11 +340,13 @@ function cholmod_l_clear_flag(arg1)
 end
 
 function cholmod_error(status, file, line, message, Common)
-    @ccall libcholmod.cholmod_error(status::Cint, file::Ptr{Cchar}, line::Cint, message::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_error(status::Cint, file::Ptr{Cchar}, line::Cint,
+                                    message::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_error(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_error(arg1::Cint, arg2::Ptr{Cchar}, arg3::Cint, arg4::Ptr{Cchar}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_error(arg1::Cint, arg2::Ptr{Cchar}, arg3::Cint,
+                                      arg4::Ptr{Cchar}, arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_dbound(dj, Common)
@@ -348,11 +366,14 @@ function cholmod_l_hypot(arg1, arg2)
 end
 
 function cholmod_divcomplex(ar, ai, br, bi, cr, ci)
-    @ccall libcholmod.cholmod_divcomplex(ar::Cdouble, ai::Cdouble, br::Cdouble, bi::Cdouble, cr::Ptr{Cdouble}, ci::Ptr{Cdouble})::Cint
+    @ccall libcholmod.cholmod_divcomplex(ar::Cdouble, ai::Cdouble, br::Cdouble, bi::Cdouble,
+                                         cr::Ptr{Cdouble}, ci::Ptr{Cdouble})::Cint
 end
 
 function cholmod_l_divcomplex(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_divcomplex(arg1::Cdouble, arg2::Cdouble, arg3::Cdouble, arg4::Cdouble, arg5::Ptr{Cdouble}, arg6::Ptr{Cdouble})::Cint
+    @ccall libcholmod.cholmod_l_divcomplex(arg1::Cdouble, arg2::Cdouble, arg3::Cdouble,
+                                           arg4::Cdouble, arg5::Ptr{Cdouble},
+                                           arg6::Ptr{Cdouble})::Cint
 end
 
 mutable struct cholmod_sparse_struct
@@ -384,155 +405,217 @@ end
 const descendantScore = cholmod_descendant_score_t
 
 function cholmod_score_comp(i, j)
-    @ccall libcholmod.cholmod_score_comp(i::Ptr{cholmod_descendant_score_t}, j::Ptr{cholmod_descendant_score_t})::Cint
+    @ccall libcholmod.cholmod_score_comp(i::Ptr{cholmod_descendant_score_t},
+                                         j::Ptr{cholmod_descendant_score_t})::Cint
 end
 
 function cholmod_l_score_comp(i, j)
-    @ccall libcholmod.cholmod_l_score_comp(i::Ptr{cholmod_descendant_score_t}, j::Ptr{cholmod_descendant_score_t})::Cint
+    @ccall libcholmod.cholmod_l_score_comp(i::Ptr{cholmod_descendant_score_t},
+                                           j::Ptr{cholmod_descendant_score_t})::Cint
 end
 
 function cholmod_allocate_sparse(nrow, ncol, nzmax, sorted, packed, stype, xtype, Common)
-    @ccall libcholmod.cholmod_allocate_sparse(nrow::Csize_t, ncol::Csize_t, nzmax::Csize_t, sorted::Cint, packed::Cint, stype::Cint, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_allocate_sparse(nrow::Csize_t, ncol::Csize_t, nzmax::Csize_t,
+                                              sorted::Cint, packed::Cint, stype::Cint,
+                                              xtype::Cint,
+                                              Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_allocate_sparse(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
-    @ccall libcholmod.cholmod_l_allocate_sparse(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t, arg4::Cint, arg5::Cint, arg6::Cint, arg7::Cint, arg8::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_allocate_sparse(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t,
+                                                arg4::Cint, arg5::Cint, arg6::Cint,
+                                                arg7::Cint,
+                                                arg8::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_free_sparse(A, Common)
-    @ccall libcholmod.cholmod_free_sparse(A::Ptr{Ptr{cholmod_sparse}}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_free_sparse(A::Ptr{Ptr{cholmod_sparse}},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_free_sparse(arg1, arg2)
-    @ccall libcholmod.cholmod_l_free_sparse(arg1::Ptr{Ptr{cholmod_sparse}}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_free_sparse(arg1::Ptr{Ptr{cholmod_sparse}},
+                                            arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_reallocate_sparse(nznew, A, Common)
-    @ccall libcholmod.cholmod_reallocate_sparse(nznew::Csize_t, A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_reallocate_sparse(nznew::Csize_t, A::Ptr{cholmod_sparse},
+                                                Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_reallocate_sparse(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_reallocate_sparse(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_reallocate_sparse(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                                  arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_nnz(A, Common)
-    @ccall libcholmod.cholmod_nnz(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_nnz(A::Ptr{cholmod_sparse},
+                                  Common::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_l_nnz(arg1, arg2)
-    @ccall libcholmod.cholmod_l_nnz(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_l_nnz(arg1::Ptr{cholmod_sparse},
+                                    arg2::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_speye(nrow, ncol, xtype, Common)
-    @ccall libcholmod.cholmod_speye(nrow::Csize_t, ncol::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_speye(nrow::Csize_t, ncol::Csize_t, xtype::Cint,
+                                    Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_speye(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_speye(arg1::Csize_t, arg2::Csize_t, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_speye(arg1::Csize_t, arg2::Csize_t, arg3::Cint,
+                                      arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_spzeros(nrow, ncol, nzmax, xtype, Common)
-    @ccall libcholmod.cholmod_spzeros(nrow::Csize_t, ncol::Csize_t, nzmax::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_spzeros(nrow::Csize_t, ncol::Csize_t, nzmax::Csize_t,
+                                      xtype::Cint,
+                                      Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_spzeros(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_spzeros(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t, arg4::Cint, arg5::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_spzeros(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t,
+                                        arg4::Cint,
+                                        arg5::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_transpose(A, values, Common)
-    @ccall libcholmod.cholmod_transpose(A::Ptr{cholmod_sparse}, values::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_transpose(A::Ptr{cholmod_sparse}, values::Cint,
+                                        Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_transpose(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_transpose(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_transpose(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                          arg3::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_transpose_unsym(A, values, Perm, fset, fsize, F, Common)
-    @ccall libcholmod.cholmod_transpose_unsym(A::Ptr{cholmod_sparse}, values::Cint, Perm::Ptr{Int32}, fset::Ptr{Int32}, fsize::Csize_t, F::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_transpose_unsym(A::Ptr{cholmod_sparse}, values::Cint,
+                                              Perm::Ptr{Int32}, fset::Ptr{Int32},
+                                              fsize::Csize_t, F::Ptr{cholmod_sparse},
+                                              Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_transpose_unsym(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_transpose_unsym(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Csize_t, arg6::Ptr{cholmod_sparse}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_transpose_unsym(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                                arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                                arg5::Csize_t, arg6::Ptr{cholmod_sparse},
+                                                arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_transpose_sym(A, values, Perm, F, Common)
-    @ccall libcholmod.cholmod_transpose_sym(A::Ptr{cholmod_sparse}, values::Cint, Perm::Ptr{Int32}, F::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_transpose_sym(A::Ptr{cholmod_sparse}, values::Cint,
+                                            Perm::Ptr{Int32}, F::Ptr{cholmod_sparse},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_transpose_sym(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_transpose_sym(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{Int64}, arg4::Ptr{cholmod_sparse}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_transpose_sym(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                              arg3::Ptr{Int64}, arg4::Ptr{cholmod_sparse},
+                                              arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_ptranspose(A, values, Perm, fset, fsize, Common)
-    @ccall libcholmod.cholmod_ptranspose(A::Ptr{cholmod_sparse}, values::Cint, Perm::Ptr{Int32}, fset::Ptr{Int32}, fsize::Csize_t, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_ptranspose(A::Ptr{cholmod_sparse}, values::Cint,
+                                         Perm::Ptr{Int32}, fset::Ptr{Int32}, fsize::Csize_t,
+                                         Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_ptranspose(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_ptranspose(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Csize_t, arg6::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_ptranspose(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                           arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                           arg5::Csize_t,
+                                           arg6::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_sort(A, Common)
-    @ccall libcholmod.cholmod_sort(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_sort(A::Ptr{cholmod_sparse},
+                                   Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_sort(arg1, arg2)
-    @ccall libcholmod.cholmod_l_sort(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_sort(arg1::Ptr{cholmod_sparse},
+                                     arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_band(A, k1, k2, mode, Common)
-    @ccall libcholmod.cholmod_band(A::Ptr{cholmod_sparse}, k1::Int64, k2::Int64, mode::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_band(A::Ptr{cholmod_sparse}, k1::Int64, k2::Int64, mode::Cint,
+                                   Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_band(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_band(arg1::Ptr{cholmod_sparse}, arg2::Int64, arg3::Int64, arg4::Cint, arg5::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_band(arg1::Ptr{cholmod_sparse}, arg2::Int64, arg3::Int64,
+                                     arg4::Cint,
+                                     arg5::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_band_inplace(k1, k2, mode, A, Common)
-    @ccall libcholmod.cholmod_band_inplace(k1::Int64, k2::Int64, mode::Cint, A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_band_inplace(k1::Int64, k2::Int64, mode::Cint,
+                                           A::Ptr{cholmod_sparse},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_band_inplace(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_band_inplace(arg1::Int64, arg2::Int64, arg3::Cint, arg4::Ptr{cholmod_sparse}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_band_inplace(arg1::Int64, arg2::Int64, arg3::Cint,
+                                             arg4::Ptr{cholmod_sparse},
+                                             arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_aat(A, fset, fsize, mode, Common)
-    @ccall libcholmod.cholmod_aat(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, mode::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_aat(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t,
+                                  mode::Cint,
+                                  Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_aat(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_aat(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Cint, arg5::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_aat(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                    arg3::Csize_t, arg4::Cint,
+                                    arg5::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_copy_sparse(A, Common)
-    @ccall libcholmod.cholmod_copy_sparse(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_copy_sparse(A::Ptr{cholmod_sparse},
+                                          Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_copy_sparse(arg1, arg2)
-    @ccall libcholmod.cholmod_l_copy_sparse(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_copy_sparse(arg1::Ptr{cholmod_sparse},
+                                            arg2::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_copy(A, stype, mode, Common)
-    @ccall libcholmod.cholmod_copy(A::Ptr{cholmod_sparse}, stype::Cint, mode::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_copy(A::Ptr{cholmod_sparse}, stype::Cint, mode::Cint,
+                                   Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_copy(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_copy(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_copy(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Cint,
+                                     arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_add(A, B, alpha, beta, values, sorted, Common)
-    @ccall libcholmod.cholmod_add(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse}, alpha::Ptr{Cdouble}, beta::Ptr{Cdouble}, values::Cint, sorted::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_add(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse},
+                                  alpha::Ptr{Cdouble}, beta::Ptr{Cdouble}, values::Cint,
+                                  sorted::Cint,
+                                  Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_add(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_add(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Ptr{Cdouble}, arg5::Cint, arg6::Cint, arg7::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_add(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse},
+                                    arg3::Ptr{Cdouble}, arg4::Ptr{Cdouble}, arg5::Cint,
+                                    arg6::Cint,
+                                    arg7::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_sparse_xtype(to_xtype, A, Common)
-    @ccall libcholmod.cholmod_sparse_xtype(to_xtype::Cint, A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_sparse_xtype(to_xtype::Cint, A::Ptr{cholmod_sparse},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_sparse_xtype(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_sparse_xtype(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_sparse_xtype(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                             arg3::Ptr{cholmod_common})::Cint
 end
 
 mutable struct cholmod_factor_struct
@@ -572,75 +655,100 @@ end
 const cholmod_factor = cholmod_factor_struct
 
 function cholmod_allocate_factor(n, Common)
-    @ccall libcholmod.cholmod_allocate_factor(n::Csize_t, Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_allocate_factor(n::Csize_t,
+                                              Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_l_allocate_factor(arg1, arg2)
-    @ccall libcholmod.cholmod_l_allocate_factor(arg1::Csize_t, arg2::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_l_allocate_factor(arg1::Csize_t,
+                                                arg2::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_free_factor(L, Common)
-    @ccall libcholmod.cholmod_free_factor(L::Ptr{Ptr{cholmod_factor}}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_free_factor(L::Ptr{Ptr{cholmod_factor}},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_free_factor(arg1, arg2)
-    @ccall libcholmod.cholmod_l_free_factor(arg1::Ptr{Ptr{cholmod_factor}}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_free_factor(arg1::Ptr{Ptr{cholmod_factor}},
+                                            arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_reallocate_factor(nznew, L, Common)
-    @ccall libcholmod.cholmod_reallocate_factor(nznew::Csize_t, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_reallocate_factor(nznew::Csize_t, L::Ptr{cholmod_factor},
+                                                Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_reallocate_factor(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_reallocate_factor(arg1::Csize_t, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_reallocate_factor(arg1::Csize_t, arg2::Ptr{cholmod_factor},
+                                                  arg3::Ptr{cholmod_common})::Cint
 end
 
-function cholmod_change_factor(to_xtype, to_ll, to_super, to_packed, to_monotonic, L, Common)
-    @ccall libcholmod.cholmod_change_factor(to_xtype::Cint, to_ll::Cint, to_super::Cint, to_packed::Cint, to_monotonic::Cint, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+function cholmod_change_factor(to_xtype, to_ll, to_super, to_packed, to_monotonic, L,
+                               Common)
+    @ccall libcholmod.cholmod_change_factor(to_xtype::Cint, to_ll::Cint, to_super::Cint,
+                                            to_packed::Cint, to_monotonic::Cint,
+                                            L::Ptr{cholmod_factor},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_change_factor(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_change_factor(arg1::Cint, arg2::Cint, arg3::Cint, arg4::Cint, arg5::Cint, arg6::Ptr{cholmod_factor}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_change_factor(arg1::Cint, arg2::Cint, arg3::Cint,
+                                              arg4::Cint, arg5::Cint,
+                                              arg6::Ptr{cholmod_factor},
+                                              arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_pack_factor(L, Common)
-    @ccall libcholmod.cholmod_pack_factor(L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_pack_factor(L::Ptr{cholmod_factor},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_pack_factor(arg1, arg2)
-    @ccall libcholmod.cholmod_l_pack_factor(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_pack_factor(arg1::Ptr{cholmod_factor},
+                                            arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_reallocate_column(j, need, L, Common)
-    @ccall libcholmod.cholmod_reallocate_column(j::Csize_t, need::Csize_t, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_reallocate_column(j::Csize_t, need::Csize_t,
+                                                L::Ptr{cholmod_factor},
+                                                Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_reallocate_column(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_reallocate_column(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{cholmod_factor}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_reallocate_column(arg1::Csize_t, arg2::Csize_t,
+                                                  arg3::Ptr{cholmod_factor},
+                                                  arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_factor_to_sparse(L, Common)
-    @ccall libcholmod.cholmod_factor_to_sparse(L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_factor_to_sparse(L::Ptr{cholmod_factor},
+                                               Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_factor_to_sparse(arg1, arg2)
-    @ccall libcholmod.cholmod_l_factor_to_sparse(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_factor_to_sparse(arg1::Ptr{cholmod_factor},
+                                                 arg2::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_copy_factor(L, Common)
-    @ccall libcholmod.cholmod_copy_factor(L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_copy_factor(L::Ptr{cholmod_factor},
+                                          Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_l_copy_factor(arg1, arg2)
-    @ccall libcholmod.cholmod_l_copy_factor(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_l_copy_factor(arg1::Ptr{cholmod_factor},
+                                            arg2::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_factor_xtype(to_xtype, L, Common)
-    @ccall libcholmod.cholmod_factor_xtype(to_xtype::Cint, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_factor_xtype(to_xtype::Cint, L::Ptr{cholmod_factor},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_factor_xtype(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_factor_xtype(arg1::Cint, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_factor_xtype(arg1::Cint, arg2::Ptr{cholmod_factor},
+                                             arg3::Ptr{cholmod_common})::Cint
 end
 
 mutable struct cholmod_dense_struct
@@ -658,91 +766,118 @@ end
 const cholmod_dense = cholmod_dense_struct
 
 function cholmod_allocate_dense(nrow, ncol, d, xtype, Common)
-    @ccall libcholmod.cholmod_allocate_dense(nrow::Csize_t, ncol::Csize_t, d::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_allocate_dense(nrow::Csize_t, ncol::Csize_t, d::Csize_t,
+                                             xtype::Cint,
+                                             Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_allocate_dense(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_allocate_dense(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t, arg4::Cint, arg5::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_allocate_dense(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t,
+                                               arg4::Cint,
+                                               arg5::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_zeros(nrow, ncol, xtype, Common)
-    @ccall libcholmod.cholmod_zeros(nrow::Csize_t, ncol::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_zeros(nrow::Csize_t, ncol::Csize_t, xtype::Cint,
+                                    Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_zeros(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_zeros(arg1::Csize_t, arg2::Csize_t, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_zeros(arg1::Csize_t, arg2::Csize_t, arg3::Cint,
+                                      arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_ones(nrow, ncol, xtype, Common)
-    @ccall libcholmod.cholmod_ones(nrow::Csize_t, ncol::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_ones(nrow::Csize_t, ncol::Csize_t, xtype::Cint,
+                                   Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_ones(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_ones(arg1::Csize_t, arg2::Csize_t, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_ones(arg1::Csize_t, arg2::Csize_t, arg3::Cint,
+                                     arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_eye(nrow, ncol, xtype, Common)
-    @ccall libcholmod.cholmod_eye(nrow::Csize_t, ncol::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_eye(nrow::Csize_t, ncol::Csize_t, xtype::Cint,
+                                  Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_eye(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_eye(arg1::Csize_t, arg2::Csize_t, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_eye(arg1::Csize_t, arg2::Csize_t, arg3::Cint,
+                                    arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_free_dense(X, Common)
-    @ccall libcholmod.cholmod_free_dense(X::Ptr{Ptr{cholmod_dense}}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_free_dense(X::Ptr{Ptr{cholmod_dense}},
+                                         Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_free_dense(arg1, arg2)
-    @ccall libcholmod.cholmod_l_free_dense(arg1::Ptr{Ptr{cholmod_dense}}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_free_dense(arg1::Ptr{Ptr{cholmod_dense}},
+                                           arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_ensure_dense(XHandle, nrow, ncol, d, xtype, Common)
-    @ccall libcholmod.cholmod_ensure_dense(XHandle::Ptr{Ptr{cholmod_dense}}, nrow::Csize_t, ncol::Csize_t, d::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_ensure_dense(XHandle::Ptr{Ptr{cholmod_dense}}, nrow::Csize_t,
+                                           ncol::Csize_t, d::Csize_t, xtype::Cint,
+                                           Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_ensure_dense(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_ensure_dense(arg1::Ptr{Ptr{cholmod_dense}}, arg2::Csize_t, arg3::Csize_t, arg4::Csize_t, arg5::Cint, arg6::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_ensure_dense(arg1::Ptr{Ptr{cholmod_dense}}, arg2::Csize_t,
+                                             arg3::Csize_t, arg4::Csize_t, arg5::Cint,
+                                             arg6::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_sparse_to_dense(A, Common)
-    @ccall libcholmod.cholmod_sparse_to_dense(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_sparse_to_dense(A::Ptr{cholmod_sparse},
+                                              Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_sparse_to_dense(arg1, arg2)
-    @ccall libcholmod.cholmod_l_sparse_to_dense(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_sparse_to_dense(arg1::Ptr{cholmod_sparse},
+                                                arg2::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_dense_to_sparse(X, values, Common)
-    @ccall libcholmod.cholmod_dense_to_sparse(X::Ptr{cholmod_dense}, values::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_dense_to_sparse(X::Ptr{cholmod_dense}, values::Cint,
+                                              Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_dense_to_sparse(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_dense_to_sparse(arg1::Ptr{cholmod_dense}, arg2::Cint, arg3::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_dense_to_sparse(arg1::Ptr{cholmod_dense}, arg2::Cint,
+                                                arg3::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_copy_dense(X, Common)
-    @ccall libcholmod.cholmod_copy_dense(X::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_copy_dense(X::Ptr{cholmod_dense},
+                                         Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_copy_dense(arg1, arg2)
-    @ccall libcholmod.cholmod_l_copy_dense(arg1::Ptr{cholmod_dense}, arg2::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_copy_dense(arg1::Ptr{cholmod_dense},
+                                           arg2::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_copy_dense2(X, Y, Common)
-    @ccall libcholmod.cholmod_copy_dense2(X::Ptr{cholmod_dense}, Y::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_copy_dense2(X::Ptr{cholmod_dense}, Y::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_copy_dense2(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_copy_dense2(arg1::Ptr{cholmod_dense}, arg2::Ptr{cholmod_dense}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_copy_dense2(arg1::Ptr{cholmod_dense},
+                                            arg2::Ptr{cholmod_dense},
+                                            arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_dense_xtype(to_xtype, X, Common)
-    @ccall libcholmod.cholmod_dense_xtype(to_xtype::Cint, X::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_dense_xtype(to_xtype::Cint, X::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_dense_xtype(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_dense_xtype(arg1::Cint, arg2::Ptr{cholmod_dense}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_dense_xtype(arg1::Cint, arg2::Ptr{cholmod_dense},
+                                            arg3::Ptr{cholmod_common})::Cint
 end
 
 mutable struct cholmod_triplet_struct
@@ -764,99 +899,137 @@ end
 const cholmod_triplet = cholmod_triplet_struct
 
 function cholmod_allocate_triplet(nrow, ncol, nzmax, stype, xtype, Common)
-    @ccall libcholmod.cholmod_allocate_triplet(nrow::Csize_t, ncol::Csize_t, nzmax::Csize_t, stype::Cint, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_allocate_triplet(nrow::Csize_t, ncol::Csize_t, nzmax::Csize_t,
+                                               stype::Cint, xtype::Cint,
+                                               Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_l_allocate_triplet(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_allocate_triplet(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t, arg4::Cint, arg5::Cint, arg6::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_l_allocate_triplet(arg1::Csize_t, arg2::Csize_t,
+                                                 arg3::Csize_t, arg4::Cint, arg5::Cint,
+                                                 arg6::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_free_triplet(T, Common)
-    @ccall libcholmod.cholmod_free_triplet(T::Ptr{Ptr{cholmod_triplet}}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_free_triplet(T::Ptr{Ptr{cholmod_triplet}},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_free_triplet(arg1, arg2)
-    @ccall libcholmod.cholmod_l_free_triplet(arg1::Ptr{Ptr{cholmod_triplet}}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_free_triplet(arg1::Ptr{Ptr{cholmod_triplet}},
+                                             arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_reallocate_triplet(nznew, T, Common)
-    @ccall libcholmod.cholmod_reallocate_triplet(nznew::Csize_t, T::Ptr{cholmod_triplet}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_reallocate_triplet(nznew::Csize_t, T::Ptr{cholmod_triplet},
+                                                 Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_reallocate_triplet(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_reallocate_triplet(arg1::Csize_t, arg2::Ptr{cholmod_triplet}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_reallocate_triplet(arg1::Csize_t,
+                                                   arg2::Ptr{cholmod_triplet},
+                                                   arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_sparse_to_triplet(A, Common)
-    @ccall libcholmod.cholmod_sparse_to_triplet(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_sparse_to_triplet(A::Ptr{cholmod_sparse},
+                                                Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_l_sparse_to_triplet(arg1, arg2)
-    @ccall libcholmod.cholmod_l_sparse_to_triplet(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_l_sparse_to_triplet(arg1::Ptr{cholmod_sparse},
+                                                  arg2::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_triplet_to_sparse(T, nzmax, Common)
-    @ccall libcholmod.cholmod_triplet_to_sparse(T::Ptr{cholmod_triplet}, nzmax::Csize_t, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_triplet_to_sparse(T::Ptr{cholmod_triplet}, nzmax::Csize_t,
+                                                Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_triplet_to_sparse(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_triplet_to_sparse(arg1::Ptr{cholmod_triplet}, arg2::Csize_t, arg3::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_triplet_to_sparse(arg1::Ptr{cholmod_triplet}, arg2::Csize_t,
+                                                  arg3::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_copy_triplet(T, Common)
-    @ccall libcholmod.cholmod_copy_triplet(T::Ptr{cholmod_triplet}, Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_copy_triplet(T::Ptr{cholmod_triplet},
+                                           Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_l_copy_triplet(arg1, arg2)
-    @ccall libcholmod.cholmod_l_copy_triplet(arg1::Ptr{cholmod_triplet}, arg2::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_l_copy_triplet(arg1::Ptr{cholmod_triplet},
+                                             arg2::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_triplet_xtype(to_xtype, T, Common)
-    @ccall libcholmod.cholmod_triplet_xtype(to_xtype::Cint, T::Ptr{cholmod_triplet}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_triplet_xtype(to_xtype::Cint, T::Ptr{cholmod_triplet},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_triplet_xtype(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_triplet_xtype(arg1::Cint, arg2::Ptr{cholmod_triplet}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_triplet_xtype(arg1::Cint, arg2::Ptr{cholmod_triplet},
+                                              arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_malloc(n, size, Common)
-    @ccall libcholmod.cholmod_malloc(n::Csize_t, size::Csize_t, Common::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_malloc(n::Csize_t, size::Csize_t,
+                                     Common::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_l_malloc(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_malloc(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_l_malloc(arg1::Csize_t, arg2::Csize_t,
+                                       arg3::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_calloc(n, size, Common)
-    @ccall libcholmod.cholmod_calloc(n::Csize_t, size::Csize_t, Common::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_calloc(n::Csize_t, size::Csize_t,
+                                     Common::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_l_calloc(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_calloc(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_l_calloc(arg1::Csize_t, arg2::Csize_t,
+                                       arg3::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_free(n, size, p, Common)
-    @ccall libcholmod.cholmod_free(n::Csize_t, size::Csize_t, p::Ptr{Cvoid}, Common::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_free(n::Csize_t, size::Csize_t, p::Ptr{Cvoid},
+                                   Common::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_l_free(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_free(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{Cvoid}, arg4::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_l_free(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{Cvoid},
+                                     arg4::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_realloc(nnew, size, p, n, Common)
-    @ccall libcholmod.cholmod_realloc(nnew::Csize_t, size::Csize_t, p::Ptr{Cvoid}, n::Ptr{Csize_t}, Common::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_realloc(nnew::Csize_t, size::Csize_t, p::Ptr{Cvoid},
+                                      n::Ptr{Csize_t},
+                                      Common::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_l_realloc(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_realloc(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{Cvoid}, arg4::Ptr{Csize_t}, arg5::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_l_realloc(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{Cvoid},
+                                        arg4::Ptr{Csize_t},
+                                        arg5::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
-function cholmod_realloc_multiple(nnew, nint, xtype, Iblock, Jblock, Xblock, Zblock, n, Common)
-    @ccall libcholmod.cholmod_realloc_multiple(nnew::Csize_t, nint::Cint, xtype::Cint, Iblock::Ptr{Ptr{Cvoid}}, Jblock::Ptr{Ptr{Cvoid}}, Xblock::Ptr{Ptr{Cvoid}}, Zblock::Ptr{Ptr{Cvoid}}, n::Ptr{Csize_t}, Common::Ptr{cholmod_common})::Cint
+function cholmod_realloc_multiple(nnew, nint, xtype, Iblock, Jblock, Xblock, Zblock, n,
+                                  Common)
+    @ccall libcholmod.cholmod_realloc_multiple(nnew::Csize_t, nint::Cint, xtype::Cint,
+                                               Iblock::Ptr{Ptr{Cvoid}},
+                                               Jblock::Ptr{Ptr{Cvoid}},
+                                               Xblock::Ptr{Ptr{Cvoid}},
+                                               Zblock::Ptr{Ptr{Cvoid}}, n::Ptr{Csize_t},
+                                               Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_realloc_multiple(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
-    @ccall libcholmod.cholmod_l_realloc_multiple(arg1::Csize_t, arg2::Cint, arg3::Cint, arg4::Ptr{Ptr{Cvoid}}, arg5::Ptr{Ptr{Cvoid}}, arg6::Ptr{Ptr{Cvoid}}, arg7::Ptr{Ptr{Cvoid}}, arg8::Ptr{Csize_t}, arg9::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_realloc_multiple(arg1::Csize_t, arg2::Cint, arg3::Cint,
+                                                 arg4::Ptr{Ptr{Cvoid}},
+                                                 arg5::Ptr{Ptr{Cvoid}},
+                                                 arg6::Ptr{Ptr{Cvoid}},
+                                                 arg7::Ptr{Ptr{Cvoid}}, arg8::Ptr{Csize_t},
+                                                 arg9::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_version(version)
@@ -876,11 +1049,13 @@ function cholmod_l_check_common(arg1)
 end
 
 function cholmod_print_common(name, Common)
-    @ccall libcholmod.cholmod_print_common(name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_common(name::Ptr{Cchar},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_common(arg1, arg2)
-    @ccall libcholmod.cholmod_l_print_common(arg1::Ptr{Cchar}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_common(arg1::Ptr{Cchar},
+                                             arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_gpu_stats(arg1)
@@ -892,643 +1067,1047 @@ function cholmod_l_gpu_stats(arg1)
 end
 
 function cholmod_check_sparse(A, Common)
-    @ccall libcholmod.cholmod_check_sparse(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_sparse(A::Ptr{cholmod_sparse},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_sparse(arg1, arg2)
-    @ccall libcholmod.cholmod_l_check_sparse(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_sparse(arg1::Ptr{cholmod_sparse},
+                                             arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_sparse(A, name, Common)
-    @ccall libcholmod.cholmod_print_sparse(A::Ptr{cholmod_sparse}, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_sparse(A::Ptr{cholmod_sparse}, name::Ptr{Cchar},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_sparse(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_print_sparse(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Cchar}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_sparse(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Cchar},
+                                             arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_check_dense(X, Common)
-    @ccall libcholmod.cholmod_check_dense(X::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_dense(X::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_dense(arg1, arg2)
-    @ccall libcholmod.cholmod_l_check_dense(arg1::Ptr{cholmod_dense}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_dense(arg1::Ptr{cholmod_dense},
+                                            arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_dense(X, name, Common)
-    @ccall libcholmod.cholmod_print_dense(X::Ptr{cholmod_dense}, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_dense(X::Ptr{cholmod_dense}, name::Ptr{Cchar},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_dense(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_print_dense(arg1::Ptr{cholmod_dense}, arg2::Ptr{Cchar}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_dense(arg1::Ptr{cholmod_dense}, arg2::Ptr{Cchar},
+                                            arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_check_factor(L, Common)
-    @ccall libcholmod.cholmod_check_factor(L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_factor(L::Ptr{cholmod_factor},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_factor(arg1, arg2)
-    @ccall libcholmod.cholmod_l_check_factor(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_factor(arg1::Ptr{cholmod_factor},
+                                             arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_factor(L, name, Common)
-    @ccall libcholmod.cholmod_print_factor(L::Ptr{cholmod_factor}, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_factor(L::Ptr{cholmod_factor}, name::Ptr{Cchar},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_factor(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_print_factor(arg1::Ptr{cholmod_factor}, arg2::Ptr{Cchar}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_factor(arg1::Ptr{cholmod_factor}, arg2::Ptr{Cchar},
+                                             arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_check_triplet(T, Common)
-    @ccall libcholmod.cholmod_check_triplet(T::Ptr{cholmod_triplet}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_triplet(T::Ptr{cholmod_triplet},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_triplet(arg1, arg2)
-    @ccall libcholmod.cholmod_l_check_triplet(arg1::Ptr{cholmod_triplet}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_triplet(arg1::Ptr{cholmod_triplet},
+                                              arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_triplet(T, name, Common)
-    @ccall libcholmod.cholmod_print_triplet(T::Ptr{cholmod_triplet}, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_triplet(T::Ptr{cholmod_triplet}, name::Ptr{Cchar},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_triplet(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_print_triplet(arg1::Ptr{cholmod_triplet}, arg2::Ptr{Cchar}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_triplet(arg1::Ptr{cholmod_triplet}, arg2::Ptr{Cchar},
+                                              arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_check_subset(Set, len, n, Common)
-    @ccall libcholmod.cholmod_check_subset(Set::Ptr{Int32}, len::Int64, n::Csize_t, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_subset(Set::Ptr{Int32}, len::Int64, n::Csize_t,
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_subset(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_check_subset(arg1::Ptr{Int64}, arg2::Int64, arg3::Csize_t, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_subset(arg1::Ptr{Int64}, arg2::Int64, arg3::Csize_t,
+                                             arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_subset(Set, len, n, name, Common)
-    @ccall libcholmod.cholmod_print_subset(Set::Ptr{Int32}, len::Int64, n::Csize_t, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_subset(Set::Ptr{Int32}, len::Int64, n::Csize_t,
+                                           name::Ptr{Cchar},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_subset(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_print_subset(arg1::Ptr{Int64}, arg2::Int64, arg3::Csize_t, arg4::Ptr{Cchar}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_subset(arg1::Ptr{Int64}, arg2::Int64, arg3::Csize_t,
+                                             arg4::Ptr{Cchar},
+                                             arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_check_perm(Perm, len, n, Common)
-    @ccall libcholmod.cholmod_check_perm(Perm::Ptr{Int32}, len::Csize_t, n::Csize_t, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_perm(Perm::Ptr{Int32}, len::Csize_t, n::Csize_t,
+                                         Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_perm(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_check_perm(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Csize_t, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_perm(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Csize_t,
+                                           arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_perm(Perm, len, n, name, Common)
-    @ccall libcholmod.cholmod_print_perm(Perm::Ptr{Int32}, len::Csize_t, n::Csize_t, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_perm(Perm::Ptr{Int32}, len::Csize_t, n::Csize_t,
+                                         name::Ptr{Cchar},
+                                         Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_perm(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_print_perm(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Csize_t, arg4::Ptr{Cchar}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_perm(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Csize_t,
+                                           arg4::Ptr{Cchar},
+                                           arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_check_parent(Parent, n, Common)
-    @ccall libcholmod.cholmod_check_parent(Parent::Ptr{Int32}, n::Csize_t, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_parent(Parent::Ptr{Int32}, n::Csize_t,
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_parent(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_check_parent(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_parent(arg1::Ptr{Int64}, arg2::Csize_t,
+                                             arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_parent(Parent, n, name, Common)
-    @ccall libcholmod.cholmod_print_parent(Parent::Ptr{Int32}, n::Csize_t, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_parent(Parent::Ptr{Int32}, n::Csize_t, name::Ptr{Cchar},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_parent(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_print_parent(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Ptr{Cchar}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_parent(arg1::Ptr{Int64}, arg2::Csize_t,
+                                             arg3::Ptr{Cchar},
+                                             arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_read_sparse(f, Common)
-    @ccall libcholmod.cholmod_read_sparse(f::Ptr{Libc.FILE}, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_read_sparse(f::Ptr{Libc.FILE},
+                                          Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_read_sparse(arg1, arg2)
-    @ccall libcholmod.cholmod_l_read_sparse(arg1::Ptr{Libc.FILE}, arg2::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_read_sparse(arg1::Ptr{Libc.FILE},
+                                            arg2::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_read_triplet(f, Common)
-    @ccall libcholmod.cholmod_read_triplet(f::Ptr{Libc.FILE}, Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_read_triplet(f::Ptr{Libc.FILE},
+                                           Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_l_read_triplet(arg1, arg2)
-    @ccall libcholmod.cholmod_l_read_triplet(arg1::Ptr{Libc.FILE}, arg2::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_l_read_triplet(arg1::Ptr{Libc.FILE},
+                                             arg2::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_read_dense(f, Common)
-    @ccall libcholmod.cholmod_read_dense(f::Ptr{Libc.FILE}, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_read_dense(f::Ptr{Libc.FILE},
+                                         Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_read_dense(arg1, arg2)
-    @ccall libcholmod.cholmod_l_read_dense(arg1::Ptr{Libc.FILE}, arg2::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_read_dense(arg1::Ptr{Libc.FILE},
+                                           arg2::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_read_matrix(f, prefer, mtype, Common)
-    @ccall libcholmod.cholmod_read_matrix(f::Ptr{Libc.FILE}, prefer::Cint, mtype::Ptr{Cint}, Common::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_read_matrix(f::Ptr{Libc.FILE}, prefer::Cint, mtype::Ptr{Cint},
+                                          Common::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_l_read_matrix(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_read_matrix(arg1::Ptr{Libc.FILE}, arg2::Cint, arg3::Ptr{Cint}, arg4::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_l_read_matrix(arg1::Ptr{Libc.FILE}, arg2::Cint,
+                                            arg3::Ptr{Cint},
+                                            arg4::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_write_sparse(f, A, Z, comments, Common)
-    @ccall libcholmod.cholmod_write_sparse(f::Ptr{Libc.FILE}, A::Ptr{cholmod_sparse}, Z::Ptr{cholmod_sparse}, comments::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_write_sparse(f::Ptr{Libc.FILE}, A::Ptr{cholmod_sparse},
+                                           Z::Ptr{cholmod_sparse}, comments::Ptr{Cchar},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_write_sparse(arg1, arg2, arg3, c, arg5)
-    @ccall libcholmod.cholmod_l_write_sparse(arg1::Ptr{Libc.FILE}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_sparse}, c::Ptr{Cchar}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_write_sparse(arg1::Ptr{Libc.FILE},
+                                             arg2::Ptr{cholmod_sparse},
+                                             arg3::Ptr{cholmod_sparse}, c::Ptr{Cchar},
+                                             arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_write_dense(f, X, comments, Common)
-    @ccall libcholmod.cholmod_write_dense(f::Ptr{Libc.FILE}, X::Ptr{cholmod_dense}, comments::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_write_dense(f::Ptr{Libc.FILE}, X::Ptr{cholmod_dense},
+                                          comments::Ptr{Cchar},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_write_dense(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_write_dense(arg1::Ptr{Libc.FILE}, arg2::Ptr{cholmod_dense}, arg3::Ptr{Cchar}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_write_dense(arg1::Ptr{Libc.FILE}, arg2::Ptr{cholmod_dense},
+                                            arg3::Ptr{Cchar},
+                                            arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_analyze(A, Common)
-    @ccall libcholmod.cholmod_analyze(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_analyze(A::Ptr{cholmod_sparse},
+                                      Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_l_analyze(arg1, arg2)
-    @ccall libcholmod.cholmod_l_analyze(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_l_analyze(arg1::Ptr{cholmod_sparse},
+                                        arg2::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_analyze_p(A, UserPerm, fset, fsize, Common)
-    @ccall libcholmod.cholmod_analyze_p(A::Ptr{cholmod_sparse}, UserPerm::Ptr{Int32}, fset::Ptr{Int32}, fsize::Csize_t, Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_analyze_p(A::Ptr{cholmod_sparse}, UserPerm::Ptr{Int32},
+                                        fset::Ptr{Int32}, fsize::Csize_t,
+                                        Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_l_analyze_p(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_analyze_p(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Ptr{Int64}, arg4::Csize_t, arg5::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_l_analyze_p(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                          arg3::Ptr{Int64}, arg4::Csize_t,
+                                          arg5::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_analyze_p2(for_whom, A, UserPerm, fset, fsize, Common)
-    @ccall libcholmod.cholmod_analyze_p2(for_whom::Cint, A::Ptr{cholmod_sparse}, UserPerm::Ptr{Int32}, fset::Ptr{Int32}, fsize::Csize_t, Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_analyze_p2(for_whom::Cint, A::Ptr{cholmod_sparse},
+                                         UserPerm::Ptr{Int32}, fset::Ptr{Int32},
+                                         fsize::Csize_t,
+                                         Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_l_analyze_p2(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_analyze_p2(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Csize_t, arg6::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_l_analyze_p2(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                           arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                           arg5::Csize_t,
+                                           arg6::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_factorize(A, L, Common)
-    @ccall libcholmod.cholmod_factorize(A::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_factorize(A::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor},
+                                        Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_factorize(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_factorize(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_factorize(arg1::Ptr{cholmod_sparse},
+                                          arg2::Ptr{cholmod_factor},
+                                          arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_factorize_p(A, beta, fset, fsize, L, Common)
-    @ccall libcholmod.cholmod_factorize_p(A::Ptr{cholmod_sparse}, beta::Ptr{Cdouble}, fset::Ptr{Int32}, fsize::Csize_t, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_factorize_p(A::Ptr{cholmod_sparse}, beta::Ptr{Cdouble},
+                                          fset::Ptr{Int32}, fsize::Csize_t,
+                                          L::Ptr{cholmod_factor},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_factorize_p(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_factorize_p(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Cdouble}, arg3::Ptr{Int64}, arg4::Csize_t, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_factorize_p(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Cdouble},
+                                            arg3::Ptr{Int64}, arg4::Csize_t,
+                                            arg5::Ptr{cholmod_factor},
+                                            arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_solve(sys, L, B, Common)
-    @ccall libcholmod.cholmod_solve(sys::Cint, L::Ptr{cholmod_factor}, B::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_solve(sys::Cint, L::Ptr{cholmod_factor},
+                                    B::Ptr{cholmod_dense},
+                                    Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_solve(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_solve(arg1::Cint, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_dense}, arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_solve(arg1::Cint, arg2::Ptr{cholmod_factor},
+                                      arg3::Ptr{cholmod_dense},
+                                      arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_solve2(sys, L, B, Bset, X_Handle, Xset_Handle, Y_Handle, E_Handle, Common)
-    @ccall libcholmod.cholmod_solve2(sys::Cint, L::Ptr{cholmod_factor}, B::Ptr{cholmod_dense}, Bset::Ptr{cholmod_sparse}, X_Handle::Ptr{Ptr{cholmod_dense}}, Xset_Handle::Ptr{Ptr{cholmod_sparse}}, Y_Handle::Ptr{Ptr{cholmod_dense}}, E_Handle::Ptr{Ptr{cholmod_dense}}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_solve2(sys::Cint, L::Ptr{cholmod_factor},
+                                     B::Ptr{cholmod_dense}, Bset::Ptr{cholmod_sparse},
+                                     X_Handle::Ptr{Ptr{cholmod_dense}},
+                                     Xset_Handle::Ptr{Ptr{cholmod_sparse}},
+                                     Y_Handle::Ptr{Ptr{cholmod_dense}},
+                                     E_Handle::Ptr{Ptr{cholmod_dense}},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_solve2(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
-    @ccall libcholmod.cholmod_l_solve2(arg1::Cint, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_dense}, arg4::Ptr{cholmod_sparse}, arg5::Ptr{Ptr{cholmod_dense}}, arg6::Ptr{Ptr{cholmod_sparse}}, arg7::Ptr{Ptr{cholmod_dense}}, arg8::Ptr{Ptr{cholmod_dense}}, arg9::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_solve2(arg1::Cint, arg2::Ptr{cholmod_factor},
+                                       arg3::Ptr{cholmod_dense}, arg4::Ptr{cholmod_sparse},
+                                       arg5::Ptr{Ptr{cholmod_dense}},
+                                       arg6::Ptr{Ptr{cholmod_sparse}},
+                                       arg7::Ptr{Ptr{cholmod_dense}},
+                                       arg8::Ptr{Ptr{cholmod_dense}},
+                                       arg9::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_spsolve(sys, L, B, Common)
-    @ccall libcholmod.cholmod_spsolve(sys::Cint, L::Ptr{cholmod_factor}, B::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_spsolve(sys::Cint, L::Ptr{cholmod_factor},
+                                      B::Ptr{cholmod_sparse},
+                                      Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_spsolve(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_spsolve(arg1::Cint, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_sparse}, arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_spsolve(arg1::Cint, arg2::Ptr{cholmod_factor},
+                                        arg3::Ptr{cholmod_sparse},
+                                        arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_etree(A, Parent, Common)
-    @ccall libcholmod.cholmod_etree(A::Ptr{cholmod_sparse}, Parent::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_etree(A::Ptr{cholmod_sparse}, Parent::Ptr{Int32},
+                                    Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_etree(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_etree(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_etree(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                      arg3::Ptr{cholmod_common})::Cint
 end
 
-function cholmod_rowcolcounts(A, fset, fsize, Parent, Post, RowCount, ColCount, First, Level, Common)
-    @ccall libcholmod.cholmod_rowcolcounts(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, Parent::Ptr{Int32}, Post::Ptr{Int32}, RowCount::Ptr{Int32}, ColCount::Ptr{Int32}, First::Ptr{Int32}, Level::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+function cholmod_rowcolcounts(A, fset, fsize, Parent, Post, RowCount, ColCount, First,
+                              Level, Common)
+    @ccall libcholmod.cholmod_rowcolcounts(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                           fsize::Csize_t, Parent::Ptr{Int32},
+                                           Post::Ptr{Int32}, RowCount::Ptr{Int32},
+                                           ColCount::Ptr{Int32}, First::Ptr{Int32},
+                                           Level::Ptr{Int32},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowcolcounts(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)
-    @ccall libcholmod.cholmod_l_rowcolcounts(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{Int64}, arg6::Ptr{Int64}, arg7::Ptr{Int64}, arg8::Ptr{Int64}, arg9::Ptr{Int64}, arg10::Ptr{cholmod_common})::Cint
-end
-
-function cholmod_analyze_ordering(A, ordering, Perm, fset, fsize, Parent, Post, ColCount, First, Level, Common)
-    @ccall libcholmod.cholmod_analyze_ordering(A::Ptr{cholmod_sparse}, ordering::Cint, Perm::Ptr{Int32}, fset::Ptr{Int32}, fsize::Csize_t, Parent::Ptr{Int32}, Post::Ptr{Int32}, ColCount::Ptr{Int32}, First::Ptr{Int32}, Level::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
-end
-
-function cholmod_l_analyze_ordering(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11)
-    @ccall libcholmod.cholmod_l_analyze_ordering(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Csize_t, arg6::Ptr{Int64}, arg7::Ptr{Int64}, arg8::Ptr{Int64}, arg9::Ptr{Int64}, arg10::Ptr{Int64}, arg11::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowcolcounts(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                             arg3::Csize_t, arg4::Ptr{Int64},
+                                             arg5::Ptr{Int64}, arg6::Ptr{Int64},
+                                             arg7::Ptr{Int64}, arg8::Ptr{Int64},
+                                             arg9::Ptr{Int64},
+                                             arg10::Ptr{cholmod_common})::Cint
+end
+
+function cholmod_analyze_ordering(A, ordering, Perm, fset, fsize, Parent, Post, ColCount,
+                                  First, Level, Common)
+    @ccall libcholmod.cholmod_analyze_ordering(A::Ptr{cholmod_sparse}, ordering::Cint,
+                                               Perm::Ptr{Int32}, fset::Ptr{Int32},
+                                               fsize::Csize_t, Parent::Ptr{Int32},
+                                               Post::Ptr{Int32}, ColCount::Ptr{Int32},
+                                               First::Ptr{Int32}, Level::Ptr{Int32},
+                                               Common::Ptr{cholmod_common})::Cint
+end
+
+function cholmod_l_analyze_ordering(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9,
+                                    arg10, arg11)
+    @ccall libcholmod.cholmod_l_analyze_ordering(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                                 arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                                 arg5::Csize_t, arg6::Ptr{Int64},
+                                                 arg7::Ptr{Int64}, arg8::Ptr{Int64},
+                                                 arg9::Ptr{Int64}, arg10::Ptr{Int64},
+                                                 arg11::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_amd(A, fset, fsize, Perm, Common)
-    @ccall libcholmod.cholmod_amd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_amd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t,
+                                  Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_amd(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_amd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_amd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                    arg3::Csize_t, arg4::Ptr{Int64},
+                                    arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_colamd(A, fset, fsize, postorder, Perm, Common)
-    @ccall libcholmod.cholmod_colamd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, postorder::Cint, Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_colamd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                     fsize::Csize_t, postorder::Cint, Perm::Ptr{Int32},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_colamd(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_colamd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Cint, arg5::Ptr{Int64}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_colamd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                       arg3::Csize_t, arg4::Cint, arg5::Ptr{Int64},
+                                       arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowfac(A, F, beta, kstart, kend, L, Common)
-    @ccall libcholmod.cholmod_rowfac(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, beta::Ptr{Cdouble}, kstart::Csize_t, kend::Csize_t, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowfac(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse},
+                                     beta::Ptr{Cdouble}, kstart::Csize_t, kend::Csize_t,
+                                     L::Ptr{cholmod_factor},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowfac(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_rowfac(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Csize_t, arg5::Csize_t, arg6::Ptr{cholmod_factor}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowfac(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse},
+                                       arg3::Ptr{Cdouble}, arg4::Csize_t, arg5::Csize_t,
+                                       arg6::Ptr{cholmod_factor},
+                                       arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowfac_mask(A, F, beta, kstart, kend, mask, RLinkUp, L, Common)
-    @ccall libcholmod.cholmod_rowfac_mask(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, beta::Ptr{Cdouble}, kstart::Csize_t, kend::Csize_t, mask::Ptr{Int32}, RLinkUp::Ptr{Int32}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowfac_mask(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse},
+                                          beta::Ptr{Cdouble}, kstart::Csize_t,
+                                          kend::Csize_t, mask::Ptr{Int32},
+                                          RLinkUp::Ptr{Int32}, L::Ptr{cholmod_factor},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowfac_mask(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
-    @ccall libcholmod.cholmod_l_rowfac_mask(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Csize_t, arg5::Csize_t, arg6::Ptr{Int64}, arg7::Ptr{Int64}, arg8::Ptr{cholmod_factor}, arg9::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowfac_mask(arg1::Ptr{cholmod_sparse},
+                                            arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble},
+                                            arg4::Csize_t, arg5::Csize_t, arg6::Ptr{Int64},
+                                            arg7::Ptr{Int64}, arg8::Ptr{cholmod_factor},
+                                            arg9::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowfac_mask2(A, F, beta, kstart, kend, mask, maskmark, RLinkUp, L, Common)
-    @ccall libcholmod.cholmod_rowfac_mask2(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, beta::Ptr{Cdouble}, kstart::Csize_t, kend::Csize_t, mask::Ptr{Int32}, maskmark::Int32, RLinkUp::Ptr{Int32}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowfac_mask2(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse},
+                                           beta::Ptr{Cdouble}, kstart::Csize_t,
+                                           kend::Csize_t, mask::Ptr{Int32}, maskmark::Int32,
+                                           RLinkUp::Ptr{Int32}, L::Ptr{cholmod_factor},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowfac_mask2(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)
-    @ccall libcholmod.cholmod_l_rowfac_mask2(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Csize_t, arg5::Csize_t, arg6::Ptr{Int64}, arg7::Int64, arg8::Ptr{Int64}, arg9::Ptr{cholmod_factor}, arg10::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowfac_mask2(arg1::Ptr{cholmod_sparse},
+                                             arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble},
+                                             arg4::Csize_t, arg5::Csize_t, arg6::Ptr{Int64},
+                                             arg7::Int64, arg8::Ptr{Int64},
+                                             arg9::Ptr{cholmod_factor},
+                                             arg10::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_row_subtree(A, F, k, Parent, R, Common)
-    @ccall libcholmod.cholmod_row_subtree(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, k::Csize_t, Parent::Ptr{Int32}, R::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_row_subtree(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse},
+                                          k::Csize_t, Parent::Ptr{Int32},
+                                          R::Ptr{cholmod_sparse},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_row_subtree(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_row_subtree(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{cholmod_sparse}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_row_subtree(arg1::Ptr{cholmod_sparse},
+                                            arg2::Ptr{cholmod_sparse}, arg3::Csize_t,
+                                            arg4::Ptr{Int64}, arg5::Ptr{cholmod_sparse},
+                                            arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_lsolve_pattern(B, L, X, Common)
-    @ccall libcholmod.cholmod_lsolve_pattern(B::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_lsolve_pattern(B::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor},
+                                             X::Ptr{cholmod_sparse},
+                                             Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_lsolve_pattern(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_lsolve_pattern(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_sparse}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_lsolve_pattern(arg1::Ptr{cholmod_sparse},
+                                               arg2::Ptr{cholmod_factor},
+                                               arg3::Ptr{cholmod_sparse},
+                                               arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_row_lsubtree(A, Fi, fnz, k, L, R, Common)
-    @ccall libcholmod.cholmod_row_lsubtree(A::Ptr{cholmod_sparse}, Fi::Ptr{Int32}, fnz::Csize_t, k::Csize_t, L::Ptr{cholmod_factor}, R::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_row_lsubtree(A::Ptr{cholmod_sparse}, Fi::Ptr{Int32},
+                                           fnz::Csize_t, k::Csize_t, L::Ptr{cholmod_factor},
+                                           R::Ptr{cholmod_sparse},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_row_lsubtree(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_row_lsubtree(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Csize_t, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_sparse}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_row_lsubtree(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                             arg3::Csize_t, arg4::Csize_t,
+                                             arg5::Ptr{cholmod_factor},
+                                             arg6::Ptr{cholmod_sparse},
+                                             arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_resymbol(A, fset, fsize, pack, L, Common)
-    @ccall libcholmod.cholmod_resymbol(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, pack::Cint, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_resymbol(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                       fsize::Csize_t, pack::Cint, L::Ptr{cholmod_factor},
+                                       Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_resymbol(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_resymbol(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Cint, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_resymbol(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                         arg3::Csize_t, arg4::Cint,
+                                         arg5::Ptr{cholmod_factor},
+                                         arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_resymbol_noperm(A, fset, fsize, pack, L, Common)
-    @ccall libcholmod.cholmod_resymbol_noperm(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, pack::Cint, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_resymbol_noperm(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                              fsize::Csize_t, pack::Cint,
+                                              L::Ptr{cholmod_factor},
+                                              Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_resymbol_noperm(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_resymbol_noperm(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Cint, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_resymbol_noperm(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                                arg3::Csize_t, arg4::Cint,
+                                                arg5::Ptr{cholmod_factor},
+                                                arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rcond(L, Common)
-    @ccall libcholmod.cholmod_rcond(L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cdouble
+    @ccall libcholmod.cholmod_rcond(L::Ptr{cholmod_factor},
+                                    Common::Ptr{cholmod_common})::Cdouble
 end
 
 function cholmod_l_rcond(arg1, arg2)
-    @ccall libcholmod.cholmod_l_rcond(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_common})::Cdouble
+    @ccall libcholmod.cholmod_l_rcond(arg1::Ptr{cholmod_factor},
+                                      arg2::Ptr{cholmod_common})::Cdouble
 end
 
 function cholmod_postorder(Parent, n, Weight_p, Post, Common)
-    @ccall libcholmod.cholmod_postorder(Parent::Ptr{Int32}, n::Csize_t, Weight_p::Ptr{Int32}, Post::Ptr{Int32}, Common::Ptr{cholmod_common})::Int32
+    @ccall libcholmod.cholmod_postorder(Parent::Ptr{Int32}, n::Csize_t,
+                                        Weight_p::Ptr{Int32}, Post::Ptr{Int32},
+                                        Common::Ptr{cholmod_common})::Int32
 end
 
 function cholmod_l_postorder(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_postorder(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_l_postorder(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Ptr{Int64},
+                                          arg4::Ptr{Int64},
+                                          arg5::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_drop(tol, A, Common)
-    @ccall libcholmod.cholmod_drop(tol::Cdouble, A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_drop(tol::Cdouble, A::Ptr{cholmod_sparse},
+                                   Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_drop(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_drop(arg1::Cdouble, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_drop(arg1::Cdouble, arg2::Ptr{cholmod_sparse},
+                                     arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_norm_dense(X, norm, Common)
-    @ccall libcholmod.cholmod_norm_dense(X::Ptr{cholmod_dense}, norm::Cint, Common::Ptr{cholmod_common})::Cdouble
+    @ccall libcholmod.cholmod_norm_dense(X::Ptr{cholmod_dense}, norm::Cint,
+                                         Common::Ptr{cholmod_common})::Cdouble
 end
 
 function cholmod_l_norm_dense(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_norm_dense(arg1::Ptr{cholmod_dense}, arg2::Cint, arg3::Ptr{cholmod_common})::Cdouble
+    @ccall libcholmod.cholmod_l_norm_dense(arg1::Ptr{cholmod_dense}, arg2::Cint,
+                                           arg3::Ptr{cholmod_common})::Cdouble
 end
 
 function cholmod_norm_sparse(A, norm, Common)
-    @ccall libcholmod.cholmod_norm_sparse(A::Ptr{cholmod_sparse}, norm::Cint, Common::Ptr{cholmod_common})::Cdouble
+    @ccall libcholmod.cholmod_norm_sparse(A::Ptr{cholmod_sparse}, norm::Cint,
+                                          Common::Ptr{cholmod_common})::Cdouble
 end
 
 function cholmod_l_norm_sparse(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_norm_sparse(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{cholmod_common})::Cdouble
+    @ccall libcholmod.cholmod_l_norm_sparse(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                            arg3::Ptr{cholmod_common})::Cdouble
 end
 
 function cholmod_horzcat(A, B, values, Common)
-    @ccall libcholmod.cholmod_horzcat(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse}, values::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_horzcat(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse},
+                                      values::Cint,
+                                      Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_horzcat(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_horzcat(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_horzcat(arg1::Ptr{cholmod_sparse},
+                                        arg2::Ptr{cholmod_sparse}, arg3::Cint,
+                                        arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_scale(S, scale, A, Common)
-    @ccall libcholmod.cholmod_scale(S::Ptr{cholmod_dense}, scale::Cint, A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_scale(S::Ptr{cholmod_dense}, scale::Cint,
+                                    A::Ptr{cholmod_sparse},
+                                    Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_scale(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_scale(arg1::Ptr{cholmod_dense}, arg2::Cint, arg3::Ptr{cholmod_sparse}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_scale(arg1::Ptr{cholmod_dense}, arg2::Cint,
+                                      arg3::Ptr{cholmod_sparse},
+                                      arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_sdmult(A, transpose, alpha, beta, X, Y, Common)
-    @ccall libcholmod.cholmod_sdmult(A::Ptr{cholmod_sparse}, transpose::Cint, alpha::Ptr{Cdouble}, beta::Ptr{Cdouble}, X::Ptr{cholmod_dense}, Y::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_sdmult(A::Ptr{cholmod_sparse}, transpose::Cint,
+                                     alpha::Ptr{Cdouble}, beta::Ptr{Cdouble},
+                                     X::Ptr{cholmod_dense}, Y::Ptr{cholmod_dense},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_sdmult(arg1, arg2, arg3, arg4, arg5, Y, arg7)
-    @ccall libcholmod.cholmod_l_sdmult(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{Cdouble}, arg4::Ptr{Cdouble}, arg5::Ptr{cholmod_dense}, Y::Ptr{cholmod_dense}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_sdmult(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                       arg3::Ptr{Cdouble}, arg4::Ptr{Cdouble},
+                                       arg5::Ptr{cholmod_dense}, Y::Ptr{cholmod_dense},
+                                       arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_ssmult(A, B, stype, values, sorted, Common)
-    @ccall libcholmod.cholmod_ssmult(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse}, stype::Cint, values::Cint, sorted::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_ssmult(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse},
+                                     stype::Cint, values::Cint, sorted::Cint,
+                                     Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_ssmult(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_ssmult(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Cint, arg4::Cint, arg5::Cint, arg6::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_ssmult(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse},
+                                       arg3::Cint, arg4::Cint, arg5::Cint,
+                                       arg6::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_submatrix(A, rset, rsize, cset, csize, values, sorted, Common)
-    @ccall libcholmod.cholmod_submatrix(A::Ptr{cholmod_sparse}, rset::Ptr{Int32}, rsize::Int64, cset::Ptr{Int32}, csize::Int64, values::Cint, sorted::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_submatrix(A::Ptr{cholmod_sparse}, rset::Ptr{Int32},
+                                        rsize::Int64, cset::Ptr{Int32}, csize::Int64,
+                                        values::Cint, sorted::Cint,
+                                        Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_submatrix(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
-    @ccall libcholmod.cholmod_l_submatrix(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Int64, arg4::Ptr{Int64}, arg5::Int64, arg6::Cint, arg7::Cint, arg8::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_submatrix(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                          arg3::Int64, arg4::Ptr{Int64}, arg5::Int64,
+                                          arg6::Cint, arg7::Cint,
+                                          arg8::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_vertcat(A, B, values, Common)
-    @ccall libcholmod.cholmod_vertcat(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse}, values::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_vertcat(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse},
+                                      values::Cint,
+                                      Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_vertcat(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_vertcat(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_vertcat(arg1::Ptr{cholmod_sparse},
+                                        arg2::Ptr{cholmod_sparse}, arg3::Cint,
+                                        arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_symmetry(A, option, xmatched, pmatched, nzoffdiag, nzdiag, Common)
-    @ccall libcholmod.cholmod_symmetry(A::Ptr{cholmod_sparse}, option::Cint, xmatched::Ptr{Int32}, pmatched::Ptr{Int32}, nzoffdiag::Ptr{Int32}, nzdiag::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_symmetry(A::Ptr{cholmod_sparse}, option::Cint,
+                                       xmatched::Ptr{Int32}, pmatched::Ptr{Int32},
+                                       nzoffdiag::Ptr{Int32}, nzdiag::Ptr{Int32},
+                                       Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_symmetry(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_symmetry(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Ptr{Int64}, arg6::Ptr{Int64}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_symmetry(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                         arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                         arg5::Ptr{Int64}, arg6::Ptr{Int64},
+                                         arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_updown(update, C, L, Common)
-    @ccall libcholmod.cholmod_updown(update::Cint, C::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_updown(update::Cint, C::Ptr{cholmod_sparse},
+                                     L::Ptr{cholmod_factor},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_updown(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_updown(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_factor}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_updown(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                       arg3::Ptr{cholmod_factor},
+                                       arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_updown_solve(update, C, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_updown_solve(update::Cint, C::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_updown_solve(update::Cint, C::Ptr{cholmod_sparse},
+                                           L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense},
+                                           DeltaB::Ptr{cholmod_dense},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_updown_solve(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_updown_solve(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_factor}, arg4::Ptr{cholmod_dense}, arg5::Ptr{cholmod_dense}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_updown_solve(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                             arg3::Ptr{cholmod_factor},
+                                             arg4::Ptr{cholmod_dense},
+                                             arg5::Ptr{cholmod_dense},
+                                             arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_updown_mark(update, C, colmark, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_updown_mark(update::Cint, C::Ptr{cholmod_sparse}, colmark::Ptr{Int32}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_updown_mark(update::Cint, C::Ptr{cholmod_sparse},
+                                          colmark::Ptr{Int32}, L::Ptr{cholmod_factor},
+                                          X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_updown_mark(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_updown_mark(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Int64}, arg4::Ptr{cholmod_factor}, arg5::Ptr{cholmod_dense}, arg6::Ptr{cholmod_dense}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_updown_mark(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                            arg3::Ptr{Int64}, arg4::Ptr{cholmod_factor},
+                                            arg5::Ptr{cholmod_dense},
+                                            arg6::Ptr{cholmod_dense},
+                                            arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_updown_mask(update, C, colmark, mask, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_updown_mask(update::Cint, C::Ptr{cholmod_sparse}, colmark::Ptr{Int32}, mask::Ptr{Int32}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_updown_mask(update::Cint, C::Ptr{cholmod_sparse},
+                                          colmark::Ptr{Int32}, mask::Ptr{Int32},
+                                          L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense},
+                                          DeltaB::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_updown_mask(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
-    @ccall libcholmod.cholmod_l_updown_mask(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_dense}, arg7::Ptr{cholmod_dense}, arg8::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_updown_mask(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                            arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                            arg5::Ptr{cholmod_factor},
+                                            arg6::Ptr{cholmod_dense},
+                                            arg7::Ptr{cholmod_dense},
+                                            arg8::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_updown_mask2(update, C, colmark, mask, maskmark, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_updown_mask2(update::Cint, C::Ptr{cholmod_sparse}, colmark::Ptr{Int32}, mask::Ptr{Int32}, maskmark::Int32, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_updown_mask2(update::Cint, C::Ptr{cholmod_sparse},
+                                           colmark::Ptr{Int32}, mask::Ptr{Int32},
+                                           maskmark::Int32, L::Ptr{cholmod_factor},
+                                           X::Ptr{cholmod_dense},
+                                           DeltaB::Ptr{cholmod_dense},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_updown_mask2(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
-    @ccall libcholmod.cholmod_l_updown_mask2(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Int64, arg6::Ptr{cholmod_factor}, arg7::Ptr{cholmod_dense}, arg8::Ptr{cholmod_dense}, arg9::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_updown_mask2(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                             arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                             arg5::Int64, arg6::Ptr{cholmod_factor},
+                                             arg7::Ptr{cholmod_dense},
+                                             arg8::Ptr{cholmod_dense},
+                                             arg9::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowadd(k, R, L, Common)
-    @ccall libcholmod.cholmod_rowadd(k::Csize_t, R::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowadd(k::Csize_t, R::Ptr{cholmod_sparse},
+                                     L::Ptr{cholmod_factor},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowadd(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_rowadd(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_factor}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowadd(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                       arg3::Ptr{cholmod_factor},
+                                       arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowadd_solve(k, R, bk, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_rowadd_solve(k::Csize_t, R::Ptr{cholmod_sparse}, bk::Ptr{Cdouble}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowadd_solve(k::Csize_t, R::Ptr{cholmod_sparse},
+                                           bk::Ptr{Cdouble}, L::Ptr{cholmod_factor},
+                                           X::Ptr{cholmod_dense},
+                                           DeltaB::Ptr{cholmod_dense},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowadd_solve(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_rowadd_solve(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Ptr{cholmod_factor}, arg5::Ptr{cholmod_dense}, arg6::Ptr{cholmod_dense}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowadd_solve(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                             arg3::Ptr{Cdouble}, arg4::Ptr{cholmod_factor},
+                                             arg5::Ptr{cholmod_dense},
+                                             arg6::Ptr{cholmod_dense},
+                                             arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowadd_mark(k, R, bk, colmark, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_rowadd_mark(k::Csize_t, R::Ptr{cholmod_sparse}, bk::Ptr{Cdouble}, colmark::Ptr{Int32}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowadd_mark(k::Csize_t, R::Ptr{cholmod_sparse},
+                                          bk::Ptr{Cdouble}, colmark::Ptr{Int32},
+                                          L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense},
+                                          DeltaB::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowadd_mark(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
-    @ccall libcholmod.cholmod_l_rowadd_mark(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Ptr{Int64}, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_dense}, arg7::Ptr{cholmod_dense}, arg8::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowadd_mark(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                            arg3::Ptr{Cdouble}, arg4::Ptr{Int64},
+                                            arg5::Ptr{cholmod_factor},
+                                            arg6::Ptr{cholmod_dense},
+                                            arg7::Ptr{cholmod_dense},
+                                            arg8::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowdel(k, R, L, Common)
-    @ccall libcholmod.cholmod_rowdel(k::Csize_t, R::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowdel(k::Csize_t, R::Ptr{cholmod_sparse},
+                                     L::Ptr{cholmod_factor},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowdel(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_rowdel(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_factor}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowdel(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                       arg3::Ptr{cholmod_factor},
+                                       arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowdel_solve(k, R, yk, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_rowdel_solve(k::Csize_t, R::Ptr{cholmod_sparse}, yk::Ptr{Cdouble}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowdel_solve(k::Csize_t, R::Ptr{cholmod_sparse},
+                                           yk::Ptr{Cdouble}, L::Ptr{cholmod_factor},
+                                           X::Ptr{cholmod_dense},
+                                           DeltaB::Ptr{cholmod_dense},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowdel_solve(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_rowdel_solve(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Ptr{cholmod_factor}, arg5::Ptr{cholmod_dense}, arg6::Ptr{cholmod_dense}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowdel_solve(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                             arg3::Ptr{Cdouble}, arg4::Ptr{cholmod_factor},
+                                             arg5::Ptr{cholmod_dense},
+                                             arg6::Ptr{cholmod_dense},
+                                             arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowdel_mark(k, R, yk, colmark, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_rowdel_mark(k::Csize_t, R::Ptr{cholmod_sparse}, yk::Ptr{Cdouble}, colmark::Ptr{Int32}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowdel_mark(k::Csize_t, R::Ptr{cholmod_sparse},
+                                          yk::Ptr{Cdouble}, colmark::Ptr{Int32},
+                                          L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense},
+                                          DeltaB::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowdel_mark(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
-    @ccall libcholmod.cholmod_l_rowdel_mark(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Ptr{Int64}, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_dense}, arg7::Ptr{cholmod_dense}, arg8::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowdel_mark(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                            arg3::Ptr{Cdouble}, arg4::Ptr{Int64},
+                                            arg5::Ptr{cholmod_factor},
+                                            arg6::Ptr{cholmod_dense},
+                                            arg7::Ptr{cholmod_dense},
+                                            arg8::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_ccolamd(A, fset, fsize, Cmember, Perm, Common)
-    @ccall libcholmod.cholmod_ccolamd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, Cmember::Ptr{Int32}, Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_ccolamd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                      fsize::Csize_t, Cmember::Ptr{Int32}, Perm::Ptr{Int32},
+                                      Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_ccolamd(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_ccolamd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{Int64}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_ccolamd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                        arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{Int64},
+                                        arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_csymamd(A, Cmember, Perm, Common)
-    @ccall libcholmod.cholmod_csymamd(A::Ptr{cholmod_sparse}, Cmember::Ptr{Int32}, Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_csymamd(A::Ptr{cholmod_sparse}, Cmember::Ptr{Int32},
+                                      Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_csymamd(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_csymamd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Ptr{Int64}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_csymamd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                        arg3::Ptr{Int64}, arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_camd(A, fset, fsize, Cmember, Perm, Common)
-    @ccall libcholmod.cholmod_camd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, Cmember::Ptr{Int32}, Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_camd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t,
+                                   Cmember::Ptr{Int32}, Perm::Ptr{Int32},
+                                   Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_camd(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_camd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{Int64}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_camd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                     arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{Int64},
+                                     arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_nested_dissection(A, fset, fsize, Perm, CParent, Cmember, Common)
-    @ccall libcholmod.cholmod_nested_dissection(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, Perm::Ptr{Int32}, CParent::Ptr{Int32}, Cmember::Ptr{Int32}, Common::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_nested_dissection(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                                fsize::Csize_t, Perm::Ptr{Int32},
+                                                CParent::Ptr{Int32}, Cmember::Ptr{Int32},
+                                                Common::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_l_nested_dissection(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_nested_dissection(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{Int64}, arg6::Ptr{Int64}, arg7::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_l_nested_dissection(arg1::Ptr{cholmod_sparse},
+                                                  arg2::Ptr{Int64}, arg3::Csize_t,
+                                                  arg4::Ptr{Int64}, arg5::Ptr{Int64},
+                                                  arg6::Ptr{Int64},
+                                                  arg7::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_metis(A, fset, fsize, postorder, Perm, Common)
-    @ccall libcholmod.cholmod_metis(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, postorder::Cint, Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_metis(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                    fsize::Csize_t, postorder::Cint, Perm::Ptr{Int32},
+                                    Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_metis(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_metis(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Cint, arg5::Ptr{Int64}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_metis(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                      arg3::Csize_t, arg4::Cint, arg5::Ptr{Int64},
+                                      arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_bisect(A, fset, fsize, compress, Partition, Common)
-    @ccall libcholmod.cholmod_bisect(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, compress::Cint, Partition::Ptr{Int32}, Common::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_bisect(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                     fsize::Csize_t, compress::Cint, Partition::Ptr{Int32},
+                                     Common::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_l_bisect(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_bisect(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Cint, arg5::Ptr{Int64}, arg6::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_l_bisect(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                       arg3::Csize_t, arg4::Cint, arg5::Ptr{Int64},
+                                       arg6::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_metis_bisector(A, Anw, Aew, Partition, Common)
-    @ccall libcholmod.cholmod_metis_bisector(A::Ptr{cholmod_sparse}, Anw::Ptr{Int32}, Aew::Ptr{Int32}, Partition::Ptr{Int32}, Common::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_metis_bisector(A::Ptr{cholmod_sparse}, Anw::Ptr{Int32},
+                                             Aew::Ptr{Int32}, Partition::Ptr{Int32},
+                                             Common::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_l_metis_bisector(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_metis_bisector(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_l_metis_bisector(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                               arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                               arg5::Ptr{cholmod_common})::Int64
 end
 
-function cholmod_collapse_septree(n, ncomponents, nd_oksep, nd_small, CParent, Cmember, Common)
-    @ccall libcholmod.cholmod_collapse_septree(n::Csize_t, ncomponents::Csize_t, nd_oksep::Cdouble, nd_small::Csize_t, CParent::Ptr{Int32}, Cmember::Ptr{Int32}, Common::Ptr{cholmod_common})::Int64
+function cholmod_collapse_septree(n, ncomponents, nd_oksep, nd_small, CParent, Cmember,
+                                  Common)
+    @ccall libcholmod.cholmod_collapse_septree(n::Csize_t, ncomponents::Csize_t,
+                                               nd_oksep::Cdouble, nd_small::Csize_t,
+                                               CParent::Ptr{Int32}, Cmember::Ptr{Int32},
+                                               Common::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_l_collapse_septree(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_collapse_septree(arg1::Csize_t, arg2::Csize_t, arg3::Cdouble, arg4::Csize_t, arg5::Ptr{Int64}, arg6::Ptr{Int64}, arg7::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_l_collapse_septree(arg1::Csize_t, arg2::Csize_t,
+                                                 arg3::Cdouble, arg4::Csize_t,
+                                                 arg5::Ptr{Int64}, arg6::Ptr{Int64},
+                                                 arg7::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_super_symbolic(A, F, Parent, L, Common)
-    @ccall libcholmod.cholmod_super_symbolic(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, Parent::Ptr{Int32}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_super_symbolic(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse},
+                                             Parent::Ptr{Int32}, L::Ptr{cholmod_factor},
+                                             Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_super_symbolic(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_super_symbolic(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Int64}, arg4::Ptr{cholmod_factor}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_super_symbolic(arg1::Ptr{cholmod_sparse},
+                                               arg2::Ptr{cholmod_sparse}, arg3::Ptr{Int64},
+                                               arg4::Ptr{cholmod_factor},
+                                               arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_super_symbolic2(for_whom, A, F, Parent, L, Common)
-    @ccall libcholmod.cholmod_super_symbolic2(for_whom::Cint, A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, Parent::Ptr{Int32}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_super_symbolic2(for_whom::Cint, A::Ptr{cholmod_sparse},
+                                              F::Ptr{cholmod_sparse}, Parent::Ptr{Int32},
+                                              L::Ptr{cholmod_factor},
+                                              Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_super_symbolic2(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_super_symbolic2(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_sparse}, arg4::Ptr{Int64}, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_super_symbolic2(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                                arg3::Ptr{cholmod_sparse}, arg4::Ptr{Int64},
+                                                arg5::Ptr{cholmod_factor},
+                                                arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_super_numeric(A, F, beta, L, Common)
-    @ccall libcholmod.cholmod_super_numeric(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, beta::Ptr{Cdouble}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_super_numeric(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse},
+                                            beta::Ptr{Cdouble}, L::Ptr{cholmod_factor},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_super_numeric(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_super_numeric(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Ptr{cholmod_factor}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_super_numeric(arg1::Ptr{cholmod_sparse},
+                                              arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble},
+                                              arg4::Ptr{cholmod_factor},
+                                              arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_super_lsolve(L, X, E, Common)
-    @ccall libcholmod.cholmod_super_lsolve(L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, E::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_super_lsolve(L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense},
+                                           E::Ptr{cholmod_dense},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_super_lsolve(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_super_lsolve(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_dense}, arg3::Ptr{cholmod_dense}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_super_lsolve(arg1::Ptr{cholmod_factor},
+                                             arg2::Ptr{cholmod_dense},
+                                             arg3::Ptr{cholmod_dense},
+                                             arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_super_ltsolve(L, X, E, Common)
-    @ccall libcholmod.cholmod_super_ltsolve(L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, E::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_super_ltsolve(L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense},
+                                            E::Ptr{cholmod_dense},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_super_ltsolve(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_super_ltsolve(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_dense}, arg3::Ptr{cholmod_dense}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_super_ltsolve(arg1::Ptr{cholmod_factor},
+                                              arg2::Ptr{cholmod_dense},
+                                              arg3::Ptr{cholmod_dense},
+                                              arg4::Ptr{cholmod_common})::Cint
+end
+
+function SuiteSparseQR_C(ordering, tol, econ, getCTX, A, Bsparse, Bdense, Zsparse, Zdense,
+                         R, E, H, HPinv, HTau, cc)
+    @ccall libspqr.SuiteSparseQR_C(ordering::Cint, tol::Cdouble, econ::Int64, getCTX::Cint,
+                                   A::Ptr{cholmod_sparse}, Bsparse::Ptr{cholmod_sparse},
+                                   Bdense::Ptr{cholmod_dense},
+                                   Zsparse::Ptr{Ptr{cholmod_sparse}},
+                                   Zdense::Ptr{Ptr{cholmod_dense}},
+                                   R::Ptr{Ptr{cholmod_sparse}}, E::Ptr{Ptr{Int64}},
+                                   H::Ptr{Ptr{cholmod_sparse}}, HPinv::Ptr{Ptr{Int64}},
+                                   HTau::Ptr{Ptr{cholmod_dense}},
+                                   cc::Ptr{cholmod_common})::Int64
+end
+
+function SuiteSparseQR_i_C(ordering, tol, econ, getCTX, A, Bsparse, Bdense, Zsparse, Zdense,
+                           R, E, H, HPinv, HTau, cc)
+    @ccall libspqr.SuiteSparseQR_i_C(ordering::Cint, tol::Cdouble, econ::Int32,
+                                     getCTX::Cint, A::Ptr{cholmod_sparse},
+                                     Bsparse::Ptr{cholmod_sparse},
+                                     Bdense::Ptr{cholmod_dense},
+                                     Zsparse::Ptr{Ptr{cholmod_sparse}},
+                                     Zdense::Ptr{Ptr{cholmod_dense}},
+                                     R::Ptr{Ptr{cholmod_sparse}}, E::Ptr{Ptr{Int32}},
+                                     H::Ptr{Ptr{cholmod_sparse}}, HPinv::Ptr{Ptr{Int32}},
+                                     HTau::Ptr{Ptr{cholmod_dense}},
+                                     cc::Ptr{cholmod_common})::Int32
 end
 
-function SuiteSparseQR_C(ordering, tol, econ, getCTX, A, Bsparse, Bdense, Zsparse, Zdense, R, E, H, HPinv, HTau, cc)
-    @ccall libspqr.SuiteSparseQR_C(ordering::Cint, tol::Cdouble, econ::Int64, getCTX::Cint, A::Ptr{cholmod_sparse}, Bsparse::Ptr{cholmod_sparse}, Bdense::Ptr{cholmod_dense}, Zsparse::Ptr{Ptr{cholmod_sparse}}, Zdense::Ptr{Ptr{cholmod_dense}}, R::Ptr{Ptr{cholmod_sparse}}, E::Ptr{Ptr{Int64}}, H::Ptr{Ptr{cholmod_sparse}}, HPinv::Ptr{Ptr{Int64}}, HTau::Ptr{Ptr{cholmod_dense}}, cc::Ptr{cholmod_common})::Int64
+function SuiteSparseQR_C_QR(ordering, tol, econ, A, Q, R, E, cc)
+    @ccall libspqr.SuiteSparseQR_C_QR(ordering::Cint, tol::Cdouble, econ::Int64,
+                                      A::Ptr{cholmod_sparse}, Q::Ptr{Ptr{cholmod_sparse}},
+                                      R::Ptr{Ptr{cholmod_sparse}}, E::Ptr{Ptr{Int64}},
+                                      cc::Ptr{cholmod_common})::Int64
 end
 
-function SuiteSparseQR_C_QR(ordering, tol, econ, A, Q, R, E, cc)
-    @ccall libspqr.SuiteSparseQR_C_QR(ordering::Cint, tol::Cdouble, econ::Int64, A::Ptr{cholmod_sparse}, Q::Ptr{Ptr{cholmod_sparse}}, R::Ptr{Ptr{cholmod_sparse}}, E::Ptr{Ptr{Int64}}, cc::Ptr{cholmod_common})::Int64
+function SuiteSparseQR_i_C_QR(ordering, tol, econ, A, Q, R, E, cc)
+    @ccall libspqr.SuiteSparseQR_i_C_QR(ordering::Cint, tol::Cdouble, econ::Int32,
+                                        A::Ptr{cholmod_sparse}, Q::Ptr{Ptr{cholmod_sparse}},
+                                        R::Ptr{Ptr{cholmod_sparse}}, E::Ptr{Ptr{Int32}},
+                                        cc::Ptr{cholmod_common})::Int32
 end
 
 function SuiteSparseQR_C_backslash(ordering, tol, A, B, cc)
-    @ccall libspqr.SuiteSparseQR_C_backslash(ordering::Cint, tol::Cdouble, A::Ptr{cholmod_sparse}, B::Ptr{cholmod_dense}, cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libspqr.SuiteSparseQR_C_backslash(ordering::Cint, tol::Cdouble,
+                                             A::Ptr{cholmod_sparse}, B::Ptr{cholmod_dense},
+                                             cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function SuiteSparseQR_C_backslash_default(A, B, cc)
-    @ccall libspqr.SuiteSparseQR_C_backslash_default(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_dense}, cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libspqr.SuiteSparseQR_C_backslash_default(A::Ptr{cholmod_sparse},
+                                                     B::Ptr{cholmod_dense},
+                                                     cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function SuiteSparseQR_C_backslash_sparse(ordering, tol, A, B, cc)
-    @ccall libspqr.SuiteSparseQR_C_backslash_sparse(ordering::Cint, tol::Cdouble, A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse}, cc::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libspqr.SuiteSparseQR_C_backslash_sparse(ordering::Cint, tol::Cdouble,
+                                                    A::Ptr{cholmod_sparse},
+                                                    B::Ptr{cholmod_sparse},
+                                                    cc::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 mutable struct SuiteSparseQR_C_factorization_struct
     xtype::Cint
+    itype::Cint
     factors::Ptr{Cvoid}
     SuiteSparseQR_C_factorization_struct() = new()
 end
@@ -1536,51 +2115,78 @@ end
 const SuiteSparseQR_C_factorization = SuiteSparseQR_C_factorization_struct
 
 function SuiteSparseQR_C_factorize(ordering, tol, A, cc)
-    @ccall libspqr.SuiteSparseQR_C_factorize(ordering::Cint, tol::Cdouble, A::Ptr{cholmod_sparse}, cc::Ptr{cholmod_common})::Ptr{SuiteSparseQR_C_factorization}
+    @ccall libspqr.SuiteSparseQR_C_factorize(ordering::Cint, tol::Cdouble,
+                                             A::Ptr{cholmod_sparse},
+                                             cc::Ptr{cholmod_common})::Ptr{SuiteSparseQR_C_factorization}
 end
 
 function SuiteSparseQR_C_symbolic(ordering, allow_tol, A, cc)
-    @ccall libspqr.SuiteSparseQR_C_symbolic(ordering::Cint, allow_tol::Cint, A::Ptr{cholmod_sparse}, cc::Ptr{cholmod_common})::Ptr{SuiteSparseQR_C_factorization}
+    @ccall libspqr.SuiteSparseQR_C_symbolic(ordering::Cint, allow_tol::Cint,
+                                            A::Ptr{cholmod_sparse},
+                                            cc::Ptr{cholmod_common})::Ptr{SuiteSparseQR_C_factorization}
 end
 
 function SuiteSparseQR_C_numeric(tol, A, QR, cc)
-    @ccall libspqr.SuiteSparseQR_C_numeric(tol::Cdouble, A::Ptr{cholmod_sparse}, QR::Ptr{SuiteSparseQR_C_factorization}, cc::Ptr{cholmod_common})::Cint
+    @ccall libspqr.SuiteSparseQR_C_numeric(tol::Cdouble, A::Ptr{cholmod_sparse},
+                                           QR::Ptr{SuiteSparseQR_C_factorization},
+                                           cc::Ptr{cholmod_common})::Cint
 end
 
 function SuiteSparseQR_C_free(QR, cc)
-    @ccall libspqr.SuiteSparseQR_C_free(QR::Ptr{Ptr{SuiteSparseQR_C_factorization}}, cc::Ptr{cholmod_common})::Cint
+    @ccall libspqr.SuiteSparseQR_C_free(QR::Ptr{Ptr{SuiteSparseQR_C_factorization}},
+                                        cc::Ptr{cholmod_common})::Cint
 end
 
 function SuiteSparseQR_C_solve(system, QR, B, cc)
-    @ccall libspqr.SuiteSparseQR_C_solve(system::Cint, QR::Ptr{SuiteSparseQR_C_factorization}, B::Ptr{cholmod_dense}, cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libspqr.SuiteSparseQR_C_solve(system::Cint,
+                                         QR::Ptr{SuiteSparseQR_C_factorization},
+                                         B::Ptr{cholmod_dense},
+                                         cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function SuiteSparseQR_C_qmult(method, QR, X, cc)
-    @ccall libspqr.SuiteSparseQR_C_qmult(method::Cint, QR::Ptr{SuiteSparseQR_C_factorization}, X::Ptr{cholmod_dense}, cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libspqr.SuiteSparseQR_C_qmult(method::Cint,
+                                         QR::Ptr{SuiteSparseQR_C_factorization},
+                                         X::Ptr{cholmod_dense},
+                                         cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function amd_order(n, Ap, Ai, P, Control, Info)
-    @ccall libamd.amd_order(n::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, P::Ptr{Int32}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libamd.amd_order(n::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, P::Ptr{Int32},
+                            Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function amd_l_order(n, Ap, Ai, P, Control, Info)
-    @ccall libamd.amd_l_order(n::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, P::Ptr{Int64}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libamd.amd_l_order(n::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, P::Ptr{Int64},
+                              Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
-function amd_2(n, Pe, Iw, Len, iwlen, pfree, Nv, Next, Last, Head, Elen, Degree, W, Control, Info)
-    @ccall libamd.amd_2(n::Int32, Pe::Ptr{Int32}, Iw::Ptr{Int32}, Len::Ptr{Int32}, iwlen::Int32, pfree::Int32, Nv::Ptr{Int32}, Next::Ptr{Int32}, Last::Ptr{Int32}, Head::Ptr{Int32}, Elen::Ptr{Int32}, Degree::Ptr{Int32}, W::Ptr{Int32}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cvoid
+function amd_2(n, Pe, Iw, Len, iwlen, pfree, Nv, Next, Last, Head, Elen, Degree, W, Control,
+               Info)
+    @ccall libamd.amd_2(n::Int32, Pe::Ptr{Int32}, Iw::Ptr{Int32}, Len::Ptr{Int32},
+                        iwlen::Int32, pfree::Int32, Nv::Ptr{Int32}, Next::Ptr{Int32},
+                        Last::Ptr{Int32}, Head::Ptr{Int32}, Elen::Ptr{Int32},
+                        Degree::Ptr{Int32}, W::Ptr{Int32}, Control::Ptr{Cdouble},
+                        Info::Ptr{Cdouble})::Cvoid
 end
 
-function amd_l2(n, Pe, Iw, Len, iwlen, pfree, Nv, Next, Last, Head, Elen, Degree, W, Control, Info)
-    @ccall libamd.amd_l2(n::Int64, Pe::Ptr{Int64}, Iw::Ptr{Int64}, Len::Ptr{Int64}, iwlen::Int64, pfree::Int64, Nv::Ptr{Int64}, Next::Ptr{Int64}, Last::Ptr{Int64}, Head::Ptr{Int64}, Elen::Ptr{Int64}, Degree::Ptr{Int64}, W::Ptr{Int64}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cvoid
+function amd_l2(n, Pe, Iw, Len, iwlen, pfree, Nv, Next, Last, Head, Elen, Degree, W,
+                Control, Info)
+    @ccall libamd.amd_l2(n::Int64, Pe::Ptr{Int64}, Iw::Ptr{Int64}, Len::Ptr{Int64},
+                         iwlen::Int64, pfree::Int64, Nv::Ptr{Int64}, Next::Ptr{Int64},
+                         Last::Ptr{Int64}, Head::Ptr{Int64}, Elen::Ptr{Int64},
+                         Degree::Ptr{Int64}, W::Ptr{Int64}, Control::Ptr{Cdouble},
+                         Info::Ptr{Cdouble})::Cvoid
 end
 
 function amd_valid(n_row, n_col, Ap, Ai)
-    @ccall libamd.amd_valid(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32})::Cint
+    @ccall libamd.amd_valid(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                            Ai::Ptr{Int32})::Cint
 end
 
 function amd_l_valid(n_row, n_col, Ap, Ai)
-    @ccall libamd.amd_l_valid(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64})::Cint
+    @ccall libamd.amd_l_valid(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                              Ai::Ptr{Int64})::Cint
 end
 
 function amd_defaults(Control)
@@ -1607,188 +2213,88 @@ function amd_l_info(Info)
     @ccall libamd.amd_l_info(Info::Ptr{Cdouble})::Cvoid
 end
 
-function colamd_recommended(nnz, n_row, n_col)
-    @ccall libcolamd.colamd_recommended(nnz::Int32, n_row::Int32, n_col::Int32)::Csize_t
-end
-
-function colamd_l_recommended(nnz, n_row, n_col)
-    @ccall libcolamd.colamd_l_recommended(nnz::Int64, n_row::Int64, n_col::Int64)::Csize_t
-end
-
-function colamd_set_defaults(knobs)
-    @ccall libcolamd.colamd_set_defaults(knobs::Ptr{Cdouble})::Cvoid
-end
-
-function colamd_l_set_defaults(knobs)
-    @ccall libcolamd.colamd_l_set_defaults(knobs::Ptr{Cdouble})::Cvoid
-end
-
-function colamd(n_row, n_col, Alen, A, p, knobs, stats)
-    @ccall libcolamd.colamd(n_row::Int32, n_col::Int32, Alen::Int32, A::Ptr{Int32}, p::Ptr{Int32}, knobs::Ptr{Cdouble}, stats::Ptr{Int32})::Cint
-end
-
-function colamd_l(n_row, n_col, Alen, A, p, knobs, stats)
-    @ccall libcolamd.colamd_l(n_row::Int64, n_col::Int64, Alen::Int64, A::Ptr{Int64}, p::Ptr{Int64}, knobs::Ptr{Cdouble}, stats::Ptr{Int64})::Cint
-end
-
-function symamd(n, A, p, perm, knobs, stats, allocate, release)
-    @ccall libcolamd.symamd(n::Int32, A::Ptr{Int32}, p::Ptr{Int32}, perm::Ptr{Int32}, knobs::Ptr{Cdouble}, stats::Ptr{Int32}, allocate::Ptr{Cvoid}, release::Ptr{Cvoid})::Cint
-end
-
-function symamd_l(n, A, p, perm, knobs, stats, allocate, release)
-    @ccall libcolamd.symamd_l(n::Int64, A::Ptr{Int64}, p::Ptr{Int64}, perm::Ptr{Int64}, knobs::Ptr{Cdouble}, stats::Ptr{Int64}, allocate::Ptr{Cvoid}, release::Ptr{Cvoid})::Cint
-end
-
-function colamd_report(stats)
-    @ccall libcolamd.colamd_report(stats::Ptr{Int32})::Cvoid
-end
-
-function colamd_l_report(stats)
-    @ccall libcolamd.colamd_l_report(stats::Ptr{Int64})::Cvoid
-end
-
-function symamd_report(stats)
-    @ccall libcolamd.symamd_report(stats::Ptr{Int32})::Cvoid
-end
-
-function symamd_l_report(stats)
-    @ccall libcolamd.symamd_l_report(stats::Ptr{Int64})::Cvoid
-end
-
-function ccolamd_recommended(nnz, n_row, n_col)
-    @ccall libcolamd.ccolamd_recommended(nnz::Cint, n_row::Cint, n_col::Cint)::Csize_t
-end
-
-function ccolamd_l_recommended(nnz, n_row, n_col)
-    @ccall libcolamd.ccolamd_l_recommended(nnz::Int64, n_row::Int64, n_col::Int64)::Csize_t
-end
-
-function ccolamd_set_defaults(knobs)
-    @ccall libcolamd.ccolamd_set_defaults(knobs::Ptr{Cdouble})::Cvoid
-end
-
-function ccolamd_l_set_defaults(knobs)
-    @ccall libcolamd.ccolamd_l_set_defaults(knobs::Ptr{Cdouble})::Cvoid
-end
-
-function ccolamd(n_row, n_col, Alen, A, p, knobs, stats, cmember)
-    @ccall libcolamd.ccolamd(n_row::Cint, n_col::Cint, Alen::Cint, A::Ptr{Cint}, p::Ptr{Cint}, knobs::Ptr{Cdouble}, stats::Ptr{Cint}, cmember::Ptr{Cint})::Cint
-end
-
-function ccolamd_l(n_row, n_col, Alen, A, p, knobs, stats, cmember)
-    @ccall libcolamd.ccolamd_l(n_row::Int64, n_col::Int64, Alen::Int64, A::Ptr{Int64}, p::Ptr{Int64}, knobs::Ptr{Cdouble}, stats::Ptr{Int64}, cmember::Ptr{Int64})::Cint
-end
-
-function csymamd(n, A, p, perm, knobs, stats, allocate, release, cmember, stype)
-    @ccall libcolamd.csymamd(n::Cint, A::Ptr{Cint}, p::Ptr{Cint}, perm::Ptr{Cint}, knobs::Ptr{Cdouble}, stats::Ptr{Cint}, allocate::Ptr{Cvoid}, release::Ptr{Cvoid}, cmember::Ptr{Cint}, stype::Cint)::Cint
-end
-
-function csymamd_l(n, A, p, perm, knobs, stats, allocate, release, cmember, stype)
-    @ccall libcolamd.csymamd_l(n::Int64, A::Ptr{Int64}, p::Ptr{Int64}, perm::Ptr{Int64}, knobs::Ptr{Cdouble}, stats::Ptr{Int64}, allocate::Ptr{Cvoid}, release::Ptr{Cvoid}, cmember::Ptr{Int64}, stype::Int64)::Cint
-end
-
-function ccolamd_report(stats)
-    @ccall libcolamd.ccolamd_report(stats::Ptr{Cint})::Cvoid
-end
-
-function ccolamd_l_report(stats)
-    @ccall libcolamd.ccolamd_l_report(stats::Ptr{Int64})::Cvoid
-end
-
-function csymamd_report(stats)
-    @ccall libcolamd.csymamd_report(stats::Ptr{Cint})::Cvoid
-end
-
-function csymamd_l_report(stats)
-    @ccall libcolamd.csymamd_l_report(stats::Ptr{Int64})::Cvoid
-end
-
-function ccolamd2(n_row, n_col, Alen, A, p, knobs, stats, Front_npivcol, Front_nrows, Front_ncols, Front_parent, Front_cols, p_nfr, InFront, cmember)
-    @ccall libcolamd.ccolamd2(n_row::Cint, n_col::Cint, Alen::Cint, A::Ptr{Cint}, p::Ptr{Cint}, knobs::Ptr{Cdouble}, stats::Ptr{Cint}, Front_npivcol::Ptr{Cint}, Front_nrows::Ptr{Cint}, Front_ncols::Ptr{Cint}, Front_parent::Ptr{Cint}, Front_cols::Ptr{Cint}, p_nfr::Ptr{Cint}, InFront::Ptr{Cint}, cmember::Ptr{Cint})::Cint
-end
-
-function ccolamd2_l(n_row, n_col, Alen, A, p, knobs, stats, Front_npivcol, Front_nrows, Front_ncols, Front_parent, Front_cols, p_nfr, InFront, cmember)
-    @ccall libcolamd.ccolamd2_l(n_row::Int64, n_col::Int64, Alen::Int64, A::Ptr{Int64}, p::Ptr{Int64}, knobs::Ptr{Cdouble}, stats::Ptr{Int64}, Front_npivcol::Ptr{Int64}, Front_nrows::Ptr{Int64}, Front_ncols::Ptr{Int64}, Front_parent::Ptr{Int64}, Front_cols::Ptr{Int64}, p_nfr::Ptr{Int64}, InFront::Ptr{Int64}, cmember::Ptr{Int64})::Cint
-end
-
-function ccolamd_apply_order(Front, Order, Temp, nn, nfr)
-    @ccall libcolamd.ccolamd_apply_order(Front::Ptr{Cint}, Order::Ptr{Cint}, Temp::Ptr{Cint}, nn::Cint, nfr::Cint)::Cvoid
-end
-
-function ccolamd_l_apply_order(Front, Order, Temp, nn, nfr)
-    @ccall libcolamd.ccolamd_l_apply_order(Front::Ptr{Int64}, Order::Ptr{Int64}, Temp::Ptr{Int64}, nn::Int64, nfr::Int64)::Cvoid
-end
-
-function ccolamd_fsize(nn, MaxFsize, Fnrows, Fncols, Parent, Npiv)
-    @ccall libcolamd.ccolamd_fsize(nn::Cint, MaxFsize::Ptr{Cint}, Fnrows::Ptr{Cint}, Fncols::Ptr{Cint}, Parent::Ptr{Cint}, Npiv::Ptr{Cint})::Cvoid
-end
-
-function ccolamd_l_fsize(nn, MaxFsize, Fnrows, Fncols, Parent, Npiv)
-    @ccall libcolamd.ccolamd_l_fsize(nn::Int64, MaxFsize::Ptr{Int64}, Fnrows::Ptr{Int64}, Fncols::Ptr{Int64}, Parent::Ptr{Int64}, Npiv::Ptr{Int64})::Cvoid
-end
-
-function ccolamd_postorder(nn, Parent, Npiv, Fsize, Order, Child, Sibling, Stack, Front_cols, cmember)
-    @ccall libcolamd.ccolamd_postorder(nn::Cint, Parent::Ptr{Cint}, Npiv::Ptr{Cint}, Fsize::Ptr{Cint}, Order::Ptr{Cint}, Child::Ptr{Cint}, Sibling::Ptr{Cint}, Stack::Ptr{Cint}, Front_cols::Ptr{Cint}, cmember::Ptr{Cint})::Cvoid
-end
-
-function ccolamd_l_postorder(nn, Parent, Npiv, Fsize, Order, Child, Sibling, Stack, Front_cols, cmember)
-    @ccall libcolamd.ccolamd_l_postorder(nn::Int64, Parent::Ptr{Int64}, Npiv::Ptr{Int64}, Fsize::Ptr{Int64}, Order::Ptr{Int64}, Child::Ptr{Int64}, Sibling::Ptr{Int64}, Stack::Ptr{Int64}, Front_cols::Ptr{Int64}, cmember::Ptr{Int64})::Cvoid
-end
-
-function ccolamd_post_tree(root, k, Child, Sibling, Order, Stack)
-    @ccall libcolamd.ccolamd_post_tree(root::Cint, k::Cint, Child::Ptr{Cint}, Sibling::Ptr{Cint}, Order::Ptr{Cint}, Stack::Ptr{Cint})::Cint
-end
-
-function ccolamd_l_post_tree(root, k, Child, Sibling, Order, Stack)
-    @ccall libcolamd.ccolamd_l_post_tree(root::Int64, k::Int64, Child::Ptr{Int64}, Sibling::Ptr{Int64}, Order::Ptr{Int64}, Stack::Ptr{Int64})::Int64
-end
-
 function umfpack_di_symbolic(n_row, n_col, Ap, Ai, Ax, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_di_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                          Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                          Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                          Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_symbolic(n_row, n_col, Ap, Ai, Ax, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_dl_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                          Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                          Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                          Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_symbolic(n_row, n_col, Ap, Ai, Ax, Az, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_zi_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                          Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                          Az::Ptr{Cdouble}, Symbolic::Ptr{Ptr{Cvoid}},
+                                          Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_symbolic(n_row, n_col, Ap, Ai, Ax, Az, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_zl_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                          Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                          Az::Ptr{Cdouble}, Symbolic::Ptr{Ptr{Cvoid}},
+                                          Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_numeric(Ap, Ai, Ax, Symbolic, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_di_numeric(Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Symbolic::Ptr{Cvoid}, Numeric::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_numeric(Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                         Symbolic::Ptr{Cvoid}, Numeric::Ptr{Ptr{Cvoid}},
+                                         Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_numeric(Ap, Ai, Ax, Symbolic, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_dl_numeric(Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Symbolic::Ptr{Cvoid}, Numeric::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_numeric(Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                         Symbolic::Ptr{Cvoid}, Numeric::Ptr{Ptr{Cvoid}},
+                                         Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_numeric(Ap, Ai, Ax, Az, Symbolic, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_zi_numeric(Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Symbolic::Ptr{Cvoid}, Numeric::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_numeric(Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                         Az::Ptr{Cdouble}, Symbolic::Ptr{Cvoid},
+                                         Numeric::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                         Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_numeric(Ap, Ai, Ax, Az, Symbolic, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_zl_numeric(Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Symbolic::Ptr{Cvoid}, Numeric::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_numeric(Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                         Az::Ptr{Cdouble}, Symbolic::Ptr{Cvoid},
+                                         Numeric::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                         Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_solve(sys, Ap, Ai, Ax, X, B, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_di_solve(sys::Cint, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_solve(sys::Cint, Ap::Ptr{Int32}, Ai::Ptr{Int32},
+                                       Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble},
+                                       Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                       Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_solve(sys, Ap, Ai, Ax, X, B, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_dl_solve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_solve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64},
+                                       Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble},
+                                       Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                       Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_solve(sys, Ap, Ai, Ax, Az, Xx, Xz, Bx, Bz, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_zi_solve(sys::Cint, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_solve(sys::Cint, Ap::Ptr{Int32}, Ai::Ptr{Int32},
+                                       Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Xx::Ptr{Cdouble},
+                                       Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble},
+                                       Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                       Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_solve(sys, Ap, Ai, Ax, Az, Xx, Xz, Bx, Bz, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_zl_solve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_solve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64},
+                                       Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Xx::Ptr{Cdouble},
+                                       Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble},
+                                       Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                       Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_free_symbolic(Symbolic)
@@ -1840,51 +2346,119 @@ function umfpack_zl_defaults(Control)
 end
 
 function umfpack_di_qsymbolic(n_row, n_col, Ap, Ai, Ax, Qinit, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_di_qsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Qinit::Ptr{Int32}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_qsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                           Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                           Qinit::Ptr{Int32}, Symbolic::Ptr{Ptr{Cvoid}},
+                                           Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_qsymbolic(n_row, n_col, Ap, Ai, Ax, Qinit, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_dl_qsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Qinit::Ptr{Int64}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_qsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                           Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                           Qinit::Ptr{Int64}, Symbolic::Ptr{Ptr{Cvoid}},
+                                           Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_qsymbolic(n_row, n_col, Ap, Ai, Ax, Az, Qinit, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_zi_qsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Qinit::Ptr{Int32}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_qsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                           Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                           Az::Ptr{Cdouble}, Qinit::Ptr{Int32},
+                                           Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                           Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_qsymbolic(n_row, n_col, Ap, Ai, Ax, Az, Qinit, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_zl_qsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Qinit::Ptr{Int64}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_di_fsymbolic(n_row, n_col, Ap, Ai, Ax, user_ordering, user_params, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_di_fsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_dl_fsymbolic(n_row, n_col, Ap, Ai, Ax, user_ordering, user_params, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_dl_fsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_zi_fsymbolic(n_row, n_col, Ap, Ai, Ax, Az, user_ordering, user_params, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_zi_fsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_zl_fsymbolic(n_row, n_col, Ap, Ai, Ax, Az, user_ordering, user_params, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_zl_fsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_di_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Qinit, user_ordering, user_params, Symbolic, SW, Control, Info)
-    @ccall libumfpack.umfpack_di_paru_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Qinit::Ptr{Int32}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_dl_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Qinit, user_ordering, user_params, Symbolic, SW, Control, Info)
-    @ccall libumfpack.umfpack_dl_paru_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Qinit::Ptr{Int64}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_zi_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Az, Qinit, user_ordering, user_params, Symbolic, SW, Control, Info)
-    @ccall libumfpack.umfpack_zi_paru_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Qinit::Ptr{Int32}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_zl_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Az, Qinit, user_ordering, user_params, Symbolic, SW, Control, Info)
-    @ccall libumfpack.umfpack_zl_paru_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Qinit::Ptr{Int64}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_qsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                           Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                           Az::Ptr{Cdouble}, Qinit::Ptr{Int64},
+                                           Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                           Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_di_fsymbolic(n_row, n_col, Ap, Ai, Ax, user_ordering, user_params,
+                              Symbolic, Control, Info)
+    @ccall libumfpack.umfpack_di_fsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                           Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                           user_ordering::Ptr{Cvoid},
+                                           user_params::Ptr{Cvoid},
+                                           Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                           Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_dl_fsymbolic(n_row, n_col, Ap, Ai, Ax, user_ordering, user_params,
+                              Symbolic, Control, Info)
+    @ccall libumfpack.umfpack_dl_fsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                           Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                           user_ordering::Ptr{Cvoid},
+                                           user_params::Ptr{Cvoid},
+                                           Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                           Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_zi_fsymbolic(n_row, n_col, Ap, Ai, Ax, Az, user_ordering, user_params,
+                              Symbolic, Control, Info)
+    @ccall libumfpack.umfpack_zi_fsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                           Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                           Az::Ptr{Cdouble}, user_ordering::Ptr{Cvoid},
+                                           user_params::Ptr{Cvoid},
+                                           Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                           Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_zl_fsymbolic(n_row, n_col, Ap, Ai, Ax, Az, user_ordering, user_params,
+                              Symbolic, Control, Info)
+    @ccall libumfpack.umfpack_zl_fsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                           Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                           Az::Ptr{Cdouble}, user_ordering::Ptr{Cvoid},
+                                           user_params::Ptr{Cvoid},
+                                           Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                           Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_di_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Qinit, user_ordering,
+                                  user_params, Symbolic, SW, Control, Info)
+    @ccall libumfpack.umfpack_di_paru_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                               Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                               Qinit::Ptr{Int32}, user_ordering::Ptr{Cvoid},
+                                               user_params::Ptr{Cvoid},
+                                               Symbolic::Ptr{Ptr{Cvoid}},
+                                               SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                               Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_dl_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Qinit, user_ordering,
+                                  user_params, Symbolic, SW, Control, Info)
+    @ccall libumfpack.umfpack_dl_paru_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                               Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                               Qinit::Ptr{Int64}, user_ordering::Ptr{Cvoid},
+                                               user_params::Ptr{Cvoid},
+                                               Symbolic::Ptr{Ptr{Cvoid}},
+                                               SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                               Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_zi_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Az, Qinit, user_ordering,
+                                  user_params, Symbolic, SW, Control, Info)
+    @ccall libumfpack.umfpack_zi_paru_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                               Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                               Az::Ptr{Cdouble}, Qinit::Ptr{Int32},
+                                               user_ordering::Ptr{Cvoid},
+                                               user_params::Ptr{Cvoid},
+                                               Symbolic::Ptr{Ptr{Cvoid}},
+                                               SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                               Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_zl_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Az, Qinit, user_ordering,
+                                  user_params, Symbolic, SW, Control, Info)
+    @ccall libumfpack.umfpack_zl_paru_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                               Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                               Az::Ptr{Cdouble}, Qinit::Ptr{Int64},
+                                               user_ordering::Ptr{Cvoid},
+                                               user_params::Ptr{Cvoid},
+                                               Symbolic::Ptr{Ptr{Cvoid}},
+                                               SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                               Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_paru_free_sw(SW)
@@ -1904,339 +2478,547 @@ function umfpack_zl_paru_free_sw(SW)
 end
 
 function umfpack_di_wsolve(sys, Ap, Ai, Ax, X, B, Numeric, Control, Info, Wi, W)
-    @ccall libumfpack.umfpack_di_wsolve(sys::Cint, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble}, Wi::Ptr{Int32}, W::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_wsolve(sys::Cint, Ap::Ptr{Int32}, Ai::Ptr{Int32},
+                                        Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble},
+                                        Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                        Info::Ptr{Cdouble}, Wi::Ptr{Int32},
+                                        W::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_wsolve(sys, Ap, Ai, Ax, X, B, Numeric, Control, Info, Wi, W)
-    @ccall libumfpack.umfpack_dl_wsolve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble}, Wi::Ptr{Int64}, W::Ptr{Cdouble})::Cint
-end
-
-function umfpack_zi_wsolve(sys, Ap, Ai, Ax, Az, Xx, Xz, Bx, Bz, Numeric, Control, Info, Wi, W)
-    @ccall libumfpack.umfpack_zi_wsolve(sys::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble}, Wi::Ptr{Int32}, W::Ptr{Cdouble})::Cint
-end
-
-function umfpack_zl_wsolve(sys, Ap, Ai, Ax, Az, Xx, Xz, Bx, Bz, Numeric, Control, Info, Wi, W)
-    @ccall libumfpack.umfpack_zl_wsolve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble}, Wi::Ptr{Int64}, W::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_wsolve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64},
+                                        Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble},
+                                        Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                        Info::Ptr{Cdouble}, Wi::Ptr{Int64},
+                                        W::Ptr{Cdouble})::Cint
+end
+
+function umfpack_zi_wsolve(sys, Ap, Ai, Ax, Az, Xx, Xz, Bx, Bz, Numeric, Control, Info, Wi,
+                           W)
+    @ccall libumfpack.umfpack_zi_wsolve(sys::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32},
+                                        Ax::Ptr{Cdouble}, Az::Ptr{Cdouble},
+                                        Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble},
+                                        Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble},
+                                        Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                        Info::Ptr{Cdouble}, Wi::Ptr{Int32},
+                                        W::Ptr{Cdouble})::Cint
+end
+
+function umfpack_zl_wsolve(sys, Ap, Ai, Ax, Az, Xx, Xz, Bx, Bz, Numeric, Control, Info, Wi,
+                           W)
+    @ccall libumfpack.umfpack_zl_wsolve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64},
+                                        Ax::Ptr{Cdouble}, Az::Ptr{Cdouble},
+                                        Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble},
+                                        Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble},
+                                        Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                        Info::Ptr{Cdouble}, Wi::Ptr{Int64},
+                                        W::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_triplet_to_col(n_row, n_col, nz, Ti, Tj, Tx, Ap, Ai, Ax, Map)
-    @ccall libumfpack.umfpack_di_triplet_to_col(n_row::Int32, n_col::Int32, nz::Int32, Ti::Ptr{Int32}, Tj::Ptr{Int32}, Tx::Ptr{Cdouble}, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Map::Ptr{Int32})::Cint
+    @ccall libumfpack.umfpack_di_triplet_to_col(n_row::Int32, n_col::Int32, nz::Int32,
+                                                Ti::Ptr{Int32}, Tj::Ptr{Int32},
+                                                Tx::Ptr{Cdouble}, Ap::Ptr{Int32},
+                                                Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                                Map::Ptr{Int32})::Cint
 end
 
 function umfpack_dl_triplet_to_col(n_row, n_col, nz, Ti, Tj, Tx, Ap, Ai, Ax, Map)
-    @ccall libumfpack.umfpack_dl_triplet_to_col(n_row::Int64, n_col::Int64, nz::Int64, Ti::Ptr{Int64}, Tj::Ptr{Int64}, Tx::Ptr{Cdouble}, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Map::Ptr{Int64})::Cint
+    @ccall libumfpack.umfpack_dl_triplet_to_col(n_row::Int64, n_col::Int64, nz::Int64,
+                                                Ti::Ptr{Int64}, Tj::Ptr{Int64},
+                                                Tx::Ptr{Cdouble}, Ap::Ptr{Int64},
+                                                Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                                Map::Ptr{Int64})::Cint
 end
 
 function umfpack_zi_triplet_to_col(n_row, n_col, nz, Ti, Tj, Tx, Tz, Ap, Ai, Ax, Az, Map)
-    @ccall libumfpack.umfpack_zi_triplet_to_col(n_row::Int32, n_col::Int32, nz::Int32, Ti::Ptr{Int32}, Tj::Ptr{Int32}, Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble}, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Map::Ptr{Int32})::Cint
+    @ccall libumfpack.umfpack_zi_triplet_to_col(n_row::Int32, n_col::Int32, nz::Int32,
+                                                Ti::Ptr{Int32}, Tj::Ptr{Int32},
+                                                Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble},
+                                                Ap::Ptr{Int32}, Ai::Ptr{Int32},
+                                                Ax::Ptr{Cdouble}, Az::Ptr{Cdouble},
+                                                Map::Ptr{Int32})::Cint
 end
 
 function umfpack_zl_triplet_to_col(n_row, n_col, nz, Ti, Tj, Tx, Tz, Ap, Ai, Ax, Az, Map)
-    @ccall libumfpack.umfpack_zl_triplet_to_col(n_row::Int64, n_col::Int64, nz::Int64, Ti::Ptr{Int64}, Tj::Ptr{Int64}, Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble}, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Map::Ptr{Int64})::Cint
+    @ccall libumfpack.umfpack_zl_triplet_to_col(n_row::Int64, n_col::Int64, nz::Int64,
+                                                Ti::Ptr{Int64}, Tj::Ptr{Int64},
+                                                Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble},
+                                                Ap::Ptr{Int64}, Ai::Ptr{Int64},
+                                                Ax::Ptr{Cdouble}, Az::Ptr{Cdouble},
+                                                Map::Ptr{Int64})::Cint
 end
 
 function umfpack_di_col_to_triplet(n_col, Ap, Tj)
-    @ccall libumfpack.umfpack_di_col_to_triplet(n_col::Int32, Ap::Ptr{Int32}, Tj::Ptr{Int32})::Cint
+    @ccall libumfpack.umfpack_di_col_to_triplet(n_col::Int32, Ap::Ptr{Int32},
+                                                Tj::Ptr{Int32})::Cint
 end
 
 function umfpack_dl_col_to_triplet(n_col, Ap, Tj)
-    @ccall libumfpack.umfpack_dl_col_to_triplet(n_col::Int64, Ap::Ptr{Int64}, Tj::Ptr{Int64})::Cint
+    @ccall libumfpack.umfpack_dl_col_to_triplet(n_col::Int64, Ap::Ptr{Int64},
+                                                Tj::Ptr{Int64})::Cint
 end
 
 function umfpack_zi_col_to_triplet(n_col, Ap, Tj)
-    @ccall libumfpack.umfpack_zi_col_to_triplet(n_col::Int32, Ap::Ptr{Int32}, Tj::Ptr{Int32})::Cint
+    @ccall libumfpack.umfpack_zi_col_to_triplet(n_col::Int32, Ap::Ptr{Int32},
+                                                Tj::Ptr{Int32})::Cint
 end
 
 function umfpack_zl_col_to_triplet(n_col, Ap, Tj)
-    @ccall libumfpack.umfpack_zl_col_to_triplet(n_col::Int64, Ap::Ptr{Int64}, Tj::Ptr{Int64})::Cint
+    @ccall libumfpack.umfpack_zl_col_to_triplet(n_col::Int64, Ap::Ptr{Int64},
+                                                Tj::Ptr{Int64})::Cint
 end
 
 function umfpack_di_transpose(n_row, n_col, Ap, Ai, Ax, P, Q, Rp, Ri, Rx)
-    @ccall libumfpack.umfpack_di_transpose(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, P::Ptr{Int32}, Q::Ptr{Int32}, Rp::Ptr{Int32}, Ri::Ptr{Int32}, Rx::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_transpose(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                           Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, P::Ptr{Int32},
+                                           Q::Ptr{Int32}, Rp::Ptr{Int32}, Ri::Ptr{Int32},
+                                           Rx::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_transpose(n_row, n_col, Ap, Ai, Ax, P, Q, Rp, Ri, Rx)
-    @ccall libumfpack.umfpack_dl_transpose(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, P::Ptr{Int64}, Q::Ptr{Int64}, Rp::Ptr{Int64}, Ri::Ptr{Int64}, Rx::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_transpose(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                           Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, P::Ptr{Int64},
+                                           Q::Ptr{Int64}, Rp::Ptr{Int64}, Ri::Ptr{Int64},
+                                           Rx::Ptr{Cdouble})::Cint
 end
 
-function umfpack_zi_transpose(n_row, n_col, Ap, Ai, Ax, Az, P, Q, Rp, Ri, Rx, Rz, do_conjugate)
-    @ccall libumfpack.umfpack_zi_transpose(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, P::Ptr{Int32}, Q::Ptr{Int32}, Rp::Ptr{Int32}, Ri::Ptr{Int32}, Rx::Ptr{Cdouble}, Rz::Ptr{Cdouble}, do_conjugate::Cint)::Cint
+function umfpack_zi_transpose(n_row, n_col, Ap, Ai, Ax, Az, P, Q, Rp, Ri, Rx, Rz,
+                              do_conjugate)
+    @ccall libumfpack.umfpack_zi_transpose(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                           Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                           Az::Ptr{Cdouble}, P::Ptr{Int32}, Q::Ptr{Int32},
+                                           Rp::Ptr{Int32}, Ri::Ptr{Int32}, Rx::Ptr{Cdouble},
+                                           Rz::Ptr{Cdouble}, do_conjugate::Cint)::Cint
 end
 
-function umfpack_zl_transpose(n_row, n_col, Ap, Ai, Ax, Az, P, Q, Rp, Ri, Rx, Rz, do_conjugate)
-    @ccall libumfpack.umfpack_zl_transpose(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, P::Ptr{Int64}, Q::Ptr{Int64}, Rp::Ptr{Int64}, Ri::Ptr{Int64}, Rx::Ptr{Cdouble}, Rz::Ptr{Cdouble}, do_conjugate::Cint)::Cint
+function umfpack_zl_transpose(n_row, n_col, Ap, Ai, Ax, Az, P, Q, Rp, Ri, Rx, Rz,
+                              do_conjugate)
+    @ccall libumfpack.umfpack_zl_transpose(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                           Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                           Az::Ptr{Cdouble}, P::Ptr{Int64}, Q::Ptr{Int64},
+                                           Rp::Ptr{Int64}, Ri::Ptr{Int64}, Rx::Ptr{Cdouble},
+                                           Rz::Ptr{Cdouble}, do_conjugate::Cint)::Cint
 end
 
 function umfpack_di_scale(X, B, Numeric)
-    @ccall libumfpack.umfpack_di_scale(X::Ptr{Cdouble}, B::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_scale(X::Ptr{Cdouble}, B::Ptr{Cdouble},
+                                       Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_scale(X, B, Numeric)
-    @ccall libumfpack.umfpack_dl_scale(X::Ptr{Cdouble}, B::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_scale(X::Ptr{Cdouble}, B::Ptr{Cdouble},
+                                       Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_scale(Xx, Xz, Bx, Bz, Numeric)
-    @ccall libumfpack.umfpack_zi_scale(Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_scale(Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble},
+                                       Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_scale(Xx, Xz, Bx, Bz, Numeric)
-    @ccall libumfpack.umfpack_zl_scale(Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_scale(Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble},
+                                       Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_get_lunz(lnz, unz, n_row, n_col, nz_udiag, Numeric)
-    @ccall libumfpack.umfpack_di_get_lunz(lnz::Ptr{Int32}, unz::Ptr{Int32}, n_row::Ptr{Int32}, n_col::Ptr{Int32}, nz_udiag::Ptr{Int32}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_get_lunz(lnz::Ptr{Int32}, unz::Ptr{Int32},
+                                          n_row::Ptr{Int32}, n_col::Ptr{Int32},
+                                          nz_udiag::Ptr{Int32}, Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_get_lunz(lnz, unz, n_row, n_col, nz_udiag, Numeric)
-    @ccall libumfpack.umfpack_dl_get_lunz(lnz::Ptr{Int64}, unz::Ptr{Int64}, n_row::Ptr{Int64}, n_col::Ptr{Int64}, nz_udiag::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_get_lunz(lnz::Ptr{Int64}, unz::Ptr{Int64},
+                                          n_row::Ptr{Int64}, n_col::Ptr{Int64},
+                                          nz_udiag::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_get_lunz(lnz, unz, n_row, n_col, nz_udiag, Numeric)
-    @ccall libumfpack.umfpack_zi_get_lunz(lnz::Ptr{Int32}, unz::Ptr{Int32}, n_row::Ptr{Int32}, n_col::Ptr{Int32}, nz_udiag::Ptr{Int32}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_get_lunz(lnz::Ptr{Int32}, unz::Ptr{Int32},
+                                          n_row::Ptr{Int32}, n_col::Ptr{Int32},
+                                          nz_udiag::Ptr{Int32}, Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_get_lunz(lnz, unz, n_row, n_col, nz_udiag, Numeric)
-    @ccall libumfpack.umfpack_zl_get_lunz(lnz::Ptr{Int64}, unz::Ptr{Int64}, n_row::Ptr{Int64}, n_col::Ptr{Int64}, nz_udiag::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_get_lunz(lnz::Ptr{Int64}, unz::Ptr{Int64},
+                                          n_row::Ptr{Int64}, n_col::Ptr{Int64},
+                                          nz_udiag::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_get_numeric(Lp, Lj, Lx, Up, Ui, Ux, P, Q, Dx, do_recip, Rs, Numeric)
-    @ccall libumfpack.umfpack_di_get_numeric(Lp::Ptr{Int32}, Lj::Ptr{Int32}, Lx::Ptr{Cdouble}, Up::Ptr{Int32}, Ui::Ptr{Int32}, Ux::Ptr{Cdouble}, P::Ptr{Int32}, Q::Ptr{Int32}, Dx::Ptr{Cdouble}, do_recip::Ptr{Int32}, Rs::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_get_numeric(Lp::Ptr{Int32}, Lj::Ptr{Int32},
+                                             Lx::Ptr{Cdouble}, Up::Ptr{Int32},
+                                             Ui::Ptr{Int32}, Ux::Ptr{Cdouble},
+                                             P::Ptr{Int32}, Q::Ptr{Int32}, Dx::Ptr{Cdouble},
+                                             do_recip::Ptr{Int32}, Rs::Ptr{Cdouble},
+                                             Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_get_numeric(Lp, Lj, Lx, Up, Ui, Ux, P, Q, Dx, do_recip, Rs, Numeric)
-    @ccall libumfpack.umfpack_dl_get_numeric(Lp::Ptr{Int64}, Lj::Ptr{Int64}, Lx::Ptr{Cdouble}, Up::Ptr{Int64}, Ui::Ptr{Int64}, Ux::Ptr{Cdouble}, P::Ptr{Int64}, Q::Ptr{Int64}, Dx::Ptr{Cdouble}, do_recip::Ptr{Int64}, Rs::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
-end
-
-function umfpack_zi_get_numeric(Lp, Lj, Lx, Lz, Up, Ui, Ux, Uz, P, Q, Dx, Dz, do_recip, Rs, Numeric)
-    @ccall libumfpack.umfpack_zi_get_numeric(Lp::Ptr{Int32}, Lj::Ptr{Int32}, Lx::Ptr{Cdouble}, Lz::Ptr{Cdouble}, Up::Ptr{Int32}, Ui::Ptr{Int32}, Ux::Ptr{Cdouble}, Uz::Ptr{Cdouble}, P::Ptr{Int32}, Q::Ptr{Int32}, Dx::Ptr{Cdouble}, Dz::Ptr{Cdouble}, do_recip::Ptr{Int32}, Rs::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
-end
-
-function umfpack_zl_get_numeric(Lp, Lj, Lx, Lz, Up, Ui, Ux, Uz, P, Q, Dx, Dz, do_recip, Rs, Numeric)
-    @ccall libumfpack.umfpack_zl_get_numeric(Lp::Ptr{Int64}, Lj::Ptr{Int64}, Lx::Ptr{Cdouble}, Lz::Ptr{Cdouble}, Up::Ptr{Int64}, Ui::Ptr{Int64}, Ux::Ptr{Cdouble}, Uz::Ptr{Cdouble}, P::Ptr{Int64}, Q::Ptr{Int64}, Dx::Ptr{Cdouble}, Dz::Ptr{Cdouble}, do_recip::Ptr{Int64}, Rs::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
-end
-
-function umfpack_di_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol, Front_parent, Front_1strow, Front_leftmostdesc, Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
-    @ccall libumfpack.umfpack_di_get_symbolic(n_row::Ptr{Int32}, n_col::Ptr{Int32}, n1::Ptr{Int32}, nz::Ptr{Int32}, nfr::Ptr{Int32}, nchains::Ptr{Int32}, P::Ptr{Int32}, Q::Ptr{Int32}, Front_npivcol::Ptr{Int32}, Front_parent::Ptr{Int32}, Front_1strow::Ptr{Int32}, Front_leftmostdesc::Ptr{Int32}, Chain_start::Ptr{Int32}, Chain_maxrows::Ptr{Int32}, Chain_maxcols::Ptr{Int32}, Dmap::Ptr{Int32}, Symbolic::Ptr{Cvoid})::Cint
-end
-
-function umfpack_dl_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol, Front_parent, Front_1strow, Front_leftmostdesc, Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
-    @ccall libumfpack.umfpack_dl_get_symbolic(n_row::Ptr{Int64}, n_col::Ptr{Int64}, n1::Ptr{Int64}, nz::Ptr{Int64}, nfr::Ptr{Int64}, nchains::Ptr{Int64}, P::Ptr{Int64}, Q::Ptr{Int64}, Front_npivcol::Ptr{Int64}, Front_parent::Ptr{Int64}, Front_1strow::Ptr{Int64}, Front_leftmostdesc::Ptr{Int64}, Chain_start::Ptr{Int64}, Chain_maxrows::Ptr{Int64}, Chain_maxcols::Ptr{Int64}, Dmap::Ptr{Int64}, Symbolic::Ptr{Cvoid})::Cint
-end
-
-function umfpack_zi_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol, Front_parent, Front_1strow, Front_leftmostdesc, Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
-    @ccall libumfpack.umfpack_zi_get_symbolic(n_row::Ptr{Int32}, n_col::Ptr{Int32}, n1::Ptr{Int32}, nz::Ptr{Int32}, nfr::Ptr{Int32}, nchains::Ptr{Int32}, P::Ptr{Int32}, Q::Ptr{Int32}, Front_npivcol::Ptr{Int32}, Front_parent::Ptr{Int32}, Front_1strow::Ptr{Int32}, Front_leftmostdesc::Ptr{Int32}, Chain_start::Ptr{Int32}, Chain_maxrows::Ptr{Int32}, Chain_maxcols::Ptr{Int32}, Dmap::Ptr{Int32}, Symbolic::Ptr{Cvoid})::Cint
-end
-
-function umfpack_zl_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol, Front_parent, Front_1strow, Front_leftmostdesc, Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
-    @ccall libumfpack.umfpack_zl_get_symbolic(n_row::Ptr{Int64}, n_col::Ptr{Int64}, n1::Ptr{Int64}, nz::Ptr{Int64}, nfr::Ptr{Int64}, nchains::Ptr{Int64}, P::Ptr{Int64}, Q::Ptr{Int64}, Front_npivcol::Ptr{Int64}, Front_parent::Ptr{Int64}, Front_1strow::Ptr{Int64}, Front_leftmostdesc::Ptr{Int64}, Chain_start::Ptr{Int64}, Chain_maxrows::Ptr{Int64}, Chain_maxcols::Ptr{Int64}, Dmap::Ptr{Int64}, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_get_numeric(Lp::Ptr{Int64}, Lj::Ptr{Int64},
+                                             Lx::Ptr{Cdouble}, Up::Ptr{Int64},
+                                             Ui::Ptr{Int64}, Ux::Ptr{Cdouble},
+                                             P::Ptr{Int64}, Q::Ptr{Int64}, Dx::Ptr{Cdouble},
+                                             do_recip::Ptr{Int64}, Rs::Ptr{Cdouble},
+                                             Numeric::Ptr{Cvoid})::Cint
+end
+
+function umfpack_zi_get_numeric(Lp, Lj, Lx, Lz, Up, Ui, Ux, Uz, P, Q, Dx, Dz, do_recip, Rs,
+                                Numeric)
+    @ccall libumfpack.umfpack_zi_get_numeric(Lp::Ptr{Int32}, Lj::Ptr{Int32},
+                                             Lx::Ptr{Cdouble}, Lz::Ptr{Cdouble},
+                                             Up::Ptr{Int32}, Ui::Ptr{Int32},
+                                             Ux::Ptr{Cdouble}, Uz::Ptr{Cdouble},
+                                             P::Ptr{Int32}, Q::Ptr{Int32}, Dx::Ptr{Cdouble},
+                                             Dz::Ptr{Cdouble}, do_recip::Ptr{Int32},
+                                             Rs::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+end
+
+function umfpack_zl_get_numeric(Lp, Lj, Lx, Lz, Up, Ui, Ux, Uz, P, Q, Dx, Dz, do_recip, Rs,
+                                Numeric)
+    @ccall libumfpack.umfpack_zl_get_numeric(Lp::Ptr{Int64}, Lj::Ptr{Int64},
+                                             Lx::Ptr{Cdouble}, Lz::Ptr{Cdouble},
+                                             Up::Ptr{Int64}, Ui::Ptr{Int64},
+                                             Ux::Ptr{Cdouble}, Uz::Ptr{Cdouble},
+                                             P::Ptr{Int64}, Q::Ptr{Int64}, Dx::Ptr{Cdouble},
+                                             Dz::Ptr{Cdouble}, do_recip::Ptr{Int64},
+                                             Rs::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+end
+
+function umfpack_di_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol,
+                                 Front_parent, Front_1strow, Front_leftmostdesc,
+                                 Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
+    @ccall libumfpack.umfpack_di_get_symbolic(n_row::Ptr{Int32}, n_col::Ptr{Int32},
+                                              n1::Ptr{Int32}, nz::Ptr{Int32},
+                                              nfr::Ptr{Int32}, nchains::Ptr{Int32},
+                                              P::Ptr{Int32}, Q::Ptr{Int32},
+                                              Front_npivcol::Ptr{Int32},
+                                              Front_parent::Ptr{Int32},
+                                              Front_1strow::Ptr{Int32},
+                                              Front_leftmostdesc::Ptr{Int32},
+                                              Chain_start::Ptr{Int32},
+                                              Chain_maxrows::Ptr{Int32},
+                                              Chain_maxcols::Ptr{Int32}, Dmap::Ptr{Int32},
+                                              Symbolic::Ptr{Cvoid})::Cint
+end
+
+function umfpack_dl_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol,
+                                 Front_parent, Front_1strow, Front_leftmostdesc,
+                                 Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
+    @ccall libumfpack.umfpack_dl_get_symbolic(n_row::Ptr{Int64}, n_col::Ptr{Int64},
+                                              n1::Ptr{Int64}, nz::Ptr{Int64},
+                                              nfr::Ptr{Int64}, nchains::Ptr{Int64},
+                                              P::Ptr{Int64}, Q::Ptr{Int64},
+                                              Front_npivcol::Ptr{Int64},
+                                              Front_parent::Ptr{Int64},
+                                              Front_1strow::Ptr{Int64},
+                                              Front_leftmostdesc::Ptr{Int64},
+                                              Chain_start::Ptr{Int64},
+                                              Chain_maxrows::Ptr{Int64},
+                                              Chain_maxcols::Ptr{Int64}, Dmap::Ptr{Int64},
+                                              Symbolic::Ptr{Cvoid})::Cint
+end
+
+function umfpack_zi_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol,
+                                 Front_parent, Front_1strow, Front_leftmostdesc,
+                                 Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
+    @ccall libumfpack.umfpack_zi_get_symbolic(n_row::Ptr{Int32}, n_col::Ptr{Int32},
+                                              n1::Ptr{Int32}, nz::Ptr{Int32},
+                                              nfr::Ptr{Int32}, nchains::Ptr{Int32},
+                                              P::Ptr{Int32}, Q::Ptr{Int32},
+                                              Front_npivcol::Ptr{Int32},
+                                              Front_parent::Ptr{Int32},
+                                              Front_1strow::Ptr{Int32},
+                                              Front_leftmostdesc::Ptr{Int32},
+                                              Chain_start::Ptr{Int32},
+                                              Chain_maxrows::Ptr{Int32},
+                                              Chain_maxcols::Ptr{Int32}, Dmap::Ptr{Int32},
+                                              Symbolic::Ptr{Cvoid})::Cint
+end
+
+function umfpack_zl_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol,
+                                 Front_parent, Front_1strow, Front_leftmostdesc,
+                                 Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
+    @ccall libumfpack.umfpack_zl_get_symbolic(n_row::Ptr{Int64}, n_col::Ptr{Int64},
+                                              n1::Ptr{Int64}, nz::Ptr{Int64},
+                                              nfr::Ptr{Int64}, nchains::Ptr{Int64},
+                                              P::Ptr{Int64}, Q::Ptr{Int64},
+                                              Front_npivcol::Ptr{Int64},
+                                              Front_parent::Ptr{Int64},
+                                              Front_1strow::Ptr{Int64},
+                                              Front_leftmostdesc::Ptr{Int64},
+                                              Chain_start::Ptr{Int64},
+                                              Chain_maxrows::Ptr{Int64},
+                                              Chain_maxcols::Ptr{Int64}, Dmap::Ptr{Int64},
+                                              Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_save_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_di_save_numeric(Numeric::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_di_save_numeric(Numeric::Ptr{Cvoid},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_dl_save_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_dl_save_numeric(Numeric::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_dl_save_numeric(Numeric::Ptr{Cvoid},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zi_save_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_zi_save_numeric(Numeric::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zi_save_numeric(Numeric::Ptr{Cvoid},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zl_save_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_zl_save_numeric(Numeric::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zl_save_numeric(Numeric::Ptr{Cvoid},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_di_load_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_di_load_numeric(Numeric::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_di_load_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_dl_load_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_dl_load_numeric(Numeric::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_dl_load_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zi_load_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_zi_load_numeric(Numeric::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zi_load_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zl_load_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_zl_load_numeric(Numeric::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zl_load_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_di_copy_numeric(Numeric, Original)
-    @ccall libumfpack.umfpack_di_copy_numeric(Numeric::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_copy_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_copy_numeric(Numeric, Original)
-    @ccall libumfpack.umfpack_dl_copy_numeric(Numeric::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_copy_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_copy_numeric(Numeric, Original)
-    @ccall libumfpack.umfpack_zi_copy_numeric(Numeric::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_copy_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_copy_numeric(Numeric, Original)
-    @ccall libumfpack.umfpack_zl_copy_numeric(Numeric::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_copy_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_serialize_numeric_size(blobsize, Numeric)
-    @ccall libumfpack.umfpack_di_serialize_numeric_size(blobsize::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_serialize_numeric_size(blobsize::Ptr{Int64},
+                                                        Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_serialize_numeric_size(blobsize, Numeric)
-    @ccall libumfpack.umfpack_dl_serialize_numeric_size(blobsize::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_serialize_numeric_size(blobsize::Ptr{Int64},
+                                                        Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_serialize_numeric_size(blobsize, Numeric)
-    @ccall libumfpack.umfpack_zi_serialize_numeric_size(blobsize::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_serialize_numeric_size(blobsize::Ptr{Int64},
+                                                        Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_serialize_numeric_size(blobsize, Numeric)
-    @ccall libumfpack.umfpack_zl_serialize_numeric_size(blobsize::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_serialize_numeric_size(blobsize::Ptr{Int64},
+                                                        Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_serialize_numeric(blob, blobsize, Numeric)
-    @ccall libumfpack.umfpack_di_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64,
+                                                   Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_serialize_numeric(blob, blobsize, Numeric)
-    @ccall libumfpack.umfpack_dl_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64,
+                                                   Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_serialize_numeric(blob, blobsize, Numeric)
-    @ccall libumfpack.umfpack_zi_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64,
+                                                   Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_serialize_numeric(blob, blobsize, Numeric)
-    @ccall libumfpack.umfpack_zl_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64,
+                                                   Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_deserialize_numeric(Numeric, blob, blobsize)
-    @ccall libumfpack.umfpack_di_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_di_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                                     blob::Ptr{Int8}, blobsize::Int64)::Cint
 end
 
 function umfpack_dl_deserialize_numeric(Numeric, blob, blobsize)
-    @ccall libumfpack.umfpack_dl_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_dl_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                                     blob::Ptr{Int8}, blobsize::Int64)::Cint
 end
 
 function umfpack_zi_deserialize_numeric(Numeric, blob, blobsize)
-    @ccall libumfpack.umfpack_zi_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_zi_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                                     blob::Ptr{Int8}, blobsize::Int64)::Cint
 end
 
 function umfpack_zl_deserialize_numeric(Numeric, blob, blobsize)
-    @ccall libumfpack.umfpack_zl_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_zl_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                                     blob::Ptr{Int8}, blobsize::Int64)::Cint
 end
 
 function umfpack_di_save_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_di_save_symbolic(Symbolic::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_di_save_symbolic(Symbolic::Ptr{Cvoid},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_dl_save_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_dl_save_symbolic(Symbolic::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_dl_save_symbolic(Symbolic::Ptr{Cvoid},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zi_save_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_zi_save_symbolic(Symbolic::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zi_save_symbolic(Symbolic::Ptr{Cvoid},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zl_save_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_zl_save_symbolic(Symbolic::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zl_save_symbolic(Symbolic::Ptr{Cvoid},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_di_load_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_di_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_di_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_dl_load_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_dl_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_dl_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zi_load_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_zi_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zi_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zl_load_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_zl_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zl_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_di_copy_symbolic(Symbolic, Original)
-    @ccall libumfpack.umfpack_di_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_copy_symbolic(Symbolic, Original)
-    @ccall libumfpack.umfpack_dl_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_copy_symbolic(Symbolic, Original)
-    @ccall libumfpack.umfpack_zi_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_copy_symbolic(Symbolic, Original)
-    @ccall libumfpack.umfpack_zl_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_serialize_symbolic_size(blobsize, Symbolic)
-    @ccall libumfpack.umfpack_di_serialize_symbolic_size(blobsize::Ptr{Int64}, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_serialize_symbolic_size(blobsize::Ptr{Int64},
+                                                         Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_serialize_symbolic_size(blobsize, Symbolic)
-    @ccall libumfpack.umfpack_dl_serialize_symbolic_size(blobsize::Ptr{Int64}, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_serialize_symbolic_size(blobsize::Ptr{Int64},
+                                                         Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_serialize_symbolic_size(blobsize, Symbolic)
-    @ccall libumfpack.umfpack_zi_serialize_symbolic_size(blobsize::Ptr{Int64}, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_serialize_symbolic_size(blobsize::Ptr{Int64},
+                                                         Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_serialize_symbolic_size(blobsize, Symbolic)
-    @ccall libumfpack.umfpack_zl_serialize_symbolic_size(blobsize::Ptr{Int64}, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_serialize_symbolic_size(blobsize::Ptr{Int64},
+                                                         Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_serialize_symbolic(blob, blobsize, Symbolic)
-    @ccall libumfpack.umfpack_di_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64,
+                                                    Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_serialize_symbolic(blob, blobsize, Symbolic)
-    @ccall libumfpack.umfpack_dl_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64,
+                                                    Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_serialize_symbolic(blob, blobsize, Symbolic)
-    @ccall libumfpack.umfpack_zi_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64,
+                                                    Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_serialize_symbolic(blob, blobsize, Symbolic)
-    @ccall libumfpack.umfpack_zl_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64,
+                                                    Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_deserialize_symbolic(Symbolic, blob, blobsize)
-    @ccall libumfpack.umfpack_di_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_di_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                                      blob::Ptr{Int8},
+                                                      blobsize::Int64)::Cint
 end
 
 function umfpack_dl_deserialize_symbolic(Symbolic, blob, blobsize)
-    @ccall libumfpack.umfpack_dl_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_dl_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                                      blob::Ptr{Int8},
+                                                      blobsize::Int64)::Cint
 end
 
 function umfpack_zi_deserialize_symbolic(Symbolic, blob, blobsize)
-    @ccall libumfpack.umfpack_zi_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_zi_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                                      blob::Ptr{Int8},
+                                                      blobsize::Int64)::Cint
 end
 
 function umfpack_zl_deserialize_symbolic(Symbolic, blob, blobsize)
-    @ccall libumfpack.umfpack_zl_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_zl_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                                      blob::Ptr{Int8},
+                                                      blobsize::Int64)::Cint
 end
 
 function umfpack_di_get_determinant(Mx, Ex, Numeric, User_Info)
-    @ccall libumfpack.umfpack_di_get_determinant(Mx::Ptr{Cdouble}, Ex::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, User_Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_get_determinant(Mx::Ptr{Cdouble}, Ex::Ptr{Cdouble},
+                                                 Numeric::Ptr{Cvoid},
+                                                 User_Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_get_determinant(Mx, Ex, Numeric, User_Info)
-    @ccall libumfpack.umfpack_dl_get_determinant(Mx::Ptr{Cdouble}, Ex::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, User_Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_get_determinant(Mx::Ptr{Cdouble}, Ex::Ptr{Cdouble},
+                                                 Numeric::Ptr{Cvoid},
+                                                 User_Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_get_determinant(Mx, Mz, Ex, Numeric, User_Info)
-    @ccall libumfpack.umfpack_zi_get_determinant(Mx::Ptr{Cdouble}, Mz::Ptr{Cdouble}, Ex::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, User_Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_get_determinant(Mx::Ptr{Cdouble}, Mz::Ptr{Cdouble},
+                                                 Ex::Ptr{Cdouble}, Numeric::Ptr{Cvoid},
+                                                 User_Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_get_determinant(Mx, Mz, Ex, Numeric, User_Info)
-    @ccall libumfpack.umfpack_zl_get_determinant(Mx::Ptr{Cdouble}, Mz::Ptr{Cdouble}, Ex::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, User_Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_get_determinant(Mx::Ptr{Cdouble}, Mz::Ptr{Cdouble},
+                                                 Ex::Ptr{Cdouble}, Numeric::Ptr{Cvoid},
+                                                 User_Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_report_status(Control, status)
@@ -2256,19 +3038,23 @@ function umfpack_zl_report_status(Control, status)
 end
 
 function umfpack_di_report_info(Control, Info)
-    @ccall libumfpack.umfpack_di_report_info(Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cvoid
+    @ccall libumfpack.umfpack_di_report_info(Control::Ptr{Cdouble},
+                                             Info::Ptr{Cdouble})::Cvoid
 end
 
 function umfpack_dl_report_info(Control, Info)
-    @ccall libumfpack.umfpack_dl_report_info(Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cvoid
+    @ccall libumfpack.umfpack_dl_report_info(Control::Ptr{Cdouble},
+                                             Info::Ptr{Cdouble})::Cvoid
 end
 
 function umfpack_zi_report_info(Control, Info)
-    @ccall libumfpack.umfpack_zi_report_info(Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cvoid
+    @ccall libumfpack.umfpack_zi_report_info(Control::Ptr{Cdouble},
+                                             Info::Ptr{Cdouble})::Cvoid
 end
 
 function umfpack_zl_report_info(Control, Info)
-    @ccall libumfpack.umfpack_zl_report_info(Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cvoid
+    @ccall libumfpack.umfpack_zl_report_info(Control::Ptr{Cdouble},
+                                             Info::Ptr{Cdouble})::Cvoid
 end
 
 function umfpack_di_report_control(Control)
@@ -2288,99 +3074,137 @@ function umfpack_zl_report_control(Control)
 end
 
 function umfpack_di_report_matrix(n_row, n_col, Ap, Ai, Ax, col_form, Control)
-    @ccall libumfpack.umfpack_di_report_matrix(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, col_form::Cint, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_report_matrix(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                               Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                               col_form::Cint, Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_report_matrix(n_row, n_col, Ap, Ai, Ax, col_form, Control)
-    @ccall libumfpack.umfpack_dl_report_matrix(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, col_form::Cint, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_report_matrix(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                               Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                               col_form::Cint, Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_report_matrix(n_row, n_col, Ap, Ai, Ax, Az, col_form, Control)
-    @ccall libumfpack.umfpack_zi_report_matrix(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, col_form::Cint, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_report_matrix(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                               Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                               Az::Ptr{Cdouble}, col_form::Cint,
+                                               Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_report_matrix(n_row, n_col, Ap, Ai, Ax, Az, col_form, Control)
-    @ccall libumfpack.umfpack_zl_report_matrix(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, col_form::Cint, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_report_matrix(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                               Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                               Az::Ptr{Cdouble}, col_form::Cint,
+                                               Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_report_triplet(n_row, n_col, nz, Ti, Tj, Tx, Control)
-    @ccall libumfpack.umfpack_di_report_triplet(n_row::Int32, n_col::Int32, nz::Int32, Ti::Ptr{Int32}, Tj::Ptr{Int32}, Tx::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_report_triplet(n_row::Int32, n_col::Int32, nz::Int32,
+                                                Ti::Ptr{Int32}, Tj::Ptr{Int32},
+                                                Tx::Ptr{Cdouble},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_report_triplet(n_row, n_col, nz, Ti, Tj, Tx, Control)
-    @ccall libumfpack.umfpack_dl_report_triplet(n_row::Int64, n_col::Int64, nz::Int64, Ti::Ptr{Int64}, Tj::Ptr{Int64}, Tx::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_report_triplet(n_row::Int64, n_col::Int64, nz::Int64,
+                                                Ti::Ptr{Int64}, Tj::Ptr{Int64},
+                                                Tx::Ptr{Cdouble},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_report_triplet(n_row, n_col, nz, Ti, Tj, Tx, Tz, Control)
-    @ccall libumfpack.umfpack_zi_report_triplet(n_row::Int32, n_col::Int32, nz::Int32, Ti::Ptr{Int32}, Tj::Ptr{Int32}, Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_report_triplet(n_row::Int32, n_col::Int32, nz::Int32,
+                                                Ti::Ptr{Int32}, Tj::Ptr{Int32},
+                                                Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_report_triplet(n_row, n_col, nz, Ti, Tj, Tx, Tz, Control)
-    @ccall libumfpack.umfpack_zl_report_triplet(n_row::Int64, n_col::Int64, nz::Int64, Ti::Ptr{Int64}, Tj::Ptr{Int64}, Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_report_triplet(n_row::Int64, n_col::Int64, nz::Int64,
+                                                Ti::Ptr{Int64}, Tj::Ptr{Int64},
+                                                Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_report_vector(n, X, Control)
-    @ccall libumfpack.umfpack_di_report_vector(n::Int32, X::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_report_vector(n::Int32, X::Ptr{Cdouble},
+                                               Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_report_vector(n, X, Control)
-    @ccall libumfpack.umfpack_dl_report_vector(n::Int64, X::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_report_vector(n::Int64, X::Ptr{Cdouble},
+                                               Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_report_vector(n, Xx, Xz, Control)
-    @ccall libumfpack.umfpack_zi_report_vector(n::Int32, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_report_vector(n::Int32, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble},
+                                               Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_report_vector(n, Xx, Xz, Control)
-    @ccall libumfpack.umfpack_zl_report_vector(n::Int64, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_report_vector(n::Int64, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble},
+                                               Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_report_symbolic(Symbolic, Control)
-    @ccall libumfpack.umfpack_di_report_symbolic(Symbolic::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_report_symbolic(Symbolic::Ptr{Cvoid},
+                                                 Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_report_symbolic(Symbolic, Control)
-    @ccall libumfpack.umfpack_dl_report_symbolic(Symbolic::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_report_symbolic(Symbolic::Ptr{Cvoid},
+                                                 Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_report_symbolic(Symbolic, Control)
-    @ccall libumfpack.umfpack_zi_report_symbolic(Symbolic::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_report_symbolic(Symbolic::Ptr{Cvoid},
+                                                 Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_report_symbolic(Symbolic, Control)
-    @ccall libumfpack.umfpack_zl_report_symbolic(Symbolic::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_report_symbolic(Symbolic::Ptr{Cvoid},
+                                                 Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_report_numeric(Numeric, Control)
-    @ccall libumfpack.umfpack_di_report_numeric(Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_report_numeric(Numeric::Ptr{Cvoid},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_report_numeric(Numeric, Control)
-    @ccall libumfpack.umfpack_dl_report_numeric(Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_report_numeric(Numeric::Ptr{Cvoid},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_report_numeric(Numeric, Control)
-    @ccall libumfpack.umfpack_zi_report_numeric(Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_report_numeric(Numeric::Ptr{Cvoid},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_report_numeric(Numeric, Control)
-    @ccall libumfpack.umfpack_zl_report_numeric(Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_report_numeric(Numeric::Ptr{Cvoid},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_report_perm(np, Perm, Control)
-    @ccall libumfpack.umfpack_di_report_perm(np::Int32, Perm::Ptr{Int32}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_report_perm(np::Int32, Perm::Ptr{Int32},
+                                             Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_report_perm(np, Perm, Control)
-    @ccall libumfpack.umfpack_dl_report_perm(np::Int64, Perm::Ptr{Int64}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_report_perm(np::Int64, Perm::Ptr{Int64},
+                                             Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_report_perm(np, Perm, Control)
-    @ccall libumfpack.umfpack_zi_report_perm(np::Int32, Perm::Ptr{Int32}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_report_perm(np::Int32, Perm::Ptr{Int32},
+                                             Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_report_perm(np, Perm, Control)
-    @ccall libumfpack.umfpack_zl_report_perm(np::Int64, Perm::Ptr{Int64}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_report_perm(np::Int64, Perm::Ptr{Int64},
+                                             Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_timer()
@@ -2395,13 +3219,13 @@ function umfpack_toc(stats)
     @ccall libumfpack.umfpack_toc(stats::Ptr{Cdouble})::Cvoid
 end
 
-const CHOLMOD_DATE = "Jan 17, 2023"
+const CHOLMOD_DATE = "June 16, 2023"
 
 const CHOLMOD_MAIN_VERSION = 4
 
 const CHOLMOD_SUB_VERSION = 0
 
-const CHOLMOD_SUBSUB_VERSION = 3
+const CHOLMOD_SUBSUB_VERSION = 4
 
 const _FILE_OFFSET_BITS = 64
 
@@ -2427,17 +3251,18 @@ const SUITESPARSE_COMPILER_MSC = 0
 
 const SUITESPARSE_COMPILER_XLC = 0
 
-const SUITESPARSE_DATE = "Jan 20, 2023"
+const SUITESPARSE_DATE = "June 29, 2023"
 
 const SUITESPARSE_MAIN_VERSION = 7
 
-const SUITESPARSE_SUB_VERSION = 0
+const SUITESPARSE_SUB_VERSION = 1
 
-const SUITESPARSE_SUBSUB_VERSION = 1
+const SUITESPARSE_SUBSUB_VERSION = 0
 
 SUITESPARSE_VER_CODE(main, sub) = main * 1000 + sub
 
-const SUITESPARSE_VERSION = SUITESPARSE_VER_CODE(SUITESPARSE_MAIN_VERSION, SUITESPARSE_SUB_VERSION)
+const SUITESPARSE_VERSION = SUITESPARSE_VER_CODE(SUITESPARSE_MAIN_VERSION,
+                                                 SUITESPARSE_SUB_VERSION)
 
 CHOLMOD_VER_CODE(main, sub) = main * 1000 + sub
 
@@ -2601,20 +3426,18 @@ const SPQR_RTX_EQUALS_B = 2
 
 const SPQR_RTX_EQUALS_ETB = 3
 
-const SPQR_DATE = "Jan 17, 2023"
+const SPQR_DATE = "July FIXME, 2023"
 
-const SPQR_MAIN_VERSION = 3
+const SPQR_MAIN_VERSION = 4
 
 const SPQR_SUB_VERSION = 0
 
-const SPQR_SUBSUB_VERSION = 3
+const SPQR_SUBSUB_VERSION = 0
 
 SPQR_VER_CODE(main, sub) = main * 1000 + sub
 
 const SPQR_VERSION = SPQR_VER_CODE(SPQR_MAIN_VERSION, SPQR_SUB_VERSION)
 
-const Complex = Float64
-
 const AMD_CONTROL = 5
 
 const AMD_INFO = 20
@@ -2663,172 +3486,29 @@ const AMD_INVALID = -2
 
 const AMD_OK_BUT_JUMBLED = 1
 
-const AMD_DATE = "Jan 17, 2023"
+const AMD_DATE = "June 16, 2023"
 
 const AMD_MAIN_VERSION = 3
 
 const AMD_SUB_VERSION = 0
 
-const AMD_SUBSUB_VERSION = 3
+const AMD_SUBSUB_VERSION = 4
 
 AMD_VERSION_CODE(main, sub) = main * 1000 + sub
 
 const AMD_VERSION = AMD_VERSION_CODE(AMD_MAIN_VERSION, AMD_SUB_VERSION)
 
-const COLAMD_DATE = "Jan 17, 2023"
-
-const COLAMD_MAIN_VERSION = 3
-
-const COLAMD_SUB_VERSION = 0
-
-const COLAMD_SUBSUB_VERSION = 3
-
-COLAMD_VERSION_CODE(main, sub) = main * 1000 + sub
-
-const COLAMD_VERSION = COLAMD_VERSION_CODE(COLAMD_MAIN_VERSION, COLAMD_SUB_VERSION)
-
-const COLAMD_KNOBS = 20
-
-const COLAMD_STATS = 20
-
-const COLAMD_DENSE_ROW = 0
-
-const COLAMD_DENSE_COL = 1
-
-const COLAMD_AGGRESSIVE = 2
-
-const COLAMD_DEFRAG_COUNT = 2
-
-const COLAMD_STATUS = 3
-
-const COLAMD_INFO1 = 4
-
-const COLAMD_INFO2 = 5
-
-const COLAMD_INFO3 = 6
-
-const COLAMD_OK = 0
-
-const COLAMD_OK_BUT_JUMBLED = 1
-
-const COLAMD_ERROR_A_not_present = -1
-
-const COLAMD_ERROR_p_not_present = -2
-
-const COLAMD_ERROR_nrow_negative = -3
-
-const COLAMD_ERROR_ncol_negative = -4
-
-const COLAMD_ERROR_nnz_negative = -5
-
-const COLAMD_ERROR_p0_nonzero = -6
-
-const COLAMD_ERROR_A_too_small = -7
-
-const COLAMD_ERROR_col_length_negative = -8
-
-const COLAMD_ERROR_row_index_out_of_bounds = -9
-
-const COLAMD_ERROR_out_of_memory = -10
-
-const COLAMD_ERROR_internal_error = -999
-
-const CCOLAMD_DATE = "Jan 17, 2023"
-
-const CCOLAMD_MAIN_VERSION = 3
-
-const CCOLAMD_SUB_VERSION = 0
-
-const CCOLAMD_SUBSUB_VERSION = 3
-
-CCOLAMD_VERSION_CODE(main, sub) = main * 1000 + sub
-
-const CCOLAMD_VERSION = CCOLAMD_VERSION_CODE(CCOLAMD_MAIN_VERSION, CCOLAMD_SUB_VERSION)
-
-const CCOLAMD_KNOBS = 20
-
-const CCOLAMD_STATS = 20
-
-const CCOLAMD_DENSE_ROW = 0
-
-const CCOLAMD_DENSE_COL = 1
-
-const CCOLAMD_AGGRESSIVE = 2
-
-const CCOLAMD_LU = 3
-
-const CCOLAMD_DEFRAG_COUNT = 2
-
-const CCOLAMD_STATUS = 3
-
-const CCOLAMD_INFO1 = 4
-
-const CCOLAMD_INFO2 = 5
-
-const CCOLAMD_INFO3 = 6
-
-const CCOLAMD_EMPTY_ROW = 7
-
-const CCOLAMD_EMPTY_COL = 8
-
-const CCOLAMD_NEWLY_EMPTY_ROW = 9
-
-const CCOLAMD_NEWLY_EMPTY_COL = 10
-
-const CCOLAMD_OK = 0
-
-const CCOLAMD_OK_BUT_JUMBLED = 1
-
-const CCOLAMD_ERROR_A_not_present = -1
-
-const CCOLAMD_ERROR_p_not_present = -2
-
-const CCOLAMD_ERROR_nrow_negative = -3
-
-const CCOLAMD_ERROR_ncol_negative = -4
-
-const CCOLAMD_ERROR_nnz_negative = -5
-
-const CCOLAMD_ERROR_p0_nonzero = -6
-
-const CCOLAMD_ERROR_A_too_small = -7
-
-const CCOLAMD_ERROR_col_length_negative = -8
-
-const CCOLAMD_ERROR_row_index_out_of_bounds = -9
-
-const CCOLAMD_ERROR_out_of_memory = -10
-
-const CCOLAMD_ERROR_invalid_cmember = -11
-
-const CCOLAMD_ERROR_internal_error = -999
-
 const UMFPACK_INFO = 90
 
 const UMFPACK_CONTROL = 20
 
-# Skipping MacroDefinition: UMFPACK_COPYRIGHT \
-#"UMFPACK:  Copyright (c) 2005-2023 by Timothy A. Davis.  All Rights Reserved.\n"
-
-# Skipping MacroDefinition: UMFPACK_LICENSE_PART1 \
-#"\nUMFPACK License: SPDX-License-Identifier: GPL-2.0+\n" \
-#"   UMFPACK is available under alternate licenses,\n" \
-#"   contact T. Davis for details.\n"
-
-const UMFPACK_LICENSE_PART2 = "\n"
-
-# Skipping MacroDefinition: UMFPACK_LICENSE_PART3 \
-#"\n" \
-#"Availability: http://www.suitesparse.com" \
-#"\n"
-
-const UMFPACK_DATE = "Jan 17, 2023"
+const UMFPACK_DATE = "June 16, 2023"
 
 const UMFPACK_MAIN_VERSION = 6
 
 const UMFPACK_SUB_VERSION = 1
 
-const UMFPACK_SUBSUB_VERSION = 0
+const UMFPACK_SUBSUB_VERSION = 1
 
 UMFPACK_VER_CODE(main, sub) = main * 1000 + sub
 
@@ -3169,4 +3849,3 @@ const UMFPACK_Q_Uat = 12
 const UMFPACK_Ut = 13
 
 const UMFPACK_Uat = 14
-
diff --git a/src/solvers/lib/x86_64-linux-gnu.jl b/src/solvers/lib/x86_64-linux-gnu.jl
index fcf756d2..a5aa4e44 100644
--- a/src/solvers/lib/x86_64-linux-gnu.jl
+++ b/src/solvers/lib/x86_64-linux-gnu.jl
@@ -1,137 +1,150 @@
 function SuiteSparse_config_printf_func_get()
-    @ccall libcholmod.SuiteSparse_config_printf_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_printf_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_malloc_func_get()
-    @ccall libcholmod.SuiteSparse_config_malloc_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_malloc_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_calloc_func_get()
-    @ccall libcholmod.SuiteSparse_config_calloc_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_calloc_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_realloc_func_get()
-    @ccall libcholmod.SuiteSparse_config_realloc_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_realloc_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_free_func_get()
-    @ccall libcholmod.SuiteSparse_config_free_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_free_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_hypot_func_get()
-    @ccall libcholmod.SuiteSparse_config_hypot_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_hypot_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_divcomplex_func_get()
-    @ccall libcholmod.SuiteSparse_config_divcomplex_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_divcomplex_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_malloc_func_set(malloc_func)
-    @ccall libcholmod.SuiteSparse_config_malloc_func_set(malloc_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_malloc_func_set(malloc_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_calloc_func_set(calloc_func)
-    @ccall libcholmod.SuiteSparse_config_calloc_func_set(calloc_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_calloc_func_set(calloc_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_realloc_func_set(realloc_func)
-    @ccall libcholmod.SuiteSparse_config_realloc_func_set(realloc_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_realloc_func_set(realloc_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_free_func_set(free_func)
-    @ccall libcholmod.SuiteSparse_config_free_func_set(free_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_free_func_set(free_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_printf_func_set(printf_func)
-    @ccall libcholmod.SuiteSparse_config_printf_func_set(printf_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_printf_func_set(printf_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_hypot_func_set(hypot_func)
-    @ccall libcholmod.SuiteSparse_config_hypot_func_set(hypot_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_hypot_func_set(hypot_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_divcomplex_func_set(divcomplex_func)
-    @ccall libcholmod.SuiteSparse_config_divcomplex_func_set(divcomplex_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_divcomplex_func_set(divcomplex_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_malloc(s)
-    @ccall libcholmod.SuiteSparse_config_malloc(s::Csize_t)::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_malloc(s::Csize_t)::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_calloc(n, s)
-    @ccall libcholmod.SuiteSparse_config_calloc(n::Csize_t, s::Csize_t)::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_calloc(n::Csize_t,
+                                                          s::Csize_t)::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_realloc(arg1, s)
-    @ccall libcholmod.SuiteSparse_config_realloc(arg1::Ptr{Cvoid}, s::Csize_t)::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_realloc(arg1::Ptr{Cvoid},
+                                                           s::Csize_t)::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_free(arg1)
-    @ccall libcholmod.SuiteSparse_config_free(arg1::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_free(arg1::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_hypot(x, y)
-    @ccall libcholmod.SuiteSparse_config_hypot(x::Cdouble, y::Cdouble)::Cdouble
+    @ccall libsuitesparseconfig.SuiteSparse_config_hypot(x::Cdouble, y::Cdouble)::Cdouble
 end
 
 function SuiteSparse_config_divcomplex(xr, xi, yr, yi, zr, zi)
-    @ccall libcholmod.SuiteSparse_config_divcomplex(xr::Cdouble, xi::Cdouble, yr::Cdouble, yi::Cdouble, zr::Ptr{Cdouble}, zi::Ptr{Cdouble})::Cint
+    @ccall libsuitesparseconfig.SuiteSparse_config_divcomplex(xr::Cdouble, xi::Cdouble,
+                                                              yr::Cdouble, yi::Cdouble,
+                                                              zr::Ptr{Cdouble},
+                                                              zi::Ptr{Cdouble})::Cint
 end
 
 function SuiteSparse_start()
-    @ccall libcholmod.SuiteSparse_start()::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_start()::Cvoid
 end
 
 function SuiteSparse_finish()
-    @ccall libcholmod.SuiteSparse_finish()::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_finish()::Cvoid
 end
 
 function SuiteSparse_malloc(nitems, size_of_item)
-    @ccall libcholmod.SuiteSparse_malloc(nitems::Csize_t, size_of_item::Csize_t)::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_malloc(nitems::Csize_t,
+                                                   size_of_item::Csize_t)::Ptr{Cvoid}
 end
 
 function SuiteSparse_calloc(nitems, size_of_item)
-    @ccall libcholmod.SuiteSparse_calloc(nitems::Csize_t, size_of_item::Csize_t)::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_calloc(nitems::Csize_t,
+                                                   size_of_item::Csize_t)::Ptr{Cvoid}
 end
 
 function SuiteSparse_realloc(nitems_new, nitems_old, size_of_item, p, ok)
-    @ccall libcholmod.SuiteSparse_realloc(nitems_new::Csize_t, nitems_old::Csize_t, size_of_item::Csize_t, p::Ptr{Cvoid}, ok::Ptr{Cint})::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_realloc(nitems_new::Csize_t,
+                                                    nitems_old::Csize_t,
+                                                    size_of_item::Csize_t, p::Ptr{Cvoid},
+                                                    ok::Ptr{Cint})::Ptr{Cvoid}
 end
 
 function SuiteSparse_free(p)
-    @ccall libcholmod.SuiteSparse_free(p::Ptr{Cvoid})::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_free(p::Ptr{Cvoid})::Ptr{Cvoid}
 end
 
 function SuiteSparse_tic(tic)
-    @ccall libcholmod.SuiteSparse_tic(tic::Ptr{Cdouble})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_tic(tic::Ptr{Cdouble})::Cvoid
 end
 
 function SuiteSparse_toc(tic)
-    @ccall libcholmod.SuiteSparse_toc(tic::Ptr{Cdouble})::Cdouble
+    @ccall libsuitesparseconfig.SuiteSparse_toc(tic::Ptr{Cdouble})::Cdouble
 end
 
 function SuiteSparse_time()
-    @ccall libcholmod.SuiteSparse_time()::Cdouble
+    @ccall libsuitesparseconfig.SuiteSparse_time()::Cdouble
 end
 
 function SuiteSparse_hypot(x, y)
-    @ccall libcholmod.SuiteSparse_hypot(x::Cdouble, y::Cdouble)::Cdouble
+    @ccall libsuitesparseconfig.SuiteSparse_hypot(x::Cdouble, y::Cdouble)::Cdouble
 end
 
 function SuiteSparse_divcomplex(ar, ai, br, bi, cr, ci)
-    @ccall libcholmod.SuiteSparse_divcomplex(ar::Cdouble, ai::Cdouble, br::Cdouble, bi::Cdouble, cr::Ptr{Cdouble}, ci::Ptr{Cdouble})::Cint
+    @ccall libsuitesparseconfig.SuiteSparse_divcomplex(ar::Cdouble, ai::Cdouble,
+                                                       br::Cdouble, bi::Cdouble,
+                                                       cr::Ptr{Cdouble},
+                                                       ci::Ptr{Cdouble})::Cint
 end
 
 function SuiteSparse_version(version)
-    @ccall libcholmod.SuiteSparse_version(version::Ptr{Cint})::Cint
+    @ccall libsuitesparseconfig.SuiteSparse_version(version::Ptr{Cint})::Cint
 end
 
 function SuiteSparse_BLAS_library()
-    @ccall libcholmod.SuiteSparse_BLAS_library()::Ptr{Cchar}
+    @ccall libsuitesparseconfig.SuiteSparse_BLAS_library()::Ptr{Cchar}
 end
 
 function SuiteSparse_BLAS_integer_size()
-    @ccall libcholmod.SuiteSparse_BLAS_integer_size()::Csize_t
+    @ccall libsuitesparseconfig.SuiteSparse_BLAS_integer_size()::Csize_t
 end
 
 struct cholmod_method_struct
@@ -140,16 +153,16 @@ struct cholmod_method_struct
     prune_dense::Cdouble
     prune_dense2::Cdouble
     nd_oksep::Cdouble
-    other_1::NTuple{4, Cdouble}
+    other_1::NTuple{4,Cdouble}
     nd_small::Csize_t
-    other_2::NTuple{4, Csize_t}
+    other_2::NTuple{4,Csize_t}
     aggressive::Cint
     order_for_lu::Cint
     nd_compress::Cint
     nd_camd::Cint
     nd_components::Cint
     ordering::Cint
-    other_3::NTuple{4, Csize_t}
+    other_3::NTuple{4,Csize_t}
 end
 
 mutable struct cholmod_common_struct
@@ -166,8 +179,8 @@ mutable struct cholmod_common_struct
     final_pack::Cint
     final_monotonic::Cint
     final_resymbol::Cint
-    zrelax::NTuple{3, Cdouble}
-    nrelax::NTuple{3, Csize_t}
+    zrelax::NTuple{3,Cdouble}
+    nrelax::NTuple{3,Csize_t}
     prefer_zomplex::Cint
     prefer_upper::Cint
     quick_return_if_not_posdef::Cint
@@ -179,7 +192,7 @@ mutable struct cholmod_common_struct
     nmethods::Cint
     current::Cint
     selected::Cint
-    method::NTuple{10, cholmod_method_struct}
+    method::NTuple{10,cholmod_method_struct}
     postorder::Cint
     default_nesdis::Cint
     metis_memory::Cdouble
@@ -222,7 +235,7 @@ mutable struct cholmod_common_struct
     SPQR_flopcount_bound::Cdouble
     SPQR_tol_used::Cdouble
     SPQR_norm_E_fro::Cdouble
-    SPQR_istat::NTuple{10, Int64}
+    SPQR_istat::NTuple{10,Int64}
     useGPU::Cint
     maxGpuMemBytes::Csize_t
     maxGpuMemFraction::Cdouble
@@ -231,10 +244,10 @@ mutable struct cholmod_common_struct
     gpuFlops::Int64
     gpuNumKernelLaunches::Cint
     cublasHandle::Ptr{Cvoid}
-    gpuStream::NTuple{8, Ptr{Cvoid}}
-    cublasEventPotrf::NTuple{3, Ptr{Cvoid}}
+    gpuStream::NTuple{8,Ptr{Cvoid}}
+    cublasEventPotrf::NTuple{3,Ptr{Cvoid}}
     updateCKernelsComplete::Ptr{Cvoid}
-    updateCBuffersFree::NTuple{8, Ptr{Cvoid}}
+    updateCBuffersFree::NTuple{8,Ptr{Cvoid}}
     dev_mempool::Ptr{Cvoid}
     dev_mempool_size::Csize_t
     host_pinned_mempool::Ptr{Cvoid}
@@ -300,11 +313,14 @@ function cholmod_l_maxrank(arg1, arg2)
 end
 
 function cholmod_allocate_work(nrow, iworksize, xworksize, Common)
-    @ccall libcholmod.cholmod_allocate_work(nrow::Csize_t, iworksize::Csize_t, xworksize::Csize_t, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_allocate_work(nrow::Csize_t, iworksize::Csize_t,
+                                            xworksize::Csize_t,
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_allocate_work(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_allocate_work(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_allocate_work(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t,
+                                              arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_free_work(Common)
@@ -324,11 +340,13 @@ function cholmod_l_clear_flag(arg1)
 end
 
 function cholmod_error(status, file, line, message, Common)
-    @ccall libcholmod.cholmod_error(status::Cint, file::Ptr{Cchar}, line::Cint, message::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_error(status::Cint, file::Ptr{Cchar}, line::Cint,
+                                    message::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_error(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_error(arg1::Cint, arg2::Ptr{Cchar}, arg3::Cint, arg4::Ptr{Cchar}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_error(arg1::Cint, arg2::Ptr{Cchar}, arg3::Cint,
+                                      arg4::Ptr{Cchar}, arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_dbound(dj, Common)
@@ -348,11 +366,14 @@ function cholmod_l_hypot(arg1, arg2)
 end
 
 function cholmod_divcomplex(ar, ai, br, bi, cr, ci)
-    @ccall libcholmod.cholmod_divcomplex(ar::Cdouble, ai::Cdouble, br::Cdouble, bi::Cdouble, cr::Ptr{Cdouble}, ci::Ptr{Cdouble})::Cint
+    @ccall libcholmod.cholmod_divcomplex(ar::Cdouble, ai::Cdouble, br::Cdouble, bi::Cdouble,
+                                         cr::Ptr{Cdouble}, ci::Ptr{Cdouble})::Cint
 end
 
 function cholmod_l_divcomplex(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_divcomplex(arg1::Cdouble, arg2::Cdouble, arg3::Cdouble, arg4::Cdouble, arg5::Ptr{Cdouble}, arg6::Ptr{Cdouble})::Cint
+    @ccall libcholmod.cholmod_l_divcomplex(arg1::Cdouble, arg2::Cdouble, arg3::Cdouble,
+                                           arg4::Cdouble, arg5::Ptr{Cdouble},
+                                           arg6::Ptr{Cdouble})::Cint
 end
 
 mutable struct cholmod_sparse_struct
@@ -384,155 +405,217 @@ end
 const descendantScore = cholmod_descendant_score_t
 
 function cholmod_score_comp(i, j)
-    @ccall libcholmod.cholmod_score_comp(i::Ptr{cholmod_descendant_score_t}, j::Ptr{cholmod_descendant_score_t})::Cint
+    @ccall libcholmod.cholmod_score_comp(i::Ptr{cholmod_descendant_score_t},
+                                         j::Ptr{cholmod_descendant_score_t})::Cint
 end
 
 function cholmod_l_score_comp(i, j)
-    @ccall libcholmod.cholmod_l_score_comp(i::Ptr{cholmod_descendant_score_t}, j::Ptr{cholmod_descendant_score_t})::Cint
+    @ccall libcholmod.cholmod_l_score_comp(i::Ptr{cholmod_descendant_score_t},
+                                           j::Ptr{cholmod_descendant_score_t})::Cint
 end
 
 function cholmod_allocate_sparse(nrow, ncol, nzmax, sorted, packed, stype, xtype, Common)
-    @ccall libcholmod.cholmod_allocate_sparse(nrow::Csize_t, ncol::Csize_t, nzmax::Csize_t, sorted::Cint, packed::Cint, stype::Cint, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_allocate_sparse(nrow::Csize_t, ncol::Csize_t, nzmax::Csize_t,
+                                              sorted::Cint, packed::Cint, stype::Cint,
+                                              xtype::Cint,
+                                              Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_allocate_sparse(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
-    @ccall libcholmod.cholmod_l_allocate_sparse(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t, arg4::Cint, arg5::Cint, arg6::Cint, arg7::Cint, arg8::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_allocate_sparse(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t,
+                                                arg4::Cint, arg5::Cint, arg6::Cint,
+                                                arg7::Cint,
+                                                arg8::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_free_sparse(A, Common)
-    @ccall libcholmod.cholmod_free_sparse(A::Ptr{Ptr{cholmod_sparse}}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_free_sparse(A::Ptr{Ptr{cholmod_sparse}},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_free_sparse(arg1, arg2)
-    @ccall libcholmod.cholmod_l_free_sparse(arg1::Ptr{Ptr{cholmod_sparse}}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_free_sparse(arg1::Ptr{Ptr{cholmod_sparse}},
+                                            arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_reallocate_sparse(nznew, A, Common)
-    @ccall libcholmod.cholmod_reallocate_sparse(nznew::Csize_t, A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_reallocate_sparse(nznew::Csize_t, A::Ptr{cholmod_sparse},
+                                                Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_reallocate_sparse(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_reallocate_sparse(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_reallocate_sparse(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                                  arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_nnz(A, Common)
-    @ccall libcholmod.cholmod_nnz(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_nnz(A::Ptr{cholmod_sparse},
+                                  Common::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_l_nnz(arg1, arg2)
-    @ccall libcholmod.cholmod_l_nnz(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_l_nnz(arg1::Ptr{cholmod_sparse},
+                                    arg2::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_speye(nrow, ncol, xtype, Common)
-    @ccall libcholmod.cholmod_speye(nrow::Csize_t, ncol::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_speye(nrow::Csize_t, ncol::Csize_t, xtype::Cint,
+                                    Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_speye(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_speye(arg1::Csize_t, arg2::Csize_t, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_speye(arg1::Csize_t, arg2::Csize_t, arg3::Cint,
+                                      arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_spzeros(nrow, ncol, nzmax, xtype, Common)
-    @ccall libcholmod.cholmod_spzeros(nrow::Csize_t, ncol::Csize_t, nzmax::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_spzeros(nrow::Csize_t, ncol::Csize_t, nzmax::Csize_t,
+                                      xtype::Cint,
+                                      Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_spzeros(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_spzeros(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t, arg4::Cint, arg5::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_spzeros(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t,
+                                        arg4::Cint,
+                                        arg5::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_transpose(A, values, Common)
-    @ccall libcholmod.cholmod_transpose(A::Ptr{cholmod_sparse}, values::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_transpose(A::Ptr{cholmod_sparse}, values::Cint,
+                                        Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_transpose(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_transpose(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_transpose(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                          arg3::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_transpose_unsym(A, values, Perm, fset, fsize, F, Common)
-    @ccall libcholmod.cholmod_transpose_unsym(A::Ptr{cholmod_sparse}, values::Cint, Perm::Ptr{Int32}, fset::Ptr{Int32}, fsize::Csize_t, F::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_transpose_unsym(A::Ptr{cholmod_sparse}, values::Cint,
+                                              Perm::Ptr{Int32}, fset::Ptr{Int32},
+                                              fsize::Csize_t, F::Ptr{cholmod_sparse},
+                                              Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_transpose_unsym(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_transpose_unsym(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Csize_t, arg6::Ptr{cholmod_sparse}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_transpose_unsym(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                                arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                                arg5::Csize_t, arg6::Ptr{cholmod_sparse},
+                                                arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_transpose_sym(A, values, Perm, F, Common)
-    @ccall libcholmod.cholmod_transpose_sym(A::Ptr{cholmod_sparse}, values::Cint, Perm::Ptr{Int32}, F::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_transpose_sym(A::Ptr{cholmod_sparse}, values::Cint,
+                                            Perm::Ptr{Int32}, F::Ptr{cholmod_sparse},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_transpose_sym(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_transpose_sym(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{Int64}, arg4::Ptr{cholmod_sparse}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_transpose_sym(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                              arg3::Ptr{Int64}, arg4::Ptr{cholmod_sparse},
+                                              arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_ptranspose(A, values, Perm, fset, fsize, Common)
-    @ccall libcholmod.cholmod_ptranspose(A::Ptr{cholmod_sparse}, values::Cint, Perm::Ptr{Int32}, fset::Ptr{Int32}, fsize::Csize_t, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_ptranspose(A::Ptr{cholmod_sparse}, values::Cint,
+                                         Perm::Ptr{Int32}, fset::Ptr{Int32}, fsize::Csize_t,
+                                         Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_ptranspose(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_ptranspose(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Csize_t, arg6::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_ptranspose(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                           arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                           arg5::Csize_t,
+                                           arg6::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_sort(A, Common)
-    @ccall libcholmod.cholmod_sort(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_sort(A::Ptr{cholmod_sparse},
+                                   Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_sort(arg1, arg2)
-    @ccall libcholmod.cholmod_l_sort(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_sort(arg1::Ptr{cholmod_sparse},
+                                     arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_band(A, k1, k2, mode, Common)
-    @ccall libcholmod.cholmod_band(A::Ptr{cholmod_sparse}, k1::Int64, k2::Int64, mode::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_band(A::Ptr{cholmod_sparse}, k1::Int64, k2::Int64, mode::Cint,
+                                   Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_band(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_band(arg1::Ptr{cholmod_sparse}, arg2::Int64, arg3::Int64, arg4::Cint, arg5::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_band(arg1::Ptr{cholmod_sparse}, arg2::Int64, arg3::Int64,
+                                     arg4::Cint,
+                                     arg5::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_band_inplace(k1, k2, mode, A, Common)
-    @ccall libcholmod.cholmod_band_inplace(k1::Int64, k2::Int64, mode::Cint, A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_band_inplace(k1::Int64, k2::Int64, mode::Cint,
+                                           A::Ptr{cholmod_sparse},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_band_inplace(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_band_inplace(arg1::Int64, arg2::Int64, arg3::Cint, arg4::Ptr{cholmod_sparse}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_band_inplace(arg1::Int64, arg2::Int64, arg3::Cint,
+                                             arg4::Ptr{cholmod_sparse},
+                                             arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_aat(A, fset, fsize, mode, Common)
-    @ccall libcholmod.cholmod_aat(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, mode::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_aat(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t,
+                                  mode::Cint,
+                                  Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_aat(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_aat(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Cint, arg5::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_aat(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                    arg3::Csize_t, arg4::Cint,
+                                    arg5::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_copy_sparse(A, Common)
-    @ccall libcholmod.cholmod_copy_sparse(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_copy_sparse(A::Ptr{cholmod_sparse},
+                                          Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_copy_sparse(arg1, arg2)
-    @ccall libcholmod.cholmod_l_copy_sparse(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_copy_sparse(arg1::Ptr{cholmod_sparse},
+                                            arg2::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_copy(A, stype, mode, Common)
-    @ccall libcholmod.cholmod_copy(A::Ptr{cholmod_sparse}, stype::Cint, mode::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_copy(A::Ptr{cholmod_sparse}, stype::Cint, mode::Cint,
+                                   Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_copy(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_copy(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_copy(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Cint,
+                                     arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_add(A, B, alpha, beta, values, sorted, Common)
-    @ccall libcholmod.cholmod_add(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse}, alpha::Ptr{Cdouble}, beta::Ptr{Cdouble}, values::Cint, sorted::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_add(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse},
+                                  alpha::Ptr{Cdouble}, beta::Ptr{Cdouble}, values::Cint,
+                                  sorted::Cint,
+                                  Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_add(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_add(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Ptr{Cdouble}, arg5::Cint, arg6::Cint, arg7::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_add(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse},
+                                    arg3::Ptr{Cdouble}, arg4::Ptr{Cdouble}, arg5::Cint,
+                                    arg6::Cint,
+                                    arg7::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_sparse_xtype(to_xtype, A, Common)
-    @ccall libcholmod.cholmod_sparse_xtype(to_xtype::Cint, A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_sparse_xtype(to_xtype::Cint, A::Ptr{cholmod_sparse},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_sparse_xtype(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_sparse_xtype(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_sparse_xtype(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                             arg3::Ptr{cholmod_common})::Cint
 end
 
 mutable struct cholmod_factor_struct
@@ -572,75 +655,100 @@ end
 const cholmod_factor = cholmod_factor_struct
 
 function cholmod_allocate_factor(n, Common)
-    @ccall libcholmod.cholmod_allocate_factor(n::Csize_t, Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_allocate_factor(n::Csize_t,
+                                              Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_l_allocate_factor(arg1, arg2)
-    @ccall libcholmod.cholmod_l_allocate_factor(arg1::Csize_t, arg2::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_l_allocate_factor(arg1::Csize_t,
+                                                arg2::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_free_factor(L, Common)
-    @ccall libcholmod.cholmod_free_factor(L::Ptr{Ptr{cholmod_factor}}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_free_factor(L::Ptr{Ptr{cholmod_factor}},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_free_factor(arg1, arg2)
-    @ccall libcholmod.cholmod_l_free_factor(arg1::Ptr{Ptr{cholmod_factor}}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_free_factor(arg1::Ptr{Ptr{cholmod_factor}},
+                                            arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_reallocate_factor(nznew, L, Common)
-    @ccall libcholmod.cholmod_reallocate_factor(nznew::Csize_t, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_reallocate_factor(nznew::Csize_t, L::Ptr{cholmod_factor},
+                                                Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_reallocate_factor(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_reallocate_factor(arg1::Csize_t, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_reallocate_factor(arg1::Csize_t, arg2::Ptr{cholmod_factor},
+                                                  arg3::Ptr{cholmod_common})::Cint
 end
 
-function cholmod_change_factor(to_xtype, to_ll, to_super, to_packed, to_monotonic, L, Common)
-    @ccall libcholmod.cholmod_change_factor(to_xtype::Cint, to_ll::Cint, to_super::Cint, to_packed::Cint, to_monotonic::Cint, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+function cholmod_change_factor(to_xtype, to_ll, to_super, to_packed, to_monotonic, L,
+                               Common)
+    @ccall libcholmod.cholmod_change_factor(to_xtype::Cint, to_ll::Cint, to_super::Cint,
+                                            to_packed::Cint, to_monotonic::Cint,
+                                            L::Ptr{cholmod_factor},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_change_factor(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_change_factor(arg1::Cint, arg2::Cint, arg3::Cint, arg4::Cint, arg5::Cint, arg6::Ptr{cholmod_factor}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_change_factor(arg1::Cint, arg2::Cint, arg3::Cint,
+                                              arg4::Cint, arg5::Cint,
+                                              arg6::Ptr{cholmod_factor},
+                                              arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_pack_factor(L, Common)
-    @ccall libcholmod.cholmod_pack_factor(L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_pack_factor(L::Ptr{cholmod_factor},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_pack_factor(arg1, arg2)
-    @ccall libcholmod.cholmod_l_pack_factor(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_pack_factor(arg1::Ptr{cholmod_factor},
+                                            arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_reallocate_column(j, need, L, Common)
-    @ccall libcholmod.cholmod_reallocate_column(j::Csize_t, need::Csize_t, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_reallocate_column(j::Csize_t, need::Csize_t,
+                                                L::Ptr{cholmod_factor},
+                                                Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_reallocate_column(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_reallocate_column(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{cholmod_factor}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_reallocate_column(arg1::Csize_t, arg2::Csize_t,
+                                                  arg3::Ptr{cholmod_factor},
+                                                  arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_factor_to_sparse(L, Common)
-    @ccall libcholmod.cholmod_factor_to_sparse(L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_factor_to_sparse(L::Ptr{cholmod_factor},
+                                               Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_factor_to_sparse(arg1, arg2)
-    @ccall libcholmod.cholmod_l_factor_to_sparse(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_factor_to_sparse(arg1::Ptr{cholmod_factor},
+                                                 arg2::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_copy_factor(L, Common)
-    @ccall libcholmod.cholmod_copy_factor(L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_copy_factor(L::Ptr{cholmod_factor},
+                                          Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_l_copy_factor(arg1, arg2)
-    @ccall libcholmod.cholmod_l_copy_factor(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_l_copy_factor(arg1::Ptr{cholmod_factor},
+                                            arg2::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_factor_xtype(to_xtype, L, Common)
-    @ccall libcholmod.cholmod_factor_xtype(to_xtype::Cint, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_factor_xtype(to_xtype::Cint, L::Ptr{cholmod_factor},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_factor_xtype(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_factor_xtype(arg1::Cint, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_factor_xtype(arg1::Cint, arg2::Ptr{cholmod_factor},
+                                             arg3::Ptr{cholmod_common})::Cint
 end
 
 mutable struct cholmod_dense_struct
@@ -658,91 +766,118 @@ end
 const cholmod_dense = cholmod_dense_struct
 
 function cholmod_allocate_dense(nrow, ncol, d, xtype, Common)
-    @ccall libcholmod.cholmod_allocate_dense(nrow::Csize_t, ncol::Csize_t, d::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_allocate_dense(nrow::Csize_t, ncol::Csize_t, d::Csize_t,
+                                             xtype::Cint,
+                                             Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_allocate_dense(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_allocate_dense(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t, arg4::Cint, arg5::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_allocate_dense(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t,
+                                               arg4::Cint,
+                                               arg5::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_zeros(nrow, ncol, xtype, Common)
-    @ccall libcholmod.cholmod_zeros(nrow::Csize_t, ncol::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_zeros(nrow::Csize_t, ncol::Csize_t, xtype::Cint,
+                                    Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_zeros(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_zeros(arg1::Csize_t, arg2::Csize_t, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_zeros(arg1::Csize_t, arg2::Csize_t, arg3::Cint,
+                                      arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_ones(nrow, ncol, xtype, Common)
-    @ccall libcholmod.cholmod_ones(nrow::Csize_t, ncol::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_ones(nrow::Csize_t, ncol::Csize_t, xtype::Cint,
+                                   Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_ones(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_ones(arg1::Csize_t, arg2::Csize_t, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_ones(arg1::Csize_t, arg2::Csize_t, arg3::Cint,
+                                     arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_eye(nrow, ncol, xtype, Common)
-    @ccall libcholmod.cholmod_eye(nrow::Csize_t, ncol::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_eye(nrow::Csize_t, ncol::Csize_t, xtype::Cint,
+                                  Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_eye(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_eye(arg1::Csize_t, arg2::Csize_t, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_eye(arg1::Csize_t, arg2::Csize_t, arg3::Cint,
+                                    arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_free_dense(X, Common)
-    @ccall libcholmod.cholmod_free_dense(X::Ptr{Ptr{cholmod_dense}}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_free_dense(X::Ptr{Ptr{cholmod_dense}},
+                                         Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_free_dense(arg1, arg2)
-    @ccall libcholmod.cholmod_l_free_dense(arg1::Ptr{Ptr{cholmod_dense}}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_free_dense(arg1::Ptr{Ptr{cholmod_dense}},
+                                           arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_ensure_dense(XHandle, nrow, ncol, d, xtype, Common)
-    @ccall libcholmod.cholmod_ensure_dense(XHandle::Ptr{Ptr{cholmod_dense}}, nrow::Csize_t, ncol::Csize_t, d::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_ensure_dense(XHandle::Ptr{Ptr{cholmod_dense}}, nrow::Csize_t,
+                                           ncol::Csize_t, d::Csize_t, xtype::Cint,
+                                           Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_ensure_dense(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_ensure_dense(arg1::Ptr{Ptr{cholmod_dense}}, arg2::Csize_t, arg3::Csize_t, arg4::Csize_t, arg5::Cint, arg6::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_ensure_dense(arg1::Ptr{Ptr{cholmod_dense}}, arg2::Csize_t,
+                                             arg3::Csize_t, arg4::Csize_t, arg5::Cint,
+                                             arg6::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_sparse_to_dense(A, Common)
-    @ccall libcholmod.cholmod_sparse_to_dense(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_sparse_to_dense(A::Ptr{cholmod_sparse},
+                                              Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_sparse_to_dense(arg1, arg2)
-    @ccall libcholmod.cholmod_l_sparse_to_dense(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_sparse_to_dense(arg1::Ptr{cholmod_sparse},
+                                                arg2::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_dense_to_sparse(X, values, Common)
-    @ccall libcholmod.cholmod_dense_to_sparse(X::Ptr{cholmod_dense}, values::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_dense_to_sparse(X::Ptr{cholmod_dense}, values::Cint,
+                                              Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_dense_to_sparse(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_dense_to_sparse(arg1::Ptr{cholmod_dense}, arg2::Cint, arg3::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_dense_to_sparse(arg1::Ptr{cholmod_dense}, arg2::Cint,
+                                                arg3::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_copy_dense(X, Common)
-    @ccall libcholmod.cholmod_copy_dense(X::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_copy_dense(X::Ptr{cholmod_dense},
+                                         Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_copy_dense(arg1, arg2)
-    @ccall libcholmod.cholmod_l_copy_dense(arg1::Ptr{cholmod_dense}, arg2::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_copy_dense(arg1::Ptr{cholmod_dense},
+                                           arg2::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_copy_dense2(X, Y, Common)
-    @ccall libcholmod.cholmod_copy_dense2(X::Ptr{cholmod_dense}, Y::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_copy_dense2(X::Ptr{cholmod_dense}, Y::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_copy_dense2(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_copy_dense2(arg1::Ptr{cholmod_dense}, arg2::Ptr{cholmod_dense}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_copy_dense2(arg1::Ptr{cholmod_dense},
+                                            arg2::Ptr{cholmod_dense},
+                                            arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_dense_xtype(to_xtype, X, Common)
-    @ccall libcholmod.cholmod_dense_xtype(to_xtype::Cint, X::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_dense_xtype(to_xtype::Cint, X::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_dense_xtype(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_dense_xtype(arg1::Cint, arg2::Ptr{cholmod_dense}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_dense_xtype(arg1::Cint, arg2::Ptr{cholmod_dense},
+                                            arg3::Ptr{cholmod_common})::Cint
 end
 
 mutable struct cholmod_triplet_struct
@@ -764,99 +899,137 @@ end
 const cholmod_triplet = cholmod_triplet_struct
 
 function cholmod_allocate_triplet(nrow, ncol, nzmax, stype, xtype, Common)
-    @ccall libcholmod.cholmod_allocate_triplet(nrow::Csize_t, ncol::Csize_t, nzmax::Csize_t, stype::Cint, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_allocate_triplet(nrow::Csize_t, ncol::Csize_t, nzmax::Csize_t,
+                                               stype::Cint, xtype::Cint,
+                                               Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_l_allocate_triplet(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_allocate_triplet(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t, arg4::Cint, arg5::Cint, arg6::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_l_allocate_triplet(arg1::Csize_t, arg2::Csize_t,
+                                                 arg3::Csize_t, arg4::Cint, arg5::Cint,
+                                                 arg6::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_free_triplet(T, Common)
-    @ccall libcholmod.cholmod_free_triplet(T::Ptr{Ptr{cholmod_triplet}}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_free_triplet(T::Ptr{Ptr{cholmod_triplet}},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_free_triplet(arg1, arg2)
-    @ccall libcholmod.cholmod_l_free_triplet(arg1::Ptr{Ptr{cholmod_triplet}}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_free_triplet(arg1::Ptr{Ptr{cholmod_triplet}},
+                                             arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_reallocate_triplet(nznew, T, Common)
-    @ccall libcholmod.cholmod_reallocate_triplet(nznew::Csize_t, T::Ptr{cholmod_triplet}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_reallocate_triplet(nznew::Csize_t, T::Ptr{cholmod_triplet},
+                                                 Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_reallocate_triplet(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_reallocate_triplet(arg1::Csize_t, arg2::Ptr{cholmod_triplet}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_reallocate_triplet(arg1::Csize_t,
+                                                   arg2::Ptr{cholmod_triplet},
+                                                   arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_sparse_to_triplet(A, Common)
-    @ccall libcholmod.cholmod_sparse_to_triplet(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_sparse_to_triplet(A::Ptr{cholmod_sparse},
+                                                Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_l_sparse_to_triplet(arg1, arg2)
-    @ccall libcholmod.cholmod_l_sparse_to_triplet(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_l_sparse_to_triplet(arg1::Ptr{cholmod_sparse},
+                                                  arg2::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_triplet_to_sparse(T, nzmax, Common)
-    @ccall libcholmod.cholmod_triplet_to_sparse(T::Ptr{cholmod_triplet}, nzmax::Csize_t, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_triplet_to_sparse(T::Ptr{cholmod_triplet}, nzmax::Csize_t,
+                                                Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_triplet_to_sparse(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_triplet_to_sparse(arg1::Ptr{cholmod_triplet}, arg2::Csize_t, arg3::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_triplet_to_sparse(arg1::Ptr{cholmod_triplet}, arg2::Csize_t,
+                                                  arg3::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_copy_triplet(T, Common)
-    @ccall libcholmod.cholmod_copy_triplet(T::Ptr{cholmod_triplet}, Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_copy_triplet(T::Ptr{cholmod_triplet},
+                                           Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_l_copy_triplet(arg1, arg2)
-    @ccall libcholmod.cholmod_l_copy_triplet(arg1::Ptr{cholmod_triplet}, arg2::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_l_copy_triplet(arg1::Ptr{cholmod_triplet},
+                                             arg2::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_triplet_xtype(to_xtype, T, Common)
-    @ccall libcholmod.cholmod_triplet_xtype(to_xtype::Cint, T::Ptr{cholmod_triplet}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_triplet_xtype(to_xtype::Cint, T::Ptr{cholmod_triplet},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_triplet_xtype(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_triplet_xtype(arg1::Cint, arg2::Ptr{cholmod_triplet}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_triplet_xtype(arg1::Cint, arg2::Ptr{cholmod_triplet},
+                                              arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_malloc(n, size, Common)
-    @ccall libcholmod.cholmod_malloc(n::Csize_t, size::Csize_t, Common::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_malloc(n::Csize_t, size::Csize_t,
+                                     Common::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_l_malloc(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_malloc(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_l_malloc(arg1::Csize_t, arg2::Csize_t,
+                                       arg3::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_calloc(n, size, Common)
-    @ccall libcholmod.cholmod_calloc(n::Csize_t, size::Csize_t, Common::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_calloc(n::Csize_t, size::Csize_t,
+                                     Common::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_l_calloc(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_calloc(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_l_calloc(arg1::Csize_t, arg2::Csize_t,
+                                       arg3::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_free(n, size, p, Common)
-    @ccall libcholmod.cholmod_free(n::Csize_t, size::Csize_t, p::Ptr{Cvoid}, Common::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_free(n::Csize_t, size::Csize_t, p::Ptr{Cvoid},
+                                   Common::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_l_free(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_free(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{Cvoid}, arg4::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_l_free(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{Cvoid},
+                                     arg4::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_realloc(nnew, size, p, n, Common)
-    @ccall libcholmod.cholmod_realloc(nnew::Csize_t, size::Csize_t, p::Ptr{Cvoid}, n::Ptr{Csize_t}, Common::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_realloc(nnew::Csize_t, size::Csize_t, p::Ptr{Cvoid},
+                                      n::Ptr{Csize_t},
+                                      Common::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_l_realloc(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_realloc(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{Cvoid}, arg4::Ptr{Csize_t}, arg5::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_l_realloc(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{Cvoid},
+                                        arg4::Ptr{Csize_t},
+                                        arg5::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
-function cholmod_realloc_multiple(nnew, nint, xtype, Iblock, Jblock, Xblock, Zblock, n, Common)
-    @ccall libcholmod.cholmod_realloc_multiple(nnew::Csize_t, nint::Cint, xtype::Cint, Iblock::Ptr{Ptr{Cvoid}}, Jblock::Ptr{Ptr{Cvoid}}, Xblock::Ptr{Ptr{Cvoid}}, Zblock::Ptr{Ptr{Cvoid}}, n::Ptr{Csize_t}, Common::Ptr{cholmod_common})::Cint
+function cholmod_realloc_multiple(nnew, nint, xtype, Iblock, Jblock, Xblock, Zblock, n,
+                                  Common)
+    @ccall libcholmod.cholmod_realloc_multiple(nnew::Csize_t, nint::Cint, xtype::Cint,
+                                               Iblock::Ptr{Ptr{Cvoid}},
+                                               Jblock::Ptr{Ptr{Cvoid}},
+                                               Xblock::Ptr{Ptr{Cvoid}},
+                                               Zblock::Ptr{Ptr{Cvoid}}, n::Ptr{Csize_t},
+                                               Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_realloc_multiple(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
-    @ccall libcholmod.cholmod_l_realloc_multiple(arg1::Csize_t, arg2::Cint, arg3::Cint, arg4::Ptr{Ptr{Cvoid}}, arg5::Ptr{Ptr{Cvoid}}, arg6::Ptr{Ptr{Cvoid}}, arg7::Ptr{Ptr{Cvoid}}, arg8::Ptr{Csize_t}, arg9::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_realloc_multiple(arg1::Csize_t, arg2::Cint, arg3::Cint,
+                                                 arg4::Ptr{Ptr{Cvoid}},
+                                                 arg5::Ptr{Ptr{Cvoid}},
+                                                 arg6::Ptr{Ptr{Cvoid}},
+                                                 arg7::Ptr{Ptr{Cvoid}}, arg8::Ptr{Csize_t},
+                                                 arg9::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_version(version)
@@ -876,11 +1049,13 @@ function cholmod_l_check_common(arg1)
 end
 
 function cholmod_print_common(name, Common)
-    @ccall libcholmod.cholmod_print_common(name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_common(name::Ptr{Cchar},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_common(arg1, arg2)
-    @ccall libcholmod.cholmod_l_print_common(arg1::Ptr{Cchar}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_common(arg1::Ptr{Cchar},
+                                             arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_gpu_stats(arg1)
@@ -892,643 +1067,1047 @@ function cholmod_l_gpu_stats(arg1)
 end
 
 function cholmod_check_sparse(A, Common)
-    @ccall libcholmod.cholmod_check_sparse(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_sparse(A::Ptr{cholmod_sparse},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_sparse(arg1, arg2)
-    @ccall libcholmod.cholmod_l_check_sparse(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_sparse(arg1::Ptr{cholmod_sparse},
+                                             arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_sparse(A, name, Common)
-    @ccall libcholmod.cholmod_print_sparse(A::Ptr{cholmod_sparse}, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_sparse(A::Ptr{cholmod_sparse}, name::Ptr{Cchar},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_sparse(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_print_sparse(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Cchar}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_sparse(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Cchar},
+                                             arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_check_dense(X, Common)
-    @ccall libcholmod.cholmod_check_dense(X::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_dense(X::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_dense(arg1, arg2)
-    @ccall libcholmod.cholmod_l_check_dense(arg1::Ptr{cholmod_dense}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_dense(arg1::Ptr{cholmod_dense},
+                                            arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_dense(X, name, Common)
-    @ccall libcholmod.cholmod_print_dense(X::Ptr{cholmod_dense}, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_dense(X::Ptr{cholmod_dense}, name::Ptr{Cchar},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_dense(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_print_dense(arg1::Ptr{cholmod_dense}, arg2::Ptr{Cchar}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_dense(arg1::Ptr{cholmod_dense}, arg2::Ptr{Cchar},
+                                            arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_check_factor(L, Common)
-    @ccall libcholmod.cholmod_check_factor(L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_factor(L::Ptr{cholmod_factor},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_factor(arg1, arg2)
-    @ccall libcholmod.cholmod_l_check_factor(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_factor(arg1::Ptr{cholmod_factor},
+                                             arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_factor(L, name, Common)
-    @ccall libcholmod.cholmod_print_factor(L::Ptr{cholmod_factor}, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_factor(L::Ptr{cholmod_factor}, name::Ptr{Cchar},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_factor(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_print_factor(arg1::Ptr{cholmod_factor}, arg2::Ptr{Cchar}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_factor(arg1::Ptr{cholmod_factor}, arg2::Ptr{Cchar},
+                                             arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_check_triplet(T, Common)
-    @ccall libcholmod.cholmod_check_triplet(T::Ptr{cholmod_triplet}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_triplet(T::Ptr{cholmod_triplet},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_triplet(arg1, arg2)
-    @ccall libcholmod.cholmod_l_check_triplet(arg1::Ptr{cholmod_triplet}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_triplet(arg1::Ptr{cholmod_triplet},
+                                              arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_triplet(T, name, Common)
-    @ccall libcholmod.cholmod_print_triplet(T::Ptr{cholmod_triplet}, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_triplet(T::Ptr{cholmod_triplet}, name::Ptr{Cchar},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_triplet(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_print_triplet(arg1::Ptr{cholmod_triplet}, arg2::Ptr{Cchar}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_triplet(arg1::Ptr{cholmod_triplet}, arg2::Ptr{Cchar},
+                                              arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_check_subset(Set, len, n, Common)
-    @ccall libcholmod.cholmod_check_subset(Set::Ptr{Int32}, len::Int64, n::Csize_t, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_subset(Set::Ptr{Int32}, len::Int64, n::Csize_t,
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_subset(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_check_subset(arg1::Ptr{Int64}, arg2::Int64, arg3::Csize_t, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_subset(arg1::Ptr{Int64}, arg2::Int64, arg3::Csize_t,
+                                             arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_subset(Set, len, n, name, Common)
-    @ccall libcholmod.cholmod_print_subset(Set::Ptr{Int32}, len::Int64, n::Csize_t, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_subset(Set::Ptr{Int32}, len::Int64, n::Csize_t,
+                                           name::Ptr{Cchar},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_subset(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_print_subset(arg1::Ptr{Int64}, arg2::Int64, arg3::Csize_t, arg4::Ptr{Cchar}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_subset(arg1::Ptr{Int64}, arg2::Int64, arg3::Csize_t,
+                                             arg4::Ptr{Cchar},
+                                             arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_check_perm(Perm, len, n, Common)
-    @ccall libcholmod.cholmod_check_perm(Perm::Ptr{Int32}, len::Csize_t, n::Csize_t, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_perm(Perm::Ptr{Int32}, len::Csize_t, n::Csize_t,
+                                         Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_perm(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_check_perm(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Csize_t, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_perm(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Csize_t,
+                                           arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_perm(Perm, len, n, name, Common)
-    @ccall libcholmod.cholmod_print_perm(Perm::Ptr{Int32}, len::Csize_t, n::Csize_t, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_perm(Perm::Ptr{Int32}, len::Csize_t, n::Csize_t,
+                                         name::Ptr{Cchar},
+                                         Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_perm(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_print_perm(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Csize_t, arg4::Ptr{Cchar}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_perm(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Csize_t,
+                                           arg4::Ptr{Cchar},
+                                           arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_check_parent(Parent, n, Common)
-    @ccall libcholmod.cholmod_check_parent(Parent::Ptr{Int32}, n::Csize_t, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_parent(Parent::Ptr{Int32}, n::Csize_t,
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_parent(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_check_parent(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_parent(arg1::Ptr{Int64}, arg2::Csize_t,
+                                             arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_parent(Parent, n, name, Common)
-    @ccall libcholmod.cholmod_print_parent(Parent::Ptr{Int32}, n::Csize_t, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_parent(Parent::Ptr{Int32}, n::Csize_t, name::Ptr{Cchar},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_parent(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_print_parent(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Ptr{Cchar}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_parent(arg1::Ptr{Int64}, arg2::Csize_t,
+                                             arg3::Ptr{Cchar},
+                                             arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_read_sparse(f, Common)
-    @ccall libcholmod.cholmod_read_sparse(f::Ptr{Libc.FILE}, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_read_sparse(f::Ptr{Libc.FILE},
+                                          Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_read_sparse(arg1, arg2)
-    @ccall libcholmod.cholmod_l_read_sparse(arg1::Ptr{Libc.FILE}, arg2::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_read_sparse(arg1::Ptr{Libc.FILE},
+                                            arg2::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_read_triplet(f, Common)
-    @ccall libcholmod.cholmod_read_triplet(f::Ptr{Libc.FILE}, Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_read_triplet(f::Ptr{Libc.FILE},
+                                           Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_l_read_triplet(arg1, arg2)
-    @ccall libcholmod.cholmod_l_read_triplet(arg1::Ptr{Libc.FILE}, arg2::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_l_read_triplet(arg1::Ptr{Libc.FILE},
+                                             arg2::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_read_dense(f, Common)
-    @ccall libcholmod.cholmod_read_dense(f::Ptr{Libc.FILE}, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_read_dense(f::Ptr{Libc.FILE},
+                                         Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_read_dense(arg1, arg2)
-    @ccall libcholmod.cholmod_l_read_dense(arg1::Ptr{Libc.FILE}, arg2::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_read_dense(arg1::Ptr{Libc.FILE},
+                                           arg2::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_read_matrix(f, prefer, mtype, Common)
-    @ccall libcholmod.cholmod_read_matrix(f::Ptr{Libc.FILE}, prefer::Cint, mtype::Ptr{Cint}, Common::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_read_matrix(f::Ptr{Libc.FILE}, prefer::Cint, mtype::Ptr{Cint},
+                                          Common::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_l_read_matrix(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_read_matrix(arg1::Ptr{Libc.FILE}, arg2::Cint, arg3::Ptr{Cint}, arg4::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_l_read_matrix(arg1::Ptr{Libc.FILE}, arg2::Cint,
+                                            arg3::Ptr{Cint},
+                                            arg4::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_write_sparse(f, A, Z, comments, Common)
-    @ccall libcholmod.cholmod_write_sparse(f::Ptr{Libc.FILE}, A::Ptr{cholmod_sparse}, Z::Ptr{cholmod_sparse}, comments::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_write_sparse(f::Ptr{Libc.FILE}, A::Ptr{cholmod_sparse},
+                                           Z::Ptr{cholmod_sparse}, comments::Ptr{Cchar},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_write_sparse(arg1, arg2, arg3, c, arg5)
-    @ccall libcholmod.cholmod_l_write_sparse(arg1::Ptr{Libc.FILE}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_sparse}, c::Ptr{Cchar}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_write_sparse(arg1::Ptr{Libc.FILE},
+                                             arg2::Ptr{cholmod_sparse},
+                                             arg3::Ptr{cholmod_sparse}, c::Ptr{Cchar},
+                                             arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_write_dense(f, X, comments, Common)
-    @ccall libcholmod.cholmod_write_dense(f::Ptr{Libc.FILE}, X::Ptr{cholmod_dense}, comments::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_write_dense(f::Ptr{Libc.FILE}, X::Ptr{cholmod_dense},
+                                          comments::Ptr{Cchar},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_write_dense(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_write_dense(arg1::Ptr{Libc.FILE}, arg2::Ptr{cholmod_dense}, arg3::Ptr{Cchar}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_write_dense(arg1::Ptr{Libc.FILE}, arg2::Ptr{cholmod_dense},
+                                            arg3::Ptr{Cchar},
+                                            arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_analyze(A, Common)
-    @ccall libcholmod.cholmod_analyze(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_analyze(A::Ptr{cholmod_sparse},
+                                      Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_l_analyze(arg1, arg2)
-    @ccall libcholmod.cholmod_l_analyze(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_l_analyze(arg1::Ptr{cholmod_sparse},
+                                        arg2::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_analyze_p(A, UserPerm, fset, fsize, Common)
-    @ccall libcholmod.cholmod_analyze_p(A::Ptr{cholmod_sparse}, UserPerm::Ptr{Int32}, fset::Ptr{Int32}, fsize::Csize_t, Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_analyze_p(A::Ptr{cholmod_sparse}, UserPerm::Ptr{Int32},
+                                        fset::Ptr{Int32}, fsize::Csize_t,
+                                        Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_l_analyze_p(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_analyze_p(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Ptr{Int64}, arg4::Csize_t, arg5::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_l_analyze_p(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                          arg3::Ptr{Int64}, arg4::Csize_t,
+                                          arg5::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_analyze_p2(for_whom, A, UserPerm, fset, fsize, Common)
-    @ccall libcholmod.cholmod_analyze_p2(for_whom::Cint, A::Ptr{cholmod_sparse}, UserPerm::Ptr{Int32}, fset::Ptr{Int32}, fsize::Csize_t, Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_analyze_p2(for_whom::Cint, A::Ptr{cholmod_sparse},
+                                         UserPerm::Ptr{Int32}, fset::Ptr{Int32},
+                                         fsize::Csize_t,
+                                         Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_l_analyze_p2(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_analyze_p2(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Csize_t, arg6::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_l_analyze_p2(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                           arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                           arg5::Csize_t,
+                                           arg6::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_factorize(A, L, Common)
-    @ccall libcholmod.cholmod_factorize(A::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_factorize(A::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor},
+                                        Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_factorize(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_factorize(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_factorize(arg1::Ptr{cholmod_sparse},
+                                          arg2::Ptr{cholmod_factor},
+                                          arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_factorize_p(A, beta, fset, fsize, L, Common)
-    @ccall libcholmod.cholmod_factorize_p(A::Ptr{cholmod_sparse}, beta::Ptr{Cdouble}, fset::Ptr{Int32}, fsize::Csize_t, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_factorize_p(A::Ptr{cholmod_sparse}, beta::Ptr{Cdouble},
+                                          fset::Ptr{Int32}, fsize::Csize_t,
+                                          L::Ptr{cholmod_factor},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_factorize_p(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_factorize_p(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Cdouble}, arg3::Ptr{Int64}, arg4::Csize_t, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_factorize_p(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Cdouble},
+                                            arg3::Ptr{Int64}, arg4::Csize_t,
+                                            arg5::Ptr{cholmod_factor},
+                                            arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_solve(sys, L, B, Common)
-    @ccall libcholmod.cholmod_solve(sys::Cint, L::Ptr{cholmod_factor}, B::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_solve(sys::Cint, L::Ptr{cholmod_factor},
+                                    B::Ptr{cholmod_dense},
+                                    Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_solve(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_solve(arg1::Cint, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_dense}, arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_solve(arg1::Cint, arg2::Ptr{cholmod_factor},
+                                      arg3::Ptr{cholmod_dense},
+                                      arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_solve2(sys, L, B, Bset, X_Handle, Xset_Handle, Y_Handle, E_Handle, Common)
-    @ccall libcholmod.cholmod_solve2(sys::Cint, L::Ptr{cholmod_factor}, B::Ptr{cholmod_dense}, Bset::Ptr{cholmod_sparse}, X_Handle::Ptr{Ptr{cholmod_dense}}, Xset_Handle::Ptr{Ptr{cholmod_sparse}}, Y_Handle::Ptr{Ptr{cholmod_dense}}, E_Handle::Ptr{Ptr{cholmod_dense}}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_solve2(sys::Cint, L::Ptr{cholmod_factor},
+                                     B::Ptr{cholmod_dense}, Bset::Ptr{cholmod_sparse},
+                                     X_Handle::Ptr{Ptr{cholmod_dense}},
+                                     Xset_Handle::Ptr{Ptr{cholmod_sparse}},
+                                     Y_Handle::Ptr{Ptr{cholmod_dense}},
+                                     E_Handle::Ptr{Ptr{cholmod_dense}},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_solve2(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
-    @ccall libcholmod.cholmod_l_solve2(arg1::Cint, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_dense}, arg4::Ptr{cholmod_sparse}, arg5::Ptr{Ptr{cholmod_dense}}, arg6::Ptr{Ptr{cholmod_sparse}}, arg7::Ptr{Ptr{cholmod_dense}}, arg8::Ptr{Ptr{cholmod_dense}}, arg9::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_solve2(arg1::Cint, arg2::Ptr{cholmod_factor},
+                                       arg3::Ptr{cholmod_dense}, arg4::Ptr{cholmod_sparse},
+                                       arg5::Ptr{Ptr{cholmod_dense}},
+                                       arg6::Ptr{Ptr{cholmod_sparse}},
+                                       arg7::Ptr{Ptr{cholmod_dense}},
+                                       arg8::Ptr{Ptr{cholmod_dense}},
+                                       arg9::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_spsolve(sys, L, B, Common)
-    @ccall libcholmod.cholmod_spsolve(sys::Cint, L::Ptr{cholmod_factor}, B::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_spsolve(sys::Cint, L::Ptr{cholmod_factor},
+                                      B::Ptr{cholmod_sparse},
+                                      Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_spsolve(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_spsolve(arg1::Cint, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_sparse}, arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_spsolve(arg1::Cint, arg2::Ptr{cholmod_factor},
+                                        arg3::Ptr{cholmod_sparse},
+                                        arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_etree(A, Parent, Common)
-    @ccall libcholmod.cholmod_etree(A::Ptr{cholmod_sparse}, Parent::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_etree(A::Ptr{cholmod_sparse}, Parent::Ptr{Int32},
+                                    Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_etree(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_etree(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_etree(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                      arg3::Ptr{cholmod_common})::Cint
 end
 
-function cholmod_rowcolcounts(A, fset, fsize, Parent, Post, RowCount, ColCount, First, Level, Common)
-    @ccall libcholmod.cholmod_rowcolcounts(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, Parent::Ptr{Int32}, Post::Ptr{Int32}, RowCount::Ptr{Int32}, ColCount::Ptr{Int32}, First::Ptr{Int32}, Level::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+function cholmod_rowcolcounts(A, fset, fsize, Parent, Post, RowCount, ColCount, First,
+                              Level, Common)
+    @ccall libcholmod.cholmod_rowcolcounts(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                           fsize::Csize_t, Parent::Ptr{Int32},
+                                           Post::Ptr{Int32}, RowCount::Ptr{Int32},
+                                           ColCount::Ptr{Int32}, First::Ptr{Int32},
+                                           Level::Ptr{Int32},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowcolcounts(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)
-    @ccall libcholmod.cholmod_l_rowcolcounts(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{Int64}, arg6::Ptr{Int64}, arg7::Ptr{Int64}, arg8::Ptr{Int64}, arg9::Ptr{Int64}, arg10::Ptr{cholmod_common})::Cint
-end
-
-function cholmod_analyze_ordering(A, ordering, Perm, fset, fsize, Parent, Post, ColCount, First, Level, Common)
-    @ccall libcholmod.cholmod_analyze_ordering(A::Ptr{cholmod_sparse}, ordering::Cint, Perm::Ptr{Int32}, fset::Ptr{Int32}, fsize::Csize_t, Parent::Ptr{Int32}, Post::Ptr{Int32}, ColCount::Ptr{Int32}, First::Ptr{Int32}, Level::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
-end
-
-function cholmod_l_analyze_ordering(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11)
-    @ccall libcholmod.cholmod_l_analyze_ordering(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Csize_t, arg6::Ptr{Int64}, arg7::Ptr{Int64}, arg8::Ptr{Int64}, arg9::Ptr{Int64}, arg10::Ptr{Int64}, arg11::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowcolcounts(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                             arg3::Csize_t, arg4::Ptr{Int64},
+                                             arg5::Ptr{Int64}, arg6::Ptr{Int64},
+                                             arg7::Ptr{Int64}, arg8::Ptr{Int64},
+                                             arg9::Ptr{Int64},
+                                             arg10::Ptr{cholmod_common})::Cint
+end
+
+function cholmod_analyze_ordering(A, ordering, Perm, fset, fsize, Parent, Post, ColCount,
+                                  First, Level, Common)
+    @ccall libcholmod.cholmod_analyze_ordering(A::Ptr{cholmod_sparse}, ordering::Cint,
+                                               Perm::Ptr{Int32}, fset::Ptr{Int32},
+                                               fsize::Csize_t, Parent::Ptr{Int32},
+                                               Post::Ptr{Int32}, ColCount::Ptr{Int32},
+                                               First::Ptr{Int32}, Level::Ptr{Int32},
+                                               Common::Ptr{cholmod_common})::Cint
+end
+
+function cholmod_l_analyze_ordering(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9,
+                                    arg10, arg11)
+    @ccall libcholmod.cholmod_l_analyze_ordering(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                                 arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                                 arg5::Csize_t, arg6::Ptr{Int64},
+                                                 arg7::Ptr{Int64}, arg8::Ptr{Int64},
+                                                 arg9::Ptr{Int64}, arg10::Ptr{Int64},
+                                                 arg11::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_amd(A, fset, fsize, Perm, Common)
-    @ccall libcholmod.cholmod_amd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_amd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t,
+                                  Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_amd(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_amd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_amd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                    arg3::Csize_t, arg4::Ptr{Int64},
+                                    arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_colamd(A, fset, fsize, postorder, Perm, Common)
-    @ccall libcholmod.cholmod_colamd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, postorder::Cint, Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_colamd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                     fsize::Csize_t, postorder::Cint, Perm::Ptr{Int32},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_colamd(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_colamd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Cint, arg5::Ptr{Int64}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_colamd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                       arg3::Csize_t, arg4::Cint, arg5::Ptr{Int64},
+                                       arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowfac(A, F, beta, kstart, kend, L, Common)
-    @ccall libcholmod.cholmod_rowfac(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, beta::Ptr{Cdouble}, kstart::Csize_t, kend::Csize_t, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowfac(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse},
+                                     beta::Ptr{Cdouble}, kstart::Csize_t, kend::Csize_t,
+                                     L::Ptr{cholmod_factor},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowfac(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_rowfac(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Csize_t, arg5::Csize_t, arg6::Ptr{cholmod_factor}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowfac(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse},
+                                       arg3::Ptr{Cdouble}, arg4::Csize_t, arg5::Csize_t,
+                                       arg6::Ptr{cholmod_factor},
+                                       arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowfac_mask(A, F, beta, kstart, kend, mask, RLinkUp, L, Common)
-    @ccall libcholmod.cholmod_rowfac_mask(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, beta::Ptr{Cdouble}, kstart::Csize_t, kend::Csize_t, mask::Ptr{Int32}, RLinkUp::Ptr{Int32}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowfac_mask(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse},
+                                          beta::Ptr{Cdouble}, kstart::Csize_t,
+                                          kend::Csize_t, mask::Ptr{Int32},
+                                          RLinkUp::Ptr{Int32}, L::Ptr{cholmod_factor},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowfac_mask(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
-    @ccall libcholmod.cholmod_l_rowfac_mask(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Csize_t, arg5::Csize_t, arg6::Ptr{Int64}, arg7::Ptr{Int64}, arg8::Ptr{cholmod_factor}, arg9::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowfac_mask(arg1::Ptr{cholmod_sparse},
+                                            arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble},
+                                            arg4::Csize_t, arg5::Csize_t, arg6::Ptr{Int64},
+                                            arg7::Ptr{Int64}, arg8::Ptr{cholmod_factor},
+                                            arg9::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowfac_mask2(A, F, beta, kstart, kend, mask, maskmark, RLinkUp, L, Common)
-    @ccall libcholmod.cholmod_rowfac_mask2(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, beta::Ptr{Cdouble}, kstart::Csize_t, kend::Csize_t, mask::Ptr{Int32}, maskmark::Int32, RLinkUp::Ptr{Int32}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowfac_mask2(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse},
+                                           beta::Ptr{Cdouble}, kstart::Csize_t,
+                                           kend::Csize_t, mask::Ptr{Int32}, maskmark::Int32,
+                                           RLinkUp::Ptr{Int32}, L::Ptr{cholmod_factor},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowfac_mask2(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)
-    @ccall libcholmod.cholmod_l_rowfac_mask2(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Csize_t, arg5::Csize_t, arg6::Ptr{Int64}, arg7::Int64, arg8::Ptr{Int64}, arg9::Ptr{cholmod_factor}, arg10::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowfac_mask2(arg1::Ptr{cholmod_sparse},
+                                             arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble},
+                                             arg4::Csize_t, arg5::Csize_t, arg6::Ptr{Int64},
+                                             arg7::Int64, arg8::Ptr{Int64},
+                                             arg9::Ptr{cholmod_factor},
+                                             arg10::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_row_subtree(A, F, k, Parent, R, Common)
-    @ccall libcholmod.cholmod_row_subtree(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, k::Csize_t, Parent::Ptr{Int32}, R::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_row_subtree(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse},
+                                          k::Csize_t, Parent::Ptr{Int32},
+                                          R::Ptr{cholmod_sparse},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_row_subtree(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_row_subtree(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{cholmod_sparse}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_row_subtree(arg1::Ptr{cholmod_sparse},
+                                            arg2::Ptr{cholmod_sparse}, arg3::Csize_t,
+                                            arg4::Ptr{Int64}, arg5::Ptr{cholmod_sparse},
+                                            arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_lsolve_pattern(B, L, X, Common)
-    @ccall libcholmod.cholmod_lsolve_pattern(B::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_lsolve_pattern(B::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor},
+                                             X::Ptr{cholmod_sparse},
+                                             Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_lsolve_pattern(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_lsolve_pattern(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_sparse}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_lsolve_pattern(arg1::Ptr{cholmod_sparse},
+                                               arg2::Ptr{cholmod_factor},
+                                               arg3::Ptr{cholmod_sparse},
+                                               arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_row_lsubtree(A, Fi, fnz, k, L, R, Common)
-    @ccall libcholmod.cholmod_row_lsubtree(A::Ptr{cholmod_sparse}, Fi::Ptr{Int32}, fnz::Csize_t, k::Csize_t, L::Ptr{cholmod_factor}, R::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_row_lsubtree(A::Ptr{cholmod_sparse}, Fi::Ptr{Int32},
+                                           fnz::Csize_t, k::Csize_t, L::Ptr{cholmod_factor},
+                                           R::Ptr{cholmod_sparse},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_row_lsubtree(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_row_lsubtree(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Csize_t, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_sparse}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_row_lsubtree(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                             arg3::Csize_t, arg4::Csize_t,
+                                             arg5::Ptr{cholmod_factor},
+                                             arg6::Ptr{cholmod_sparse},
+                                             arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_resymbol(A, fset, fsize, pack, L, Common)
-    @ccall libcholmod.cholmod_resymbol(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, pack::Cint, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_resymbol(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                       fsize::Csize_t, pack::Cint, L::Ptr{cholmod_factor},
+                                       Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_resymbol(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_resymbol(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Cint, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_resymbol(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                         arg3::Csize_t, arg4::Cint,
+                                         arg5::Ptr{cholmod_factor},
+                                         arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_resymbol_noperm(A, fset, fsize, pack, L, Common)
-    @ccall libcholmod.cholmod_resymbol_noperm(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, pack::Cint, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_resymbol_noperm(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                              fsize::Csize_t, pack::Cint,
+                                              L::Ptr{cholmod_factor},
+                                              Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_resymbol_noperm(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_resymbol_noperm(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Cint, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_resymbol_noperm(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                                arg3::Csize_t, arg4::Cint,
+                                                arg5::Ptr{cholmod_factor},
+                                                arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rcond(L, Common)
-    @ccall libcholmod.cholmod_rcond(L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cdouble
+    @ccall libcholmod.cholmod_rcond(L::Ptr{cholmod_factor},
+                                    Common::Ptr{cholmod_common})::Cdouble
 end
 
 function cholmod_l_rcond(arg1, arg2)
-    @ccall libcholmod.cholmod_l_rcond(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_common})::Cdouble
+    @ccall libcholmod.cholmod_l_rcond(arg1::Ptr{cholmod_factor},
+                                      arg2::Ptr{cholmod_common})::Cdouble
 end
 
 function cholmod_postorder(Parent, n, Weight_p, Post, Common)
-    @ccall libcholmod.cholmod_postorder(Parent::Ptr{Int32}, n::Csize_t, Weight_p::Ptr{Int32}, Post::Ptr{Int32}, Common::Ptr{cholmod_common})::Int32
+    @ccall libcholmod.cholmod_postorder(Parent::Ptr{Int32}, n::Csize_t,
+                                        Weight_p::Ptr{Int32}, Post::Ptr{Int32},
+                                        Common::Ptr{cholmod_common})::Int32
 end
 
 function cholmod_l_postorder(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_postorder(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_l_postorder(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Ptr{Int64},
+                                          arg4::Ptr{Int64},
+                                          arg5::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_drop(tol, A, Common)
-    @ccall libcholmod.cholmod_drop(tol::Cdouble, A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_drop(tol::Cdouble, A::Ptr{cholmod_sparse},
+                                   Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_drop(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_drop(arg1::Cdouble, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_drop(arg1::Cdouble, arg2::Ptr{cholmod_sparse},
+                                     arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_norm_dense(X, norm, Common)
-    @ccall libcholmod.cholmod_norm_dense(X::Ptr{cholmod_dense}, norm::Cint, Common::Ptr{cholmod_common})::Cdouble
+    @ccall libcholmod.cholmod_norm_dense(X::Ptr{cholmod_dense}, norm::Cint,
+                                         Common::Ptr{cholmod_common})::Cdouble
 end
 
 function cholmod_l_norm_dense(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_norm_dense(arg1::Ptr{cholmod_dense}, arg2::Cint, arg3::Ptr{cholmod_common})::Cdouble
+    @ccall libcholmod.cholmod_l_norm_dense(arg1::Ptr{cholmod_dense}, arg2::Cint,
+                                           arg3::Ptr{cholmod_common})::Cdouble
 end
 
 function cholmod_norm_sparse(A, norm, Common)
-    @ccall libcholmod.cholmod_norm_sparse(A::Ptr{cholmod_sparse}, norm::Cint, Common::Ptr{cholmod_common})::Cdouble
+    @ccall libcholmod.cholmod_norm_sparse(A::Ptr{cholmod_sparse}, norm::Cint,
+                                          Common::Ptr{cholmod_common})::Cdouble
 end
 
 function cholmod_l_norm_sparse(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_norm_sparse(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{cholmod_common})::Cdouble
+    @ccall libcholmod.cholmod_l_norm_sparse(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                            arg3::Ptr{cholmod_common})::Cdouble
 end
 
 function cholmod_horzcat(A, B, values, Common)
-    @ccall libcholmod.cholmod_horzcat(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse}, values::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_horzcat(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse},
+                                      values::Cint,
+                                      Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_horzcat(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_horzcat(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_horzcat(arg1::Ptr{cholmod_sparse},
+                                        arg2::Ptr{cholmod_sparse}, arg3::Cint,
+                                        arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_scale(S, scale, A, Common)
-    @ccall libcholmod.cholmod_scale(S::Ptr{cholmod_dense}, scale::Cint, A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_scale(S::Ptr{cholmod_dense}, scale::Cint,
+                                    A::Ptr{cholmod_sparse},
+                                    Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_scale(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_scale(arg1::Ptr{cholmod_dense}, arg2::Cint, arg3::Ptr{cholmod_sparse}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_scale(arg1::Ptr{cholmod_dense}, arg2::Cint,
+                                      arg3::Ptr{cholmod_sparse},
+                                      arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_sdmult(A, transpose, alpha, beta, X, Y, Common)
-    @ccall libcholmod.cholmod_sdmult(A::Ptr{cholmod_sparse}, transpose::Cint, alpha::Ptr{Cdouble}, beta::Ptr{Cdouble}, X::Ptr{cholmod_dense}, Y::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_sdmult(A::Ptr{cholmod_sparse}, transpose::Cint,
+                                     alpha::Ptr{Cdouble}, beta::Ptr{Cdouble},
+                                     X::Ptr{cholmod_dense}, Y::Ptr{cholmod_dense},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_sdmult(arg1, arg2, arg3, arg4, arg5, Y, arg7)
-    @ccall libcholmod.cholmod_l_sdmult(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{Cdouble}, arg4::Ptr{Cdouble}, arg5::Ptr{cholmod_dense}, Y::Ptr{cholmod_dense}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_sdmult(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                       arg3::Ptr{Cdouble}, arg4::Ptr{Cdouble},
+                                       arg5::Ptr{cholmod_dense}, Y::Ptr{cholmod_dense},
+                                       arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_ssmult(A, B, stype, values, sorted, Common)
-    @ccall libcholmod.cholmod_ssmult(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse}, stype::Cint, values::Cint, sorted::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_ssmult(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse},
+                                     stype::Cint, values::Cint, sorted::Cint,
+                                     Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_ssmult(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_ssmult(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Cint, arg4::Cint, arg5::Cint, arg6::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_ssmult(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse},
+                                       arg3::Cint, arg4::Cint, arg5::Cint,
+                                       arg6::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_submatrix(A, rset, rsize, cset, csize, values, sorted, Common)
-    @ccall libcholmod.cholmod_submatrix(A::Ptr{cholmod_sparse}, rset::Ptr{Int32}, rsize::Int64, cset::Ptr{Int32}, csize::Int64, values::Cint, sorted::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_submatrix(A::Ptr{cholmod_sparse}, rset::Ptr{Int32},
+                                        rsize::Int64, cset::Ptr{Int32}, csize::Int64,
+                                        values::Cint, sorted::Cint,
+                                        Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_submatrix(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
-    @ccall libcholmod.cholmod_l_submatrix(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Int64, arg4::Ptr{Int64}, arg5::Int64, arg6::Cint, arg7::Cint, arg8::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_submatrix(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                          arg3::Int64, arg4::Ptr{Int64}, arg5::Int64,
+                                          arg6::Cint, arg7::Cint,
+                                          arg8::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_vertcat(A, B, values, Common)
-    @ccall libcholmod.cholmod_vertcat(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse}, values::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_vertcat(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse},
+                                      values::Cint,
+                                      Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_vertcat(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_vertcat(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_vertcat(arg1::Ptr{cholmod_sparse},
+                                        arg2::Ptr{cholmod_sparse}, arg3::Cint,
+                                        arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_symmetry(A, option, xmatched, pmatched, nzoffdiag, nzdiag, Common)
-    @ccall libcholmod.cholmod_symmetry(A::Ptr{cholmod_sparse}, option::Cint, xmatched::Ptr{Int32}, pmatched::Ptr{Int32}, nzoffdiag::Ptr{Int32}, nzdiag::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_symmetry(A::Ptr{cholmod_sparse}, option::Cint,
+                                       xmatched::Ptr{Int32}, pmatched::Ptr{Int32},
+                                       nzoffdiag::Ptr{Int32}, nzdiag::Ptr{Int32},
+                                       Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_symmetry(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_symmetry(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Ptr{Int64}, arg6::Ptr{Int64}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_symmetry(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                         arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                         arg5::Ptr{Int64}, arg6::Ptr{Int64},
+                                         arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_updown(update, C, L, Common)
-    @ccall libcholmod.cholmod_updown(update::Cint, C::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_updown(update::Cint, C::Ptr{cholmod_sparse},
+                                     L::Ptr{cholmod_factor},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_updown(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_updown(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_factor}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_updown(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                       arg3::Ptr{cholmod_factor},
+                                       arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_updown_solve(update, C, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_updown_solve(update::Cint, C::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_updown_solve(update::Cint, C::Ptr{cholmod_sparse},
+                                           L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense},
+                                           DeltaB::Ptr{cholmod_dense},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_updown_solve(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_updown_solve(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_factor}, arg4::Ptr{cholmod_dense}, arg5::Ptr{cholmod_dense}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_updown_solve(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                             arg3::Ptr{cholmod_factor},
+                                             arg4::Ptr{cholmod_dense},
+                                             arg5::Ptr{cholmod_dense},
+                                             arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_updown_mark(update, C, colmark, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_updown_mark(update::Cint, C::Ptr{cholmod_sparse}, colmark::Ptr{Int32}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_updown_mark(update::Cint, C::Ptr{cholmod_sparse},
+                                          colmark::Ptr{Int32}, L::Ptr{cholmod_factor},
+                                          X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_updown_mark(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_updown_mark(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Int64}, arg4::Ptr{cholmod_factor}, arg5::Ptr{cholmod_dense}, arg6::Ptr{cholmod_dense}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_updown_mark(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                            arg3::Ptr{Int64}, arg4::Ptr{cholmod_factor},
+                                            arg5::Ptr{cholmod_dense},
+                                            arg6::Ptr{cholmod_dense},
+                                            arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_updown_mask(update, C, colmark, mask, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_updown_mask(update::Cint, C::Ptr{cholmod_sparse}, colmark::Ptr{Int32}, mask::Ptr{Int32}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_updown_mask(update::Cint, C::Ptr{cholmod_sparse},
+                                          colmark::Ptr{Int32}, mask::Ptr{Int32},
+                                          L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense},
+                                          DeltaB::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_updown_mask(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
-    @ccall libcholmod.cholmod_l_updown_mask(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_dense}, arg7::Ptr{cholmod_dense}, arg8::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_updown_mask(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                            arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                            arg5::Ptr{cholmod_factor},
+                                            arg6::Ptr{cholmod_dense},
+                                            arg7::Ptr{cholmod_dense},
+                                            arg8::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_updown_mask2(update, C, colmark, mask, maskmark, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_updown_mask2(update::Cint, C::Ptr{cholmod_sparse}, colmark::Ptr{Int32}, mask::Ptr{Int32}, maskmark::Int32, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_updown_mask2(update::Cint, C::Ptr{cholmod_sparse},
+                                           colmark::Ptr{Int32}, mask::Ptr{Int32},
+                                           maskmark::Int32, L::Ptr{cholmod_factor},
+                                           X::Ptr{cholmod_dense},
+                                           DeltaB::Ptr{cholmod_dense},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_updown_mask2(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
-    @ccall libcholmod.cholmod_l_updown_mask2(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Int64, arg6::Ptr{cholmod_factor}, arg7::Ptr{cholmod_dense}, arg8::Ptr{cholmod_dense}, arg9::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_updown_mask2(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                             arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                             arg5::Int64, arg6::Ptr{cholmod_factor},
+                                             arg7::Ptr{cholmod_dense},
+                                             arg8::Ptr{cholmod_dense},
+                                             arg9::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowadd(k, R, L, Common)
-    @ccall libcholmod.cholmod_rowadd(k::Csize_t, R::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowadd(k::Csize_t, R::Ptr{cholmod_sparse},
+                                     L::Ptr{cholmod_factor},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowadd(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_rowadd(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_factor}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowadd(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                       arg3::Ptr{cholmod_factor},
+                                       arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowadd_solve(k, R, bk, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_rowadd_solve(k::Csize_t, R::Ptr{cholmod_sparse}, bk::Ptr{Cdouble}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowadd_solve(k::Csize_t, R::Ptr{cholmod_sparse},
+                                           bk::Ptr{Cdouble}, L::Ptr{cholmod_factor},
+                                           X::Ptr{cholmod_dense},
+                                           DeltaB::Ptr{cholmod_dense},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowadd_solve(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_rowadd_solve(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Ptr{cholmod_factor}, arg5::Ptr{cholmod_dense}, arg6::Ptr{cholmod_dense}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowadd_solve(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                             arg3::Ptr{Cdouble}, arg4::Ptr{cholmod_factor},
+                                             arg5::Ptr{cholmod_dense},
+                                             arg6::Ptr{cholmod_dense},
+                                             arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowadd_mark(k, R, bk, colmark, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_rowadd_mark(k::Csize_t, R::Ptr{cholmod_sparse}, bk::Ptr{Cdouble}, colmark::Ptr{Int32}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowadd_mark(k::Csize_t, R::Ptr{cholmod_sparse},
+                                          bk::Ptr{Cdouble}, colmark::Ptr{Int32},
+                                          L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense},
+                                          DeltaB::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowadd_mark(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
-    @ccall libcholmod.cholmod_l_rowadd_mark(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Ptr{Int64}, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_dense}, arg7::Ptr{cholmod_dense}, arg8::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowadd_mark(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                            arg3::Ptr{Cdouble}, arg4::Ptr{Int64},
+                                            arg5::Ptr{cholmod_factor},
+                                            arg6::Ptr{cholmod_dense},
+                                            arg7::Ptr{cholmod_dense},
+                                            arg8::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowdel(k, R, L, Common)
-    @ccall libcholmod.cholmod_rowdel(k::Csize_t, R::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowdel(k::Csize_t, R::Ptr{cholmod_sparse},
+                                     L::Ptr{cholmod_factor},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowdel(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_rowdel(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_factor}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowdel(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                       arg3::Ptr{cholmod_factor},
+                                       arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowdel_solve(k, R, yk, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_rowdel_solve(k::Csize_t, R::Ptr{cholmod_sparse}, yk::Ptr{Cdouble}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowdel_solve(k::Csize_t, R::Ptr{cholmod_sparse},
+                                           yk::Ptr{Cdouble}, L::Ptr{cholmod_factor},
+                                           X::Ptr{cholmod_dense},
+                                           DeltaB::Ptr{cholmod_dense},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowdel_solve(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_rowdel_solve(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Ptr{cholmod_factor}, arg5::Ptr{cholmod_dense}, arg6::Ptr{cholmod_dense}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowdel_solve(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                             arg3::Ptr{Cdouble}, arg4::Ptr{cholmod_factor},
+                                             arg5::Ptr{cholmod_dense},
+                                             arg6::Ptr{cholmod_dense},
+                                             arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowdel_mark(k, R, yk, colmark, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_rowdel_mark(k::Csize_t, R::Ptr{cholmod_sparse}, yk::Ptr{Cdouble}, colmark::Ptr{Int32}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowdel_mark(k::Csize_t, R::Ptr{cholmod_sparse},
+                                          yk::Ptr{Cdouble}, colmark::Ptr{Int32},
+                                          L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense},
+                                          DeltaB::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowdel_mark(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
-    @ccall libcholmod.cholmod_l_rowdel_mark(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Ptr{Int64}, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_dense}, arg7::Ptr{cholmod_dense}, arg8::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowdel_mark(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                            arg3::Ptr{Cdouble}, arg4::Ptr{Int64},
+                                            arg5::Ptr{cholmod_factor},
+                                            arg6::Ptr{cholmod_dense},
+                                            arg7::Ptr{cholmod_dense},
+                                            arg8::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_ccolamd(A, fset, fsize, Cmember, Perm, Common)
-    @ccall libcholmod.cholmod_ccolamd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, Cmember::Ptr{Int32}, Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_ccolamd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                      fsize::Csize_t, Cmember::Ptr{Int32}, Perm::Ptr{Int32},
+                                      Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_ccolamd(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_ccolamd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{Int64}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_ccolamd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                        arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{Int64},
+                                        arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_csymamd(A, Cmember, Perm, Common)
-    @ccall libcholmod.cholmod_csymamd(A::Ptr{cholmod_sparse}, Cmember::Ptr{Int32}, Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_csymamd(A::Ptr{cholmod_sparse}, Cmember::Ptr{Int32},
+                                      Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_csymamd(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_csymamd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Ptr{Int64}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_csymamd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                        arg3::Ptr{Int64}, arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_camd(A, fset, fsize, Cmember, Perm, Common)
-    @ccall libcholmod.cholmod_camd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, Cmember::Ptr{Int32}, Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_camd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t,
+                                   Cmember::Ptr{Int32}, Perm::Ptr{Int32},
+                                   Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_camd(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_camd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{Int64}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_camd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                     arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{Int64},
+                                     arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_nested_dissection(A, fset, fsize, Perm, CParent, Cmember, Common)
-    @ccall libcholmod.cholmod_nested_dissection(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, Perm::Ptr{Int32}, CParent::Ptr{Int32}, Cmember::Ptr{Int32}, Common::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_nested_dissection(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                                fsize::Csize_t, Perm::Ptr{Int32},
+                                                CParent::Ptr{Int32}, Cmember::Ptr{Int32},
+                                                Common::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_l_nested_dissection(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_nested_dissection(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{Int64}, arg6::Ptr{Int64}, arg7::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_l_nested_dissection(arg1::Ptr{cholmod_sparse},
+                                                  arg2::Ptr{Int64}, arg3::Csize_t,
+                                                  arg4::Ptr{Int64}, arg5::Ptr{Int64},
+                                                  arg6::Ptr{Int64},
+                                                  arg7::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_metis(A, fset, fsize, postorder, Perm, Common)
-    @ccall libcholmod.cholmod_metis(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, postorder::Cint, Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_metis(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                    fsize::Csize_t, postorder::Cint, Perm::Ptr{Int32},
+                                    Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_metis(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_metis(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Cint, arg5::Ptr{Int64}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_metis(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                      arg3::Csize_t, arg4::Cint, arg5::Ptr{Int64},
+                                      arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_bisect(A, fset, fsize, compress, Partition, Common)
-    @ccall libcholmod.cholmod_bisect(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, compress::Cint, Partition::Ptr{Int32}, Common::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_bisect(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                     fsize::Csize_t, compress::Cint, Partition::Ptr{Int32},
+                                     Common::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_l_bisect(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_bisect(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Cint, arg5::Ptr{Int64}, arg6::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_l_bisect(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                       arg3::Csize_t, arg4::Cint, arg5::Ptr{Int64},
+                                       arg6::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_metis_bisector(A, Anw, Aew, Partition, Common)
-    @ccall libcholmod.cholmod_metis_bisector(A::Ptr{cholmod_sparse}, Anw::Ptr{Int32}, Aew::Ptr{Int32}, Partition::Ptr{Int32}, Common::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_metis_bisector(A::Ptr{cholmod_sparse}, Anw::Ptr{Int32},
+                                             Aew::Ptr{Int32}, Partition::Ptr{Int32},
+                                             Common::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_l_metis_bisector(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_metis_bisector(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_l_metis_bisector(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                               arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                               arg5::Ptr{cholmod_common})::Int64
 end
 
-function cholmod_collapse_septree(n, ncomponents, nd_oksep, nd_small, CParent, Cmember, Common)
-    @ccall libcholmod.cholmod_collapse_septree(n::Csize_t, ncomponents::Csize_t, nd_oksep::Cdouble, nd_small::Csize_t, CParent::Ptr{Int32}, Cmember::Ptr{Int32}, Common::Ptr{cholmod_common})::Int64
+function cholmod_collapse_septree(n, ncomponents, nd_oksep, nd_small, CParent, Cmember,
+                                  Common)
+    @ccall libcholmod.cholmod_collapse_septree(n::Csize_t, ncomponents::Csize_t,
+                                               nd_oksep::Cdouble, nd_small::Csize_t,
+                                               CParent::Ptr{Int32}, Cmember::Ptr{Int32},
+                                               Common::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_l_collapse_septree(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_collapse_septree(arg1::Csize_t, arg2::Csize_t, arg3::Cdouble, arg4::Csize_t, arg5::Ptr{Int64}, arg6::Ptr{Int64}, arg7::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_l_collapse_septree(arg1::Csize_t, arg2::Csize_t,
+                                                 arg3::Cdouble, arg4::Csize_t,
+                                                 arg5::Ptr{Int64}, arg6::Ptr{Int64},
+                                                 arg7::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_super_symbolic(A, F, Parent, L, Common)
-    @ccall libcholmod.cholmod_super_symbolic(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, Parent::Ptr{Int32}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_super_symbolic(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse},
+                                             Parent::Ptr{Int32}, L::Ptr{cholmod_factor},
+                                             Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_super_symbolic(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_super_symbolic(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Int64}, arg4::Ptr{cholmod_factor}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_super_symbolic(arg1::Ptr{cholmod_sparse},
+                                               arg2::Ptr{cholmod_sparse}, arg3::Ptr{Int64},
+                                               arg4::Ptr{cholmod_factor},
+                                               arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_super_symbolic2(for_whom, A, F, Parent, L, Common)
-    @ccall libcholmod.cholmod_super_symbolic2(for_whom::Cint, A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, Parent::Ptr{Int32}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_super_symbolic2(for_whom::Cint, A::Ptr{cholmod_sparse},
+                                              F::Ptr{cholmod_sparse}, Parent::Ptr{Int32},
+                                              L::Ptr{cholmod_factor},
+                                              Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_super_symbolic2(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_super_symbolic2(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_sparse}, arg4::Ptr{Int64}, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_super_symbolic2(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                                arg3::Ptr{cholmod_sparse}, arg4::Ptr{Int64},
+                                                arg5::Ptr{cholmod_factor},
+                                                arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_super_numeric(A, F, beta, L, Common)
-    @ccall libcholmod.cholmod_super_numeric(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, beta::Ptr{Cdouble}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_super_numeric(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse},
+                                            beta::Ptr{Cdouble}, L::Ptr{cholmod_factor},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_super_numeric(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_super_numeric(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Ptr{cholmod_factor}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_super_numeric(arg1::Ptr{cholmod_sparse},
+                                              arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble},
+                                              arg4::Ptr{cholmod_factor},
+                                              arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_super_lsolve(L, X, E, Common)
-    @ccall libcholmod.cholmod_super_lsolve(L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, E::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_super_lsolve(L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense},
+                                           E::Ptr{cholmod_dense},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_super_lsolve(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_super_lsolve(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_dense}, arg3::Ptr{cholmod_dense}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_super_lsolve(arg1::Ptr{cholmod_factor},
+                                             arg2::Ptr{cholmod_dense},
+                                             arg3::Ptr{cholmod_dense},
+                                             arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_super_ltsolve(L, X, E, Common)
-    @ccall libcholmod.cholmod_super_ltsolve(L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, E::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_super_ltsolve(L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense},
+                                            E::Ptr{cholmod_dense},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_super_ltsolve(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_super_ltsolve(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_dense}, arg3::Ptr{cholmod_dense}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_super_ltsolve(arg1::Ptr{cholmod_factor},
+                                              arg2::Ptr{cholmod_dense},
+                                              arg3::Ptr{cholmod_dense},
+                                              arg4::Ptr{cholmod_common})::Cint
+end
+
+function SuiteSparseQR_C(ordering, tol, econ, getCTX, A, Bsparse, Bdense, Zsparse, Zdense,
+                         R, E, H, HPinv, HTau, cc)
+    @ccall libspqr.SuiteSparseQR_C(ordering::Cint, tol::Cdouble, econ::Int64, getCTX::Cint,
+                                   A::Ptr{cholmod_sparse}, Bsparse::Ptr{cholmod_sparse},
+                                   Bdense::Ptr{cholmod_dense},
+                                   Zsparse::Ptr{Ptr{cholmod_sparse}},
+                                   Zdense::Ptr{Ptr{cholmod_dense}},
+                                   R::Ptr{Ptr{cholmod_sparse}}, E::Ptr{Ptr{Int64}},
+                                   H::Ptr{Ptr{cholmod_sparse}}, HPinv::Ptr{Ptr{Int64}},
+                                   HTau::Ptr{Ptr{cholmod_dense}},
+                                   cc::Ptr{cholmod_common})::Int64
+end
+
+function SuiteSparseQR_i_C(ordering, tol, econ, getCTX, A, Bsparse, Bdense, Zsparse, Zdense,
+                           R, E, H, HPinv, HTau, cc)
+    @ccall libspqr.SuiteSparseQR_i_C(ordering::Cint, tol::Cdouble, econ::Int32,
+                                     getCTX::Cint, A::Ptr{cholmod_sparse},
+                                     Bsparse::Ptr{cholmod_sparse},
+                                     Bdense::Ptr{cholmod_dense},
+                                     Zsparse::Ptr{Ptr{cholmod_sparse}},
+                                     Zdense::Ptr{Ptr{cholmod_dense}},
+                                     R::Ptr{Ptr{cholmod_sparse}}, E::Ptr{Ptr{Int32}},
+                                     H::Ptr{Ptr{cholmod_sparse}}, HPinv::Ptr{Ptr{Int32}},
+                                     HTau::Ptr{Ptr{cholmod_dense}},
+                                     cc::Ptr{cholmod_common})::Int32
 end
 
-function SuiteSparseQR_C(ordering, tol, econ, getCTX, A, Bsparse, Bdense, Zsparse, Zdense, R, E, H, HPinv, HTau, cc)
-    @ccall libspqr.SuiteSparseQR_C(ordering::Cint, tol::Cdouble, econ::Int64, getCTX::Cint, A::Ptr{cholmod_sparse}, Bsparse::Ptr{cholmod_sparse}, Bdense::Ptr{cholmod_dense}, Zsparse::Ptr{Ptr{cholmod_sparse}}, Zdense::Ptr{Ptr{cholmod_dense}}, R::Ptr{Ptr{cholmod_sparse}}, E::Ptr{Ptr{Int64}}, H::Ptr{Ptr{cholmod_sparse}}, HPinv::Ptr{Ptr{Int64}}, HTau::Ptr{Ptr{cholmod_dense}}, cc::Ptr{cholmod_common})::Int64
+function SuiteSparseQR_C_QR(ordering, tol, econ, A, Q, R, E, cc)
+    @ccall libspqr.SuiteSparseQR_C_QR(ordering::Cint, tol::Cdouble, econ::Int64,
+                                      A::Ptr{cholmod_sparse}, Q::Ptr{Ptr{cholmod_sparse}},
+                                      R::Ptr{Ptr{cholmod_sparse}}, E::Ptr{Ptr{Int64}},
+                                      cc::Ptr{cholmod_common})::Int64
 end
 
-function SuiteSparseQR_C_QR(ordering, tol, econ, A, Q, R, E, cc)
-    @ccall libspqr.SuiteSparseQR_C_QR(ordering::Cint, tol::Cdouble, econ::Int64, A::Ptr{cholmod_sparse}, Q::Ptr{Ptr{cholmod_sparse}}, R::Ptr{Ptr{cholmod_sparse}}, E::Ptr{Ptr{Int64}}, cc::Ptr{cholmod_common})::Int64
+function SuiteSparseQR_i_C_QR(ordering, tol, econ, A, Q, R, E, cc)
+    @ccall libspqr.SuiteSparseQR_i_C_QR(ordering::Cint, tol::Cdouble, econ::Int32,
+                                        A::Ptr{cholmod_sparse}, Q::Ptr{Ptr{cholmod_sparse}},
+                                        R::Ptr{Ptr{cholmod_sparse}}, E::Ptr{Ptr{Int32}},
+                                        cc::Ptr{cholmod_common})::Int32
 end
 
 function SuiteSparseQR_C_backslash(ordering, tol, A, B, cc)
-    @ccall libspqr.SuiteSparseQR_C_backslash(ordering::Cint, tol::Cdouble, A::Ptr{cholmod_sparse}, B::Ptr{cholmod_dense}, cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libspqr.SuiteSparseQR_C_backslash(ordering::Cint, tol::Cdouble,
+                                             A::Ptr{cholmod_sparse}, B::Ptr{cholmod_dense},
+                                             cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function SuiteSparseQR_C_backslash_default(A, B, cc)
-    @ccall libspqr.SuiteSparseQR_C_backslash_default(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_dense}, cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libspqr.SuiteSparseQR_C_backslash_default(A::Ptr{cholmod_sparse},
+                                                     B::Ptr{cholmod_dense},
+                                                     cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function SuiteSparseQR_C_backslash_sparse(ordering, tol, A, B, cc)
-    @ccall libspqr.SuiteSparseQR_C_backslash_sparse(ordering::Cint, tol::Cdouble, A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse}, cc::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libspqr.SuiteSparseQR_C_backslash_sparse(ordering::Cint, tol::Cdouble,
+                                                    A::Ptr{cholmod_sparse},
+                                                    B::Ptr{cholmod_sparse},
+                                                    cc::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 mutable struct SuiteSparseQR_C_factorization_struct
     xtype::Cint
+    itype::Cint
     factors::Ptr{Cvoid}
     SuiteSparseQR_C_factorization_struct() = new()
 end
@@ -1536,51 +2115,78 @@ end
 const SuiteSparseQR_C_factorization = SuiteSparseQR_C_factorization_struct
 
 function SuiteSparseQR_C_factorize(ordering, tol, A, cc)
-    @ccall libspqr.SuiteSparseQR_C_factorize(ordering::Cint, tol::Cdouble, A::Ptr{cholmod_sparse}, cc::Ptr{cholmod_common})::Ptr{SuiteSparseQR_C_factorization}
+    @ccall libspqr.SuiteSparseQR_C_factorize(ordering::Cint, tol::Cdouble,
+                                             A::Ptr{cholmod_sparse},
+                                             cc::Ptr{cholmod_common})::Ptr{SuiteSparseQR_C_factorization}
 end
 
 function SuiteSparseQR_C_symbolic(ordering, allow_tol, A, cc)
-    @ccall libspqr.SuiteSparseQR_C_symbolic(ordering::Cint, allow_tol::Cint, A::Ptr{cholmod_sparse}, cc::Ptr{cholmod_common})::Ptr{SuiteSparseQR_C_factorization}
+    @ccall libspqr.SuiteSparseQR_C_symbolic(ordering::Cint, allow_tol::Cint,
+                                            A::Ptr{cholmod_sparse},
+                                            cc::Ptr{cholmod_common})::Ptr{SuiteSparseQR_C_factorization}
 end
 
 function SuiteSparseQR_C_numeric(tol, A, QR, cc)
-    @ccall libspqr.SuiteSparseQR_C_numeric(tol::Cdouble, A::Ptr{cholmod_sparse}, QR::Ptr{SuiteSparseQR_C_factorization}, cc::Ptr{cholmod_common})::Cint
+    @ccall libspqr.SuiteSparseQR_C_numeric(tol::Cdouble, A::Ptr{cholmod_sparse},
+                                           QR::Ptr{SuiteSparseQR_C_factorization},
+                                           cc::Ptr{cholmod_common})::Cint
 end
 
 function SuiteSparseQR_C_free(QR, cc)
-    @ccall libspqr.SuiteSparseQR_C_free(QR::Ptr{Ptr{SuiteSparseQR_C_factorization}}, cc::Ptr{cholmod_common})::Cint
+    @ccall libspqr.SuiteSparseQR_C_free(QR::Ptr{Ptr{SuiteSparseQR_C_factorization}},
+                                        cc::Ptr{cholmod_common})::Cint
 end
 
 function SuiteSparseQR_C_solve(system, QR, B, cc)
-    @ccall libspqr.SuiteSparseQR_C_solve(system::Cint, QR::Ptr{SuiteSparseQR_C_factorization}, B::Ptr{cholmod_dense}, cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libspqr.SuiteSparseQR_C_solve(system::Cint,
+                                         QR::Ptr{SuiteSparseQR_C_factorization},
+                                         B::Ptr{cholmod_dense},
+                                         cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function SuiteSparseQR_C_qmult(method, QR, X, cc)
-    @ccall libspqr.SuiteSparseQR_C_qmult(method::Cint, QR::Ptr{SuiteSparseQR_C_factorization}, X::Ptr{cholmod_dense}, cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libspqr.SuiteSparseQR_C_qmult(method::Cint,
+                                         QR::Ptr{SuiteSparseQR_C_factorization},
+                                         X::Ptr{cholmod_dense},
+                                         cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function amd_order(n, Ap, Ai, P, Control, Info)
-    @ccall libamd.amd_order(n::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, P::Ptr{Int32}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libamd.amd_order(n::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, P::Ptr{Int32},
+                            Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function amd_l_order(n, Ap, Ai, P, Control, Info)
-    @ccall libamd.amd_l_order(n::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, P::Ptr{Int64}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libamd.amd_l_order(n::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, P::Ptr{Int64},
+                              Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
-function amd_2(n, Pe, Iw, Len, iwlen, pfree, Nv, Next, Last, Head, Elen, Degree, W, Control, Info)
-    @ccall libamd.amd_2(n::Int32, Pe::Ptr{Int32}, Iw::Ptr{Int32}, Len::Ptr{Int32}, iwlen::Int32, pfree::Int32, Nv::Ptr{Int32}, Next::Ptr{Int32}, Last::Ptr{Int32}, Head::Ptr{Int32}, Elen::Ptr{Int32}, Degree::Ptr{Int32}, W::Ptr{Int32}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cvoid
+function amd_2(n, Pe, Iw, Len, iwlen, pfree, Nv, Next, Last, Head, Elen, Degree, W, Control,
+               Info)
+    @ccall libamd.amd_2(n::Int32, Pe::Ptr{Int32}, Iw::Ptr{Int32}, Len::Ptr{Int32},
+                        iwlen::Int32, pfree::Int32, Nv::Ptr{Int32}, Next::Ptr{Int32},
+                        Last::Ptr{Int32}, Head::Ptr{Int32}, Elen::Ptr{Int32},
+                        Degree::Ptr{Int32}, W::Ptr{Int32}, Control::Ptr{Cdouble},
+                        Info::Ptr{Cdouble})::Cvoid
 end
 
-function amd_l2(n, Pe, Iw, Len, iwlen, pfree, Nv, Next, Last, Head, Elen, Degree, W, Control, Info)
-    @ccall libamd.amd_l2(n::Int64, Pe::Ptr{Int64}, Iw::Ptr{Int64}, Len::Ptr{Int64}, iwlen::Int64, pfree::Int64, Nv::Ptr{Int64}, Next::Ptr{Int64}, Last::Ptr{Int64}, Head::Ptr{Int64}, Elen::Ptr{Int64}, Degree::Ptr{Int64}, W::Ptr{Int64}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cvoid
+function amd_l2(n, Pe, Iw, Len, iwlen, pfree, Nv, Next, Last, Head, Elen, Degree, W,
+                Control, Info)
+    @ccall libamd.amd_l2(n::Int64, Pe::Ptr{Int64}, Iw::Ptr{Int64}, Len::Ptr{Int64},
+                         iwlen::Int64, pfree::Int64, Nv::Ptr{Int64}, Next::Ptr{Int64},
+                         Last::Ptr{Int64}, Head::Ptr{Int64}, Elen::Ptr{Int64},
+                         Degree::Ptr{Int64}, W::Ptr{Int64}, Control::Ptr{Cdouble},
+                         Info::Ptr{Cdouble})::Cvoid
 end
 
 function amd_valid(n_row, n_col, Ap, Ai)
-    @ccall libamd.amd_valid(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32})::Cint
+    @ccall libamd.amd_valid(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                            Ai::Ptr{Int32})::Cint
 end
 
 function amd_l_valid(n_row, n_col, Ap, Ai)
-    @ccall libamd.amd_l_valid(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64})::Cint
+    @ccall libamd.amd_l_valid(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                              Ai::Ptr{Int64})::Cint
 end
 
 function amd_defaults(Control)
@@ -1607,188 +2213,88 @@ function amd_l_info(Info)
     @ccall libamd.amd_l_info(Info::Ptr{Cdouble})::Cvoid
 end
 
-function colamd_recommended(nnz, n_row, n_col)
-    @ccall libcolamd.colamd_recommended(nnz::Int32, n_row::Int32, n_col::Int32)::Csize_t
-end
-
-function colamd_l_recommended(nnz, n_row, n_col)
-    @ccall libcolamd.colamd_l_recommended(nnz::Int64, n_row::Int64, n_col::Int64)::Csize_t
-end
-
-function colamd_set_defaults(knobs)
-    @ccall libcolamd.colamd_set_defaults(knobs::Ptr{Cdouble})::Cvoid
-end
-
-function colamd_l_set_defaults(knobs)
-    @ccall libcolamd.colamd_l_set_defaults(knobs::Ptr{Cdouble})::Cvoid
-end
-
-function colamd(n_row, n_col, Alen, A, p, knobs, stats)
-    @ccall libcolamd.colamd(n_row::Int32, n_col::Int32, Alen::Int32, A::Ptr{Int32}, p::Ptr{Int32}, knobs::Ptr{Cdouble}, stats::Ptr{Int32})::Cint
-end
-
-function colamd_l(n_row, n_col, Alen, A, p, knobs, stats)
-    @ccall libcolamd.colamd_l(n_row::Int64, n_col::Int64, Alen::Int64, A::Ptr{Int64}, p::Ptr{Int64}, knobs::Ptr{Cdouble}, stats::Ptr{Int64})::Cint
-end
-
-function symamd(n, A, p, perm, knobs, stats, allocate, release)
-    @ccall libcolamd.symamd(n::Int32, A::Ptr{Int32}, p::Ptr{Int32}, perm::Ptr{Int32}, knobs::Ptr{Cdouble}, stats::Ptr{Int32}, allocate::Ptr{Cvoid}, release::Ptr{Cvoid})::Cint
-end
-
-function symamd_l(n, A, p, perm, knobs, stats, allocate, release)
-    @ccall libcolamd.symamd_l(n::Int64, A::Ptr{Int64}, p::Ptr{Int64}, perm::Ptr{Int64}, knobs::Ptr{Cdouble}, stats::Ptr{Int64}, allocate::Ptr{Cvoid}, release::Ptr{Cvoid})::Cint
-end
-
-function colamd_report(stats)
-    @ccall libcolamd.colamd_report(stats::Ptr{Int32})::Cvoid
-end
-
-function colamd_l_report(stats)
-    @ccall libcolamd.colamd_l_report(stats::Ptr{Int64})::Cvoid
-end
-
-function symamd_report(stats)
-    @ccall libcolamd.symamd_report(stats::Ptr{Int32})::Cvoid
-end
-
-function symamd_l_report(stats)
-    @ccall libcolamd.symamd_l_report(stats::Ptr{Int64})::Cvoid
-end
-
-function ccolamd_recommended(nnz, n_row, n_col)
-    @ccall libcolamd.ccolamd_recommended(nnz::Cint, n_row::Cint, n_col::Cint)::Csize_t
-end
-
-function ccolamd_l_recommended(nnz, n_row, n_col)
-    @ccall libcolamd.ccolamd_l_recommended(nnz::Int64, n_row::Int64, n_col::Int64)::Csize_t
-end
-
-function ccolamd_set_defaults(knobs)
-    @ccall libcolamd.ccolamd_set_defaults(knobs::Ptr{Cdouble})::Cvoid
-end
-
-function ccolamd_l_set_defaults(knobs)
-    @ccall libcolamd.ccolamd_l_set_defaults(knobs::Ptr{Cdouble})::Cvoid
-end
-
-function ccolamd(n_row, n_col, Alen, A, p, knobs, stats, cmember)
-    @ccall libcolamd.ccolamd(n_row::Cint, n_col::Cint, Alen::Cint, A::Ptr{Cint}, p::Ptr{Cint}, knobs::Ptr{Cdouble}, stats::Ptr{Cint}, cmember::Ptr{Cint})::Cint
-end
-
-function ccolamd_l(n_row, n_col, Alen, A, p, knobs, stats, cmember)
-    @ccall libcolamd.ccolamd_l(n_row::Int64, n_col::Int64, Alen::Int64, A::Ptr{Int64}, p::Ptr{Int64}, knobs::Ptr{Cdouble}, stats::Ptr{Int64}, cmember::Ptr{Int64})::Cint
-end
-
-function csymamd(n, A, p, perm, knobs, stats, allocate, release, cmember, stype)
-    @ccall libcolamd.csymamd(n::Cint, A::Ptr{Cint}, p::Ptr{Cint}, perm::Ptr{Cint}, knobs::Ptr{Cdouble}, stats::Ptr{Cint}, allocate::Ptr{Cvoid}, release::Ptr{Cvoid}, cmember::Ptr{Cint}, stype::Cint)::Cint
-end
-
-function csymamd_l(n, A, p, perm, knobs, stats, allocate, release, cmember, stype)
-    @ccall libcolamd.csymamd_l(n::Int64, A::Ptr{Int64}, p::Ptr{Int64}, perm::Ptr{Int64}, knobs::Ptr{Cdouble}, stats::Ptr{Int64}, allocate::Ptr{Cvoid}, release::Ptr{Cvoid}, cmember::Ptr{Int64}, stype::Int64)::Cint
-end
-
-function ccolamd_report(stats)
-    @ccall libcolamd.ccolamd_report(stats::Ptr{Cint})::Cvoid
-end
-
-function ccolamd_l_report(stats)
-    @ccall libcolamd.ccolamd_l_report(stats::Ptr{Int64})::Cvoid
-end
-
-function csymamd_report(stats)
-    @ccall libcolamd.csymamd_report(stats::Ptr{Cint})::Cvoid
-end
-
-function csymamd_l_report(stats)
-    @ccall libcolamd.csymamd_l_report(stats::Ptr{Int64})::Cvoid
-end
-
-function ccolamd2(n_row, n_col, Alen, A, p, knobs, stats, Front_npivcol, Front_nrows, Front_ncols, Front_parent, Front_cols, p_nfr, InFront, cmember)
-    @ccall libcolamd.ccolamd2(n_row::Cint, n_col::Cint, Alen::Cint, A::Ptr{Cint}, p::Ptr{Cint}, knobs::Ptr{Cdouble}, stats::Ptr{Cint}, Front_npivcol::Ptr{Cint}, Front_nrows::Ptr{Cint}, Front_ncols::Ptr{Cint}, Front_parent::Ptr{Cint}, Front_cols::Ptr{Cint}, p_nfr::Ptr{Cint}, InFront::Ptr{Cint}, cmember::Ptr{Cint})::Cint
-end
-
-function ccolamd2_l(n_row, n_col, Alen, A, p, knobs, stats, Front_npivcol, Front_nrows, Front_ncols, Front_parent, Front_cols, p_nfr, InFront, cmember)
-    @ccall libcolamd.ccolamd2_l(n_row::Int64, n_col::Int64, Alen::Int64, A::Ptr{Int64}, p::Ptr{Int64}, knobs::Ptr{Cdouble}, stats::Ptr{Int64}, Front_npivcol::Ptr{Int64}, Front_nrows::Ptr{Int64}, Front_ncols::Ptr{Int64}, Front_parent::Ptr{Int64}, Front_cols::Ptr{Int64}, p_nfr::Ptr{Int64}, InFront::Ptr{Int64}, cmember::Ptr{Int64})::Cint
-end
-
-function ccolamd_apply_order(Front, Order, Temp, nn, nfr)
-    @ccall libcolamd.ccolamd_apply_order(Front::Ptr{Cint}, Order::Ptr{Cint}, Temp::Ptr{Cint}, nn::Cint, nfr::Cint)::Cvoid
-end
-
-function ccolamd_l_apply_order(Front, Order, Temp, nn, nfr)
-    @ccall libcolamd.ccolamd_l_apply_order(Front::Ptr{Int64}, Order::Ptr{Int64}, Temp::Ptr{Int64}, nn::Int64, nfr::Int64)::Cvoid
-end
-
-function ccolamd_fsize(nn, MaxFsize, Fnrows, Fncols, Parent, Npiv)
-    @ccall libcolamd.ccolamd_fsize(nn::Cint, MaxFsize::Ptr{Cint}, Fnrows::Ptr{Cint}, Fncols::Ptr{Cint}, Parent::Ptr{Cint}, Npiv::Ptr{Cint})::Cvoid
-end
-
-function ccolamd_l_fsize(nn, MaxFsize, Fnrows, Fncols, Parent, Npiv)
-    @ccall libcolamd.ccolamd_l_fsize(nn::Int64, MaxFsize::Ptr{Int64}, Fnrows::Ptr{Int64}, Fncols::Ptr{Int64}, Parent::Ptr{Int64}, Npiv::Ptr{Int64})::Cvoid
-end
-
-function ccolamd_postorder(nn, Parent, Npiv, Fsize, Order, Child, Sibling, Stack, Front_cols, cmember)
-    @ccall libcolamd.ccolamd_postorder(nn::Cint, Parent::Ptr{Cint}, Npiv::Ptr{Cint}, Fsize::Ptr{Cint}, Order::Ptr{Cint}, Child::Ptr{Cint}, Sibling::Ptr{Cint}, Stack::Ptr{Cint}, Front_cols::Ptr{Cint}, cmember::Ptr{Cint})::Cvoid
-end
-
-function ccolamd_l_postorder(nn, Parent, Npiv, Fsize, Order, Child, Sibling, Stack, Front_cols, cmember)
-    @ccall libcolamd.ccolamd_l_postorder(nn::Int64, Parent::Ptr{Int64}, Npiv::Ptr{Int64}, Fsize::Ptr{Int64}, Order::Ptr{Int64}, Child::Ptr{Int64}, Sibling::Ptr{Int64}, Stack::Ptr{Int64}, Front_cols::Ptr{Int64}, cmember::Ptr{Int64})::Cvoid
-end
-
-function ccolamd_post_tree(root, k, Child, Sibling, Order, Stack)
-    @ccall libcolamd.ccolamd_post_tree(root::Cint, k::Cint, Child::Ptr{Cint}, Sibling::Ptr{Cint}, Order::Ptr{Cint}, Stack::Ptr{Cint})::Cint
-end
-
-function ccolamd_l_post_tree(root, k, Child, Sibling, Order, Stack)
-    @ccall libcolamd.ccolamd_l_post_tree(root::Int64, k::Int64, Child::Ptr{Int64}, Sibling::Ptr{Int64}, Order::Ptr{Int64}, Stack::Ptr{Int64})::Int64
-end
-
 function umfpack_di_symbolic(n_row, n_col, Ap, Ai, Ax, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_di_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                          Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                          Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                          Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_symbolic(n_row, n_col, Ap, Ai, Ax, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_dl_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                          Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                          Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                          Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_symbolic(n_row, n_col, Ap, Ai, Ax, Az, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_zi_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                          Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                          Az::Ptr{Cdouble}, Symbolic::Ptr{Ptr{Cvoid}},
+                                          Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_symbolic(n_row, n_col, Ap, Ai, Ax, Az, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_zl_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                          Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                          Az::Ptr{Cdouble}, Symbolic::Ptr{Ptr{Cvoid}},
+                                          Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_numeric(Ap, Ai, Ax, Symbolic, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_di_numeric(Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Symbolic::Ptr{Cvoid}, Numeric::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_numeric(Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                         Symbolic::Ptr{Cvoid}, Numeric::Ptr{Ptr{Cvoid}},
+                                         Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_numeric(Ap, Ai, Ax, Symbolic, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_dl_numeric(Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Symbolic::Ptr{Cvoid}, Numeric::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_numeric(Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                         Symbolic::Ptr{Cvoid}, Numeric::Ptr{Ptr{Cvoid}},
+                                         Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_numeric(Ap, Ai, Ax, Az, Symbolic, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_zi_numeric(Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Symbolic::Ptr{Cvoid}, Numeric::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_numeric(Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                         Az::Ptr{Cdouble}, Symbolic::Ptr{Cvoid},
+                                         Numeric::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                         Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_numeric(Ap, Ai, Ax, Az, Symbolic, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_zl_numeric(Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Symbolic::Ptr{Cvoid}, Numeric::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_numeric(Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                         Az::Ptr{Cdouble}, Symbolic::Ptr{Cvoid},
+                                         Numeric::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                         Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_solve(sys, Ap, Ai, Ax, X, B, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_di_solve(sys::Cint, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_solve(sys::Cint, Ap::Ptr{Int32}, Ai::Ptr{Int32},
+                                       Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble},
+                                       Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                       Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_solve(sys, Ap, Ai, Ax, X, B, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_dl_solve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_solve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64},
+                                       Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble},
+                                       Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                       Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_solve(sys, Ap, Ai, Ax, Az, Xx, Xz, Bx, Bz, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_zi_solve(sys::Cint, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_solve(sys::Cint, Ap::Ptr{Int32}, Ai::Ptr{Int32},
+                                       Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Xx::Ptr{Cdouble},
+                                       Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble},
+                                       Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                       Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_solve(sys, Ap, Ai, Ax, Az, Xx, Xz, Bx, Bz, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_zl_solve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_solve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64},
+                                       Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Xx::Ptr{Cdouble},
+                                       Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble},
+                                       Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                       Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_free_symbolic(Symbolic)
@@ -1840,51 +2346,119 @@ function umfpack_zl_defaults(Control)
 end
 
 function umfpack_di_qsymbolic(n_row, n_col, Ap, Ai, Ax, Qinit, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_di_qsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Qinit::Ptr{Int32}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_qsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                           Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                           Qinit::Ptr{Int32}, Symbolic::Ptr{Ptr{Cvoid}},
+                                           Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_qsymbolic(n_row, n_col, Ap, Ai, Ax, Qinit, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_dl_qsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Qinit::Ptr{Int64}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_qsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                           Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                           Qinit::Ptr{Int64}, Symbolic::Ptr{Ptr{Cvoid}},
+                                           Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_qsymbolic(n_row, n_col, Ap, Ai, Ax, Az, Qinit, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_zi_qsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Qinit::Ptr{Int32}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_qsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                           Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                           Az::Ptr{Cdouble}, Qinit::Ptr{Int32},
+                                           Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                           Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_qsymbolic(n_row, n_col, Ap, Ai, Ax, Az, Qinit, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_zl_qsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Qinit::Ptr{Int64}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_di_fsymbolic(n_row, n_col, Ap, Ai, Ax, user_ordering, user_params, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_di_fsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_dl_fsymbolic(n_row, n_col, Ap, Ai, Ax, user_ordering, user_params, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_dl_fsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_zi_fsymbolic(n_row, n_col, Ap, Ai, Ax, Az, user_ordering, user_params, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_zi_fsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_zl_fsymbolic(n_row, n_col, Ap, Ai, Ax, Az, user_ordering, user_params, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_zl_fsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_di_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Qinit, user_ordering, user_params, Symbolic, SW, Control, Info)
-    @ccall libumfpack.umfpack_di_paru_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Qinit::Ptr{Int32}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_dl_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Qinit, user_ordering, user_params, Symbolic, SW, Control, Info)
-    @ccall libumfpack.umfpack_dl_paru_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Qinit::Ptr{Int64}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_zi_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Az, Qinit, user_ordering, user_params, Symbolic, SW, Control, Info)
-    @ccall libumfpack.umfpack_zi_paru_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Qinit::Ptr{Int32}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_zl_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Az, Qinit, user_ordering, user_params, Symbolic, SW, Control, Info)
-    @ccall libumfpack.umfpack_zl_paru_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Qinit::Ptr{Int64}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_qsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                           Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                           Az::Ptr{Cdouble}, Qinit::Ptr{Int64},
+                                           Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                           Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_di_fsymbolic(n_row, n_col, Ap, Ai, Ax, user_ordering, user_params,
+                              Symbolic, Control, Info)
+    @ccall libumfpack.umfpack_di_fsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                           Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                           user_ordering::Ptr{Cvoid},
+                                           user_params::Ptr{Cvoid},
+                                           Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                           Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_dl_fsymbolic(n_row, n_col, Ap, Ai, Ax, user_ordering, user_params,
+                              Symbolic, Control, Info)
+    @ccall libumfpack.umfpack_dl_fsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                           Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                           user_ordering::Ptr{Cvoid},
+                                           user_params::Ptr{Cvoid},
+                                           Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                           Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_zi_fsymbolic(n_row, n_col, Ap, Ai, Ax, Az, user_ordering, user_params,
+                              Symbolic, Control, Info)
+    @ccall libumfpack.umfpack_zi_fsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                           Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                           Az::Ptr{Cdouble}, user_ordering::Ptr{Cvoid},
+                                           user_params::Ptr{Cvoid},
+                                           Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                           Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_zl_fsymbolic(n_row, n_col, Ap, Ai, Ax, Az, user_ordering, user_params,
+                              Symbolic, Control, Info)
+    @ccall libumfpack.umfpack_zl_fsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                           Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                           Az::Ptr{Cdouble}, user_ordering::Ptr{Cvoid},
+                                           user_params::Ptr{Cvoid},
+                                           Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                           Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_di_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Qinit, user_ordering,
+                                  user_params, Symbolic, SW, Control, Info)
+    @ccall libumfpack.umfpack_di_paru_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                               Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                               Qinit::Ptr{Int32}, user_ordering::Ptr{Cvoid},
+                                               user_params::Ptr{Cvoid},
+                                               Symbolic::Ptr{Ptr{Cvoid}},
+                                               SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                               Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_dl_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Qinit, user_ordering,
+                                  user_params, Symbolic, SW, Control, Info)
+    @ccall libumfpack.umfpack_dl_paru_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                               Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                               Qinit::Ptr{Int64}, user_ordering::Ptr{Cvoid},
+                                               user_params::Ptr{Cvoid},
+                                               Symbolic::Ptr{Ptr{Cvoid}},
+                                               SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                               Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_zi_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Az, Qinit, user_ordering,
+                                  user_params, Symbolic, SW, Control, Info)
+    @ccall libumfpack.umfpack_zi_paru_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                               Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                               Az::Ptr{Cdouble}, Qinit::Ptr{Int32},
+                                               user_ordering::Ptr{Cvoid},
+                                               user_params::Ptr{Cvoid},
+                                               Symbolic::Ptr{Ptr{Cvoid}},
+                                               SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                               Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_zl_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Az, Qinit, user_ordering,
+                                  user_params, Symbolic, SW, Control, Info)
+    @ccall libumfpack.umfpack_zl_paru_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                               Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                               Az::Ptr{Cdouble}, Qinit::Ptr{Int64},
+                                               user_ordering::Ptr{Cvoid},
+                                               user_params::Ptr{Cvoid},
+                                               Symbolic::Ptr{Ptr{Cvoid}},
+                                               SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                               Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_paru_free_sw(SW)
@@ -1904,339 +2478,547 @@ function umfpack_zl_paru_free_sw(SW)
 end
 
 function umfpack_di_wsolve(sys, Ap, Ai, Ax, X, B, Numeric, Control, Info, Wi, W)
-    @ccall libumfpack.umfpack_di_wsolve(sys::Cint, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble}, Wi::Ptr{Int32}, W::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_wsolve(sys::Cint, Ap::Ptr{Int32}, Ai::Ptr{Int32},
+                                        Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble},
+                                        Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                        Info::Ptr{Cdouble}, Wi::Ptr{Int32},
+                                        W::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_wsolve(sys, Ap, Ai, Ax, X, B, Numeric, Control, Info, Wi, W)
-    @ccall libumfpack.umfpack_dl_wsolve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble}, Wi::Ptr{Int64}, W::Ptr{Cdouble})::Cint
-end
-
-function umfpack_zi_wsolve(sys, Ap, Ai, Ax, Az, Xx, Xz, Bx, Bz, Numeric, Control, Info, Wi, W)
-    @ccall libumfpack.umfpack_zi_wsolve(sys::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble}, Wi::Ptr{Int32}, W::Ptr{Cdouble})::Cint
-end
-
-function umfpack_zl_wsolve(sys, Ap, Ai, Ax, Az, Xx, Xz, Bx, Bz, Numeric, Control, Info, Wi, W)
-    @ccall libumfpack.umfpack_zl_wsolve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble}, Wi::Ptr{Int64}, W::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_wsolve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64},
+                                        Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble},
+                                        Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                        Info::Ptr{Cdouble}, Wi::Ptr{Int64},
+                                        W::Ptr{Cdouble})::Cint
+end
+
+function umfpack_zi_wsolve(sys, Ap, Ai, Ax, Az, Xx, Xz, Bx, Bz, Numeric, Control, Info, Wi,
+                           W)
+    @ccall libumfpack.umfpack_zi_wsolve(sys::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32},
+                                        Ax::Ptr{Cdouble}, Az::Ptr{Cdouble},
+                                        Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble},
+                                        Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble},
+                                        Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                        Info::Ptr{Cdouble}, Wi::Ptr{Int32},
+                                        W::Ptr{Cdouble})::Cint
+end
+
+function umfpack_zl_wsolve(sys, Ap, Ai, Ax, Az, Xx, Xz, Bx, Bz, Numeric, Control, Info, Wi,
+                           W)
+    @ccall libumfpack.umfpack_zl_wsolve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64},
+                                        Ax::Ptr{Cdouble}, Az::Ptr{Cdouble},
+                                        Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble},
+                                        Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble},
+                                        Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                        Info::Ptr{Cdouble}, Wi::Ptr{Int64},
+                                        W::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_triplet_to_col(n_row, n_col, nz, Ti, Tj, Tx, Ap, Ai, Ax, Map)
-    @ccall libumfpack.umfpack_di_triplet_to_col(n_row::Int32, n_col::Int32, nz::Int32, Ti::Ptr{Int32}, Tj::Ptr{Int32}, Tx::Ptr{Cdouble}, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Map::Ptr{Int32})::Cint
+    @ccall libumfpack.umfpack_di_triplet_to_col(n_row::Int32, n_col::Int32, nz::Int32,
+                                                Ti::Ptr{Int32}, Tj::Ptr{Int32},
+                                                Tx::Ptr{Cdouble}, Ap::Ptr{Int32},
+                                                Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                                Map::Ptr{Int32})::Cint
 end
 
 function umfpack_dl_triplet_to_col(n_row, n_col, nz, Ti, Tj, Tx, Ap, Ai, Ax, Map)
-    @ccall libumfpack.umfpack_dl_triplet_to_col(n_row::Int64, n_col::Int64, nz::Int64, Ti::Ptr{Int64}, Tj::Ptr{Int64}, Tx::Ptr{Cdouble}, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Map::Ptr{Int64})::Cint
+    @ccall libumfpack.umfpack_dl_triplet_to_col(n_row::Int64, n_col::Int64, nz::Int64,
+                                                Ti::Ptr{Int64}, Tj::Ptr{Int64},
+                                                Tx::Ptr{Cdouble}, Ap::Ptr{Int64},
+                                                Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                                Map::Ptr{Int64})::Cint
 end
 
 function umfpack_zi_triplet_to_col(n_row, n_col, nz, Ti, Tj, Tx, Tz, Ap, Ai, Ax, Az, Map)
-    @ccall libumfpack.umfpack_zi_triplet_to_col(n_row::Int32, n_col::Int32, nz::Int32, Ti::Ptr{Int32}, Tj::Ptr{Int32}, Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble}, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Map::Ptr{Int32})::Cint
+    @ccall libumfpack.umfpack_zi_triplet_to_col(n_row::Int32, n_col::Int32, nz::Int32,
+                                                Ti::Ptr{Int32}, Tj::Ptr{Int32},
+                                                Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble},
+                                                Ap::Ptr{Int32}, Ai::Ptr{Int32},
+                                                Ax::Ptr{Cdouble}, Az::Ptr{Cdouble},
+                                                Map::Ptr{Int32})::Cint
 end
 
 function umfpack_zl_triplet_to_col(n_row, n_col, nz, Ti, Tj, Tx, Tz, Ap, Ai, Ax, Az, Map)
-    @ccall libumfpack.umfpack_zl_triplet_to_col(n_row::Int64, n_col::Int64, nz::Int64, Ti::Ptr{Int64}, Tj::Ptr{Int64}, Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble}, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Map::Ptr{Int64})::Cint
+    @ccall libumfpack.umfpack_zl_triplet_to_col(n_row::Int64, n_col::Int64, nz::Int64,
+                                                Ti::Ptr{Int64}, Tj::Ptr{Int64},
+                                                Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble},
+                                                Ap::Ptr{Int64}, Ai::Ptr{Int64},
+                                                Ax::Ptr{Cdouble}, Az::Ptr{Cdouble},
+                                                Map::Ptr{Int64})::Cint
 end
 
 function umfpack_di_col_to_triplet(n_col, Ap, Tj)
-    @ccall libumfpack.umfpack_di_col_to_triplet(n_col::Int32, Ap::Ptr{Int32}, Tj::Ptr{Int32})::Cint
+    @ccall libumfpack.umfpack_di_col_to_triplet(n_col::Int32, Ap::Ptr{Int32},
+                                                Tj::Ptr{Int32})::Cint
 end
 
 function umfpack_dl_col_to_triplet(n_col, Ap, Tj)
-    @ccall libumfpack.umfpack_dl_col_to_triplet(n_col::Int64, Ap::Ptr{Int64}, Tj::Ptr{Int64})::Cint
+    @ccall libumfpack.umfpack_dl_col_to_triplet(n_col::Int64, Ap::Ptr{Int64},
+                                                Tj::Ptr{Int64})::Cint
 end
 
 function umfpack_zi_col_to_triplet(n_col, Ap, Tj)
-    @ccall libumfpack.umfpack_zi_col_to_triplet(n_col::Int32, Ap::Ptr{Int32}, Tj::Ptr{Int32})::Cint
+    @ccall libumfpack.umfpack_zi_col_to_triplet(n_col::Int32, Ap::Ptr{Int32},
+                                                Tj::Ptr{Int32})::Cint
 end
 
 function umfpack_zl_col_to_triplet(n_col, Ap, Tj)
-    @ccall libumfpack.umfpack_zl_col_to_triplet(n_col::Int64, Ap::Ptr{Int64}, Tj::Ptr{Int64})::Cint
+    @ccall libumfpack.umfpack_zl_col_to_triplet(n_col::Int64, Ap::Ptr{Int64},
+                                                Tj::Ptr{Int64})::Cint
 end
 
 function umfpack_di_transpose(n_row, n_col, Ap, Ai, Ax, P, Q, Rp, Ri, Rx)
-    @ccall libumfpack.umfpack_di_transpose(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, P::Ptr{Int32}, Q::Ptr{Int32}, Rp::Ptr{Int32}, Ri::Ptr{Int32}, Rx::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_transpose(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                           Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, P::Ptr{Int32},
+                                           Q::Ptr{Int32}, Rp::Ptr{Int32}, Ri::Ptr{Int32},
+                                           Rx::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_transpose(n_row, n_col, Ap, Ai, Ax, P, Q, Rp, Ri, Rx)
-    @ccall libumfpack.umfpack_dl_transpose(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, P::Ptr{Int64}, Q::Ptr{Int64}, Rp::Ptr{Int64}, Ri::Ptr{Int64}, Rx::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_transpose(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                           Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, P::Ptr{Int64},
+                                           Q::Ptr{Int64}, Rp::Ptr{Int64}, Ri::Ptr{Int64},
+                                           Rx::Ptr{Cdouble})::Cint
 end
 
-function umfpack_zi_transpose(n_row, n_col, Ap, Ai, Ax, Az, P, Q, Rp, Ri, Rx, Rz, do_conjugate)
-    @ccall libumfpack.umfpack_zi_transpose(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, P::Ptr{Int32}, Q::Ptr{Int32}, Rp::Ptr{Int32}, Ri::Ptr{Int32}, Rx::Ptr{Cdouble}, Rz::Ptr{Cdouble}, do_conjugate::Cint)::Cint
+function umfpack_zi_transpose(n_row, n_col, Ap, Ai, Ax, Az, P, Q, Rp, Ri, Rx, Rz,
+                              do_conjugate)
+    @ccall libumfpack.umfpack_zi_transpose(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                           Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                           Az::Ptr{Cdouble}, P::Ptr{Int32}, Q::Ptr{Int32},
+                                           Rp::Ptr{Int32}, Ri::Ptr{Int32}, Rx::Ptr{Cdouble},
+                                           Rz::Ptr{Cdouble}, do_conjugate::Cint)::Cint
 end
 
-function umfpack_zl_transpose(n_row, n_col, Ap, Ai, Ax, Az, P, Q, Rp, Ri, Rx, Rz, do_conjugate)
-    @ccall libumfpack.umfpack_zl_transpose(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, P::Ptr{Int64}, Q::Ptr{Int64}, Rp::Ptr{Int64}, Ri::Ptr{Int64}, Rx::Ptr{Cdouble}, Rz::Ptr{Cdouble}, do_conjugate::Cint)::Cint
+function umfpack_zl_transpose(n_row, n_col, Ap, Ai, Ax, Az, P, Q, Rp, Ri, Rx, Rz,
+                              do_conjugate)
+    @ccall libumfpack.umfpack_zl_transpose(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                           Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                           Az::Ptr{Cdouble}, P::Ptr{Int64}, Q::Ptr{Int64},
+                                           Rp::Ptr{Int64}, Ri::Ptr{Int64}, Rx::Ptr{Cdouble},
+                                           Rz::Ptr{Cdouble}, do_conjugate::Cint)::Cint
 end
 
 function umfpack_di_scale(X, B, Numeric)
-    @ccall libumfpack.umfpack_di_scale(X::Ptr{Cdouble}, B::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_scale(X::Ptr{Cdouble}, B::Ptr{Cdouble},
+                                       Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_scale(X, B, Numeric)
-    @ccall libumfpack.umfpack_dl_scale(X::Ptr{Cdouble}, B::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_scale(X::Ptr{Cdouble}, B::Ptr{Cdouble},
+                                       Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_scale(Xx, Xz, Bx, Bz, Numeric)
-    @ccall libumfpack.umfpack_zi_scale(Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_scale(Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble},
+                                       Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_scale(Xx, Xz, Bx, Bz, Numeric)
-    @ccall libumfpack.umfpack_zl_scale(Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_scale(Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble},
+                                       Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_get_lunz(lnz, unz, n_row, n_col, nz_udiag, Numeric)
-    @ccall libumfpack.umfpack_di_get_lunz(lnz::Ptr{Int32}, unz::Ptr{Int32}, n_row::Ptr{Int32}, n_col::Ptr{Int32}, nz_udiag::Ptr{Int32}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_get_lunz(lnz::Ptr{Int32}, unz::Ptr{Int32},
+                                          n_row::Ptr{Int32}, n_col::Ptr{Int32},
+                                          nz_udiag::Ptr{Int32}, Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_get_lunz(lnz, unz, n_row, n_col, nz_udiag, Numeric)
-    @ccall libumfpack.umfpack_dl_get_lunz(lnz::Ptr{Int64}, unz::Ptr{Int64}, n_row::Ptr{Int64}, n_col::Ptr{Int64}, nz_udiag::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_get_lunz(lnz::Ptr{Int64}, unz::Ptr{Int64},
+                                          n_row::Ptr{Int64}, n_col::Ptr{Int64},
+                                          nz_udiag::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_get_lunz(lnz, unz, n_row, n_col, nz_udiag, Numeric)
-    @ccall libumfpack.umfpack_zi_get_lunz(lnz::Ptr{Int32}, unz::Ptr{Int32}, n_row::Ptr{Int32}, n_col::Ptr{Int32}, nz_udiag::Ptr{Int32}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_get_lunz(lnz::Ptr{Int32}, unz::Ptr{Int32},
+                                          n_row::Ptr{Int32}, n_col::Ptr{Int32},
+                                          nz_udiag::Ptr{Int32}, Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_get_lunz(lnz, unz, n_row, n_col, nz_udiag, Numeric)
-    @ccall libumfpack.umfpack_zl_get_lunz(lnz::Ptr{Int64}, unz::Ptr{Int64}, n_row::Ptr{Int64}, n_col::Ptr{Int64}, nz_udiag::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_get_lunz(lnz::Ptr{Int64}, unz::Ptr{Int64},
+                                          n_row::Ptr{Int64}, n_col::Ptr{Int64},
+                                          nz_udiag::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_get_numeric(Lp, Lj, Lx, Up, Ui, Ux, P, Q, Dx, do_recip, Rs, Numeric)
-    @ccall libumfpack.umfpack_di_get_numeric(Lp::Ptr{Int32}, Lj::Ptr{Int32}, Lx::Ptr{Cdouble}, Up::Ptr{Int32}, Ui::Ptr{Int32}, Ux::Ptr{Cdouble}, P::Ptr{Int32}, Q::Ptr{Int32}, Dx::Ptr{Cdouble}, do_recip::Ptr{Int32}, Rs::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_get_numeric(Lp::Ptr{Int32}, Lj::Ptr{Int32},
+                                             Lx::Ptr{Cdouble}, Up::Ptr{Int32},
+                                             Ui::Ptr{Int32}, Ux::Ptr{Cdouble},
+                                             P::Ptr{Int32}, Q::Ptr{Int32}, Dx::Ptr{Cdouble},
+                                             do_recip::Ptr{Int32}, Rs::Ptr{Cdouble},
+                                             Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_get_numeric(Lp, Lj, Lx, Up, Ui, Ux, P, Q, Dx, do_recip, Rs, Numeric)
-    @ccall libumfpack.umfpack_dl_get_numeric(Lp::Ptr{Int64}, Lj::Ptr{Int64}, Lx::Ptr{Cdouble}, Up::Ptr{Int64}, Ui::Ptr{Int64}, Ux::Ptr{Cdouble}, P::Ptr{Int64}, Q::Ptr{Int64}, Dx::Ptr{Cdouble}, do_recip::Ptr{Int64}, Rs::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
-end
-
-function umfpack_zi_get_numeric(Lp, Lj, Lx, Lz, Up, Ui, Ux, Uz, P, Q, Dx, Dz, do_recip, Rs, Numeric)
-    @ccall libumfpack.umfpack_zi_get_numeric(Lp::Ptr{Int32}, Lj::Ptr{Int32}, Lx::Ptr{Cdouble}, Lz::Ptr{Cdouble}, Up::Ptr{Int32}, Ui::Ptr{Int32}, Ux::Ptr{Cdouble}, Uz::Ptr{Cdouble}, P::Ptr{Int32}, Q::Ptr{Int32}, Dx::Ptr{Cdouble}, Dz::Ptr{Cdouble}, do_recip::Ptr{Int32}, Rs::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
-end
-
-function umfpack_zl_get_numeric(Lp, Lj, Lx, Lz, Up, Ui, Ux, Uz, P, Q, Dx, Dz, do_recip, Rs, Numeric)
-    @ccall libumfpack.umfpack_zl_get_numeric(Lp::Ptr{Int64}, Lj::Ptr{Int64}, Lx::Ptr{Cdouble}, Lz::Ptr{Cdouble}, Up::Ptr{Int64}, Ui::Ptr{Int64}, Ux::Ptr{Cdouble}, Uz::Ptr{Cdouble}, P::Ptr{Int64}, Q::Ptr{Int64}, Dx::Ptr{Cdouble}, Dz::Ptr{Cdouble}, do_recip::Ptr{Int64}, Rs::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
-end
-
-function umfpack_di_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol, Front_parent, Front_1strow, Front_leftmostdesc, Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
-    @ccall libumfpack.umfpack_di_get_symbolic(n_row::Ptr{Int32}, n_col::Ptr{Int32}, n1::Ptr{Int32}, nz::Ptr{Int32}, nfr::Ptr{Int32}, nchains::Ptr{Int32}, P::Ptr{Int32}, Q::Ptr{Int32}, Front_npivcol::Ptr{Int32}, Front_parent::Ptr{Int32}, Front_1strow::Ptr{Int32}, Front_leftmostdesc::Ptr{Int32}, Chain_start::Ptr{Int32}, Chain_maxrows::Ptr{Int32}, Chain_maxcols::Ptr{Int32}, Dmap::Ptr{Int32}, Symbolic::Ptr{Cvoid})::Cint
-end
-
-function umfpack_dl_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol, Front_parent, Front_1strow, Front_leftmostdesc, Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
-    @ccall libumfpack.umfpack_dl_get_symbolic(n_row::Ptr{Int64}, n_col::Ptr{Int64}, n1::Ptr{Int64}, nz::Ptr{Int64}, nfr::Ptr{Int64}, nchains::Ptr{Int64}, P::Ptr{Int64}, Q::Ptr{Int64}, Front_npivcol::Ptr{Int64}, Front_parent::Ptr{Int64}, Front_1strow::Ptr{Int64}, Front_leftmostdesc::Ptr{Int64}, Chain_start::Ptr{Int64}, Chain_maxrows::Ptr{Int64}, Chain_maxcols::Ptr{Int64}, Dmap::Ptr{Int64}, Symbolic::Ptr{Cvoid})::Cint
-end
-
-function umfpack_zi_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol, Front_parent, Front_1strow, Front_leftmostdesc, Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
-    @ccall libumfpack.umfpack_zi_get_symbolic(n_row::Ptr{Int32}, n_col::Ptr{Int32}, n1::Ptr{Int32}, nz::Ptr{Int32}, nfr::Ptr{Int32}, nchains::Ptr{Int32}, P::Ptr{Int32}, Q::Ptr{Int32}, Front_npivcol::Ptr{Int32}, Front_parent::Ptr{Int32}, Front_1strow::Ptr{Int32}, Front_leftmostdesc::Ptr{Int32}, Chain_start::Ptr{Int32}, Chain_maxrows::Ptr{Int32}, Chain_maxcols::Ptr{Int32}, Dmap::Ptr{Int32}, Symbolic::Ptr{Cvoid})::Cint
-end
-
-function umfpack_zl_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol, Front_parent, Front_1strow, Front_leftmostdesc, Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
-    @ccall libumfpack.umfpack_zl_get_symbolic(n_row::Ptr{Int64}, n_col::Ptr{Int64}, n1::Ptr{Int64}, nz::Ptr{Int64}, nfr::Ptr{Int64}, nchains::Ptr{Int64}, P::Ptr{Int64}, Q::Ptr{Int64}, Front_npivcol::Ptr{Int64}, Front_parent::Ptr{Int64}, Front_1strow::Ptr{Int64}, Front_leftmostdesc::Ptr{Int64}, Chain_start::Ptr{Int64}, Chain_maxrows::Ptr{Int64}, Chain_maxcols::Ptr{Int64}, Dmap::Ptr{Int64}, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_get_numeric(Lp::Ptr{Int64}, Lj::Ptr{Int64},
+                                             Lx::Ptr{Cdouble}, Up::Ptr{Int64},
+                                             Ui::Ptr{Int64}, Ux::Ptr{Cdouble},
+                                             P::Ptr{Int64}, Q::Ptr{Int64}, Dx::Ptr{Cdouble},
+                                             do_recip::Ptr{Int64}, Rs::Ptr{Cdouble},
+                                             Numeric::Ptr{Cvoid})::Cint
+end
+
+function umfpack_zi_get_numeric(Lp, Lj, Lx, Lz, Up, Ui, Ux, Uz, P, Q, Dx, Dz, do_recip, Rs,
+                                Numeric)
+    @ccall libumfpack.umfpack_zi_get_numeric(Lp::Ptr{Int32}, Lj::Ptr{Int32},
+                                             Lx::Ptr{Cdouble}, Lz::Ptr{Cdouble},
+                                             Up::Ptr{Int32}, Ui::Ptr{Int32},
+                                             Ux::Ptr{Cdouble}, Uz::Ptr{Cdouble},
+                                             P::Ptr{Int32}, Q::Ptr{Int32}, Dx::Ptr{Cdouble},
+                                             Dz::Ptr{Cdouble}, do_recip::Ptr{Int32},
+                                             Rs::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+end
+
+function umfpack_zl_get_numeric(Lp, Lj, Lx, Lz, Up, Ui, Ux, Uz, P, Q, Dx, Dz, do_recip, Rs,
+                                Numeric)
+    @ccall libumfpack.umfpack_zl_get_numeric(Lp::Ptr{Int64}, Lj::Ptr{Int64},
+                                             Lx::Ptr{Cdouble}, Lz::Ptr{Cdouble},
+                                             Up::Ptr{Int64}, Ui::Ptr{Int64},
+                                             Ux::Ptr{Cdouble}, Uz::Ptr{Cdouble},
+                                             P::Ptr{Int64}, Q::Ptr{Int64}, Dx::Ptr{Cdouble},
+                                             Dz::Ptr{Cdouble}, do_recip::Ptr{Int64},
+                                             Rs::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+end
+
+function umfpack_di_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol,
+                                 Front_parent, Front_1strow, Front_leftmostdesc,
+                                 Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
+    @ccall libumfpack.umfpack_di_get_symbolic(n_row::Ptr{Int32}, n_col::Ptr{Int32},
+                                              n1::Ptr{Int32}, nz::Ptr{Int32},
+                                              nfr::Ptr{Int32}, nchains::Ptr{Int32},
+                                              P::Ptr{Int32}, Q::Ptr{Int32},
+                                              Front_npivcol::Ptr{Int32},
+                                              Front_parent::Ptr{Int32},
+                                              Front_1strow::Ptr{Int32},
+                                              Front_leftmostdesc::Ptr{Int32},
+                                              Chain_start::Ptr{Int32},
+                                              Chain_maxrows::Ptr{Int32},
+                                              Chain_maxcols::Ptr{Int32}, Dmap::Ptr{Int32},
+                                              Symbolic::Ptr{Cvoid})::Cint
+end
+
+function umfpack_dl_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol,
+                                 Front_parent, Front_1strow, Front_leftmostdesc,
+                                 Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
+    @ccall libumfpack.umfpack_dl_get_symbolic(n_row::Ptr{Int64}, n_col::Ptr{Int64},
+                                              n1::Ptr{Int64}, nz::Ptr{Int64},
+                                              nfr::Ptr{Int64}, nchains::Ptr{Int64},
+                                              P::Ptr{Int64}, Q::Ptr{Int64},
+                                              Front_npivcol::Ptr{Int64},
+                                              Front_parent::Ptr{Int64},
+                                              Front_1strow::Ptr{Int64},
+                                              Front_leftmostdesc::Ptr{Int64},
+                                              Chain_start::Ptr{Int64},
+                                              Chain_maxrows::Ptr{Int64},
+                                              Chain_maxcols::Ptr{Int64}, Dmap::Ptr{Int64},
+                                              Symbolic::Ptr{Cvoid})::Cint
+end
+
+function umfpack_zi_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol,
+                                 Front_parent, Front_1strow, Front_leftmostdesc,
+                                 Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
+    @ccall libumfpack.umfpack_zi_get_symbolic(n_row::Ptr{Int32}, n_col::Ptr{Int32},
+                                              n1::Ptr{Int32}, nz::Ptr{Int32},
+                                              nfr::Ptr{Int32}, nchains::Ptr{Int32},
+                                              P::Ptr{Int32}, Q::Ptr{Int32},
+                                              Front_npivcol::Ptr{Int32},
+                                              Front_parent::Ptr{Int32},
+                                              Front_1strow::Ptr{Int32},
+                                              Front_leftmostdesc::Ptr{Int32},
+                                              Chain_start::Ptr{Int32},
+                                              Chain_maxrows::Ptr{Int32},
+                                              Chain_maxcols::Ptr{Int32}, Dmap::Ptr{Int32},
+                                              Symbolic::Ptr{Cvoid})::Cint
+end
+
+function umfpack_zl_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol,
+                                 Front_parent, Front_1strow, Front_leftmostdesc,
+                                 Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
+    @ccall libumfpack.umfpack_zl_get_symbolic(n_row::Ptr{Int64}, n_col::Ptr{Int64},
+                                              n1::Ptr{Int64}, nz::Ptr{Int64},
+                                              nfr::Ptr{Int64}, nchains::Ptr{Int64},
+                                              P::Ptr{Int64}, Q::Ptr{Int64},
+                                              Front_npivcol::Ptr{Int64},
+                                              Front_parent::Ptr{Int64},
+                                              Front_1strow::Ptr{Int64},
+                                              Front_leftmostdesc::Ptr{Int64},
+                                              Chain_start::Ptr{Int64},
+                                              Chain_maxrows::Ptr{Int64},
+                                              Chain_maxcols::Ptr{Int64}, Dmap::Ptr{Int64},
+                                              Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_save_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_di_save_numeric(Numeric::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_di_save_numeric(Numeric::Ptr{Cvoid},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_dl_save_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_dl_save_numeric(Numeric::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_dl_save_numeric(Numeric::Ptr{Cvoid},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zi_save_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_zi_save_numeric(Numeric::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zi_save_numeric(Numeric::Ptr{Cvoid},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zl_save_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_zl_save_numeric(Numeric::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zl_save_numeric(Numeric::Ptr{Cvoid},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_di_load_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_di_load_numeric(Numeric::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_di_load_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_dl_load_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_dl_load_numeric(Numeric::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_dl_load_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zi_load_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_zi_load_numeric(Numeric::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zi_load_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zl_load_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_zl_load_numeric(Numeric::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zl_load_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_di_copy_numeric(Numeric, Original)
-    @ccall libumfpack.umfpack_di_copy_numeric(Numeric::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_copy_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_copy_numeric(Numeric, Original)
-    @ccall libumfpack.umfpack_dl_copy_numeric(Numeric::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_copy_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_copy_numeric(Numeric, Original)
-    @ccall libumfpack.umfpack_zi_copy_numeric(Numeric::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_copy_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_copy_numeric(Numeric, Original)
-    @ccall libumfpack.umfpack_zl_copy_numeric(Numeric::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_copy_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_serialize_numeric_size(blobsize, Numeric)
-    @ccall libumfpack.umfpack_di_serialize_numeric_size(blobsize::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_serialize_numeric_size(blobsize::Ptr{Int64},
+                                                        Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_serialize_numeric_size(blobsize, Numeric)
-    @ccall libumfpack.umfpack_dl_serialize_numeric_size(blobsize::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_serialize_numeric_size(blobsize::Ptr{Int64},
+                                                        Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_serialize_numeric_size(blobsize, Numeric)
-    @ccall libumfpack.umfpack_zi_serialize_numeric_size(blobsize::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_serialize_numeric_size(blobsize::Ptr{Int64},
+                                                        Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_serialize_numeric_size(blobsize, Numeric)
-    @ccall libumfpack.umfpack_zl_serialize_numeric_size(blobsize::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_serialize_numeric_size(blobsize::Ptr{Int64},
+                                                        Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_serialize_numeric(blob, blobsize, Numeric)
-    @ccall libumfpack.umfpack_di_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64,
+                                                   Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_serialize_numeric(blob, blobsize, Numeric)
-    @ccall libumfpack.umfpack_dl_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64,
+                                                   Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_serialize_numeric(blob, blobsize, Numeric)
-    @ccall libumfpack.umfpack_zi_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64,
+                                                   Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_serialize_numeric(blob, blobsize, Numeric)
-    @ccall libumfpack.umfpack_zl_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64,
+                                                   Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_deserialize_numeric(Numeric, blob, blobsize)
-    @ccall libumfpack.umfpack_di_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_di_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                                     blob::Ptr{Int8}, blobsize::Int64)::Cint
 end
 
 function umfpack_dl_deserialize_numeric(Numeric, blob, blobsize)
-    @ccall libumfpack.umfpack_dl_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_dl_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                                     blob::Ptr{Int8}, blobsize::Int64)::Cint
 end
 
 function umfpack_zi_deserialize_numeric(Numeric, blob, blobsize)
-    @ccall libumfpack.umfpack_zi_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_zi_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                                     blob::Ptr{Int8}, blobsize::Int64)::Cint
 end
 
 function umfpack_zl_deserialize_numeric(Numeric, blob, blobsize)
-    @ccall libumfpack.umfpack_zl_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_zl_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                                     blob::Ptr{Int8}, blobsize::Int64)::Cint
 end
 
 function umfpack_di_save_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_di_save_symbolic(Symbolic::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_di_save_symbolic(Symbolic::Ptr{Cvoid},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_dl_save_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_dl_save_symbolic(Symbolic::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_dl_save_symbolic(Symbolic::Ptr{Cvoid},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zi_save_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_zi_save_symbolic(Symbolic::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zi_save_symbolic(Symbolic::Ptr{Cvoid},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zl_save_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_zl_save_symbolic(Symbolic::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zl_save_symbolic(Symbolic::Ptr{Cvoid},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_di_load_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_di_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_di_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_dl_load_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_dl_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_dl_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zi_load_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_zi_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zi_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zl_load_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_zl_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zl_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_di_copy_symbolic(Symbolic, Original)
-    @ccall libumfpack.umfpack_di_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_copy_symbolic(Symbolic, Original)
-    @ccall libumfpack.umfpack_dl_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_copy_symbolic(Symbolic, Original)
-    @ccall libumfpack.umfpack_zi_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_copy_symbolic(Symbolic, Original)
-    @ccall libumfpack.umfpack_zl_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_serialize_symbolic_size(blobsize, Symbolic)
-    @ccall libumfpack.umfpack_di_serialize_symbolic_size(blobsize::Ptr{Int64}, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_serialize_symbolic_size(blobsize::Ptr{Int64},
+                                                         Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_serialize_symbolic_size(blobsize, Symbolic)
-    @ccall libumfpack.umfpack_dl_serialize_symbolic_size(blobsize::Ptr{Int64}, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_serialize_symbolic_size(blobsize::Ptr{Int64},
+                                                         Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_serialize_symbolic_size(blobsize, Symbolic)
-    @ccall libumfpack.umfpack_zi_serialize_symbolic_size(blobsize::Ptr{Int64}, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_serialize_symbolic_size(blobsize::Ptr{Int64},
+                                                         Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_serialize_symbolic_size(blobsize, Symbolic)
-    @ccall libumfpack.umfpack_zl_serialize_symbolic_size(blobsize::Ptr{Int64}, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_serialize_symbolic_size(blobsize::Ptr{Int64},
+                                                         Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_serialize_symbolic(blob, blobsize, Symbolic)
-    @ccall libumfpack.umfpack_di_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64,
+                                                    Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_serialize_symbolic(blob, blobsize, Symbolic)
-    @ccall libumfpack.umfpack_dl_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64,
+                                                    Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_serialize_symbolic(blob, blobsize, Symbolic)
-    @ccall libumfpack.umfpack_zi_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64,
+                                                    Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_serialize_symbolic(blob, blobsize, Symbolic)
-    @ccall libumfpack.umfpack_zl_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64,
+                                                    Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_deserialize_symbolic(Symbolic, blob, blobsize)
-    @ccall libumfpack.umfpack_di_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_di_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                                      blob::Ptr{Int8},
+                                                      blobsize::Int64)::Cint
 end
 
 function umfpack_dl_deserialize_symbolic(Symbolic, blob, blobsize)
-    @ccall libumfpack.umfpack_dl_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_dl_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                                      blob::Ptr{Int8},
+                                                      blobsize::Int64)::Cint
 end
 
 function umfpack_zi_deserialize_symbolic(Symbolic, blob, blobsize)
-    @ccall libumfpack.umfpack_zi_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_zi_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                                      blob::Ptr{Int8},
+                                                      blobsize::Int64)::Cint
 end
 
 function umfpack_zl_deserialize_symbolic(Symbolic, blob, blobsize)
-    @ccall libumfpack.umfpack_zl_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_zl_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                                      blob::Ptr{Int8},
+                                                      blobsize::Int64)::Cint
 end
 
 function umfpack_di_get_determinant(Mx, Ex, Numeric, User_Info)
-    @ccall libumfpack.umfpack_di_get_determinant(Mx::Ptr{Cdouble}, Ex::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, User_Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_get_determinant(Mx::Ptr{Cdouble}, Ex::Ptr{Cdouble},
+                                                 Numeric::Ptr{Cvoid},
+                                                 User_Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_get_determinant(Mx, Ex, Numeric, User_Info)
-    @ccall libumfpack.umfpack_dl_get_determinant(Mx::Ptr{Cdouble}, Ex::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, User_Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_get_determinant(Mx::Ptr{Cdouble}, Ex::Ptr{Cdouble},
+                                                 Numeric::Ptr{Cvoid},
+                                                 User_Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_get_determinant(Mx, Mz, Ex, Numeric, User_Info)
-    @ccall libumfpack.umfpack_zi_get_determinant(Mx::Ptr{Cdouble}, Mz::Ptr{Cdouble}, Ex::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, User_Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_get_determinant(Mx::Ptr{Cdouble}, Mz::Ptr{Cdouble},
+                                                 Ex::Ptr{Cdouble}, Numeric::Ptr{Cvoid},
+                                                 User_Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_get_determinant(Mx, Mz, Ex, Numeric, User_Info)
-    @ccall libumfpack.umfpack_zl_get_determinant(Mx::Ptr{Cdouble}, Mz::Ptr{Cdouble}, Ex::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, User_Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_get_determinant(Mx::Ptr{Cdouble}, Mz::Ptr{Cdouble},
+                                                 Ex::Ptr{Cdouble}, Numeric::Ptr{Cvoid},
+                                                 User_Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_report_status(Control, status)
@@ -2256,19 +3038,23 @@ function umfpack_zl_report_status(Control, status)
 end
 
 function umfpack_di_report_info(Control, Info)
-    @ccall libumfpack.umfpack_di_report_info(Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cvoid
+    @ccall libumfpack.umfpack_di_report_info(Control::Ptr{Cdouble},
+                                             Info::Ptr{Cdouble})::Cvoid
 end
 
 function umfpack_dl_report_info(Control, Info)
-    @ccall libumfpack.umfpack_dl_report_info(Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cvoid
+    @ccall libumfpack.umfpack_dl_report_info(Control::Ptr{Cdouble},
+                                             Info::Ptr{Cdouble})::Cvoid
 end
 
 function umfpack_zi_report_info(Control, Info)
-    @ccall libumfpack.umfpack_zi_report_info(Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cvoid
+    @ccall libumfpack.umfpack_zi_report_info(Control::Ptr{Cdouble},
+                                             Info::Ptr{Cdouble})::Cvoid
 end
 
 function umfpack_zl_report_info(Control, Info)
-    @ccall libumfpack.umfpack_zl_report_info(Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cvoid
+    @ccall libumfpack.umfpack_zl_report_info(Control::Ptr{Cdouble},
+                                             Info::Ptr{Cdouble})::Cvoid
 end
 
 function umfpack_di_report_control(Control)
@@ -2288,99 +3074,137 @@ function umfpack_zl_report_control(Control)
 end
 
 function umfpack_di_report_matrix(n_row, n_col, Ap, Ai, Ax, col_form, Control)
-    @ccall libumfpack.umfpack_di_report_matrix(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, col_form::Cint, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_report_matrix(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                               Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                               col_form::Cint, Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_report_matrix(n_row, n_col, Ap, Ai, Ax, col_form, Control)
-    @ccall libumfpack.umfpack_dl_report_matrix(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, col_form::Cint, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_report_matrix(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                               Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                               col_form::Cint, Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_report_matrix(n_row, n_col, Ap, Ai, Ax, Az, col_form, Control)
-    @ccall libumfpack.umfpack_zi_report_matrix(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, col_form::Cint, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_report_matrix(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                               Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                               Az::Ptr{Cdouble}, col_form::Cint,
+                                               Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_report_matrix(n_row, n_col, Ap, Ai, Ax, Az, col_form, Control)
-    @ccall libumfpack.umfpack_zl_report_matrix(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, col_form::Cint, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_report_matrix(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                               Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                               Az::Ptr{Cdouble}, col_form::Cint,
+                                               Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_report_triplet(n_row, n_col, nz, Ti, Tj, Tx, Control)
-    @ccall libumfpack.umfpack_di_report_triplet(n_row::Int32, n_col::Int32, nz::Int32, Ti::Ptr{Int32}, Tj::Ptr{Int32}, Tx::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_report_triplet(n_row::Int32, n_col::Int32, nz::Int32,
+                                                Ti::Ptr{Int32}, Tj::Ptr{Int32},
+                                                Tx::Ptr{Cdouble},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_report_triplet(n_row, n_col, nz, Ti, Tj, Tx, Control)
-    @ccall libumfpack.umfpack_dl_report_triplet(n_row::Int64, n_col::Int64, nz::Int64, Ti::Ptr{Int64}, Tj::Ptr{Int64}, Tx::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_report_triplet(n_row::Int64, n_col::Int64, nz::Int64,
+                                                Ti::Ptr{Int64}, Tj::Ptr{Int64},
+                                                Tx::Ptr{Cdouble},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_report_triplet(n_row, n_col, nz, Ti, Tj, Tx, Tz, Control)
-    @ccall libumfpack.umfpack_zi_report_triplet(n_row::Int32, n_col::Int32, nz::Int32, Ti::Ptr{Int32}, Tj::Ptr{Int32}, Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_report_triplet(n_row::Int32, n_col::Int32, nz::Int32,
+                                                Ti::Ptr{Int32}, Tj::Ptr{Int32},
+                                                Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_report_triplet(n_row, n_col, nz, Ti, Tj, Tx, Tz, Control)
-    @ccall libumfpack.umfpack_zl_report_triplet(n_row::Int64, n_col::Int64, nz::Int64, Ti::Ptr{Int64}, Tj::Ptr{Int64}, Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_report_triplet(n_row::Int64, n_col::Int64, nz::Int64,
+                                                Ti::Ptr{Int64}, Tj::Ptr{Int64},
+                                                Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_report_vector(n, X, Control)
-    @ccall libumfpack.umfpack_di_report_vector(n::Int32, X::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_report_vector(n::Int32, X::Ptr{Cdouble},
+                                               Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_report_vector(n, X, Control)
-    @ccall libumfpack.umfpack_dl_report_vector(n::Int64, X::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_report_vector(n::Int64, X::Ptr{Cdouble},
+                                               Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_report_vector(n, Xx, Xz, Control)
-    @ccall libumfpack.umfpack_zi_report_vector(n::Int32, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_report_vector(n::Int32, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble},
+                                               Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_report_vector(n, Xx, Xz, Control)
-    @ccall libumfpack.umfpack_zl_report_vector(n::Int64, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_report_vector(n::Int64, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble},
+                                               Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_report_symbolic(Symbolic, Control)
-    @ccall libumfpack.umfpack_di_report_symbolic(Symbolic::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_report_symbolic(Symbolic::Ptr{Cvoid},
+                                                 Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_report_symbolic(Symbolic, Control)
-    @ccall libumfpack.umfpack_dl_report_symbolic(Symbolic::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_report_symbolic(Symbolic::Ptr{Cvoid},
+                                                 Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_report_symbolic(Symbolic, Control)
-    @ccall libumfpack.umfpack_zi_report_symbolic(Symbolic::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_report_symbolic(Symbolic::Ptr{Cvoid},
+                                                 Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_report_symbolic(Symbolic, Control)
-    @ccall libumfpack.umfpack_zl_report_symbolic(Symbolic::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_report_symbolic(Symbolic::Ptr{Cvoid},
+                                                 Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_report_numeric(Numeric, Control)
-    @ccall libumfpack.umfpack_di_report_numeric(Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_report_numeric(Numeric::Ptr{Cvoid},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_report_numeric(Numeric, Control)
-    @ccall libumfpack.umfpack_dl_report_numeric(Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_report_numeric(Numeric::Ptr{Cvoid},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_report_numeric(Numeric, Control)
-    @ccall libumfpack.umfpack_zi_report_numeric(Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_report_numeric(Numeric::Ptr{Cvoid},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_report_numeric(Numeric, Control)
-    @ccall libumfpack.umfpack_zl_report_numeric(Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_report_numeric(Numeric::Ptr{Cvoid},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_report_perm(np, Perm, Control)
-    @ccall libumfpack.umfpack_di_report_perm(np::Int32, Perm::Ptr{Int32}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_report_perm(np::Int32, Perm::Ptr{Int32},
+                                             Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_report_perm(np, Perm, Control)
-    @ccall libumfpack.umfpack_dl_report_perm(np::Int64, Perm::Ptr{Int64}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_report_perm(np::Int64, Perm::Ptr{Int64},
+                                             Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_report_perm(np, Perm, Control)
-    @ccall libumfpack.umfpack_zi_report_perm(np::Int32, Perm::Ptr{Int32}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_report_perm(np::Int32, Perm::Ptr{Int32},
+                                             Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_report_perm(np, Perm, Control)
-    @ccall libumfpack.umfpack_zl_report_perm(np::Int64, Perm::Ptr{Int64}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_report_perm(np::Int64, Perm::Ptr{Int64},
+                                             Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_timer()
@@ -2395,13 +3219,13 @@ function umfpack_toc(stats)
     @ccall libumfpack.umfpack_toc(stats::Ptr{Cdouble})::Cvoid
 end
 
-const CHOLMOD_DATE = "Jan 17, 2023"
+const CHOLMOD_DATE = "June 16, 2023"
 
 const CHOLMOD_MAIN_VERSION = 4
 
 const CHOLMOD_SUB_VERSION = 0
 
-const CHOLMOD_SUBSUB_VERSION = 3
+const CHOLMOD_SUBSUB_VERSION = 4
 
 const _FILE_OFFSET_BITS = 64
 
@@ -2427,17 +3251,18 @@ const SUITESPARSE_COMPILER_MSC = 0
 
 const SUITESPARSE_COMPILER_XLC = 0
 
-const SUITESPARSE_DATE = "Jan 20, 2023"
+const SUITESPARSE_DATE = "June 29, 2023"
 
 const SUITESPARSE_MAIN_VERSION = 7
 
-const SUITESPARSE_SUB_VERSION = 0
+const SUITESPARSE_SUB_VERSION = 1
 
-const SUITESPARSE_SUBSUB_VERSION = 1
+const SUITESPARSE_SUBSUB_VERSION = 0
 
 SUITESPARSE_VER_CODE(main, sub) = main * 1000 + sub
 
-const SUITESPARSE_VERSION = SUITESPARSE_VER_CODE(SUITESPARSE_MAIN_VERSION, SUITESPARSE_SUB_VERSION)
+const SUITESPARSE_VERSION = SUITESPARSE_VER_CODE(SUITESPARSE_MAIN_VERSION,
+                                                 SUITESPARSE_SUB_VERSION)
 
 CHOLMOD_VER_CODE(main, sub) = main * 1000 + sub
 
@@ -2601,20 +3426,18 @@ const SPQR_RTX_EQUALS_B = 2
 
 const SPQR_RTX_EQUALS_ETB = 3
 
-const SPQR_DATE = "Jan 17, 2023"
+const SPQR_DATE = "July FIXME, 2023"
 
-const SPQR_MAIN_VERSION = 3
+const SPQR_MAIN_VERSION = 4
 
 const SPQR_SUB_VERSION = 0
 
-const SPQR_SUBSUB_VERSION = 3
+const SPQR_SUBSUB_VERSION = 0
 
 SPQR_VER_CODE(main, sub) = main * 1000 + sub
 
 const SPQR_VERSION = SPQR_VER_CODE(SPQR_MAIN_VERSION, SPQR_SUB_VERSION)
 
-const Complex = Float64
-
 const AMD_CONTROL = 5
 
 const AMD_INFO = 20
@@ -2663,172 +3486,29 @@ const AMD_INVALID = -2
 
 const AMD_OK_BUT_JUMBLED = 1
 
-const AMD_DATE = "Jan 17, 2023"
+const AMD_DATE = "June 16, 2023"
 
 const AMD_MAIN_VERSION = 3
 
 const AMD_SUB_VERSION = 0
 
-const AMD_SUBSUB_VERSION = 3
+const AMD_SUBSUB_VERSION = 4
 
 AMD_VERSION_CODE(main, sub) = main * 1000 + sub
 
 const AMD_VERSION = AMD_VERSION_CODE(AMD_MAIN_VERSION, AMD_SUB_VERSION)
 
-const COLAMD_DATE = "Jan 17, 2023"
-
-const COLAMD_MAIN_VERSION = 3
-
-const COLAMD_SUB_VERSION = 0
-
-const COLAMD_SUBSUB_VERSION = 3
-
-COLAMD_VERSION_CODE(main, sub) = main * 1000 + sub
-
-const COLAMD_VERSION = COLAMD_VERSION_CODE(COLAMD_MAIN_VERSION, COLAMD_SUB_VERSION)
-
-const COLAMD_KNOBS = 20
-
-const COLAMD_STATS = 20
-
-const COLAMD_DENSE_ROW = 0
-
-const COLAMD_DENSE_COL = 1
-
-const COLAMD_AGGRESSIVE = 2
-
-const COLAMD_DEFRAG_COUNT = 2
-
-const COLAMD_STATUS = 3
-
-const COLAMD_INFO1 = 4
-
-const COLAMD_INFO2 = 5
-
-const COLAMD_INFO3 = 6
-
-const COLAMD_OK = 0
-
-const COLAMD_OK_BUT_JUMBLED = 1
-
-const COLAMD_ERROR_A_not_present = -1
-
-const COLAMD_ERROR_p_not_present = -2
-
-const COLAMD_ERROR_nrow_negative = -3
-
-const COLAMD_ERROR_ncol_negative = -4
-
-const COLAMD_ERROR_nnz_negative = -5
-
-const COLAMD_ERROR_p0_nonzero = -6
-
-const COLAMD_ERROR_A_too_small = -7
-
-const COLAMD_ERROR_col_length_negative = -8
-
-const COLAMD_ERROR_row_index_out_of_bounds = -9
-
-const COLAMD_ERROR_out_of_memory = -10
-
-const COLAMD_ERROR_internal_error = -999
-
-const CCOLAMD_DATE = "Jan 17, 2023"
-
-const CCOLAMD_MAIN_VERSION = 3
-
-const CCOLAMD_SUB_VERSION = 0
-
-const CCOLAMD_SUBSUB_VERSION = 3
-
-CCOLAMD_VERSION_CODE(main, sub) = main * 1000 + sub
-
-const CCOLAMD_VERSION = CCOLAMD_VERSION_CODE(CCOLAMD_MAIN_VERSION, CCOLAMD_SUB_VERSION)
-
-const CCOLAMD_KNOBS = 20
-
-const CCOLAMD_STATS = 20
-
-const CCOLAMD_DENSE_ROW = 0
-
-const CCOLAMD_DENSE_COL = 1
-
-const CCOLAMD_AGGRESSIVE = 2
-
-const CCOLAMD_LU = 3
-
-const CCOLAMD_DEFRAG_COUNT = 2
-
-const CCOLAMD_STATUS = 3
-
-const CCOLAMD_INFO1 = 4
-
-const CCOLAMD_INFO2 = 5
-
-const CCOLAMD_INFO3 = 6
-
-const CCOLAMD_EMPTY_ROW = 7
-
-const CCOLAMD_EMPTY_COL = 8
-
-const CCOLAMD_NEWLY_EMPTY_ROW = 9
-
-const CCOLAMD_NEWLY_EMPTY_COL = 10
-
-const CCOLAMD_OK = 0
-
-const CCOLAMD_OK_BUT_JUMBLED = 1
-
-const CCOLAMD_ERROR_A_not_present = -1
-
-const CCOLAMD_ERROR_p_not_present = -2
-
-const CCOLAMD_ERROR_nrow_negative = -3
-
-const CCOLAMD_ERROR_ncol_negative = -4
-
-const CCOLAMD_ERROR_nnz_negative = -5
-
-const CCOLAMD_ERROR_p0_nonzero = -6
-
-const CCOLAMD_ERROR_A_too_small = -7
-
-const CCOLAMD_ERROR_col_length_negative = -8
-
-const CCOLAMD_ERROR_row_index_out_of_bounds = -9
-
-const CCOLAMD_ERROR_out_of_memory = -10
-
-const CCOLAMD_ERROR_invalid_cmember = -11
-
-const CCOLAMD_ERROR_internal_error = -999
-
 const UMFPACK_INFO = 90
 
 const UMFPACK_CONTROL = 20
 
-# Skipping MacroDefinition: UMFPACK_COPYRIGHT \
-#"UMFPACK:  Copyright (c) 2005-2023 by Timothy A. Davis.  All Rights Reserved.\n"
-
-# Skipping MacroDefinition: UMFPACK_LICENSE_PART1 \
-#"\nUMFPACK License: SPDX-License-Identifier: GPL-2.0+\n" \
-#"   UMFPACK is available under alternate licenses,\n" \
-#"   contact T. Davis for details.\n"
-
-const UMFPACK_LICENSE_PART2 = "\n"
-
-# Skipping MacroDefinition: UMFPACK_LICENSE_PART3 \
-#"\n" \
-#"Availability: http://www.suitesparse.com" \
-#"\n"
-
-const UMFPACK_DATE = "Jan 17, 2023"
+const UMFPACK_DATE = "June 16, 2023"
 
 const UMFPACK_MAIN_VERSION = 6
 
 const UMFPACK_SUB_VERSION = 1
 
-const UMFPACK_SUBSUB_VERSION = 0
+const UMFPACK_SUBSUB_VERSION = 1
 
 UMFPACK_VER_CODE(main, sub) = main * 1000 + sub
 
@@ -3169,4 +3849,3 @@ const UMFPACK_Q_Uat = 12
 const UMFPACK_Ut = 13
 
 const UMFPACK_Uat = 14
-
diff --git a/src/solvers/lib/x86_64-linux-musl.jl b/src/solvers/lib/x86_64-linux-musl.jl
index fcf756d2..a5aa4e44 100644
--- a/src/solvers/lib/x86_64-linux-musl.jl
+++ b/src/solvers/lib/x86_64-linux-musl.jl
@@ -1,137 +1,150 @@
 function SuiteSparse_config_printf_func_get()
-    @ccall libcholmod.SuiteSparse_config_printf_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_printf_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_malloc_func_get()
-    @ccall libcholmod.SuiteSparse_config_malloc_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_malloc_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_calloc_func_get()
-    @ccall libcholmod.SuiteSparse_config_calloc_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_calloc_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_realloc_func_get()
-    @ccall libcholmod.SuiteSparse_config_realloc_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_realloc_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_free_func_get()
-    @ccall libcholmod.SuiteSparse_config_free_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_free_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_hypot_func_get()
-    @ccall libcholmod.SuiteSparse_config_hypot_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_hypot_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_divcomplex_func_get()
-    @ccall libcholmod.SuiteSparse_config_divcomplex_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_divcomplex_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_malloc_func_set(malloc_func)
-    @ccall libcholmod.SuiteSparse_config_malloc_func_set(malloc_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_malloc_func_set(malloc_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_calloc_func_set(calloc_func)
-    @ccall libcholmod.SuiteSparse_config_calloc_func_set(calloc_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_calloc_func_set(calloc_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_realloc_func_set(realloc_func)
-    @ccall libcholmod.SuiteSparse_config_realloc_func_set(realloc_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_realloc_func_set(realloc_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_free_func_set(free_func)
-    @ccall libcholmod.SuiteSparse_config_free_func_set(free_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_free_func_set(free_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_printf_func_set(printf_func)
-    @ccall libcholmod.SuiteSparse_config_printf_func_set(printf_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_printf_func_set(printf_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_hypot_func_set(hypot_func)
-    @ccall libcholmod.SuiteSparse_config_hypot_func_set(hypot_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_hypot_func_set(hypot_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_divcomplex_func_set(divcomplex_func)
-    @ccall libcholmod.SuiteSparse_config_divcomplex_func_set(divcomplex_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_divcomplex_func_set(divcomplex_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_malloc(s)
-    @ccall libcholmod.SuiteSparse_config_malloc(s::Csize_t)::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_malloc(s::Csize_t)::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_calloc(n, s)
-    @ccall libcholmod.SuiteSparse_config_calloc(n::Csize_t, s::Csize_t)::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_calloc(n::Csize_t,
+                                                          s::Csize_t)::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_realloc(arg1, s)
-    @ccall libcholmod.SuiteSparse_config_realloc(arg1::Ptr{Cvoid}, s::Csize_t)::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_realloc(arg1::Ptr{Cvoid},
+                                                           s::Csize_t)::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_free(arg1)
-    @ccall libcholmod.SuiteSparse_config_free(arg1::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_free(arg1::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_hypot(x, y)
-    @ccall libcholmod.SuiteSparse_config_hypot(x::Cdouble, y::Cdouble)::Cdouble
+    @ccall libsuitesparseconfig.SuiteSparse_config_hypot(x::Cdouble, y::Cdouble)::Cdouble
 end
 
 function SuiteSparse_config_divcomplex(xr, xi, yr, yi, zr, zi)
-    @ccall libcholmod.SuiteSparse_config_divcomplex(xr::Cdouble, xi::Cdouble, yr::Cdouble, yi::Cdouble, zr::Ptr{Cdouble}, zi::Ptr{Cdouble})::Cint
+    @ccall libsuitesparseconfig.SuiteSparse_config_divcomplex(xr::Cdouble, xi::Cdouble,
+                                                              yr::Cdouble, yi::Cdouble,
+                                                              zr::Ptr{Cdouble},
+                                                              zi::Ptr{Cdouble})::Cint
 end
 
 function SuiteSparse_start()
-    @ccall libcholmod.SuiteSparse_start()::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_start()::Cvoid
 end
 
 function SuiteSparse_finish()
-    @ccall libcholmod.SuiteSparse_finish()::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_finish()::Cvoid
 end
 
 function SuiteSparse_malloc(nitems, size_of_item)
-    @ccall libcholmod.SuiteSparse_malloc(nitems::Csize_t, size_of_item::Csize_t)::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_malloc(nitems::Csize_t,
+                                                   size_of_item::Csize_t)::Ptr{Cvoid}
 end
 
 function SuiteSparse_calloc(nitems, size_of_item)
-    @ccall libcholmod.SuiteSparse_calloc(nitems::Csize_t, size_of_item::Csize_t)::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_calloc(nitems::Csize_t,
+                                                   size_of_item::Csize_t)::Ptr{Cvoid}
 end
 
 function SuiteSparse_realloc(nitems_new, nitems_old, size_of_item, p, ok)
-    @ccall libcholmod.SuiteSparse_realloc(nitems_new::Csize_t, nitems_old::Csize_t, size_of_item::Csize_t, p::Ptr{Cvoid}, ok::Ptr{Cint})::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_realloc(nitems_new::Csize_t,
+                                                    nitems_old::Csize_t,
+                                                    size_of_item::Csize_t, p::Ptr{Cvoid},
+                                                    ok::Ptr{Cint})::Ptr{Cvoid}
 end
 
 function SuiteSparse_free(p)
-    @ccall libcholmod.SuiteSparse_free(p::Ptr{Cvoid})::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_free(p::Ptr{Cvoid})::Ptr{Cvoid}
 end
 
 function SuiteSparse_tic(tic)
-    @ccall libcholmod.SuiteSparse_tic(tic::Ptr{Cdouble})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_tic(tic::Ptr{Cdouble})::Cvoid
 end
 
 function SuiteSparse_toc(tic)
-    @ccall libcholmod.SuiteSparse_toc(tic::Ptr{Cdouble})::Cdouble
+    @ccall libsuitesparseconfig.SuiteSparse_toc(tic::Ptr{Cdouble})::Cdouble
 end
 
 function SuiteSparse_time()
-    @ccall libcholmod.SuiteSparse_time()::Cdouble
+    @ccall libsuitesparseconfig.SuiteSparse_time()::Cdouble
 end
 
 function SuiteSparse_hypot(x, y)
-    @ccall libcholmod.SuiteSparse_hypot(x::Cdouble, y::Cdouble)::Cdouble
+    @ccall libsuitesparseconfig.SuiteSparse_hypot(x::Cdouble, y::Cdouble)::Cdouble
 end
 
 function SuiteSparse_divcomplex(ar, ai, br, bi, cr, ci)
-    @ccall libcholmod.SuiteSparse_divcomplex(ar::Cdouble, ai::Cdouble, br::Cdouble, bi::Cdouble, cr::Ptr{Cdouble}, ci::Ptr{Cdouble})::Cint
+    @ccall libsuitesparseconfig.SuiteSparse_divcomplex(ar::Cdouble, ai::Cdouble,
+                                                       br::Cdouble, bi::Cdouble,
+                                                       cr::Ptr{Cdouble},
+                                                       ci::Ptr{Cdouble})::Cint
 end
 
 function SuiteSparse_version(version)
-    @ccall libcholmod.SuiteSparse_version(version::Ptr{Cint})::Cint
+    @ccall libsuitesparseconfig.SuiteSparse_version(version::Ptr{Cint})::Cint
 end
 
 function SuiteSparse_BLAS_library()
-    @ccall libcholmod.SuiteSparse_BLAS_library()::Ptr{Cchar}
+    @ccall libsuitesparseconfig.SuiteSparse_BLAS_library()::Ptr{Cchar}
 end
 
 function SuiteSparse_BLAS_integer_size()
-    @ccall libcholmod.SuiteSparse_BLAS_integer_size()::Csize_t
+    @ccall libsuitesparseconfig.SuiteSparse_BLAS_integer_size()::Csize_t
 end
 
 struct cholmod_method_struct
@@ -140,16 +153,16 @@ struct cholmod_method_struct
     prune_dense::Cdouble
     prune_dense2::Cdouble
     nd_oksep::Cdouble
-    other_1::NTuple{4, Cdouble}
+    other_1::NTuple{4,Cdouble}
     nd_small::Csize_t
-    other_2::NTuple{4, Csize_t}
+    other_2::NTuple{4,Csize_t}
     aggressive::Cint
     order_for_lu::Cint
     nd_compress::Cint
     nd_camd::Cint
     nd_components::Cint
     ordering::Cint
-    other_3::NTuple{4, Csize_t}
+    other_3::NTuple{4,Csize_t}
 end
 
 mutable struct cholmod_common_struct
@@ -166,8 +179,8 @@ mutable struct cholmod_common_struct
     final_pack::Cint
     final_monotonic::Cint
     final_resymbol::Cint
-    zrelax::NTuple{3, Cdouble}
-    nrelax::NTuple{3, Csize_t}
+    zrelax::NTuple{3,Cdouble}
+    nrelax::NTuple{3,Csize_t}
     prefer_zomplex::Cint
     prefer_upper::Cint
     quick_return_if_not_posdef::Cint
@@ -179,7 +192,7 @@ mutable struct cholmod_common_struct
     nmethods::Cint
     current::Cint
     selected::Cint
-    method::NTuple{10, cholmod_method_struct}
+    method::NTuple{10,cholmod_method_struct}
     postorder::Cint
     default_nesdis::Cint
     metis_memory::Cdouble
@@ -222,7 +235,7 @@ mutable struct cholmod_common_struct
     SPQR_flopcount_bound::Cdouble
     SPQR_tol_used::Cdouble
     SPQR_norm_E_fro::Cdouble
-    SPQR_istat::NTuple{10, Int64}
+    SPQR_istat::NTuple{10,Int64}
     useGPU::Cint
     maxGpuMemBytes::Csize_t
     maxGpuMemFraction::Cdouble
@@ -231,10 +244,10 @@ mutable struct cholmod_common_struct
     gpuFlops::Int64
     gpuNumKernelLaunches::Cint
     cublasHandle::Ptr{Cvoid}
-    gpuStream::NTuple{8, Ptr{Cvoid}}
-    cublasEventPotrf::NTuple{3, Ptr{Cvoid}}
+    gpuStream::NTuple{8,Ptr{Cvoid}}
+    cublasEventPotrf::NTuple{3,Ptr{Cvoid}}
     updateCKernelsComplete::Ptr{Cvoid}
-    updateCBuffersFree::NTuple{8, Ptr{Cvoid}}
+    updateCBuffersFree::NTuple{8,Ptr{Cvoid}}
     dev_mempool::Ptr{Cvoid}
     dev_mempool_size::Csize_t
     host_pinned_mempool::Ptr{Cvoid}
@@ -300,11 +313,14 @@ function cholmod_l_maxrank(arg1, arg2)
 end
 
 function cholmod_allocate_work(nrow, iworksize, xworksize, Common)
-    @ccall libcholmod.cholmod_allocate_work(nrow::Csize_t, iworksize::Csize_t, xworksize::Csize_t, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_allocate_work(nrow::Csize_t, iworksize::Csize_t,
+                                            xworksize::Csize_t,
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_allocate_work(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_allocate_work(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_allocate_work(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t,
+                                              arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_free_work(Common)
@@ -324,11 +340,13 @@ function cholmod_l_clear_flag(arg1)
 end
 
 function cholmod_error(status, file, line, message, Common)
-    @ccall libcholmod.cholmod_error(status::Cint, file::Ptr{Cchar}, line::Cint, message::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_error(status::Cint, file::Ptr{Cchar}, line::Cint,
+                                    message::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_error(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_error(arg1::Cint, arg2::Ptr{Cchar}, arg3::Cint, arg4::Ptr{Cchar}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_error(arg1::Cint, arg2::Ptr{Cchar}, arg3::Cint,
+                                      arg4::Ptr{Cchar}, arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_dbound(dj, Common)
@@ -348,11 +366,14 @@ function cholmod_l_hypot(arg1, arg2)
 end
 
 function cholmod_divcomplex(ar, ai, br, bi, cr, ci)
-    @ccall libcholmod.cholmod_divcomplex(ar::Cdouble, ai::Cdouble, br::Cdouble, bi::Cdouble, cr::Ptr{Cdouble}, ci::Ptr{Cdouble})::Cint
+    @ccall libcholmod.cholmod_divcomplex(ar::Cdouble, ai::Cdouble, br::Cdouble, bi::Cdouble,
+                                         cr::Ptr{Cdouble}, ci::Ptr{Cdouble})::Cint
 end
 
 function cholmod_l_divcomplex(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_divcomplex(arg1::Cdouble, arg2::Cdouble, arg3::Cdouble, arg4::Cdouble, arg5::Ptr{Cdouble}, arg6::Ptr{Cdouble})::Cint
+    @ccall libcholmod.cholmod_l_divcomplex(arg1::Cdouble, arg2::Cdouble, arg3::Cdouble,
+                                           arg4::Cdouble, arg5::Ptr{Cdouble},
+                                           arg6::Ptr{Cdouble})::Cint
 end
 
 mutable struct cholmod_sparse_struct
@@ -384,155 +405,217 @@ end
 const descendantScore = cholmod_descendant_score_t
 
 function cholmod_score_comp(i, j)
-    @ccall libcholmod.cholmod_score_comp(i::Ptr{cholmod_descendant_score_t}, j::Ptr{cholmod_descendant_score_t})::Cint
+    @ccall libcholmod.cholmod_score_comp(i::Ptr{cholmod_descendant_score_t},
+                                         j::Ptr{cholmod_descendant_score_t})::Cint
 end
 
 function cholmod_l_score_comp(i, j)
-    @ccall libcholmod.cholmod_l_score_comp(i::Ptr{cholmod_descendant_score_t}, j::Ptr{cholmod_descendant_score_t})::Cint
+    @ccall libcholmod.cholmod_l_score_comp(i::Ptr{cholmod_descendant_score_t},
+                                           j::Ptr{cholmod_descendant_score_t})::Cint
 end
 
 function cholmod_allocate_sparse(nrow, ncol, nzmax, sorted, packed, stype, xtype, Common)
-    @ccall libcholmod.cholmod_allocate_sparse(nrow::Csize_t, ncol::Csize_t, nzmax::Csize_t, sorted::Cint, packed::Cint, stype::Cint, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_allocate_sparse(nrow::Csize_t, ncol::Csize_t, nzmax::Csize_t,
+                                              sorted::Cint, packed::Cint, stype::Cint,
+                                              xtype::Cint,
+                                              Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_allocate_sparse(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
-    @ccall libcholmod.cholmod_l_allocate_sparse(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t, arg4::Cint, arg5::Cint, arg6::Cint, arg7::Cint, arg8::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_allocate_sparse(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t,
+                                                arg4::Cint, arg5::Cint, arg6::Cint,
+                                                arg7::Cint,
+                                                arg8::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_free_sparse(A, Common)
-    @ccall libcholmod.cholmod_free_sparse(A::Ptr{Ptr{cholmod_sparse}}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_free_sparse(A::Ptr{Ptr{cholmod_sparse}},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_free_sparse(arg1, arg2)
-    @ccall libcholmod.cholmod_l_free_sparse(arg1::Ptr{Ptr{cholmod_sparse}}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_free_sparse(arg1::Ptr{Ptr{cholmod_sparse}},
+                                            arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_reallocate_sparse(nznew, A, Common)
-    @ccall libcholmod.cholmod_reallocate_sparse(nznew::Csize_t, A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_reallocate_sparse(nznew::Csize_t, A::Ptr{cholmod_sparse},
+                                                Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_reallocate_sparse(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_reallocate_sparse(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_reallocate_sparse(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                                  arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_nnz(A, Common)
-    @ccall libcholmod.cholmod_nnz(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_nnz(A::Ptr{cholmod_sparse},
+                                  Common::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_l_nnz(arg1, arg2)
-    @ccall libcholmod.cholmod_l_nnz(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_l_nnz(arg1::Ptr{cholmod_sparse},
+                                    arg2::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_speye(nrow, ncol, xtype, Common)
-    @ccall libcholmod.cholmod_speye(nrow::Csize_t, ncol::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_speye(nrow::Csize_t, ncol::Csize_t, xtype::Cint,
+                                    Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_speye(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_speye(arg1::Csize_t, arg2::Csize_t, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_speye(arg1::Csize_t, arg2::Csize_t, arg3::Cint,
+                                      arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_spzeros(nrow, ncol, nzmax, xtype, Common)
-    @ccall libcholmod.cholmod_spzeros(nrow::Csize_t, ncol::Csize_t, nzmax::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_spzeros(nrow::Csize_t, ncol::Csize_t, nzmax::Csize_t,
+                                      xtype::Cint,
+                                      Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_spzeros(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_spzeros(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t, arg4::Cint, arg5::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_spzeros(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t,
+                                        arg4::Cint,
+                                        arg5::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_transpose(A, values, Common)
-    @ccall libcholmod.cholmod_transpose(A::Ptr{cholmod_sparse}, values::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_transpose(A::Ptr{cholmod_sparse}, values::Cint,
+                                        Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_transpose(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_transpose(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_transpose(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                          arg3::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_transpose_unsym(A, values, Perm, fset, fsize, F, Common)
-    @ccall libcholmod.cholmod_transpose_unsym(A::Ptr{cholmod_sparse}, values::Cint, Perm::Ptr{Int32}, fset::Ptr{Int32}, fsize::Csize_t, F::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_transpose_unsym(A::Ptr{cholmod_sparse}, values::Cint,
+                                              Perm::Ptr{Int32}, fset::Ptr{Int32},
+                                              fsize::Csize_t, F::Ptr{cholmod_sparse},
+                                              Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_transpose_unsym(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_transpose_unsym(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Csize_t, arg6::Ptr{cholmod_sparse}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_transpose_unsym(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                                arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                                arg5::Csize_t, arg6::Ptr{cholmod_sparse},
+                                                arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_transpose_sym(A, values, Perm, F, Common)
-    @ccall libcholmod.cholmod_transpose_sym(A::Ptr{cholmod_sparse}, values::Cint, Perm::Ptr{Int32}, F::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_transpose_sym(A::Ptr{cholmod_sparse}, values::Cint,
+                                            Perm::Ptr{Int32}, F::Ptr{cholmod_sparse},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_transpose_sym(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_transpose_sym(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{Int64}, arg4::Ptr{cholmod_sparse}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_transpose_sym(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                              arg3::Ptr{Int64}, arg4::Ptr{cholmod_sparse},
+                                              arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_ptranspose(A, values, Perm, fset, fsize, Common)
-    @ccall libcholmod.cholmod_ptranspose(A::Ptr{cholmod_sparse}, values::Cint, Perm::Ptr{Int32}, fset::Ptr{Int32}, fsize::Csize_t, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_ptranspose(A::Ptr{cholmod_sparse}, values::Cint,
+                                         Perm::Ptr{Int32}, fset::Ptr{Int32}, fsize::Csize_t,
+                                         Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_ptranspose(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_ptranspose(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Csize_t, arg6::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_ptranspose(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                           arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                           arg5::Csize_t,
+                                           arg6::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_sort(A, Common)
-    @ccall libcholmod.cholmod_sort(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_sort(A::Ptr{cholmod_sparse},
+                                   Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_sort(arg1, arg2)
-    @ccall libcholmod.cholmod_l_sort(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_sort(arg1::Ptr{cholmod_sparse},
+                                     arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_band(A, k1, k2, mode, Common)
-    @ccall libcholmod.cholmod_band(A::Ptr{cholmod_sparse}, k1::Int64, k2::Int64, mode::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_band(A::Ptr{cholmod_sparse}, k1::Int64, k2::Int64, mode::Cint,
+                                   Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_band(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_band(arg1::Ptr{cholmod_sparse}, arg2::Int64, arg3::Int64, arg4::Cint, arg5::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_band(arg1::Ptr{cholmod_sparse}, arg2::Int64, arg3::Int64,
+                                     arg4::Cint,
+                                     arg5::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_band_inplace(k1, k2, mode, A, Common)
-    @ccall libcholmod.cholmod_band_inplace(k1::Int64, k2::Int64, mode::Cint, A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_band_inplace(k1::Int64, k2::Int64, mode::Cint,
+                                           A::Ptr{cholmod_sparse},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_band_inplace(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_band_inplace(arg1::Int64, arg2::Int64, arg3::Cint, arg4::Ptr{cholmod_sparse}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_band_inplace(arg1::Int64, arg2::Int64, arg3::Cint,
+                                             arg4::Ptr{cholmod_sparse},
+                                             arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_aat(A, fset, fsize, mode, Common)
-    @ccall libcholmod.cholmod_aat(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, mode::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_aat(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t,
+                                  mode::Cint,
+                                  Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_aat(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_aat(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Cint, arg5::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_aat(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                    arg3::Csize_t, arg4::Cint,
+                                    arg5::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_copy_sparse(A, Common)
-    @ccall libcholmod.cholmod_copy_sparse(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_copy_sparse(A::Ptr{cholmod_sparse},
+                                          Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_copy_sparse(arg1, arg2)
-    @ccall libcholmod.cholmod_l_copy_sparse(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_copy_sparse(arg1::Ptr{cholmod_sparse},
+                                            arg2::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_copy(A, stype, mode, Common)
-    @ccall libcholmod.cholmod_copy(A::Ptr{cholmod_sparse}, stype::Cint, mode::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_copy(A::Ptr{cholmod_sparse}, stype::Cint, mode::Cint,
+                                   Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_copy(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_copy(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_copy(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Cint,
+                                     arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_add(A, B, alpha, beta, values, sorted, Common)
-    @ccall libcholmod.cholmod_add(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse}, alpha::Ptr{Cdouble}, beta::Ptr{Cdouble}, values::Cint, sorted::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_add(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse},
+                                  alpha::Ptr{Cdouble}, beta::Ptr{Cdouble}, values::Cint,
+                                  sorted::Cint,
+                                  Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_add(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_add(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Ptr{Cdouble}, arg5::Cint, arg6::Cint, arg7::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_add(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse},
+                                    arg3::Ptr{Cdouble}, arg4::Ptr{Cdouble}, arg5::Cint,
+                                    arg6::Cint,
+                                    arg7::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_sparse_xtype(to_xtype, A, Common)
-    @ccall libcholmod.cholmod_sparse_xtype(to_xtype::Cint, A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_sparse_xtype(to_xtype::Cint, A::Ptr{cholmod_sparse},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_sparse_xtype(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_sparse_xtype(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_sparse_xtype(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                             arg3::Ptr{cholmod_common})::Cint
 end
 
 mutable struct cholmod_factor_struct
@@ -572,75 +655,100 @@ end
 const cholmod_factor = cholmod_factor_struct
 
 function cholmod_allocate_factor(n, Common)
-    @ccall libcholmod.cholmod_allocate_factor(n::Csize_t, Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_allocate_factor(n::Csize_t,
+                                              Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_l_allocate_factor(arg1, arg2)
-    @ccall libcholmod.cholmod_l_allocate_factor(arg1::Csize_t, arg2::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_l_allocate_factor(arg1::Csize_t,
+                                                arg2::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_free_factor(L, Common)
-    @ccall libcholmod.cholmod_free_factor(L::Ptr{Ptr{cholmod_factor}}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_free_factor(L::Ptr{Ptr{cholmod_factor}},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_free_factor(arg1, arg2)
-    @ccall libcholmod.cholmod_l_free_factor(arg1::Ptr{Ptr{cholmod_factor}}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_free_factor(arg1::Ptr{Ptr{cholmod_factor}},
+                                            arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_reallocate_factor(nznew, L, Common)
-    @ccall libcholmod.cholmod_reallocate_factor(nznew::Csize_t, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_reallocate_factor(nznew::Csize_t, L::Ptr{cholmod_factor},
+                                                Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_reallocate_factor(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_reallocate_factor(arg1::Csize_t, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_reallocate_factor(arg1::Csize_t, arg2::Ptr{cholmod_factor},
+                                                  arg3::Ptr{cholmod_common})::Cint
 end
 
-function cholmod_change_factor(to_xtype, to_ll, to_super, to_packed, to_monotonic, L, Common)
-    @ccall libcholmod.cholmod_change_factor(to_xtype::Cint, to_ll::Cint, to_super::Cint, to_packed::Cint, to_monotonic::Cint, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+function cholmod_change_factor(to_xtype, to_ll, to_super, to_packed, to_monotonic, L,
+                               Common)
+    @ccall libcholmod.cholmod_change_factor(to_xtype::Cint, to_ll::Cint, to_super::Cint,
+                                            to_packed::Cint, to_monotonic::Cint,
+                                            L::Ptr{cholmod_factor},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_change_factor(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_change_factor(arg1::Cint, arg2::Cint, arg3::Cint, arg4::Cint, arg5::Cint, arg6::Ptr{cholmod_factor}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_change_factor(arg1::Cint, arg2::Cint, arg3::Cint,
+                                              arg4::Cint, arg5::Cint,
+                                              arg6::Ptr{cholmod_factor},
+                                              arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_pack_factor(L, Common)
-    @ccall libcholmod.cholmod_pack_factor(L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_pack_factor(L::Ptr{cholmod_factor},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_pack_factor(arg1, arg2)
-    @ccall libcholmod.cholmod_l_pack_factor(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_pack_factor(arg1::Ptr{cholmod_factor},
+                                            arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_reallocate_column(j, need, L, Common)
-    @ccall libcholmod.cholmod_reallocate_column(j::Csize_t, need::Csize_t, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_reallocate_column(j::Csize_t, need::Csize_t,
+                                                L::Ptr{cholmod_factor},
+                                                Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_reallocate_column(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_reallocate_column(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{cholmod_factor}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_reallocate_column(arg1::Csize_t, arg2::Csize_t,
+                                                  arg3::Ptr{cholmod_factor},
+                                                  arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_factor_to_sparse(L, Common)
-    @ccall libcholmod.cholmod_factor_to_sparse(L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_factor_to_sparse(L::Ptr{cholmod_factor},
+                                               Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_factor_to_sparse(arg1, arg2)
-    @ccall libcholmod.cholmod_l_factor_to_sparse(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_factor_to_sparse(arg1::Ptr{cholmod_factor},
+                                                 arg2::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_copy_factor(L, Common)
-    @ccall libcholmod.cholmod_copy_factor(L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_copy_factor(L::Ptr{cholmod_factor},
+                                          Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_l_copy_factor(arg1, arg2)
-    @ccall libcholmod.cholmod_l_copy_factor(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_l_copy_factor(arg1::Ptr{cholmod_factor},
+                                            arg2::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_factor_xtype(to_xtype, L, Common)
-    @ccall libcholmod.cholmod_factor_xtype(to_xtype::Cint, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_factor_xtype(to_xtype::Cint, L::Ptr{cholmod_factor},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_factor_xtype(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_factor_xtype(arg1::Cint, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_factor_xtype(arg1::Cint, arg2::Ptr{cholmod_factor},
+                                             arg3::Ptr{cholmod_common})::Cint
 end
 
 mutable struct cholmod_dense_struct
@@ -658,91 +766,118 @@ end
 const cholmod_dense = cholmod_dense_struct
 
 function cholmod_allocate_dense(nrow, ncol, d, xtype, Common)
-    @ccall libcholmod.cholmod_allocate_dense(nrow::Csize_t, ncol::Csize_t, d::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_allocate_dense(nrow::Csize_t, ncol::Csize_t, d::Csize_t,
+                                             xtype::Cint,
+                                             Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_allocate_dense(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_allocate_dense(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t, arg4::Cint, arg5::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_allocate_dense(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t,
+                                               arg4::Cint,
+                                               arg5::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_zeros(nrow, ncol, xtype, Common)
-    @ccall libcholmod.cholmod_zeros(nrow::Csize_t, ncol::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_zeros(nrow::Csize_t, ncol::Csize_t, xtype::Cint,
+                                    Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_zeros(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_zeros(arg1::Csize_t, arg2::Csize_t, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_zeros(arg1::Csize_t, arg2::Csize_t, arg3::Cint,
+                                      arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_ones(nrow, ncol, xtype, Common)
-    @ccall libcholmod.cholmod_ones(nrow::Csize_t, ncol::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_ones(nrow::Csize_t, ncol::Csize_t, xtype::Cint,
+                                   Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_ones(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_ones(arg1::Csize_t, arg2::Csize_t, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_ones(arg1::Csize_t, arg2::Csize_t, arg3::Cint,
+                                     arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_eye(nrow, ncol, xtype, Common)
-    @ccall libcholmod.cholmod_eye(nrow::Csize_t, ncol::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_eye(nrow::Csize_t, ncol::Csize_t, xtype::Cint,
+                                  Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_eye(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_eye(arg1::Csize_t, arg2::Csize_t, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_eye(arg1::Csize_t, arg2::Csize_t, arg3::Cint,
+                                    arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_free_dense(X, Common)
-    @ccall libcholmod.cholmod_free_dense(X::Ptr{Ptr{cholmod_dense}}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_free_dense(X::Ptr{Ptr{cholmod_dense}},
+                                         Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_free_dense(arg1, arg2)
-    @ccall libcholmod.cholmod_l_free_dense(arg1::Ptr{Ptr{cholmod_dense}}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_free_dense(arg1::Ptr{Ptr{cholmod_dense}},
+                                           arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_ensure_dense(XHandle, nrow, ncol, d, xtype, Common)
-    @ccall libcholmod.cholmod_ensure_dense(XHandle::Ptr{Ptr{cholmod_dense}}, nrow::Csize_t, ncol::Csize_t, d::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_ensure_dense(XHandle::Ptr{Ptr{cholmod_dense}}, nrow::Csize_t,
+                                           ncol::Csize_t, d::Csize_t, xtype::Cint,
+                                           Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_ensure_dense(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_ensure_dense(arg1::Ptr{Ptr{cholmod_dense}}, arg2::Csize_t, arg3::Csize_t, arg4::Csize_t, arg5::Cint, arg6::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_ensure_dense(arg1::Ptr{Ptr{cholmod_dense}}, arg2::Csize_t,
+                                             arg3::Csize_t, arg4::Csize_t, arg5::Cint,
+                                             arg6::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_sparse_to_dense(A, Common)
-    @ccall libcholmod.cholmod_sparse_to_dense(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_sparse_to_dense(A::Ptr{cholmod_sparse},
+                                              Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_sparse_to_dense(arg1, arg2)
-    @ccall libcholmod.cholmod_l_sparse_to_dense(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_sparse_to_dense(arg1::Ptr{cholmod_sparse},
+                                                arg2::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_dense_to_sparse(X, values, Common)
-    @ccall libcholmod.cholmod_dense_to_sparse(X::Ptr{cholmod_dense}, values::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_dense_to_sparse(X::Ptr{cholmod_dense}, values::Cint,
+                                              Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_dense_to_sparse(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_dense_to_sparse(arg1::Ptr{cholmod_dense}, arg2::Cint, arg3::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_dense_to_sparse(arg1::Ptr{cholmod_dense}, arg2::Cint,
+                                                arg3::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_copy_dense(X, Common)
-    @ccall libcholmod.cholmod_copy_dense(X::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_copy_dense(X::Ptr{cholmod_dense},
+                                         Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_copy_dense(arg1, arg2)
-    @ccall libcholmod.cholmod_l_copy_dense(arg1::Ptr{cholmod_dense}, arg2::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_copy_dense(arg1::Ptr{cholmod_dense},
+                                           arg2::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_copy_dense2(X, Y, Common)
-    @ccall libcholmod.cholmod_copy_dense2(X::Ptr{cholmod_dense}, Y::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_copy_dense2(X::Ptr{cholmod_dense}, Y::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_copy_dense2(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_copy_dense2(arg1::Ptr{cholmod_dense}, arg2::Ptr{cholmod_dense}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_copy_dense2(arg1::Ptr{cholmod_dense},
+                                            arg2::Ptr{cholmod_dense},
+                                            arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_dense_xtype(to_xtype, X, Common)
-    @ccall libcholmod.cholmod_dense_xtype(to_xtype::Cint, X::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_dense_xtype(to_xtype::Cint, X::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_dense_xtype(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_dense_xtype(arg1::Cint, arg2::Ptr{cholmod_dense}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_dense_xtype(arg1::Cint, arg2::Ptr{cholmod_dense},
+                                            arg3::Ptr{cholmod_common})::Cint
 end
 
 mutable struct cholmod_triplet_struct
@@ -764,99 +899,137 @@ end
 const cholmod_triplet = cholmod_triplet_struct
 
 function cholmod_allocate_triplet(nrow, ncol, nzmax, stype, xtype, Common)
-    @ccall libcholmod.cholmod_allocate_triplet(nrow::Csize_t, ncol::Csize_t, nzmax::Csize_t, stype::Cint, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_allocate_triplet(nrow::Csize_t, ncol::Csize_t, nzmax::Csize_t,
+                                               stype::Cint, xtype::Cint,
+                                               Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_l_allocate_triplet(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_allocate_triplet(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t, arg4::Cint, arg5::Cint, arg6::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_l_allocate_triplet(arg1::Csize_t, arg2::Csize_t,
+                                                 arg3::Csize_t, arg4::Cint, arg5::Cint,
+                                                 arg6::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_free_triplet(T, Common)
-    @ccall libcholmod.cholmod_free_triplet(T::Ptr{Ptr{cholmod_triplet}}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_free_triplet(T::Ptr{Ptr{cholmod_triplet}},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_free_triplet(arg1, arg2)
-    @ccall libcholmod.cholmod_l_free_triplet(arg1::Ptr{Ptr{cholmod_triplet}}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_free_triplet(arg1::Ptr{Ptr{cholmod_triplet}},
+                                             arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_reallocate_triplet(nznew, T, Common)
-    @ccall libcholmod.cholmod_reallocate_triplet(nznew::Csize_t, T::Ptr{cholmod_triplet}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_reallocate_triplet(nznew::Csize_t, T::Ptr{cholmod_triplet},
+                                                 Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_reallocate_triplet(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_reallocate_triplet(arg1::Csize_t, arg2::Ptr{cholmod_triplet}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_reallocate_triplet(arg1::Csize_t,
+                                                   arg2::Ptr{cholmod_triplet},
+                                                   arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_sparse_to_triplet(A, Common)
-    @ccall libcholmod.cholmod_sparse_to_triplet(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_sparse_to_triplet(A::Ptr{cholmod_sparse},
+                                                Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_l_sparse_to_triplet(arg1, arg2)
-    @ccall libcholmod.cholmod_l_sparse_to_triplet(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_l_sparse_to_triplet(arg1::Ptr{cholmod_sparse},
+                                                  arg2::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_triplet_to_sparse(T, nzmax, Common)
-    @ccall libcholmod.cholmod_triplet_to_sparse(T::Ptr{cholmod_triplet}, nzmax::Csize_t, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_triplet_to_sparse(T::Ptr{cholmod_triplet}, nzmax::Csize_t,
+                                                Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_triplet_to_sparse(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_triplet_to_sparse(arg1::Ptr{cholmod_triplet}, arg2::Csize_t, arg3::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_triplet_to_sparse(arg1::Ptr{cholmod_triplet}, arg2::Csize_t,
+                                                  arg3::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_copy_triplet(T, Common)
-    @ccall libcholmod.cholmod_copy_triplet(T::Ptr{cholmod_triplet}, Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_copy_triplet(T::Ptr{cholmod_triplet},
+                                           Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_l_copy_triplet(arg1, arg2)
-    @ccall libcholmod.cholmod_l_copy_triplet(arg1::Ptr{cholmod_triplet}, arg2::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_l_copy_triplet(arg1::Ptr{cholmod_triplet},
+                                             arg2::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_triplet_xtype(to_xtype, T, Common)
-    @ccall libcholmod.cholmod_triplet_xtype(to_xtype::Cint, T::Ptr{cholmod_triplet}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_triplet_xtype(to_xtype::Cint, T::Ptr{cholmod_triplet},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_triplet_xtype(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_triplet_xtype(arg1::Cint, arg2::Ptr{cholmod_triplet}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_triplet_xtype(arg1::Cint, arg2::Ptr{cholmod_triplet},
+                                              arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_malloc(n, size, Common)
-    @ccall libcholmod.cholmod_malloc(n::Csize_t, size::Csize_t, Common::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_malloc(n::Csize_t, size::Csize_t,
+                                     Common::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_l_malloc(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_malloc(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_l_malloc(arg1::Csize_t, arg2::Csize_t,
+                                       arg3::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_calloc(n, size, Common)
-    @ccall libcholmod.cholmod_calloc(n::Csize_t, size::Csize_t, Common::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_calloc(n::Csize_t, size::Csize_t,
+                                     Common::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_l_calloc(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_calloc(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_l_calloc(arg1::Csize_t, arg2::Csize_t,
+                                       arg3::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_free(n, size, p, Common)
-    @ccall libcholmod.cholmod_free(n::Csize_t, size::Csize_t, p::Ptr{Cvoid}, Common::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_free(n::Csize_t, size::Csize_t, p::Ptr{Cvoid},
+                                   Common::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_l_free(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_free(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{Cvoid}, arg4::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_l_free(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{Cvoid},
+                                     arg4::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_realloc(nnew, size, p, n, Common)
-    @ccall libcholmod.cholmod_realloc(nnew::Csize_t, size::Csize_t, p::Ptr{Cvoid}, n::Ptr{Csize_t}, Common::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_realloc(nnew::Csize_t, size::Csize_t, p::Ptr{Cvoid},
+                                      n::Ptr{Csize_t},
+                                      Common::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_l_realloc(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_realloc(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{Cvoid}, arg4::Ptr{Csize_t}, arg5::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_l_realloc(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{Cvoid},
+                                        arg4::Ptr{Csize_t},
+                                        arg5::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
-function cholmod_realloc_multiple(nnew, nint, xtype, Iblock, Jblock, Xblock, Zblock, n, Common)
-    @ccall libcholmod.cholmod_realloc_multiple(nnew::Csize_t, nint::Cint, xtype::Cint, Iblock::Ptr{Ptr{Cvoid}}, Jblock::Ptr{Ptr{Cvoid}}, Xblock::Ptr{Ptr{Cvoid}}, Zblock::Ptr{Ptr{Cvoid}}, n::Ptr{Csize_t}, Common::Ptr{cholmod_common})::Cint
+function cholmod_realloc_multiple(nnew, nint, xtype, Iblock, Jblock, Xblock, Zblock, n,
+                                  Common)
+    @ccall libcholmod.cholmod_realloc_multiple(nnew::Csize_t, nint::Cint, xtype::Cint,
+                                               Iblock::Ptr{Ptr{Cvoid}},
+                                               Jblock::Ptr{Ptr{Cvoid}},
+                                               Xblock::Ptr{Ptr{Cvoid}},
+                                               Zblock::Ptr{Ptr{Cvoid}}, n::Ptr{Csize_t},
+                                               Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_realloc_multiple(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
-    @ccall libcholmod.cholmod_l_realloc_multiple(arg1::Csize_t, arg2::Cint, arg3::Cint, arg4::Ptr{Ptr{Cvoid}}, arg5::Ptr{Ptr{Cvoid}}, arg6::Ptr{Ptr{Cvoid}}, arg7::Ptr{Ptr{Cvoid}}, arg8::Ptr{Csize_t}, arg9::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_realloc_multiple(arg1::Csize_t, arg2::Cint, arg3::Cint,
+                                                 arg4::Ptr{Ptr{Cvoid}},
+                                                 arg5::Ptr{Ptr{Cvoid}},
+                                                 arg6::Ptr{Ptr{Cvoid}},
+                                                 arg7::Ptr{Ptr{Cvoid}}, arg8::Ptr{Csize_t},
+                                                 arg9::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_version(version)
@@ -876,11 +1049,13 @@ function cholmod_l_check_common(arg1)
 end
 
 function cholmod_print_common(name, Common)
-    @ccall libcholmod.cholmod_print_common(name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_common(name::Ptr{Cchar},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_common(arg1, arg2)
-    @ccall libcholmod.cholmod_l_print_common(arg1::Ptr{Cchar}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_common(arg1::Ptr{Cchar},
+                                             arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_gpu_stats(arg1)
@@ -892,643 +1067,1047 @@ function cholmod_l_gpu_stats(arg1)
 end
 
 function cholmod_check_sparse(A, Common)
-    @ccall libcholmod.cholmod_check_sparse(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_sparse(A::Ptr{cholmod_sparse},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_sparse(arg1, arg2)
-    @ccall libcholmod.cholmod_l_check_sparse(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_sparse(arg1::Ptr{cholmod_sparse},
+                                             arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_sparse(A, name, Common)
-    @ccall libcholmod.cholmod_print_sparse(A::Ptr{cholmod_sparse}, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_sparse(A::Ptr{cholmod_sparse}, name::Ptr{Cchar},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_sparse(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_print_sparse(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Cchar}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_sparse(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Cchar},
+                                             arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_check_dense(X, Common)
-    @ccall libcholmod.cholmod_check_dense(X::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_dense(X::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_dense(arg1, arg2)
-    @ccall libcholmod.cholmod_l_check_dense(arg1::Ptr{cholmod_dense}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_dense(arg1::Ptr{cholmod_dense},
+                                            arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_dense(X, name, Common)
-    @ccall libcholmod.cholmod_print_dense(X::Ptr{cholmod_dense}, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_dense(X::Ptr{cholmod_dense}, name::Ptr{Cchar},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_dense(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_print_dense(arg1::Ptr{cholmod_dense}, arg2::Ptr{Cchar}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_dense(arg1::Ptr{cholmod_dense}, arg2::Ptr{Cchar},
+                                            arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_check_factor(L, Common)
-    @ccall libcholmod.cholmod_check_factor(L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_factor(L::Ptr{cholmod_factor},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_factor(arg1, arg2)
-    @ccall libcholmod.cholmod_l_check_factor(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_factor(arg1::Ptr{cholmod_factor},
+                                             arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_factor(L, name, Common)
-    @ccall libcholmod.cholmod_print_factor(L::Ptr{cholmod_factor}, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_factor(L::Ptr{cholmod_factor}, name::Ptr{Cchar},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_factor(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_print_factor(arg1::Ptr{cholmod_factor}, arg2::Ptr{Cchar}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_factor(arg1::Ptr{cholmod_factor}, arg2::Ptr{Cchar},
+                                             arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_check_triplet(T, Common)
-    @ccall libcholmod.cholmod_check_triplet(T::Ptr{cholmod_triplet}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_triplet(T::Ptr{cholmod_triplet},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_triplet(arg1, arg2)
-    @ccall libcholmod.cholmod_l_check_triplet(arg1::Ptr{cholmod_triplet}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_triplet(arg1::Ptr{cholmod_triplet},
+                                              arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_triplet(T, name, Common)
-    @ccall libcholmod.cholmod_print_triplet(T::Ptr{cholmod_triplet}, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_triplet(T::Ptr{cholmod_triplet}, name::Ptr{Cchar},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_triplet(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_print_triplet(arg1::Ptr{cholmod_triplet}, arg2::Ptr{Cchar}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_triplet(arg1::Ptr{cholmod_triplet}, arg2::Ptr{Cchar},
+                                              arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_check_subset(Set, len, n, Common)
-    @ccall libcholmod.cholmod_check_subset(Set::Ptr{Int32}, len::Int64, n::Csize_t, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_subset(Set::Ptr{Int32}, len::Int64, n::Csize_t,
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_subset(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_check_subset(arg1::Ptr{Int64}, arg2::Int64, arg3::Csize_t, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_subset(arg1::Ptr{Int64}, arg2::Int64, arg3::Csize_t,
+                                             arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_subset(Set, len, n, name, Common)
-    @ccall libcholmod.cholmod_print_subset(Set::Ptr{Int32}, len::Int64, n::Csize_t, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_subset(Set::Ptr{Int32}, len::Int64, n::Csize_t,
+                                           name::Ptr{Cchar},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_subset(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_print_subset(arg1::Ptr{Int64}, arg2::Int64, arg3::Csize_t, arg4::Ptr{Cchar}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_subset(arg1::Ptr{Int64}, arg2::Int64, arg3::Csize_t,
+                                             arg4::Ptr{Cchar},
+                                             arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_check_perm(Perm, len, n, Common)
-    @ccall libcholmod.cholmod_check_perm(Perm::Ptr{Int32}, len::Csize_t, n::Csize_t, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_perm(Perm::Ptr{Int32}, len::Csize_t, n::Csize_t,
+                                         Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_perm(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_check_perm(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Csize_t, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_perm(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Csize_t,
+                                           arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_perm(Perm, len, n, name, Common)
-    @ccall libcholmod.cholmod_print_perm(Perm::Ptr{Int32}, len::Csize_t, n::Csize_t, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_perm(Perm::Ptr{Int32}, len::Csize_t, n::Csize_t,
+                                         name::Ptr{Cchar},
+                                         Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_perm(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_print_perm(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Csize_t, arg4::Ptr{Cchar}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_perm(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Csize_t,
+                                           arg4::Ptr{Cchar},
+                                           arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_check_parent(Parent, n, Common)
-    @ccall libcholmod.cholmod_check_parent(Parent::Ptr{Int32}, n::Csize_t, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_parent(Parent::Ptr{Int32}, n::Csize_t,
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_parent(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_check_parent(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_parent(arg1::Ptr{Int64}, arg2::Csize_t,
+                                             arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_parent(Parent, n, name, Common)
-    @ccall libcholmod.cholmod_print_parent(Parent::Ptr{Int32}, n::Csize_t, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_parent(Parent::Ptr{Int32}, n::Csize_t, name::Ptr{Cchar},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_parent(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_print_parent(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Ptr{Cchar}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_parent(arg1::Ptr{Int64}, arg2::Csize_t,
+                                             arg3::Ptr{Cchar},
+                                             arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_read_sparse(f, Common)
-    @ccall libcholmod.cholmod_read_sparse(f::Ptr{Libc.FILE}, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_read_sparse(f::Ptr{Libc.FILE},
+                                          Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_read_sparse(arg1, arg2)
-    @ccall libcholmod.cholmod_l_read_sparse(arg1::Ptr{Libc.FILE}, arg2::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_read_sparse(arg1::Ptr{Libc.FILE},
+                                            arg2::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_read_triplet(f, Common)
-    @ccall libcholmod.cholmod_read_triplet(f::Ptr{Libc.FILE}, Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_read_triplet(f::Ptr{Libc.FILE},
+                                           Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_l_read_triplet(arg1, arg2)
-    @ccall libcholmod.cholmod_l_read_triplet(arg1::Ptr{Libc.FILE}, arg2::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_l_read_triplet(arg1::Ptr{Libc.FILE},
+                                             arg2::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_read_dense(f, Common)
-    @ccall libcholmod.cholmod_read_dense(f::Ptr{Libc.FILE}, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_read_dense(f::Ptr{Libc.FILE},
+                                         Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_read_dense(arg1, arg2)
-    @ccall libcholmod.cholmod_l_read_dense(arg1::Ptr{Libc.FILE}, arg2::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_read_dense(arg1::Ptr{Libc.FILE},
+                                           arg2::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_read_matrix(f, prefer, mtype, Common)
-    @ccall libcholmod.cholmod_read_matrix(f::Ptr{Libc.FILE}, prefer::Cint, mtype::Ptr{Cint}, Common::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_read_matrix(f::Ptr{Libc.FILE}, prefer::Cint, mtype::Ptr{Cint},
+                                          Common::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_l_read_matrix(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_read_matrix(arg1::Ptr{Libc.FILE}, arg2::Cint, arg3::Ptr{Cint}, arg4::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_l_read_matrix(arg1::Ptr{Libc.FILE}, arg2::Cint,
+                                            arg3::Ptr{Cint},
+                                            arg4::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_write_sparse(f, A, Z, comments, Common)
-    @ccall libcholmod.cholmod_write_sparse(f::Ptr{Libc.FILE}, A::Ptr{cholmod_sparse}, Z::Ptr{cholmod_sparse}, comments::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_write_sparse(f::Ptr{Libc.FILE}, A::Ptr{cholmod_sparse},
+                                           Z::Ptr{cholmod_sparse}, comments::Ptr{Cchar},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_write_sparse(arg1, arg2, arg3, c, arg5)
-    @ccall libcholmod.cholmod_l_write_sparse(arg1::Ptr{Libc.FILE}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_sparse}, c::Ptr{Cchar}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_write_sparse(arg1::Ptr{Libc.FILE},
+                                             arg2::Ptr{cholmod_sparse},
+                                             arg3::Ptr{cholmod_sparse}, c::Ptr{Cchar},
+                                             arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_write_dense(f, X, comments, Common)
-    @ccall libcholmod.cholmod_write_dense(f::Ptr{Libc.FILE}, X::Ptr{cholmod_dense}, comments::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_write_dense(f::Ptr{Libc.FILE}, X::Ptr{cholmod_dense},
+                                          comments::Ptr{Cchar},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_write_dense(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_write_dense(arg1::Ptr{Libc.FILE}, arg2::Ptr{cholmod_dense}, arg3::Ptr{Cchar}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_write_dense(arg1::Ptr{Libc.FILE}, arg2::Ptr{cholmod_dense},
+                                            arg3::Ptr{Cchar},
+                                            arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_analyze(A, Common)
-    @ccall libcholmod.cholmod_analyze(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_analyze(A::Ptr{cholmod_sparse},
+                                      Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_l_analyze(arg1, arg2)
-    @ccall libcholmod.cholmod_l_analyze(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_l_analyze(arg1::Ptr{cholmod_sparse},
+                                        arg2::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_analyze_p(A, UserPerm, fset, fsize, Common)
-    @ccall libcholmod.cholmod_analyze_p(A::Ptr{cholmod_sparse}, UserPerm::Ptr{Int32}, fset::Ptr{Int32}, fsize::Csize_t, Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_analyze_p(A::Ptr{cholmod_sparse}, UserPerm::Ptr{Int32},
+                                        fset::Ptr{Int32}, fsize::Csize_t,
+                                        Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_l_analyze_p(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_analyze_p(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Ptr{Int64}, arg4::Csize_t, arg5::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_l_analyze_p(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                          arg3::Ptr{Int64}, arg4::Csize_t,
+                                          arg5::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_analyze_p2(for_whom, A, UserPerm, fset, fsize, Common)
-    @ccall libcholmod.cholmod_analyze_p2(for_whom::Cint, A::Ptr{cholmod_sparse}, UserPerm::Ptr{Int32}, fset::Ptr{Int32}, fsize::Csize_t, Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_analyze_p2(for_whom::Cint, A::Ptr{cholmod_sparse},
+                                         UserPerm::Ptr{Int32}, fset::Ptr{Int32},
+                                         fsize::Csize_t,
+                                         Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_l_analyze_p2(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_analyze_p2(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Csize_t, arg6::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_l_analyze_p2(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                           arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                           arg5::Csize_t,
+                                           arg6::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_factorize(A, L, Common)
-    @ccall libcholmod.cholmod_factorize(A::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_factorize(A::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor},
+                                        Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_factorize(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_factorize(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_factorize(arg1::Ptr{cholmod_sparse},
+                                          arg2::Ptr{cholmod_factor},
+                                          arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_factorize_p(A, beta, fset, fsize, L, Common)
-    @ccall libcholmod.cholmod_factorize_p(A::Ptr{cholmod_sparse}, beta::Ptr{Cdouble}, fset::Ptr{Int32}, fsize::Csize_t, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_factorize_p(A::Ptr{cholmod_sparse}, beta::Ptr{Cdouble},
+                                          fset::Ptr{Int32}, fsize::Csize_t,
+                                          L::Ptr{cholmod_factor},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_factorize_p(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_factorize_p(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Cdouble}, arg3::Ptr{Int64}, arg4::Csize_t, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_factorize_p(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Cdouble},
+                                            arg3::Ptr{Int64}, arg4::Csize_t,
+                                            arg5::Ptr{cholmod_factor},
+                                            arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_solve(sys, L, B, Common)
-    @ccall libcholmod.cholmod_solve(sys::Cint, L::Ptr{cholmod_factor}, B::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_solve(sys::Cint, L::Ptr{cholmod_factor},
+                                    B::Ptr{cholmod_dense},
+                                    Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_solve(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_solve(arg1::Cint, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_dense}, arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_solve(arg1::Cint, arg2::Ptr{cholmod_factor},
+                                      arg3::Ptr{cholmod_dense},
+                                      arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_solve2(sys, L, B, Bset, X_Handle, Xset_Handle, Y_Handle, E_Handle, Common)
-    @ccall libcholmod.cholmod_solve2(sys::Cint, L::Ptr{cholmod_factor}, B::Ptr{cholmod_dense}, Bset::Ptr{cholmod_sparse}, X_Handle::Ptr{Ptr{cholmod_dense}}, Xset_Handle::Ptr{Ptr{cholmod_sparse}}, Y_Handle::Ptr{Ptr{cholmod_dense}}, E_Handle::Ptr{Ptr{cholmod_dense}}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_solve2(sys::Cint, L::Ptr{cholmod_factor},
+                                     B::Ptr{cholmod_dense}, Bset::Ptr{cholmod_sparse},
+                                     X_Handle::Ptr{Ptr{cholmod_dense}},
+                                     Xset_Handle::Ptr{Ptr{cholmod_sparse}},
+                                     Y_Handle::Ptr{Ptr{cholmod_dense}},
+                                     E_Handle::Ptr{Ptr{cholmod_dense}},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_solve2(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
-    @ccall libcholmod.cholmod_l_solve2(arg1::Cint, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_dense}, arg4::Ptr{cholmod_sparse}, arg5::Ptr{Ptr{cholmod_dense}}, arg6::Ptr{Ptr{cholmod_sparse}}, arg7::Ptr{Ptr{cholmod_dense}}, arg8::Ptr{Ptr{cholmod_dense}}, arg9::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_solve2(arg1::Cint, arg2::Ptr{cholmod_factor},
+                                       arg3::Ptr{cholmod_dense}, arg4::Ptr{cholmod_sparse},
+                                       arg5::Ptr{Ptr{cholmod_dense}},
+                                       arg6::Ptr{Ptr{cholmod_sparse}},
+                                       arg7::Ptr{Ptr{cholmod_dense}},
+                                       arg8::Ptr{Ptr{cholmod_dense}},
+                                       arg9::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_spsolve(sys, L, B, Common)
-    @ccall libcholmod.cholmod_spsolve(sys::Cint, L::Ptr{cholmod_factor}, B::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_spsolve(sys::Cint, L::Ptr{cholmod_factor},
+                                      B::Ptr{cholmod_sparse},
+                                      Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_spsolve(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_spsolve(arg1::Cint, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_sparse}, arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_spsolve(arg1::Cint, arg2::Ptr{cholmod_factor},
+                                        arg3::Ptr{cholmod_sparse},
+                                        arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_etree(A, Parent, Common)
-    @ccall libcholmod.cholmod_etree(A::Ptr{cholmod_sparse}, Parent::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_etree(A::Ptr{cholmod_sparse}, Parent::Ptr{Int32},
+                                    Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_etree(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_etree(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_etree(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                      arg3::Ptr{cholmod_common})::Cint
 end
 
-function cholmod_rowcolcounts(A, fset, fsize, Parent, Post, RowCount, ColCount, First, Level, Common)
-    @ccall libcholmod.cholmod_rowcolcounts(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, Parent::Ptr{Int32}, Post::Ptr{Int32}, RowCount::Ptr{Int32}, ColCount::Ptr{Int32}, First::Ptr{Int32}, Level::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+function cholmod_rowcolcounts(A, fset, fsize, Parent, Post, RowCount, ColCount, First,
+                              Level, Common)
+    @ccall libcholmod.cholmod_rowcolcounts(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                           fsize::Csize_t, Parent::Ptr{Int32},
+                                           Post::Ptr{Int32}, RowCount::Ptr{Int32},
+                                           ColCount::Ptr{Int32}, First::Ptr{Int32},
+                                           Level::Ptr{Int32},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowcolcounts(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)
-    @ccall libcholmod.cholmod_l_rowcolcounts(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{Int64}, arg6::Ptr{Int64}, arg7::Ptr{Int64}, arg8::Ptr{Int64}, arg9::Ptr{Int64}, arg10::Ptr{cholmod_common})::Cint
-end
-
-function cholmod_analyze_ordering(A, ordering, Perm, fset, fsize, Parent, Post, ColCount, First, Level, Common)
-    @ccall libcholmod.cholmod_analyze_ordering(A::Ptr{cholmod_sparse}, ordering::Cint, Perm::Ptr{Int32}, fset::Ptr{Int32}, fsize::Csize_t, Parent::Ptr{Int32}, Post::Ptr{Int32}, ColCount::Ptr{Int32}, First::Ptr{Int32}, Level::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
-end
-
-function cholmod_l_analyze_ordering(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11)
-    @ccall libcholmod.cholmod_l_analyze_ordering(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Csize_t, arg6::Ptr{Int64}, arg7::Ptr{Int64}, arg8::Ptr{Int64}, arg9::Ptr{Int64}, arg10::Ptr{Int64}, arg11::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowcolcounts(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                             arg3::Csize_t, arg4::Ptr{Int64},
+                                             arg5::Ptr{Int64}, arg6::Ptr{Int64},
+                                             arg7::Ptr{Int64}, arg8::Ptr{Int64},
+                                             arg9::Ptr{Int64},
+                                             arg10::Ptr{cholmod_common})::Cint
+end
+
+function cholmod_analyze_ordering(A, ordering, Perm, fset, fsize, Parent, Post, ColCount,
+                                  First, Level, Common)
+    @ccall libcholmod.cholmod_analyze_ordering(A::Ptr{cholmod_sparse}, ordering::Cint,
+                                               Perm::Ptr{Int32}, fset::Ptr{Int32},
+                                               fsize::Csize_t, Parent::Ptr{Int32},
+                                               Post::Ptr{Int32}, ColCount::Ptr{Int32},
+                                               First::Ptr{Int32}, Level::Ptr{Int32},
+                                               Common::Ptr{cholmod_common})::Cint
+end
+
+function cholmod_l_analyze_ordering(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9,
+                                    arg10, arg11)
+    @ccall libcholmod.cholmod_l_analyze_ordering(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                                 arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                                 arg5::Csize_t, arg6::Ptr{Int64},
+                                                 arg7::Ptr{Int64}, arg8::Ptr{Int64},
+                                                 arg9::Ptr{Int64}, arg10::Ptr{Int64},
+                                                 arg11::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_amd(A, fset, fsize, Perm, Common)
-    @ccall libcholmod.cholmod_amd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_amd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t,
+                                  Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_amd(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_amd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_amd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                    arg3::Csize_t, arg4::Ptr{Int64},
+                                    arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_colamd(A, fset, fsize, postorder, Perm, Common)
-    @ccall libcholmod.cholmod_colamd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, postorder::Cint, Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_colamd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                     fsize::Csize_t, postorder::Cint, Perm::Ptr{Int32},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_colamd(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_colamd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Cint, arg5::Ptr{Int64}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_colamd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                       arg3::Csize_t, arg4::Cint, arg5::Ptr{Int64},
+                                       arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowfac(A, F, beta, kstart, kend, L, Common)
-    @ccall libcholmod.cholmod_rowfac(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, beta::Ptr{Cdouble}, kstart::Csize_t, kend::Csize_t, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowfac(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse},
+                                     beta::Ptr{Cdouble}, kstart::Csize_t, kend::Csize_t,
+                                     L::Ptr{cholmod_factor},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowfac(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_rowfac(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Csize_t, arg5::Csize_t, arg6::Ptr{cholmod_factor}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowfac(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse},
+                                       arg3::Ptr{Cdouble}, arg4::Csize_t, arg5::Csize_t,
+                                       arg6::Ptr{cholmod_factor},
+                                       arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowfac_mask(A, F, beta, kstart, kend, mask, RLinkUp, L, Common)
-    @ccall libcholmod.cholmod_rowfac_mask(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, beta::Ptr{Cdouble}, kstart::Csize_t, kend::Csize_t, mask::Ptr{Int32}, RLinkUp::Ptr{Int32}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowfac_mask(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse},
+                                          beta::Ptr{Cdouble}, kstart::Csize_t,
+                                          kend::Csize_t, mask::Ptr{Int32},
+                                          RLinkUp::Ptr{Int32}, L::Ptr{cholmod_factor},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowfac_mask(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
-    @ccall libcholmod.cholmod_l_rowfac_mask(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Csize_t, arg5::Csize_t, arg6::Ptr{Int64}, arg7::Ptr{Int64}, arg8::Ptr{cholmod_factor}, arg9::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowfac_mask(arg1::Ptr{cholmod_sparse},
+                                            arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble},
+                                            arg4::Csize_t, arg5::Csize_t, arg6::Ptr{Int64},
+                                            arg7::Ptr{Int64}, arg8::Ptr{cholmod_factor},
+                                            arg9::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowfac_mask2(A, F, beta, kstart, kend, mask, maskmark, RLinkUp, L, Common)
-    @ccall libcholmod.cholmod_rowfac_mask2(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, beta::Ptr{Cdouble}, kstart::Csize_t, kend::Csize_t, mask::Ptr{Int32}, maskmark::Int32, RLinkUp::Ptr{Int32}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowfac_mask2(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse},
+                                           beta::Ptr{Cdouble}, kstart::Csize_t,
+                                           kend::Csize_t, mask::Ptr{Int32}, maskmark::Int32,
+                                           RLinkUp::Ptr{Int32}, L::Ptr{cholmod_factor},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowfac_mask2(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)
-    @ccall libcholmod.cholmod_l_rowfac_mask2(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Csize_t, arg5::Csize_t, arg6::Ptr{Int64}, arg7::Int64, arg8::Ptr{Int64}, arg9::Ptr{cholmod_factor}, arg10::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowfac_mask2(arg1::Ptr{cholmod_sparse},
+                                             arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble},
+                                             arg4::Csize_t, arg5::Csize_t, arg6::Ptr{Int64},
+                                             arg7::Int64, arg8::Ptr{Int64},
+                                             arg9::Ptr{cholmod_factor},
+                                             arg10::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_row_subtree(A, F, k, Parent, R, Common)
-    @ccall libcholmod.cholmod_row_subtree(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, k::Csize_t, Parent::Ptr{Int32}, R::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_row_subtree(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse},
+                                          k::Csize_t, Parent::Ptr{Int32},
+                                          R::Ptr{cholmod_sparse},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_row_subtree(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_row_subtree(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{cholmod_sparse}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_row_subtree(arg1::Ptr{cholmod_sparse},
+                                            arg2::Ptr{cholmod_sparse}, arg3::Csize_t,
+                                            arg4::Ptr{Int64}, arg5::Ptr{cholmod_sparse},
+                                            arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_lsolve_pattern(B, L, X, Common)
-    @ccall libcholmod.cholmod_lsolve_pattern(B::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_lsolve_pattern(B::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor},
+                                             X::Ptr{cholmod_sparse},
+                                             Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_lsolve_pattern(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_lsolve_pattern(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_sparse}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_lsolve_pattern(arg1::Ptr{cholmod_sparse},
+                                               arg2::Ptr{cholmod_factor},
+                                               arg3::Ptr{cholmod_sparse},
+                                               arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_row_lsubtree(A, Fi, fnz, k, L, R, Common)
-    @ccall libcholmod.cholmod_row_lsubtree(A::Ptr{cholmod_sparse}, Fi::Ptr{Int32}, fnz::Csize_t, k::Csize_t, L::Ptr{cholmod_factor}, R::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_row_lsubtree(A::Ptr{cholmod_sparse}, Fi::Ptr{Int32},
+                                           fnz::Csize_t, k::Csize_t, L::Ptr{cholmod_factor},
+                                           R::Ptr{cholmod_sparse},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_row_lsubtree(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_row_lsubtree(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Csize_t, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_sparse}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_row_lsubtree(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                             arg3::Csize_t, arg4::Csize_t,
+                                             arg5::Ptr{cholmod_factor},
+                                             arg6::Ptr{cholmod_sparse},
+                                             arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_resymbol(A, fset, fsize, pack, L, Common)
-    @ccall libcholmod.cholmod_resymbol(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, pack::Cint, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_resymbol(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                       fsize::Csize_t, pack::Cint, L::Ptr{cholmod_factor},
+                                       Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_resymbol(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_resymbol(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Cint, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_resymbol(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                         arg3::Csize_t, arg4::Cint,
+                                         arg5::Ptr{cholmod_factor},
+                                         arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_resymbol_noperm(A, fset, fsize, pack, L, Common)
-    @ccall libcholmod.cholmod_resymbol_noperm(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, pack::Cint, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_resymbol_noperm(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                              fsize::Csize_t, pack::Cint,
+                                              L::Ptr{cholmod_factor},
+                                              Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_resymbol_noperm(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_resymbol_noperm(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Cint, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_resymbol_noperm(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                                arg3::Csize_t, arg4::Cint,
+                                                arg5::Ptr{cholmod_factor},
+                                                arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rcond(L, Common)
-    @ccall libcholmod.cholmod_rcond(L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cdouble
+    @ccall libcholmod.cholmod_rcond(L::Ptr{cholmod_factor},
+                                    Common::Ptr{cholmod_common})::Cdouble
 end
 
 function cholmod_l_rcond(arg1, arg2)
-    @ccall libcholmod.cholmod_l_rcond(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_common})::Cdouble
+    @ccall libcholmod.cholmod_l_rcond(arg1::Ptr{cholmod_factor},
+                                      arg2::Ptr{cholmod_common})::Cdouble
 end
 
 function cholmod_postorder(Parent, n, Weight_p, Post, Common)
-    @ccall libcholmod.cholmod_postorder(Parent::Ptr{Int32}, n::Csize_t, Weight_p::Ptr{Int32}, Post::Ptr{Int32}, Common::Ptr{cholmod_common})::Int32
+    @ccall libcholmod.cholmod_postorder(Parent::Ptr{Int32}, n::Csize_t,
+                                        Weight_p::Ptr{Int32}, Post::Ptr{Int32},
+                                        Common::Ptr{cholmod_common})::Int32
 end
 
 function cholmod_l_postorder(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_postorder(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_l_postorder(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Ptr{Int64},
+                                          arg4::Ptr{Int64},
+                                          arg5::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_drop(tol, A, Common)
-    @ccall libcholmod.cholmod_drop(tol::Cdouble, A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_drop(tol::Cdouble, A::Ptr{cholmod_sparse},
+                                   Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_drop(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_drop(arg1::Cdouble, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_drop(arg1::Cdouble, arg2::Ptr{cholmod_sparse},
+                                     arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_norm_dense(X, norm, Common)
-    @ccall libcholmod.cholmod_norm_dense(X::Ptr{cholmod_dense}, norm::Cint, Common::Ptr{cholmod_common})::Cdouble
+    @ccall libcholmod.cholmod_norm_dense(X::Ptr{cholmod_dense}, norm::Cint,
+                                         Common::Ptr{cholmod_common})::Cdouble
 end
 
 function cholmod_l_norm_dense(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_norm_dense(arg1::Ptr{cholmod_dense}, arg2::Cint, arg3::Ptr{cholmod_common})::Cdouble
+    @ccall libcholmod.cholmod_l_norm_dense(arg1::Ptr{cholmod_dense}, arg2::Cint,
+                                           arg3::Ptr{cholmod_common})::Cdouble
 end
 
 function cholmod_norm_sparse(A, norm, Common)
-    @ccall libcholmod.cholmod_norm_sparse(A::Ptr{cholmod_sparse}, norm::Cint, Common::Ptr{cholmod_common})::Cdouble
+    @ccall libcholmod.cholmod_norm_sparse(A::Ptr{cholmod_sparse}, norm::Cint,
+                                          Common::Ptr{cholmod_common})::Cdouble
 end
 
 function cholmod_l_norm_sparse(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_norm_sparse(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{cholmod_common})::Cdouble
+    @ccall libcholmod.cholmod_l_norm_sparse(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                            arg3::Ptr{cholmod_common})::Cdouble
 end
 
 function cholmod_horzcat(A, B, values, Common)
-    @ccall libcholmod.cholmod_horzcat(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse}, values::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_horzcat(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse},
+                                      values::Cint,
+                                      Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_horzcat(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_horzcat(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_horzcat(arg1::Ptr{cholmod_sparse},
+                                        arg2::Ptr{cholmod_sparse}, arg3::Cint,
+                                        arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_scale(S, scale, A, Common)
-    @ccall libcholmod.cholmod_scale(S::Ptr{cholmod_dense}, scale::Cint, A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_scale(S::Ptr{cholmod_dense}, scale::Cint,
+                                    A::Ptr{cholmod_sparse},
+                                    Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_scale(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_scale(arg1::Ptr{cholmod_dense}, arg2::Cint, arg3::Ptr{cholmod_sparse}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_scale(arg1::Ptr{cholmod_dense}, arg2::Cint,
+                                      arg3::Ptr{cholmod_sparse},
+                                      arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_sdmult(A, transpose, alpha, beta, X, Y, Common)
-    @ccall libcholmod.cholmod_sdmult(A::Ptr{cholmod_sparse}, transpose::Cint, alpha::Ptr{Cdouble}, beta::Ptr{Cdouble}, X::Ptr{cholmod_dense}, Y::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_sdmult(A::Ptr{cholmod_sparse}, transpose::Cint,
+                                     alpha::Ptr{Cdouble}, beta::Ptr{Cdouble},
+                                     X::Ptr{cholmod_dense}, Y::Ptr{cholmod_dense},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_sdmult(arg1, arg2, arg3, arg4, arg5, Y, arg7)
-    @ccall libcholmod.cholmod_l_sdmult(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{Cdouble}, arg4::Ptr{Cdouble}, arg5::Ptr{cholmod_dense}, Y::Ptr{cholmod_dense}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_sdmult(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                       arg3::Ptr{Cdouble}, arg4::Ptr{Cdouble},
+                                       arg5::Ptr{cholmod_dense}, Y::Ptr{cholmod_dense},
+                                       arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_ssmult(A, B, stype, values, sorted, Common)
-    @ccall libcholmod.cholmod_ssmult(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse}, stype::Cint, values::Cint, sorted::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_ssmult(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse},
+                                     stype::Cint, values::Cint, sorted::Cint,
+                                     Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_ssmult(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_ssmult(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Cint, arg4::Cint, arg5::Cint, arg6::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_ssmult(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse},
+                                       arg3::Cint, arg4::Cint, arg5::Cint,
+                                       arg6::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_submatrix(A, rset, rsize, cset, csize, values, sorted, Common)
-    @ccall libcholmod.cholmod_submatrix(A::Ptr{cholmod_sparse}, rset::Ptr{Int32}, rsize::Int64, cset::Ptr{Int32}, csize::Int64, values::Cint, sorted::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_submatrix(A::Ptr{cholmod_sparse}, rset::Ptr{Int32},
+                                        rsize::Int64, cset::Ptr{Int32}, csize::Int64,
+                                        values::Cint, sorted::Cint,
+                                        Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_submatrix(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
-    @ccall libcholmod.cholmod_l_submatrix(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Int64, arg4::Ptr{Int64}, arg5::Int64, arg6::Cint, arg7::Cint, arg8::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_submatrix(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                          arg3::Int64, arg4::Ptr{Int64}, arg5::Int64,
+                                          arg6::Cint, arg7::Cint,
+                                          arg8::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_vertcat(A, B, values, Common)
-    @ccall libcholmod.cholmod_vertcat(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse}, values::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_vertcat(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse},
+                                      values::Cint,
+                                      Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_vertcat(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_vertcat(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_vertcat(arg1::Ptr{cholmod_sparse},
+                                        arg2::Ptr{cholmod_sparse}, arg3::Cint,
+                                        arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_symmetry(A, option, xmatched, pmatched, nzoffdiag, nzdiag, Common)
-    @ccall libcholmod.cholmod_symmetry(A::Ptr{cholmod_sparse}, option::Cint, xmatched::Ptr{Int32}, pmatched::Ptr{Int32}, nzoffdiag::Ptr{Int32}, nzdiag::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_symmetry(A::Ptr{cholmod_sparse}, option::Cint,
+                                       xmatched::Ptr{Int32}, pmatched::Ptr{Int32},
+                                       nzoffdiag::Ptr{Int32}, nzdiag::Ptr{Int32},
+                                       Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_symmetry(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_symmetry(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Ptr{Int64}, arg6::Ptr{Int64}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_symmetry(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                         arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                         arg5::Ptr{Int64}, arg6::Ptr{Int64},
+                                         arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_updown(update, C, L, Common)
-    @ccall libcholmod.cholmod_updown(update::Cint, C::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_updown(update::Cint, C::Ptr{cholmod_sparse},
+                                     L::Ptr{cholmod_factor},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_updown(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_updown(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_factor}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_updown(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                       arg3::Ptr{cholmod_factor},
+                                       arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_updown_solve(update, C, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_updown_solve(update::Cint, C::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_updown_solve(update::Cint, C::Ptr{cholmod_sparse},
+                                           L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense},
+                                           DeltaB::Ptr{cholmod_dense},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_updown_solve(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_updown_solve(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_factor}, arg4::Ptr{cholmod_dense}, arg5::Ptr{cholmod_dense}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_updown_solve(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                             arg3::Ptr{cholmod_factor},
+                                             arg4::Ptr{cholmod_dense},
+                                             arg5::Ptr{cholmod_dense},
+                                             arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_updown_mark(update, C, colmark, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_updown_mark(update::Cint, C::Ptr{cholmod_sparse}, colmark::Ptr{Int32}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_updown_mark(update::Cint, C::Ptr{cholmod_sparse},
+                                          colmark::Ptr{Int32}, L::Ptr{cholmod_factor},
+                                          X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_updown_mark(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_updown_mark(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Int64}, arg4::Ptr{cholmod_factor}, arg5::Ptr{cholmod_dense}, arg6::Ptr{cholmod_dense}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_updown_mark(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                            arg3::Ptr{Int64}, arg4::Ptr{cholmod_factor},
+                                            arg5::Ptr{cholmod_dense},
+                                            arg6::Ptr{cholmod_dense},
+                                            arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_updown_mask(update, C, colmark, mask, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_updown_mask(update::Cint, C::Ptr{cholmod_sparse}, colmark::Ptr{Int32}, mask::Ptr{Int32}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_updown_mask(update::Cint, C::Ptr{cholmod_sparse},
+                                          colmark::Ptr{Int32}, mask::Ptr{Int32},
+                                          L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense},
+                                          DeltaB::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_updown_mask(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
-    @ccall libcholmod.cholmod_l_updown_mask(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_dense}, arg7::Ptr{cholmod_dense}, arg8::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_updown_mask(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                            arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                            arg5::Ptr{cholmod_factor},
+                                            arg6::Ptr{cholmod_dense},
+                                            arg7::Ptr{cholmod_dense},
+                                            arg8::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_updown_mask2(update, C, colmark, mask, maskmark, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_updown_mask2(update::Cint, C::Ptr{cholmod_sparse}, colmark::Ptr{Int32}, mask::Ptr{Int32}, maskmark::Int32, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_updown_mask2(update::Cint, C::Ptr{cholmod_sparse},
+                                           colmark::Ptr{Int32}, mask::Ptr{Int32},
+                                           maskmark::Int32, L::Ptr{cholmod_factor},
+                                           X::Ptr{cholmod_dense},
+                                           DeltaB::Ptr{cholmod_dense},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_updown_mask2(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
-    @ccall libcholmod.cholmod_l_updown_mask2(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Int64, arg6::Ptr{cholmod_factor}, arg7::Ptr{cholmod_dense}, arg8::Ptr{cholmod_dense}, arg9::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_updown_mask2(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                             arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                             arg5::Int64, arg6::Ptr{cholmod_factor},
+                                             arg7::Ptr{cholmod_dense},
+                                             arg8::Ptr{cholmod_dense},
+                                             arg9::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowadd(k, R, L, Common)
-    @ccall libcholmod.cholmod_rowadd(k::Csize_t, R::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowadd(k::Csize_t, R::Ptr{cholmod_sparse},
+                                     L::Ptr{cholmod_factor},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowadd(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_rowadd(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_factor}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowadd(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                       arg3::Ptr{cholmod_factor},
+                                       arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowadd_solve(k, R, bk, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_rowadd_solve(k::Csize_t, R::Ptr{cholmod_sparse}, bk::Ptr{Cdouble}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowadd_solve(k::Csize_t, R::Ptr{cholmod_sparse},
+                                           bk::Ptr{Cdouble}, L::Ptr{cholmod_factor},
+                                           X::Ptr{cholmod_dense},
+                                           DeltaB::Ptr{cholmod_dense},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowadd_solve(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_rowadd_solve(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Ptr{cholmod_factor}, arg5::Ptr{cholmod_dense}, arg6::Ptr{cholmod_dense}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowadd_solve(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                             arg3::Ptr{Cdouble}, arg4::Ptr{cholmod_factor},
+                                             arg5::Ptr{cholmod_dense},
+                                             arg6::Ptr{cholmod_dense},
+                                             arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowadd_mark(k, R, bk, colmark, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_rowadd_mark(k::Csize_t, R::Ptr{cholmod_sparse}, bk::Ptr{Cdouble}, colmark::Ptr{Int32}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowadd_mark(k::Csize_t, R::Ptr{cholmod_sparse},
+                                          bk::Ptr{Cdouble}, colmark::Ptr{Int32},
+                                          L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense},
+                                          DeltaB::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowadd_mark(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
-    @ccall libcholmod.cholmod_l_rowadd_mark(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Ptr{Int64}, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_dense}, arg7::Ptr{cholmod_dense}, arg8::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowadd_mark(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                            arg3::Ptr{Cdouble}, arg4::Ptr{Int64},
+                                            arg5::Ptr{cholmod_factor},
+                                            arg6::Ptr{cholmod_dense},
+                                            arg7::Ptr{cholmod_dense},
+                                            arg8::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowdel(k, R, L, Common)
-    @ccall libcholmod.cholmod_rowdel(k::Csize_t, R::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowdel(k::Csize_t, R::Ptr{cholmod_sparse},
+                                     L::Ptr{cholmod_factor},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowdel(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_rowdel(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_factor}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowdel(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                       arg3::Ptr{cholmod_factor},
+                                       arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowdel_solve(k, R, yk, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_rowdel_solve(k::Csize_t, R::Ptr{cholmod_sparse}, yk::Ptr{Cdouble}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowdel_solve(k::Csize_t, R::Ptr{cholmod_sparse},
+                                           yk::Ptr{Cdouble}, L::Ptr{cholmod_factor},
+                                           X::Ptr{cholmod_dense},
+                                           DeltaB::Ptr{cholmod_dense},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowdel_solve(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_rowdel_solve(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Ptr{cholmod_factor}, arg5::Ptr{cholmod_dense}, arg6::Ptr{cholmod_dense}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowdel_solve(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                             arg3::Ptr{Cdouble}, arg4::Ptr{cholmod_factor},
+                                             arg5::Ptr{cholmod_dense},
+                                             arg6::Ptr{cholmod_dense},
+                                             arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowdel_mark(k, R, yk, colmark, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_rowdel_mark(k::Csize_t, R::Ptr{cholmod_sparse}, yk::Ptr{Cdouble}, colmark::Ptr{Int32}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowdel_mark(k::Csize_t, R::Ptr{cholmod_sparse},
+                                          yk::Ptr{Cdouble}, colmark::Ptr{Int32},
+                                          L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense},
+                                          DeltaB::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowdel_mark(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
-    @ccall libcholmod.cholmod_l_rowdel_mark(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Ptr{Int64}, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_dense}, arg7::Ptr{cholmod_dense}, arg8::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowdel_mark(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                            arg3::Ptr{Cdouble}, arg4::Ptr{Int64},
+                                            arg5::Ptr{cholmod_factor},
+                                            arg6::Ptr{cholmod_dense},
+                                            arg7::Ptr{cholmod_dense},
+                                            arg8::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_ccolamd(A, fset, fsize, Cmember, Perm, Common)
-    @ccall libcholmod.cholmod_ccolamd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, Cmember::Ptr{Int32}, Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_ccolamd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                      fsize::Csize_t, Cmember::Ptr{Int32}, Perm::Ptr{Int32},
+                                      Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_ccolamd(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_ccolamd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{Int64}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_ccolamd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                        arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{Int64},
+                                        arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_csymamd(A, Cmember, Perm, Common)
-    @ccall libcholmod.cholmod_csymamd(A::Ptr{cholmod_sparse}, Cmember::Ptr{Int32}, Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_csymamd(A::Ptr{cholmod_sparse}, Cmember::Ptr{Int32},
+                                      Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_csymamd(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_csymamd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Ptr{Int64}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_csymamd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                        arg3::Ptr{Int64}, arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_camd(A, fset, fsize, Cmember, Perm, Common)
-    @ccall libcholmod.cholmod_camd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, Cmember::Ptr{Int32}, Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_camd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t,
+                                   Cmember::Ptr{Int32}, Perm::Ptr{Int32},
+                                   Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_camd(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_camd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{Int64}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_camd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                     arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{Int64},
+                                     arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_nested_dissection(A, fset, fsize, Perm, CParent, Cmember, Common)
-    @ccall libcholmod.cholmod_nested_dissection(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, Perm::Ptr{Int32}, CParent::Ptr{Int32}, Cmember::Ptr{Int32}, Common::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_nested_dissection(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                                fsize::Csize_t, Perm::Ptr{Int32},
+                                                CParent::Ptr{Int32}, Cmember::Ptr{Int32},
+                                                Common::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_l_nested_dissection(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_nested_dissection(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{Int64}, arg6::Ptr{Int64}, arg7::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_l_nested_dissection(arg1::Ptr{cholmod_sparse},
+                                                  arg2::Ptr{Int64}, arg3::Csize_t,
+                                                  arg4::Ptr{Int64}, arg5::Ptr{Int64},
+                                                  arg6::Ptr{Int64},
+                                                  arg7::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_metis(A, fset, fsize, postorder, Perm, Common)
-    @ccall libcholmod.cholmod_metis(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, postorder::Cint, Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_metis(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                    fsize::Csize_t, postorder::Cint, Perm::Ptr{Int32},
+                                    Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_metis(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_metis(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Cint, arg5::Ptr{Int64}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_metis(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                      arg3::Csize_t, arg4::Cint, arg5::Ptr{Int64},
+                                      arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_bisect(A, fset, fsize, compress, Partition, Common)
-    @ccall libcholmod.cholmod_bisect(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, compress::Cint, Partition::Ptr{Int32}, Common::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_bisect(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                     fsize::Csize_t, compress::Cint, Partition::Ptr{Int32},
+                                     Common::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_l_bisect(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_bisect(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Cint, arg5::Ptr{Int64}, arg6::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_l_bisect(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                       arg3::Csize_t, arg4::Cint, arg5::Ptr{Int64},
+                                       arg6::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_metis_bisector(A, Anw, Aew, Partition, Common)
-    @ccall libcholmod.cholmod_metis_bisector(A::Ptr{cholmod_sparse}, Anw::Ptr{Int32}, Aew::Ptr{Int32}, Partition::Ptr{Int32}, Common::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_metis_bisector(A::Ptr{cholmod_sparse}, Anw::Ptr{Int32},
+                                             Aew::Ptr{Int32}, Partition::Ptr{Int32},
+                                             Common::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_l_metis_bisector(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_metis_bisector(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_l_metis_bisector(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                               arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                               arg5::Ptr{cholmod_common})::Int64
 end
 
-function cholmod_collapse_septree(n, ncomponents, nd_oksep, nd_small, CParent, Cmember, Common)
-    @ccall libcholmod.cholmod_collapse_septree(n::Csize_t, ncomponents::Csize_t, nd_oksep::Cdouble, nd_small::Csize_t, CParent::Ptr{Int32}, Cmember::Ptr{Int32}, Common::Ptr{cholmod_common})::Int64
+function cholmod_collapse_septree(n, ncomponents, nd_oksep, nd_small, CParent, Cmember,
+                                  Common)
+    @ccall libcholmod.cholmod_collapse_septree(n::Csize_t, ncomponents::Csize_t,
+                                               nd_oksep::Cdouble, nd_small::Csize_t,
+                                               CParent::Ptr{Int32}, Cmember::Ptr{Int32},
+                                               Common::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_l_collapse_septree(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_collapse_septree(arg1::Csize_t, arg2::Csize_t, arg3::Cdouble, arg4::Csize_t, arg5::Ptr{Int64}, arg6::Ptr{Int64}, arg7::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_l_collapse_septree(arg1::Csize_t, arg2::Csize_t,
+                                                 arg3::Cdouble, arg4::Csize_t,
+                                                 arg5::Ptr{Int64}, arg6::Ptr{Int64},
+                                                 arg7::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_super_symbolic(A, F, Parent, L, Common)
-    @ccall libcholmod.cholmod_super_symbolic(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, Parent::Ptr{Int32}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_super_symbolic(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse},
+                                             Parent::Ptr{Int32}, L::Ptr{cholmod_factor},
+                                             Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_super_symbolic(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_super_symbolic(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Int64}, arg4::Ptr{cholmod_factor}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_super_symbolic(arg1::Ptr{cholmod_sparse},
+                                               arg2::Ptr{cholmod_sparse}, arg3::Ptr{Int64},
+                                               arg4::Ptr{cholmod_factor},
+                                               arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_super_symbolic2(for_whom, A, F, Parent, L, Common)
-    @ccall libcholmod.cholmod_super_symbolic2(for_whom::Cint, A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, Parent::Ptr{Int32}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_super_symbolic2(for_whom::Cint, A::Ptr{cholmod_sparse},
+                                              F::Ptr{cholmod_sparse}, Parent::Ptr{Int32},
+                                              L::Ptr{cholmod_factor},
+                                              Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_super_symbolic2(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_super_symbolic2(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_sparse}, arg4::Ptr{Int64}, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_super_symbolic2(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                                arg3::Ptr{cholmod_sparse}, arg4::Ptr{Int64},
+                                                arg5::Ptr{cholmod_factor},
+                                                arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_super_numeric(A, F, beta, L, Common)
-    @ccall libcholmod.cholmod_super_numeric(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, beta::Ptr{Cdouble}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_super_numeric(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse},
+                                            beta::Ptr{Cdouble}, L::Ptr{cholmod_factor},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_super_numeric(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_super_numeric(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Ptr{cholmod_factor}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_super_numeric(arg1::Ptr{cholmod_sparse},
+                                              arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble},
+                                              arg4::Ptr{cholmod_factor},
+                                              arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_super_lsolve(L, X, E, Common)
-    @ccall libcholmod.cholmod_super_lsolve(L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, E::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_super_lsolve(L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense},
+                                           E::Ptr{cholmod_dense},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_super_lsolve(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_super_lsolve(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_dense}, arg3::Ptr{cholmod_dense}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_super_lsolve(arg1::Ptr{cholmod_factor},
+                                             arg2::Ptr{cholmod_dense},
+                                             arg3::Ptr{cholmod_dense},
+                                             arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_super_ltsolve(L, X, E, Common)
-    @ccall libcholmod.cholmod_super_ltsolve(L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, E::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_super_ltsolve(L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense},
+                                            E::Ptr{cholmod_dense},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_super_ltsolve(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_super_ltsolve(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_dense}, arg3::Ptr{cholmod_dense}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_super_ltsolve(arg1::Ptr{cholmod_factor},
+                                              arg2::Ptr{cholmod_dense},
+                                              arg3::Ptr{cholmod_dense},
+                                              arg4::Ptr{cholmod_common})::Cint
+end
+
+function SuiteSparseQR_C(ordering, tol, econ, getCTX, A, Bsparse, Bdense, Zsparse, Zdense,
+                         R, E, H, HPinv, HTau, cc)
+    @ccall libspqr.SuiteSparseQR_C(ordering::Cint, tol::Cdouble, econ::Int64, getCTX::Cint,
+                                   A::Ptr{cholmod_sparse}, Bsparse::Ptr{cholmod_sparse},
+                                   Bdense::Ptr{cholmod_dense},
+                                   Zsparse::Ptr{Ptr{cholmod_sparse}},
+                                   Zdense::Ptr{Ptr{cholmod_dense}},
+                                   R::Ptr{Ptr{cholmod_sparse}}, E::Ptr{Ptr{Int64}},
+                                   H::Ptr{Ptr{cholmod_sparse}}, HPinv::Ptr{Ptr{Int64}},
+                                   HTau::Ptr{Ptr{cholmod_dense}},
+                                   cc::Ptr{cholmod_common})::Int64
+end
+
+function SuiteSparseQR_i_C(ordering, tol, econ, getCTX, A, Bsparse, Bdense, Zsparse, Zdense,
+                           R, E, H, HPinv, HTau, cc)
+    @ccall libspqr.SuiteSparseQR_i_C(ordering::Cint, tol::Cdouble, econ::Int32,
+                                     getCTX::Cint, A::Ptr{cholmod_sparse},
+                                     Bsparse::Ptr{cholmod_sparse},
+                                     Bdense::Ptr{cholmod_dense},
+                                     Zsparse::Ptr{Ptr{cholmod_sparse}},
+                                     Zdense::Ptr{Ptr{cholmod_dense}},
+                                     R::Ptr{Ptr{cholmod_sparse}}, E::Ptr{Ptr{Int32}},
+                                     H::Ptr{Ptr{cholmod_sparse}}, HPinv::Ptr{Ptr{Int32}},
+                                     HTau::Ptr{Ptr{cholmod_dense}},
+                                     cc::Ptr{cholmod_common})::Int32
 end
 
-function SuiteSparseQR_C(ordering, tol, econ, getCTX, A, Bsparse, Bdense, Zsparse, Zdense, R, E, H, HPinv, HTau, cc)
-    @ccall libspqr.SuiteSparseQR_C(ordering::Cint, tol::Cdouble, econ::Int64, getCTX::Cint, A::Ptr{cholmod_sparse}, Bsparse::Ptr{cholmod_sparse}, Bdense::Ptr{cholmod_dense}, Zsparse::Ptr{Ptr{cholmod_sparse}}, Zdense::Ptr{Ptr{cholmod_dense}}, R::Ptr{Ptr{cholmod_sparse}}, E::Ptr{Ptr{Int64}}, H::Ptr{Ptr{cholmod_sparse}}, HPinv::Ptr{Ptr{Int64}}, HTau::Ptr{Ptr{cholmod_dense}}, cc::Ptr{cholmod_common})::Int64
+function SuiteSparseQR_C_QR(ordering, tol, econ, A, Q, R, E, cc)
+    @ccall libspqr.SuiteSparseQR_C_QR(ordering::Cint, tol::Cdouble, econ::Int64,
+                                      A::Ptr{cholmod_sparse}, Q::Ptr{Ptr{cholmod_sparse}},
+                                      R::Ptr{Ptr{cholmod_sparse}}, E::Ptr{Ptr{Int64}},
+                                      cc::Ptr{cholmod_common})::Int64
 end
 
-function SuiteSparseQR_C_QR(ordering, tol, econ, A, Q, R, E, cc)
-    @ccall libspqr.SuiteSparseQR_C_QR(ordering::Cint, tol::Cdouble, econ::Int64, A::Ptr{cholmod_sparse}, Q::Ptr{Ptr{cholmod_sparse}}, R::Ptr{Ptr{cholmod_sparse}}, E::Ptr{Ptr{Int64}}, cc::Ptr{cholmod_common})::Int64
+function SuiteSparseQR_i_C_QR(ordering, tol, econ, A, Q, R, E, cc)
+    @ccall libspqr.SuiteSparseQR_i_C_QR(ordering::Cint, tol::Cdouble, econ::Int32,
+                                        A::Ptr{cholmod_sparse}, Q::Ptr{Ptr{cholmod_sparse}},
+                                        R::Ptr{Ptr{cholmod_sparse}}, E::Ptr{Ptr{Int32}},
+                                        cc::Ptr{cholmod_common})::Int32
 end
 
 function SuiteSparseQR_C_backslash(ordering, tol, A, B, cc)
-    @ccall libspqr.SuiteSparseQR_C_backslash(ordering::Cint, tol::Cdouble, A::Ptr{cholmod_sparse}, B::Ptr{cholmod_dense}, cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libspqr.SuiteSparseQR_C_backslash(ordering::Cint, tol::Cdouble,
+                                             A::Ptr{cholmod_sparse}, B::Ptr{cholmod_dense},
+                                             cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function SuiteSparseQR_C_backslash_default(A, B, cc)
-    @ccall libspqr.SuiteSparseQR_C_backslash_default(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_dense}, cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libspqr.SuiteSparseQR_C_backslash_default(A::Ptr{cholmod_sparse},
+                                                     B::Ptr{cholmod_dense},
+                                                     cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function SuiteSparseQR_C_backslash_sparse(ordering, tol, A, B, cc)
-    @ccall libspqr.SuiteSparseQR_C_backslash_sparse(ordering::Cint, tol::Cdouble, A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse}, cc::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libspqr.SuiteSparseQR_C_backslash_sparse(ordering::Cint, tol::Cdouble,
+                                                    A::Ptr{cholmod_sparse},
+                                                    B::Ptr{cholmod_sparse},
+                                                    cc::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 mutable struct SuiteSparseQR_C_factorization_struct
     xtype::Cint
+    itype::Cint
     factors::Ptr{Cvoid}
     SuiteSparseQR_C_factorization_struct() = new()
 end
@@ -1536,51 +2115,78 @@ end
 const SuiteSparseQR_C_factorization = SuiteSparseQR_C_factorization_struct
 
 function SuiteSparseQR_C_factorize(ordering, tol, A, cc)
-    @ccall libspqr.SuiteSparseQR_C_factorize(ordering::Cint, tol::Cdouble, A::Ptr{cholmod_sparse}, cc::Ptr{cholmod_common})::Ptr{SuiteSparseQR_C_factorization}
+    @ccall libspqr.SuiteSparseQR_C_factorize(ordering::Cint, tol::Cdouble,
+                                             A::Ptr{cholmod_sparse},
+                                             cc::Ptr{cholmod_common})::Ptr{SuiteSparseQR_C_factorization}
 end
 
 function SuiteSparseQR_C_symbolic(ordering, allow_tol, A, cc)
-    @ccall libspqr.SuiteSparseQR_C_symbolic(ordering::Cint, allow_tol::Cint, A::Ptr{cholmod_sparse}, cc::Ptr{cholmod_common})::Ptr{SuiteSparseQR_C_factorization}
+    @ccall libspqr.SuiteSparseQR_C_symbolic(ordering::Cint, allow_tol::Cint,
+                                            A::Ptr{cholmod_sparse},
+                                            cc::Ptr{cholmod_common})::Ptr{SuiteSparseQR_C_factorization}
 end
 
 function SuiteSparseQR_C_numeric(tol, A, QR, cc)
-    @ccall libspqr.SuiteSparseQR_C_numeric(tol::Cdouble, A::Ptr{cholmod_sparse}, QR::Ptr{SuiteSparseQR_C_factorization}, cc::Ptr{cholmod_common})::Cint
+    @ccall libspqr.SuiteSparseQR_C_numeric(tol::Cdouble, A::Ptr{cholmod_sparse},
+                                           QR::Ptr{SuiteSparseQR_C_factorization},
+                                           cc::Ptr{cholmod_common})::Cint
 end
 
 function SuiteSparseQR_C_free(QR, cc)
-    @ccall libspqr.SuiteSparseQR_C_free(QR::Ptr{Ptr{SuiteSparseQR_C_factorization}}, cc::Ptr{cholmod_common})::Cint
+    @ccall libspqr.SuiteSparseQR_C_free(QR::Ptr{Ptr{SuiteSparseQR_C_factorization}},
+                                        cc::Ptr{cholmod_common})::Cint
 end
 
 function SuiteSparseQR_C_solve(system, QR, B, cc)
-    @ccall libspqr.SuiteSparseQR_C_solve(system::Cint, QR::Ptr{SuiteSparseQR_C_factorization}, B::Ptr{cholmod_dense}, cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libspqr.SuiteSparseQR_C_solve(system::Cint,
+                                         QR::Ptr{SuiteSparseQR_C_factorization},
+                                         B::Ptr{cholmod_dense},
+                                         cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function SuiteSparseQR_C_qmult(method, QR, X, cc)
-    @ccall libspqr.SuiteSparseQR_C_qmult(method::Cint, QR::Ptr{SuiteSparseQR_C_factorization}, X::Ptr{cholmod_dense}, cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libspqr.SuiteSparseQR_C_qmult(method::Cint,
+                                         QR::Ptr{SuiteSparseQR_C_factorization},
+                                         X::Ptr{cholmod_dense},
+                                         cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function amd_order(n, Ap, Ai, P, Control, Info)
-    @ccall libamd.amd_order(n::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, P::Ptr{Int32}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libamd.amd_order(n::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, P::Ptr{Int32},
+                            Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function amd_l_order(n, Ap, Ai, P, Control, Info)
-    @ccall libamd.amd_l_order(n::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, P::Ptr{Int64}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libamd.amd_l_order(n::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, P::Ptr{Int64},
+                              Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
-function amd_2(n, Pe, Iw, Len, iwlen, pfree, Nv, Next, Last, Head, Elen, Degree, W, Control, Info)
-    @ccall libamd.amd_2(n::Int32, Pe::Ptr{Int32}, Iw::Ptr{Int32}, Len::Ptr{Int32}, iwlen::Int32, pfree::Int32, Nv::Ptr{Int32}, Next::Ptr{Int32}, Last::Ptr{Int32}, Head::Ptr{Int32}, Elen::Ptr{Int32}, Degree::Ptr{Int32}, W::Ptr{Int32}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cvoid
+function amd_2(n, Pe, Iw, Len, iwlen, pfree, Nv, Next, Last, Head, Elen, Degree, W, Control,
+               Info)
+    @ccall libamd.amd_2(n::Int32, Pe::Ptr{Int32}, Iw::Ptr{Int32}, Len::Ptr{Int32},
+                        iwlen::Int32, pfree::Int32, Nv::Ptr{Int32}, Next::Ptr{Int32},
+                        Last::Ptr{Int32}, Head::Ptr{Int32}, Elen::Ptr{Int32},
+                        Degree::Ptr{Int32}, W::Ptr{Int32}, Control::Ptr{Cdouble},
+                        Info::Ptr{Cdouble})::Cvoid
 end
 
-function amd_l2(n, Pe, Iw, Len, iwlen, pfree, Nv, Next, Last, Head, Elen, Degree, W, Control, Info)
-    @ccall libamd.amd_l2(n::Int64, Pe::Ptr{Int64}, Iw::Ptr{Int64}, Len::Ptr{Int64}, iwlen::Int64, pfree::Int64, Nv::Ptr{Int64}, Next::Ptr{Int64}, Last::Ptr{Int64}, Head::Ptr{Int64}, Elen::Ptr{Int64}, Degree::Ptr{Int64}, W::Ptr{Int64}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cvoid
+function amd_l2(n, Pe, Iw, Len, iwlen, pfree, Nv, Next, Last, Head, Elen, Degree, W,
+                Control, Info)
+    @ccall libamd.amd_l2(n::Int64, Pe::Ptr{Int64}, Iw::Ptr{Int64}, Len::Ptr{Int64},
+                         iwlen::Int64, pfree::Int64, Nv::Ptr{Int64}, Next::Ptr{Int64},
+                         Last::Ptr{Int64}, Head::Ptr{Int64}, Elen::Ptr{Int64},
+                         Degree::Ptr{Int64}, W::Ptr{Int64}, Control::Ptr{Cdouble},
+                         Info::Ptr{Cdouble})::Cvoid
 end
 
 function amd_valid(n_row, n_col, Ap, Ai)
-    @ccall libamd.amd_valid(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32})::Cint
+    @ccall libamd.amd_valid(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                            Ai::Ptr{Int32})::Cint
 end
 
 function amd_l_valid(n_row, n_col, Ap, Ai)
-    @ccall libamd.amd_l_valid(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64})::Cint
+    @ccall libamd.amd_l_valid(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                              Ai::Ptr{Int64})::Cint
 end
 
 function amd_defaults(Control)
@@ -1607,188 +2213,88 @@ function amd_l_info(Info)
     @ccall libamd.amd_l_info(Info::Ptr{Cdouble})::Cvoid
 end
 
-function colamd_recommended(nnz, n_row, n_col)
-    @ccall libcolamd.colamd_recommended(nnz::Int32, n_row::Int32, n_col::Int32)::Csize_t
-end
-
-function colamd_l_recommended(nnz, n_row, n_col)
-    @ccall libcolamd.colamd_l_recommended(nnz::Int64, n_row::Int64, n_col::Int64)::Csize_t
-end
-
-function colamd_set_defaults(knobs)
-    @ccall libcolamd.colamd_set_defaults(knobs::Ptr{Cdouble})::Cvoid
-end
-
-function colamd_l_set_defaults(knobs)
-    @ccall libcolamd.colamd_l_set_defaults(knobs::Ptr{Cdouble})::Cvoid
-end
-
-function colamd(n_row, n_col, Alen, A, p, knobs, stats)
-    @ccall libcolamd.colamd(n_row::Int32, n_col::Int32, Alen::Int32, A::Ptr{Int32}, p::Ptr{Int32}, knobs::Ptr{Cdouble}, stats::Ptr{Int32})::Cint
-end
-
-function colamd_l(n_row, n_col, Alen, A, p, knobs, stats)
-    @ccall libcolamd.colamd_l(n_row::Int64, n_col::Int64, Alen::Int64, A::Ptr{Int64}, p::Ptr{Int64}, knobs::Ptr{Cdouble}, stats::Ptr{Int64})::Cint
-end
-
-function symamd(n, A, p, perm, knobs, stats, allocate, release)
-    @ccall libcolamd.symamd(n::Int32, A::Ptr{Int32}, p::Ptr{Int32}, perm::Ptr{Int32}, knobs::Ptr{Cdouble}, stats::Ptr{Int32}, allocate::Ptr{Cvoid}, release::Ptr{Cvoid})::Cint
-end
-
-function symamd_l(n, A, p, perm, knobs, stats, allocate, release)
-    @ccall libcolamd.symamd_l(n::Int64, A::Ptr{Int64}, p::Ptr{Int64}, perm::Ptr{Int64}, knobs::Ptr{Cdouble}, stats::Ptr{Int64}, allocate::Ptr{Cvoid}, release::Ptr{Cvoid})::Cint
-end
-
-function colamd_report(stats)
-    @ccall libcolamd.colamd_report(stats::Ptr{Int32})::Cvoid
-end
-
-function colamd_l_report(stats)
-    @ccall libcolamd.colamd_l_report(stats::Ptr{Int64})::Cvoid
-end
-
-function symamd_report(stats)
-    @ccall libcolamd.symamd_report(stats::Ptr{Int32})::Cvoid
-end
-
-function symamd_l_report(stats)
-    @ccall libcolamd.symamd_l_report(stats::Ptr{Int64})::Cvoid
-end
-
-function ccolamd_recommended(nnz, n_row, n_col)
-    @ccall libcolamd.ccolamd_recommended(nnz::Cint, n_row::Cint, n_col::Cint)::Csize_t
-end
-
-function ccolamd_l_recommended(nnz, n_row, n_col)
-    @ccall libcolamd.ccolamd_l_recommended(nnz::Int64, n_row::Int64, n_col::Int64)::Csize_t
-end
-
-function ccolamd_set_defaults(knobs)
-    @ccall libcolamd.ccolamd_set_defaults(knobs::Ptr{Cdouble})::Cvoid
-end
-
-function ccolamd_l_set_defaults(knobs)
-    @ccall libcolamd.ccolamd_l_set_defaults(knobs::Ptr{Cdouble})::Cvoid
-end
-
-function ccolamd(n_row, n_col, Alen, A, p, knobs, stats, cmember)
-    @ccall libcolamd.ccolamd(n_row::Cint, n_col::Cint, Alen::Cint, A::Ptr{Cint}, p::Ptr{Cint}, knobs::Ptr{Cdouble}, stats::Ptr{Cint}, cmember::Ptr{Cint})::Cint
-end
-
-function ccolamd_l(n_row, n_col, Alen, A, p, knobs, stats, cmember)
-    @ccall libcolamd.ccolamd_l(n_row::Int64, n_col::Int64, Alen::Int64, A::Ptr{Int64}, p::Ptr{Int64}, knobs::Ptr{Cdouble}, stats::Ptr{Int64}, cmember::Ptr{Int64})::Cint
-end
-
-function csymamd(n, A, p, perm, knobs, stats, allocate, release, cmember, stype)
-    @ccall libcolamd.csymamd(n::Cint, A::Ptr{Cint}, p::Ptr{Cint}, perm::Ptr{Cint}, knobs::Ptr{Cdouble}, stats::Ptr{Cint}, allocate::Ptr{Cvoid}, release::Ptr{Cvoid}, cmember::Ptr{Cint}, stype::Cint)::Cint
-end
-
-function csymamd_l(n, A, p, perm, knobs, stats, allocate, release, cmember, stype)
-    @ccall libcolamd.csymamd_l(n::Int64, A::Ptr{Int64}, p::Ptr{Int64}, perm::Ptr{Int64}, knobs::Ptr{Cdouble}, stats::Ptr{Int64}, allocate::Ptr{Cvoid}, release::Ptr{Cvoid}, cmember::Ptr{Int64}, stype::Int64)::Cint
-end
-
-function ccolamd_report(stats)
-    @ccall libcolamd.ccolamd_report(stats::Ptr{Cint})::Cvoid
-end
-
-function ccolamd_l_report(stats)
-    @ccall libcolamd.ccolamd_l_report(stats::Ptr{Int64})::Cvoid
-end
-
-function csymamd_report(stats)
-    @ccall libcolamd.csymamd_report(stats::Ptr{Cint})::Cvoid
-end
-
-function csymamd_l_report(stats)
-    @ccall libcolamd.csymamd_l_report(stats::Ptr{Int64})::Cvoid
-end
-
-function ccolamd2(n_row, n_col, Alen, A, p, knobs, stats, Front_npivcol, Front_nrows, Front_ncols, Front_parent, Front_cols, p_nfr, InFront, cmember)
-    @ccall libcolamd.ccolamd2(n_row::Cint, n_col::Cint, Alen::Cint, A::Ptr{Cint}, p::Ptr{Cint}, knobs::Ptr{Cdouble}, stats::Ptr{Cint}, Front_npivcol::Ptr{Cint}, Front_nrows::Ptr{Cint}, Front_ncols::Ptr{Cint}, Front_parent::Ptr{Cint}, Front_cols::Ptr{Cint}, p_nfr::Ptr{Cint}, InFront::Ptr{Cint}, cmember::Ptr{Cint})::Cint
-end
-
-function ccolamd2_l(n_row, n_col, Alen, A, p, knobs, stats, Front_npivcol, Front_nrows, Front_ncols, Front_parent, Front_cols, p_nfr, InFront, cmember)
-    @ccall libcolamd.ccolamd2_l(n_row::Int64, n_col::Int64, Alen::Int64, A::Ptr{Int64}, p::Ptr{Int64}, knobs::Ptr{Cdouble}, stats::Ptr{Int64}, Front_npivcol::Ptr{Int64}, Front_nrows::Ptr{Int64}, Front_ncols::Ptr{Int64}, Front_parent::Ptr{Int64}, Front_cols::Ptr{Int64}, p_nfr::Ptr{Int64}, InFront::Ptr{Int64}, cmember::Ptr{Int64})::Cint
-end
-
-function ccolamd_apply_order(Front, Order, Temp, nn, nfr)
-    @ccall libcolamd.ccolamd_apply_order(Front::Ptr{Cint}, Order::Ptr{Cint}, Temp::Ptr{Cint}, nn::Cint, nfr::Cint)::Cvoid
-end
-
-function ccolamd_l_apply_order(Front, Order, Temp, nn, nfr)
-    @ccall libcolamd.ccolamd_l_apply_order(Front::Ptr{Int64}, Order::Ptr{Int64}, Temp::Ptr{Int64}, nn::Int64, nfr::Int64)::Cvoid
-end
-
-function ccolamd_fsize(nn, MaxFsize, Fnrows, Fncols, Parent, Npiv)
-    @ccall libcolamd.ccolamd_fsize(nn::Cint, MaxFsize::Ptr{Cint}, Fnrows::Ptr{Cint}, Fncols::Ptr{Cint}, Parent::Ptr{Cint}, Npiv::Ptr{Cint})::Cvoid
-end
-
-function ccolamd_l_fsize(nn, MaxFsize, Fnrows, Fncols, Parent, Npiv)
-    @ccall libcolamd.ccolamd_l_fsize(nn::Int64, MaxFsize::Ptr{Int64}, Fnrows::Ptr{Int64}, Fncols::Ptr{Int64}, Parent::Ptr{Int64}, Npiv::Ptr{Int64})::Cvoid
-end
-
-function ccolamd_postorder(nn, Parent, Npiv, Fsize, Order, Child, Sibling, Stack, Front_cols, cmember)
-    @ccall libcolamd.ccolamd_postorder(nn::Cint, Parent::Ptr{Cint}, Npiv::Ptr{Cint}, Fsize::Ptr{Cint}, Order::Ptr{Cint}, Child::Ptr{Cint}, Sibling::Ptr{Cint}, Stack::Ptr{Cint}, Front_cols::Ptr{Cint}, cmember::Ptr{Cint})::Cvoid
-end
-
-function ccolamd_l_postorder(nn, Parent, Npiv, Fsize, Order, Child, Sibling, Stack, Front_cols, cmember)
-    @ccall libcolamd.ccolamd_l_postorder(nn::Int64, Parent::Ptr{Int64}, Npiv::Ptr{Int64}, Fsize::Ptr{Int64}, Order::Ptr{Int64}, Child::Ptr{Int64}, Sibling::Ptr{Int64}, Stack::Ptr{Int64}, Front_cols::Ptr{Int64}, cmember::Ptr{Int64})::Cvoid
-end
-
-function ccolamd_post_tree(root, k, Child, Sibling, Order, Stack)
-    @ccall libcolamd.ccolamd_post_tree(root::Cint, k::Cint, Child::Ptr{Cint}, Sibling::Ptr{Cint}, Order::Ptr{Cint}, Stack::Ptr{Cint})::Cint
-end
-
-function ccolamd_l_post_tree(root, k, Child, Sibling, Order, Stack)
-    @ccall libcolamd.ccolamd_l_post_tree(root::Int64, k::Int64, Child::Ptr{Int64}, Sibling::Ptr{Int64}, Order::Ptr{Int64}, Stack::Ptr{Int64})::Int64
-end
-
 function umfpack_di_symbolic(n_row, n_col, Ap, Ai, Ax, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_di_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                          Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                          Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                          Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_symbolic(n_row, n_col, Ap, Ai, Ax, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_dl_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                          Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                          Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                          Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_symbolic(n_row, n_col, Ap, Ai, Ax, Az, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_zi_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                          Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                          Az::Ptr{Cdouble}, Symbolic::Ptr{Ptr{Cvoid}},
+                                          Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_symbolic(n_row, n_col, Ap, Ai, Ax, Az, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_zl_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                          Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                          Az::Ptr{Cdouble}, Symbolic::Ptr{Ptr{Cvoid}},
+                                          Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_numeric(Ap, Ai, Ax, Symbolic, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_di_numeric(Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Symbolic::Ptr{Cvoid}, Numeric::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_numeric(Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                         Symbolic::Ptr{Cvoid}, Numeric::Ptr{Ptr{Cvoid}},
+                                         Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_numeric(Ap, Ai, Ax, Symbolic, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_dl_numeric(Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Symbolic::Ptr{Cvoid}, Numeric::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_numeric(Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                         Symbolic::Ptr{Cvoid}, Numeric::Ptr{Ptr{Cvoid}},
+                                         Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_numeric(Ap, Ai, Ax, Az, Symbolic, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_zi_numeric(Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Symbolic::Ptr{Cvoid}, Numeric::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_numeric(Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                         Az::Ptr{Cdouble}, Symbolic::Ptr{Cvoid},
+                                         Numeric::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                         Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_numeric(Ap, Ai, Ax, Az, Symbolic, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_zl_numeric(Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Symbolic::Ptr{Cvoid}, Numeric::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_numeric(Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                         Az::Ptr{Cdouble}, Symbolic::Ptr{Cvoid},
+                                         Numeric::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                         Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_solve(sys, Ap, Ai, Ax, X, B, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_di_solve(sys::Cint, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_solve(sys::Cint, Ap::Ptr{Int32}, Ai::Ptr{Int32},
+                                       Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble},
+                                       Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                       Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_solve(sys, Ap, Ai, Ax, X, B, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_dl_solve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_solve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64},
+                                       Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble},
+                                       Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                       Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_solve(sys, Ap, Ai, Ax, Az, Xx, Xz, Bx, Bz, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_zi_solve(sys::Cint, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_solve(sys::Cint, Ap::Ptr{Int32}, Ai::Ptr{Int32},
+                                       Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Xx::Ptr{Cdouble},
+                                       Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble},
+                                       Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                       Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_solve(sys, Ap, Ai, Ax, Az, Xx, Xz, Bx, Bz, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_zl_solve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_solve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64},
+                                       Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Xx::Ptr{Cdouble},
+                                       Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble},
+                                       Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                       Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_free_symbolic(Symbolic)
@@ -1840,51 +2346,119 @@ function umfpack_zl_defaults(Control)
 end
 
 function umfpack_di_qsymbolic(n_row, n_col, Ap, Ai, Ax, Qinit, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_di_qsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Qinit::Ptr{Int32}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_qsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                           Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                           Qinit::Ptr{Int32}, Symbolic::Ptr{Ptr{Cvoid}},
+                                           Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_qsymbolic(n_row, n_col, Ap, Ai, Ax, Qinit, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_dl_qsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Qinit::Ptr{Int64}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_qsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                           Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                           Qinit::Ptr{Int64}, Symbolic::Ptr{Ptr{Cvoid}},
+                                           Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_qsymbolic(n_row, n_col, Ap, Ai, Ax, Az, Qinit, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_zi_qsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Qinit::Ptr{Int32}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_qsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                           Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                           Az::Ptr{Cdouble}, Qinit::Ptr{Int32},
+                                           Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                           Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_qsymbolic(n_row, n_col, Ap, Ai, Ax, Az, Qinit, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_zl_qsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Qinit::Ptr{Int64}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_di_fsymbolic(n_row, n_col, Ap, Ai, Ax, user_ordering, user_params, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_di_fsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_dl_fsymbolic(n_row, n_col, Ap, Ai, Ax, user_ordering, user_params, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_dl_fsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_zi_fsymbolic(n_row, n_col, Ap, Ai, Ax, Az, user_ordering, user_params, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_zi_fsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_zl_fsymbolic(n_row, n_col, Ap, Ai, Ax, Az, user_ordering, user_params, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_zl_fsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_di_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Qinit, user_ordering, user_params, Symbolic, SW, Control, Info)
-    @ccall libumfpack.umfpack_di_paru_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Qinit::Ptr{Int32}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_dl_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Qinit, user_ordering, user_params, Symbolic, SW, Control, Info)
-    @ccall libumfpack.umfpack_dl_paru_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Qinit::Ptr{Int64}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_zi_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Az, Qinit, user_ordering, user_params, Symbolic, SW, Control, Info)
-    @ccall libumfpack.umfpack_zi_paru_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Qinit::Ptr{Int32}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_zl_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Az, Qinit, user_ordering, user_params, Symbolic, SW, Control, Info)
-    @ccall libumfpack.umfpack_zl_paru_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Qinit::Ptr{Int64}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_qsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                           Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                           Az::Ptr{Cdouble}, Qinit::Ptr{Int64},
+                                           Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                           Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_di_fsymbolic(n_row, n_col, Ap, Ai, Ax, user_ordering, user_params,
+                              Symbolic, Control, Info)
+    @ccall libumfpack.umfpack_di_fsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                           Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                           user_ordering::Ptr{Cvoid},
+                                           user_params::Ptr{Cvoid},
+                                           Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                           Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_dl_fsymbolic(n_row, n_col, Ap, Ai, Ax, user_ordering, user_params,
+                              Symbolic, Control, Info)
+    @ccall libumfpack.umfpack_dl_fsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                           Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                           user_ordering::Ptr{Cvoid},
+                                           user_params::Ptr{Cvoid},
+                                           Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                           Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_zi_fsymbolic(n_row, n_col, Ap, Ai, Ax, Az, user_ordering, user_params,
+                              Symbolic, Control, Info)
+    @ccall libumfpack.umfpack_zi_fsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                           Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                           Az::Ptr{Cdouble}, user_ordering::Ptr{Cvoid},
+                                           user_params::Ptr{Cvoid},
+                                           Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                           Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_zl_fsymbolic(n_row, n_col, Ap, Ai, Ax, Az, user_ordering, user_params,
+                              Symbolic, Control, Info)
+    @ccall libumfpack.umfpack_zl_fsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                           Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                           Az::Ptr{Cdouble}, user_ordering::Ptr{Cvoid},
+                                           user_params::Ptr{Cvoid},
+                                           Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                           Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_di_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Qinit, user_ordering,
+                                  user_params, Symbolic, SW, Control, Info)
+    @ccall libumfpack.umfpack_di_paru_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                               Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                               Qinit::Ptr{Int32}, user_ordering::Ptr{Cvoid},
+                                               user_params::Ptr{Cvoid},
+                                               Symbolic::Ptr{Ptr{Cvoid}},
+                                               SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                               Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_dl_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Qinit, user_ordering,
+                                  user_params, Symbolic, SW, Control, Info)
+    @ccall libumfpack.umfpack_dl_paru_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                               Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                               Qinit::Ptr{Int64}, user_ordering::Ptr{Cvoid},
+                                               user_params::Ptr{Cvoid},
+                                               Symbolic::Ptr{Ptr{Cvoid}},
+                                               SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                               Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_zi_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Az, Qinit, user_ordering,
+                                  user_params, Symbolic, SW, Control, Info)
+    @ccall libumfpack.umfpack_zi_paru_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                               Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                               Az::Ptr{Cdouble}, Qinit::Ptr{Int32},
+                                               user_ordering::Ptr{Cvoid},
+                                               user_params::Ptr{Cvoid},
+                                               Symbolic::Ptr{Ptr{Cvoid}},
+                                               SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                               Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_zl_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Az, Qinit, user_ordering,
+                                  user_params, Symbolic, SW, Control, Info)
+    @ccall libumfpack.umfpack_zl_paru_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                               Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                               Az::Ptr{Cdouble}, Qinit::Ptr{Int64},
+                                               user_ordering::Ptr{Cvoid},
+                                               user_params::Ptr{Cvoid},
+                                               Symbolic::Ptr{Ptr{Cvoid}},
+                                               SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                               Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_paru_free_sw(SW)
@@ -1904,339 +2478,547 @@ function umfpack_zl_paru_free_sw(SW)
 end
 
 function umfpack_di_wsolve(sys, Ap, Ai, Ax, X, B, Numeric, Control, Info, Wi, W)
-    @ccall libumfpack.umfpack_di_wsolve(sys::Cint, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble}, Wi::Ptr{Int32}, W::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_wsolve(sys::Cint, Ap::Ptr{Int32}, Ai::Ptr{Int32},
+                                        Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble},
+                                        Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                        Info::Ptr{Cdouble}, Wi::Ptr{Int32},
+                                        W::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_wsolve(sys, Ap, Ai, Ax, X, B, Numeric, Control, Info, Wi, W)
-    @ccall libumfpack.umfpack_dl_wsolve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble}, Wi::Ptr{Int64}, W::Ptr{Cdouble})::Cint
-end
-
-function umfpack_zi_wsolve(sys, Ap, Ai, Ax, Az, Xx, Xz, Bx, Bz, Numeric, Control, Info, Wi, W)
-    @ccall libumfpack.umfpack_zi_wsolve(sys::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble}, Wi::Ptr{Int32}, W::Ptr{Cdouble})::Cint
-end
-
-function umfpack_zl_wsolve(sys, Ap, Ai, Ax, Az, Xx, Xz, Bx, Bz, Numeric, Control, Info, Wi, W)
-    @ccall libumfpack.umfpack_zl_wsolve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble}, Wi::Ptr{Int64}, W::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_wsolve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64},
+                                        Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble},
+                                        Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                        Info::Ptr{Cdouble}, Wi::Ptr{Int64},
+                                        W::Ptr{Cdouble})::Cint
+end
+
+function umfpack_zi_wsolve(sys, Ap, Ai, Ax, Az, Xx, Xz, Bx, Bz, Numeric, Control, Info, Wi,
+                           W)
+    @ccall libumfpack.umfpack_zi_wsolve(sys::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32},
+                                        Ax::Ptr{Cdouble}, Az::Ptr{Cdouble},
+                                        Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble},
+                                        Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble},
+                                        Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                        Info::Ptr{Cdouble}, Wi::Ptr{Int32},
+                                        W::Ptr{Cdouble})::Cint
+end
+
+function umfpack_zl_wsolve(sys, Ap, Ai, Ax, Az, Xx, Xz, Bx, Bz, Numeric, Control, Info, Wi,
+                           W)
+    @ccall libumfpack.umfpack_zl_wsolve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64},
+                                        Ax::Ptr{Cdouble}, Az::Ptr{Cdouble},
+                                        Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble},
+                                        Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble},
+                                        Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                        Info::Ptr{Cdouble}, Wi::Ptr{Int64},
+                                        W::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_triplet_to_col(n_row, n_col, nz, Ti, Tj, Tx, Ap, Ai, Ax, Map)
-    @ccall libumfpack.umfpack_di_triplet_to_col(n_row::Int32, n_col::Int32, nz::Int32, Ti::Ptr{Int32}, Tj::Ptr{Int32}, Tx::Ptr{Cdouble}, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Map::Ptr{Int32})::Cint
+    @ccall libumfpack.umfpack_di_triplet_to_col(n_row::Int32, n_col::Int32, nz::Int32,
+                                                Ti::Ptr{Int32}, Tj::Ptr{Int32},
+                                                Tx::Ptr{Cdouble}, Ap::Ptr{Int32},
+                                                Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                                Map::Ptr{Int32})::Cint
 end
 
 function umfpack_dl_triplet_to_col(n_row, n_col, nz, Ti, Tj, Tx, Ap, Ai, Ax, Map)
-    @ccall libumfpack.umfpack_dl_triplet_to_col(n_row::Int64, n_col::Int64, nz::Int64, Ti::Ptr{Int64}, Tj::Ptr{Int64}, Tx::Ptr{Cdouble}, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Map::Ptr{Int64})::Cint
+    @ccall libumfpack.umfpack_dl_triplet_to_col(n_row::Int64, n_col::Int64, nz::Int64,
+                                                Ti::Ptr{Int64}, Tj::Ptr{Int64},
+                                                Tx::Ptr{Cdouble}, Ap::Ptr{Int64},
+                                                Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                                Map::Ptr{Int64})::Cint
 end
 
 function umfpack_zi_triplet_to_col(n_row, n_col, nz, Ti, Tj, Tx, Tz, Ap, Ai, Ax, Az, Map)
-    @ccall libumfpack.umfpack_zi_triplet_to_col(n_row::Int32, n_col::Int32, nz::Int32, Ti::Ptr{Int32}, Tj::Ptr{Int32}, Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble}, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Map::Ptr{Int32})::Cint
+    @ccall libumfpack.umfpack_zi_triplet_to_col(n_row::Int32, n_col::Int32, nz::Int32,
+                                                Ti::Ptr{Int32}, Tj::Ptr{Int32},
+                                                Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble},
+                                                Ap::Ptr{Int32}, Ai::Ptr{Int32},
+                                                Ax::Ptr{Cdouble}, Az::Ptr{Cdouble},
+                                                Map::Ptr{Int32})::Cint
 end
 
 function umfpack_zl_triplet_to_col(n_row, n_col, nz, Ti, Tj, Tx, Tz, Ap, Ai, Ax, Az, Map)
-    @ccall libumfpack.umfpack_zl_triplet_to_col(n_row::Int64, n_col::Int64, nz::Int64, Ti::Ptr{Int64}, Tj::Ptr{Int64}, Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble}, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Map::Ptr{Int64})::Cint
+    @ccall libumfpack.umfpack_zl_triplet_to_col(n_row::Int64, n_col::Int64, nz::Int64,
+                                                Ti::Ptr{Int64}, Tj::Ptr{Int64},
+                                                Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble},
+                                                Ap::Ptr{Int64}, Ai::Ptr{Int64},
+                                                Ax::Ptr{Cdouble}, Az::Ptr{Cdouble},
+                                                Map::Ptr{Int64})::Cint
 end
 
 function umfpack_di_col_to_triplet(n_col, Ap, Tj)
-    @ccall libumfpack.umfpack_di_col_to_triplet(n_col::Int32, Ap::Ptr{Int32}, Tj::Ptr{Int32})::Cint
+    @ccall libumfpack.umfpack_di_col_to_triplet(n_col::Int32, Ap::Ptr{Int32},
+                                                Tj::Ptr{Int32})::Cint
 end
 
 function umfpack_dl_col_to_triplet(n_col, Ap, Tj)
-    @ccall libumfpack.umfpack_dl_col_to_triplet(n_col::Int64, Ap::Ptr{Int64}, Tj::Ptr{Int64})::Cint
+    @ccall libumfpack.umfpack_dl_col_to_triplet(n_col::Int64, Ap::Ptr{Int64},
+                                                Tj::Ptr{Int64})::Cint
 end
 
 function umfpack_zi_col_to_triplet(n_col, Ap, Tj)
-    @ccall libumfpack.umfpack_zi_col_to_triplet(n_col::Int32, Ap::Ptr{Int32}, Tj::Ptr{Int32})::Cint
+    @ccall libumfpack.umfpack_zi_col_to_triplet(n_col::Int32, Ap::Ptr{Int32},
+                                                Tj::Ptr{Int32})::Cint
 end
 
 function umfpack_zl_col_to_triplet(n_col, Ap, Tj)
-    @ccall libumfpack.umfpack_zl_col_to_triplet(n_col::Int64, Ap::Ptr{Int64}, Tj::Ptr{Int64})::Cint
+    @ccall libumfpack.umfpack_zl_col_to_triplet(n_col::Int64, Ap::Ptr{Int64},
+                                                Tj::Ptr{Int64})::Cint
 end
 
 function umfpack_di_transpose(n_row, n_col, Ap, Ai, Ax, P, Q, Rp, Ri, Rx)
-    @ccall libumfpack.umfpack_di_transpose(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, P::Ptr{Int32}, Q::Ptr{Int32}, Rp::Ptr{Int32}, Ri::Ptr{Int32}, Rx::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_transpose(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                           Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, P::Ptr{Int32},
+                                           Q::Ptr{Int32}, Rp::Ptr{Int32}, Ri::Ptr{Int32},
+                                           Rx::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_transpose(n_row, n_col, Ap, Ai, Ax, P, Q, Rp, Ri, Rx)
-    @ccall libumfpack.umfpack_dl_transpose(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, P::Ptr{Int64}, Q::Ptr{Int64}, Rp::Ptr{Int64}, Ri::Ptr{Int64}, Rx::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_transpose(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                           Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, P::Ptr{Int64},
+                                           Q::Ptr{Int64}, Rp::Ptr{Int64}, Ri::Ptr{Int64},
+                                           Rx::Ptr{Cdouble})::Cint
 end
 
-function umfpack_zi_transpose(n_row, n_col, Ap, Ai, Ax, Az, P, Q, Rp, Ri, Rx, Rz, do_conjugate)
-    @ccall libumfpack.umfpack_zi_transpose(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, P::Ptr{Int32}, Q::Ptr{Int32}, Rp::Ptr{Int32}, Ri::Ptr{Int32}, Rx::Ptr{Cdouble}, Rz::Ptr{Cdouble}, do_conjugate::Cint)::Cint
+function umfpack_zi_transpose(n_row, n_col, Ap, Ai, Ax, Az, P, Q, Rp, Ri, Rx, Rz,
+                              do_conjugate)
+    @ccall libumfpack.umfpack_zi_transpose(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                           Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                           Az::Ptr{Cdouble}, P::Ptr{Int32}, Q::Ptr{Int32},
+                                           Rp::Ptr{Int32}, Ri::Ptr{Int32}, Rx::Ptr{Cdouble},
+                                           Rz::Ptr{Cdouble}, do_conjugate::Cint)::Cint
 end
 
-function umfpack_zl_transpose(n_row, n_col, Ap, Ai, Ax, Az, P, Q, Rp, Ri, Rx, Rz, do_conjugate)
-    @ccall libumfpack.umfpack_zl_transpose(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, P::Ptr{Int64}, Q::Ptr{Int64}, Rp::Ptr{Int64}, Ri::Ptr{Int64}, Rx::Ptr{Cdouble}, Rz::Ptr{Cdouble}, do_conjugate::Cint)::Cint
+function umfpack_zl_transpose(n_row, n_col, Ap, Ai, Ax, Az, P, Q, Rp, Ri, Rx, Rz,
+                              do_conjugate)
+    @ccall libumfpack.umfpack_zl_transpose(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                           Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                           Az::Ptr{Cdouble}, P::Ptr{Int64}, Q::Ptr{Int64},
+                                           Rp::Ptr{Int64}, Ri::Ptr{Int64}, Rx::Ptr{Cdouble},
+                                           Rz::Ptr{Cdouble}, do_conjugate::Cint)::Cint
 end
 
 function umfpack_di_scale(X, B, Numeric)
-    @ccall libumfpack.umfpack_di_scale(X::Ptr{Cdouble}, B::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_scale(X::Ptr{Cdouble}, B::Ptr{Cdouble},
+                                       Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_scale(X, B, Numeric)
-    @ccall libumfpack.umfpack_dl_scale(X::Ptr{Cdouble}, B::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_scale(X::Ptr{Cdouble}, B::Ptr{Cdouble},
+                                       Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_scale(Xx, Xz, Bx, Bz, Numeric)
-    @ccall libumfpack.umfpack_zi_scale(Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_scale(Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble},
+                                       Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_scale(Xx, Xz, Bx, Bz, Numeric)
-    @ccall libumfpack.umfpack_zl_scale(Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_scale(Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble},
+                                       Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_get_lunz(lnz, unz, n_row, n_col, nz_udiag, Numeric)
-    @ccall libumfpack.umfpack_di_get_lunz(lnz::Ptr{Int32}, unz::Ptr{Int32}, n_row::Ptr{Int32}, n_col::Ptr{Int32}, nz_udiag::Ptr{Int32}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_get_lunz(lnz::Ptr{Int32}, unz::Ptr{Int32},
+                                          n_row::Ptr{Int32}, n_col::Ptr{Int32},
+                                          nz_udiag::Ptr{Int32}, Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_get_lunz(lnz, unz, n_row, n_col, nz_udiag, Numeric)
-    @ccall libumfpack.umfpack_dl_get_lunz(lnz::Ptr{Int64}, unz::Ptr{Int64}, n_row::Ptr{Int64}, n_col::Ptr{Int64}, nz_udiag::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_get_lunz(lnz::Ptr{Int64}, unz::Ptr{Int64},
+                                          n_row::Ptr{Int64}, n_col::Ptr{Int64},
+                                          nz_udiag::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_get_lunz(lnz, unz, n_row, n_col, nz_udiag, Numeric)
-    @ccall libumfpack.umfpack_zi_get_lunz(lnz::Ptr{Int32}, unz::Ptr{Int32}, n_row::Ptr{Int32}, n_col::Ptr{Int32}, nz_udiag::Ptr{Int32}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_get_lunz(lnz::Ptr{Int32}, unz::Ptr{Int32},
+                                          n_row::Ptr{Int32}, n_col::Ptr{Int32},
+                                          nz_udiag::Ptr{Int32}, Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_get_lunz(lnz, unz, n_row, n_col, nz_udiag, Numeric)
-    @ccall libumfpack.umfpack_zl_get_lunz(lnz::Ptr{Int64}, unz::Ptr{Int64}, n_row::Ptr{Int64}, n_col::Ptr{Int64}, nz_udiag::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_get_lunz(lnz::Ptr{Int64}, unz::Ptr{Int64},
+                                          n_row::Ptr{Int64}, n_col::Ptr{Int64},
+                                          nz_udiag::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_get_numeric(Lp, Lj, Lx, Up, Ui, Ux, P, Q, Dx, do_recip, Rs, Numeric)
-    @ccall libumfpack.umfpack_di_get_numeric(Lp::Ptr{Int32}, Lj::Ptr{Int32}, Lx::Ptr{Cdouble}, Up::Ptr{Int32}, Ui::Ptr{Int32}, Ux::Ptr{Cdouble}, P::Ptr{Int32}, Q::Ptr{Int32}, Dx::Ptr{Cdouble}, do_recip::Ptr{Int32}, Rs::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_get_numeric(Lp::Ptr{Int32}, Lj::Ptr{Int32},
+                                             Lx::Ptr{Cdouble}, Up::Ptr{Int32},
+                                             Ui::Ptr{Int32}, Ux::Ptr{Cdouble},
+                                             P::Ptr{Int32}, Q::Ptr{Int32}, Dx::Ptr{Cdouble},
+                                             do_recip::Ptr{Int32}, Rs::Ptr{Cdouble},
+                                             Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_get_numeric(Lp, Lj, Lx, Up, Ui, Ux, P, Q, Dx, do_recip, Rs, Numeric)
-    @ccall libumfpack.umfpack_dl_get_numeric(Lp::Ptr{Int64}, Lj::Ptr{Int64}, Lx::Ptr{Cdouble}, Up::Ptr{Int64}, Ui::Ptr{Int64}, Ux::Ptr{Cdouble}, P::Ptr{Int64}, Q::Ptr{Int64}, Dx::Ptr{Cdouble}, do_recip::Ptr{Int64}, Rs::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
-end
-
-function umfpack_zi_get_numeric(Lp, Lj, Lx, Lz, Up, Ui, Ux, Uz, P, Q, Dx, Dz, do_recip, Rs, Numeric)
-    @ccall libumfpack.umfpack_zi_get_numeric(Lp::Ptr{Int32}, Lj::Ptr{Int32}, Lx::Ptr{Cdouble}, Lz::Ptr{Cdouble}, Up::Ptr{Int32}, Ui::Ptr{Int32}, Ux::Ptr{Cdouble}, Uz::Ptr{Cdouble}, P::Ptr{Int32}, Q::Ptr{Int32}, Dx::Ptr{Cdouble}, Dz::Ptr{Cdouble}, do_recip::Ptr{Int32}, Rs::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
-end
-
-function umfpack_zl_get_numeric(Lp, Lj, Lx, Lz, Up, Ui, Ux, Uz, P, Q, Dx, Dz, do_recip, Rs, Numeric)
-    @ccall libumfpack.umfpack_zl_get_numeric(Lp::Ptr{Int64}, Lj::Ptr{Int64}, Lx::Ptr{Cdouble}, Lz::Ptr{Cdouble}, Up::Ptr{Int64}, Ui::Ptr{Int64}, Ux::Ptr{Cdouble}, Uz::Ptr{Cdouble}, P::Ptr{Int64}, Q::Ptr{Int64}, Dx::Ptr{Cdouble}, Dz::Ptr{Cdouble}, do_recip::Ptr{Int64}, Rs::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
-end
-
-function umfpack_di_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol, Front_parent, Front_1strow, Front_leftmostdesc, Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
-    @ccall libumfpack.umfpack_di_get_symbolic(n_row::Ptr{Int32}, n_col::Ptr{Int32}, n1::Ptr{Int32}, nz::Ptr{Int32}, nfr::Ptr{Int32}, nchains::Ptr{Int32}, P::Ptr{Int32}, Q::Ptr{Int32}, Front_npivcol::Ptr{Int32}, Front_parent::Ptr{Int32}, Front_1strow::Ptr{Int32}, Front_leftmostdesc::Ptr{Int32}, Chain_start::Ptr{Int32}, Chain_maxrows::Ptr{Int32}, Chain_maxcols::Ptr{Int32}, Dmap::Ptr{Int32}, Symbolic::Ptr{Cvoid})::Cint
-end
-
-function umfpack_dl_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol, Front_parent, Front_1strow, Front_leftmostdesc, Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
-    @ccall libumfpack.umfpack_dl_get_symbolic(n_row::Ptr{Int64}, n_col::Ptr{Int64}, n1::Ptr{Int64}, nz::Ptr{Int64}, nfr::Ptr{Int64}, nchains::Ptr{Int64}, P::Ptr{Int64}, Q::Ptr{Int64}, Front_npivcol::Ptr{Int64}, Front_parent::Ptr{Int64}, Front_1strow::Ptr{Int64}, Front_leftmostdesc::Ptr{Int64}, Chain_start::Ptr{Int64}, Chain_maxrows::Ptr{Int64}, Chain_maxcols::Ptr{Int64}, Dmap::Ptr{Int64}, Symbolic::Ptr{Cvoid})::Cint
-end
-
-function umfpack_zi_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol, Front_parent, Front_1strow, Front_leftmostdesc, Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
-    @ccall libumfpack.umfpack_zi_get_symbolic(n_row::Ptr{Int32}, n_col::Ptr{Int32}, n1::Ptr{Int32}, nz::Ptr{Int32}, nfr::Ptr{Int32}, nchains::Ptr{Int32}, P::Ptr{Int32}, Q::Ptr{Int32}, Front_npivcol::Ptr{Int32}, Front_parent::Ptr{Int32}, Front_1strow::Ptr{Int32}, Front_leftmostdesc::Ptr{Int32}, Chain_start::Ptr{Int32}, Chain_maxrows::Ptr{Int32}, Chain_maxcols::Ptr{Int32}, Dmap::Ptr{Int32}, Symbolic::Ptr{Cvoid})::Cint
-end
-
-function umfpack_zl_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol, Front_parent, Front_1strow, Front_leftmostdesc, Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
-    @ccall libumfpack.umfpack_zl_get_symbolic(n_row::Ptr{Int64}, n_col::Ptr{Int64}, n1::Ptr{Int64}, nz::Ptr{Int64}, nfr::Ptr{Int64}, nchains::Ptr{Int64}, P::Ptr{Int64}, Q::Ptr{Int64}, Front_npivcol::Ptr{Int64}, Front_parent::Ptr{Int64}, Front_1strow::Ptr{Int64}, Front_leftmostdesc::Ptr{Int64}, Chain_start::Ptr{Int64}, Chain_maxrows::Ptr{Int64}, Chain_maxcols::Ptr{Int64}, Dmap::Ptr{Int64}, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_get_numeric(Lp::Ptr{Int64}, Lj::Ptr{Int64},
+                                             Lx::Ptr{Cdouble}, Up::Ptr{Int64},
+                                             Ui::Ptr{Int64}, Ux::Ptr{Cdouble},
+                                             P::Ptr{Int64}, Q::Ptr{Int64}, Dx::Ptr{Cdouble},
+                                             do_recip::Ptr{Int64}, Rs::Ptr{Cdouble},
+                                             Numeric::Ptr{Cvoid})::Cint
+end
+
+function umfpack_zi_get_numeric(Lp, Lj, Lx, Lz, Up, Ui, Ux, Uz, P, Q, Dx, Dz, do_recip, Rs,
+                                Numeric)
+    @ccall libumfpack.umfpack_zi_get_numeric(Lp::Ptr{Int32}, Lj::Ptr{Int32},
+                                             Lx::Ptr{Cdouble}, Lz::Ptr{Cdouble},
+                                             Up::Ptr{Int32}, Ui::Ptr{Int32},
+                                             Ux::Ptr{Cdouble}, Uz::Ptr{Cdouble},
+                                             P::Ptr{Int32}, Q::Ptr{Int32}, Dx::Ptr{Cdouble},
+                                             Dz::Ptr{Cdouble}, do_recip::Ptr{Int32},
+                                             Rs::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+end
+
+function umfpack_zl_get_numeric(Lp, Lj, Lx, Lz, Up, Ui, Ux, Uz, P, Q, Dx, Dz, do_recip, Rs,
+                                Numeric)
+    @ccall libumfpack.umfpack_zl_get_numeric(Lp::Ptr{Int64}, Lj::Ptr{Int64},
+                                             Lx::Ptr{Cdouble}, Lz::Ptr{Cdouble},
+                                             Up::Ptr{Int64}, Ui::Ptr{Int64},
+                                             Ux::Ptr{Cdouble}, Uz::Ptr{Cdouble},
+                                             P::Ptr{Int64}, Q::Ptr{Int64}, Dx::Ptr{Cdouble},
+                                             Dz::Ptr{Cdouble}, do_recip::Ptr{Int64},
+                                             Rs::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+end
+
+function umfpack_di_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol,
+                                 Front_parent, Front_1strow, Front_leftmostdesc,
+                                 Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
+    @ccall libumfpack.umfpack_di_get_symbolic(n_row::Ptr{Int32}, n_col::Ptr{Int32},
+                                              n1::Ptr{Int32}, nz::Ptr{Int32},
+                                              nfr::Ptr{Int32}, nchains::Ptr{Int32},
+                                              P::Ptr{Int32}, Q::Ptr{Int32},
+                                              Front_npivcol::Ptr{Int32},
+                                              Front_parent::Ptr{Int32},
+                                              Front_1strow::Ptr{Int32},
+                                              Front_leftmostdesc::Ptr{Int32},
+                                              Chain_start::Ptr{Int32},
+                                              Chain_maxrows::Ptr{Int32},
+                                              Chain_maxcols::Ptr{Int32}, Dmap::Ptr{Int32},
+                                              Symbolic::Ptr{Cvoid})::Cint
+end
+
+function umfpack_dl_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol,
+                                 Front_parent, Front_1strow, Front_leftmostdesc,
+                                 Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
+    @ccall libumfpack.umfpack_dl_get_symbolic(n_row::Ptr{Int64}, n_col::Ptr{Int64},
+                                              n1::Ptr{Int64}, nz::Ptr{Int64},
+                                              nfr::Ptr{Int64}, nchains::Ptr{Int64},
+                                              P::Ptr{Int64}, Q::Ptr{Int64},
+                                              Front_npivcol::Ptr{Int64},
+                                              Front_parent::Ptr{Int64},
+                                              Front_1strow::Ptr{Int64},
+                                              Front_leftmostdesc::Ptr{Int64},
+                                              Chain_start::Ptr{Int64},
+                                              Chain_maxrows::Ptr{Int64},
+                                              Chain_maxcols::Ptr{Int64}, Dmap::Ptr{Int64},
+                                              Symbolic::Ptr{Cvoid})::Cint
+end
+
+function umfpack_zi_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol,
+                                 Front_parent, Front_1strow, Front_leftmostdesc,
+                                 Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
+    @ccall libumfpack.umfpack_zi_get_symbolic(n_row::Ptr{Int32}, n_col::Ptr{Int32},
+                                              n1::Ptr{Int32}, nz::Ptr{Int32},
+                                              nfr::Ptr{Int32}, nchains::Ptr{Int32},
+                                              P::Ptr{Int32}, Q::Ptr{Int32},
+                                              Front_npivcol::Ptr{Int32},
+                                              Front_parent::Ptr{Int32},
+                                              Front_1strow::Ptr{Int32},
+                                              Front_leftmostdesc::Ptr{Int32},
+                                              Chain_start::Ptr{Int32},
+                                              Chain_maxrows::Ptr{Int32},
+                                              Chain_maxcols::Ptr{Int32}, Dmap::Ptr{Int32},
+                                              Symbolic::Ptr{Cvoid})::Cint
+end
+
+function umfpack_zl_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol,
+                                 Front_parent, Front_1strow, Front_leftmostdesc,
+                                 Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
+    @ccall libumfpack.umfpack_zl_get_symbolic(n_row::Ptr{Int64}, n_col::Ptr{Int64},
+                                              n1::Ptr{Int64}, nz::Ptr{Int64},
+                                              nfr::Ptr{Int64}, nchains::Ptr{Int64},
+                                              P::Ptr{Int64}, Q::Ptr{Int64},
+                                              Front_npivcol::Ptr{Int64},
+                                              Front_parent::Ptr{Int64},
+                                              Front_1strow::Ptr{Int64},
+                                              Front_leftmostdesc::Ptr{Int64},
+                                              Chain_start::Ptr{Int64},
+                                              Chain_maxrows::Ptr{Int64},
+                                              Chain_maxcols::Ptr{Int64}, Dmap::Ptr{Int64},
+                                              Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_save_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_di_save_numeric(Numeric::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_di_save_numeric(Numeric::Ptr{Cvoid},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_dl_save_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_dl_save_numeric(Numeric::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_dl_save_numeric(Numeric::Ptr{Cvoid},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zi_save_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_zi_save_numeric(Numeric::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zi_save_numeric(Numeric::Ptr{Cvoid},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zl_save_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_zl_save_numeric(Numeric::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zl_save_numeric(Numeric::Ptr{Cvoid},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_di_load_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_di_load_numeric(Numeric::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_di_load_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_dl_load_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_dl_load_numeric(Numeric::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_dl_load_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zi_load_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_zi_load_numeric(Numeric::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zi_load_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zl_load_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_zl_load_numeric(Numeric::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zl_load_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_di_copy_numeric(Numeric, Original)
-    @ccall libumfpack.umfpack_di_copy_numeric(Numeric::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_copy_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_copy_numeric(Numeric, Original)
-    @ccall libumfpack.umfpack_dl_copy_numeric(Numeric::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_copy_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_copy_numeric(Numeric, Original)
-    @ccall libumfpack.umfpack_zi_copy_numeric(Numeric::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_copy_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_copy_numeric(Numeric, Original)
-    @ccall libumfpack.umfpack_zl_copy_numeric(Numeric::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_copy_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_serialize_numeric_size(blobsize, Numeric)
-    @ccall libumfpack.umfpack_di_serialize_numeric_size(blobsize::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_serialize_numeric_size(blobsize::Ptr{Int64},
+                                                        Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_serialize_numeric_size(blobsize, Numeric)
-    @ccall libumfpack.umfpack_dl_serialize_numeric_size(blobsize::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_serialize_numeric_size(blobsize::Ptr{Int64},
+                                                        Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_serialize_numeric_size(blobsize, Numeric)
-    @ccall libumfpack.umfpack_zi_serialize_numeric_size(blobsize::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_serialize_numeric_size(blobsize::Ptr{Int64},
+                                                        Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_serialize_numeric_size(blobsize, Numeric)
-    @ccall libumfpack.umfpack_zl_serialize_numeric_size(blobsize::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_serialize_numeric_size(blobsize::Ptr{Int64},
+                                                        Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_serialize_numeric(blob, blobsize, Numeric)
-    @ccall libumfpack.umfpack_di_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64,
+                                                   Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_serialize_numeric(blob, blobsize, Numeric)
-    @ccall libumfpack.umfpack_dl_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64,
+                                                   Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_serialize_numeric(blob, blobsize, Numeric)
-    @ccall libumfpack.umfpack_zi_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64,
+                                                   Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_serialize_numeric(blob, blobsize, Numeric)
-    @ccall libumfpack.umfpack_zl_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64,
+                                                   Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_deserialize_numeric(Numeric, blob, blobsize)
-    @ccall libumfpack.umfpack_di_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_di_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                                     blob::Ptr{Int8}, blobsize::Int64)::Cint
 end
 
 function umfpack_dl_deserialize_numeric(Numeric, blob, blobsize)
-    @ccall libumfpack.umfpack_dl_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_dl_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                                     blob::Ptr{Int8}, blobsize::Int64)::Cint
 end
 
 function umfpack_zi_deserialize_numeric(Numeric, blob, blobsize)
-    @ccall libumfpack.umfpack_zi_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_zi_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                                     blob::Ptr{Int8}, blobsize::Int64)::Cint
 end
 
 function umfpack_zl_deserialize_numeric(Numeric, blob, blobsize)
-    @ccall libumfpack.umfpack_zl_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_zl_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                                     blob::Ptr{Int8}, blobsize::Int64)::Cint
 end
 
 function umfpack_di_save_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_di_save_symbolic(Symbolic::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_di_save_symbolic(Symbolic::Ptr{Cvoid},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_dl_save_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_dl_save_symbolic(Symbolic::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_dl_save_symbolic(Symbolic::Ptr{Cvoid},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zi_save_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_zi_save_symbolic(Symbolic::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zi_save_symbolic(Symbolic::Ptr{Cvoid},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zl_save_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_zl_save_symbolic(Symbolic::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zl_save_symbolic(Symbolic::Ptr{Cvoid},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_di_load_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_di_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_di_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_dl_load_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_dl_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_dl_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zi_load_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_zi_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zi_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zl_load_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_zl_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zl_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_di_copy_symbolic(Symbolic, Original)
-    @ccall libumfpack.umfpack_di_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_copy_symbolic(Symbolic, Original)
-    @ccall libumfpack.umfpack_dl_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_copy_symbolic(Symbolic, Original)
-    @ccall libumfpack.umfpack_zi_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_copy_symbolic(Symbolic, Original)
-    @ccall libumfpack.umfpack_zl_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_serialize_symbolic_size(blobsize, Symbolic)
-    @ccall libumfpack.umfpack_di_serialize_symbolic_size(blobsize::Ptr{Int64}, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_serialize_symbolic_size(blobsize::Ptr{Int64},
+                                                         Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_serialize_symbolic_size(blobsize, Symbolic)
-    @ccall libumfpack.umfpack_dl_serialize_symbolic_size(blobsize::Ptr{Int64}, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_serialize_symbolic_size(blobsize::Ptr{Int64},
+                                                         Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_serialize_symbolic_size(blobsize, Symbolic)
-    @ccall libumfpack.umfpack_zi_serialize_symbolic_size(blobsize::Ptr{Int64}, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_serialize_symbolic_size(blobsize::Ptr{Int64},
+                                                         Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_serialize_symbolic_size(blobsize, Symbolic)
-    @ccall libumfpack.umfpack_zl_serialize_symbolic_size(blobsize::Ptr{Int64}, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_serialize_symbolic_size(blobsize::Ptr{Int64},
+                                                         Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_serialize_symbolic(blob, blobsize, Symbolic)
-    @ccall libumfpack.umfpack_di_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64,
+                                                    Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_serialize_symbolic(blob, blobsize, Symbolic)
-    @ccall libumfpack.umfpack_dl_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64,
+                                                    Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_serialize_symbolic(blob, blobsize, Symbolic)
-    @ccall libumfpack.umfpack_zi_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64,
+                                                    Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_serialize_symbolic(blob, blobsize, Symbolic)
-    @ccall libumfpack.umfpack_zl_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64,
+                                                    Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_deserialize_symbolic(Symbolic, blob, blobsize)
-    @ccall libumfpack.umfpack_di_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_di_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                                      blob::Ptr{Int8},
+                                                      blobsize::Int64)::Cint
 end
 
 function umfpack_dl_deserialize_symbolic(Symbolic, blob, blobsize)
-    @ccall libumfpack.umfpack_dl_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_dl_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                                      blob::Ptr{Int8},
+                                                      blobsize::Int64)::Cint
 end
 
 function umfpack_zi_deserialize_symbolic(Symbolic, blob, blobsize)
-    @ccall libumfpack.umfpack_zi_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_zi_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                                      blob::Ptr{Int8},
+                                                      blobsize::Int64)::Cint
 end
 
 function umfpack_zl_deserialize_symbolic(Symbolic, blob, blobsize)
-    @ccall libumfpack.umfpack_zl_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_zl_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                                      blob::Ptr{Int8},
+                                                      blobsize::Int64)::Cint
 end
 
 function umfpack_di_get_determinant(Mx, Ex, Numeric, User_Info)
-    @ccall libumfpack.umfpack_di_get_determinant(Mx::Ptr{Cdouble}, Ex::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, User_Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_get_determinant(Mx::Ptr{Cdouble}, Ex::Ptr{Cdouble},
+                                                 Numeric::Ptr{Cvoid},
+                                                 User_Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_get_determinant(Mx, Ex, Numeric, User_Info)
-    @ccall libumfpack.umfpack_dl_get_determinant(Mx::Ptr{Cdouble}, Ex::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, User_Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_get_determinant(Mx::Ptr{Cdouble}, Ex::Ptr{Cdouble},
+                                                 Numeric::Ptr{Cvoid},
+                                                 User_Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_get_determinant(Mx, Mz, Ex, Numeric, User_Info)
-    @ccall libumfpack.umfpack_zi_get_determinant(Mx::Ptr{Cdouble}, Mz::Ptr{Cdouble}, Ex::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, User_Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_get_determinant(Mx::Ptr{Cdouble}, Mz::Ptr{Cdouble},
+                                                 Ex::Ptr{Cdouble}, Numeric::Ptr{Cvoid},
+                                                 User_Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_get_determinant(Mx, Mz, Ex, Numeric, User_Info)
-    @ccall libumfpack.umfpack_zl_get_determinant(Mx::Ptr{Cdouble}, Mz::Ptr{Cdouble}, Ex::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, User_Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_get_determinant(Mx::Ptr{Cdouble}, Mz::Ptr{Cdouble},
+                                                 Ex::Ptr{Cdouble}, Numeric::Ptr{Cvoid},
+                                                 User_Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_report_status(Control, status)
@@ -2256,19 +3038,23 @@ function umfpack_zl_report_status(Control, status)
 end
 
 function umfpack_di_report_info(Control, Info)
-    @ccall libumfpack.umfpack_di_report_info(Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cvoid
+    @ccall libumfpack.umfpack_di_report_info(Control::Ptr{Cdouble},
+                                             Info::Ptr{Cdouble})::Cvoid
 end
 
 function umfpack_dl_report_info(Control, Info)
-    @ccall libumfpack.umfpack_dl_report_info(Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cvoid
+    @ccall libumfpack.umfpack_dl_report_info(Control::Ptr{Cdouble},
+                                             Info::Ptr{Cdouble})::Cvoid
 end
 
 function umfpack_zi_report_info(Control, Info)
-    @ccall libumfpack.umfpack_zi_report_info(Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cvoid
+    @ccall libumfpack.umfpack_zi_report_info(Control::Ptr{Cdouble},
+                                             Info::Ptr{Cdouble})::Cvoid
 end
 
 function umfpack_zl_report_info(Control, Info)
-    @ccall libumfpack.umfpack_zl_report_info(Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cvoid
+    @ccall libumfpack.umfpack_zl_report_info(Control::Ptr{Cdouble},
+                                             Info::Ptr{Cdouble})::Cvoid
 end
 
 function umfpack_di_report_control(Control)
@@ -2288,99 +3074,137 @@ function umfpack_zl_report_control(Control)
 end
 
 function umfpack_di_report_matrix(n_row, n_col, Ap, Ai, Ax, col_form, Control)
-    @ccall libumfpack.umfpack_di_report_matrix(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, col_form::Cint, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_report_matrix(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                               Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                               col_form::Cint, Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_report_matrix(n_row, n_col, Ap, Ai, Ax, col_form, Control)
-    @ccall libumfpack.umfpack_dl_report_matrix(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, col_form::Cint, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_report_matrix(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                               Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                               col_form::Cint, Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_report_matrix(n_row, n_col, Ap, Ai, Ax, Az, col_form, Control)
-    @ccall libumfpack.umfpack_zi_report_matrix(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, col_form::Cint, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_report_matrix(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                               Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                               Az::Ptr{Cdouble}, col_form::Cint,
+                                               Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_report_matrix(n_row, n_col, Ap, Ai, Ax, Az, col_form, Control)
-    @ccall libumfpack.umfpack_zl_report_matrix(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, col_form::Cint, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_report_matrix(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                               Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                               Az::Ptr{Cdouble}, col_form::Cint,
+                                               Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_report_triplet(n_row, n_col, nz, Ti, Tj, Tx, Control)
-    @ccall libumfpack.umfpack_di_report_triplet(n_row::Int32, n_col::Int32, nz::Int32, Ti::Ptr{Int32}, Tj::Ptr{Int32}, Tx::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_report_triplet(n_row::Int32, n_col::Int32, nz::Int32,
+                                                Ti::Ptr{Int32}, Tj::Ptr{Int32},
+                                                Tx::Ptr{Cdouble},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_report_triplet(n_row, n_col, nz, Ti, Tj, Tx, Control)
-    @ccall libumfpack.umfpack_dl_report_triplet(n_row::Int64, n_col::Int64, nz::Int64, Ti::Ptr{Int64}, Tj::Ptr{Int64}, Tx::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_report_triplet(n_row::Int64, n_col::Int64, nz::Int64,
+                                                Ti::Ptr{Int64}, Tj::Ptr{Int64},
+                                                Tx::Ptr{Cdouble},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_report_triplet(n_row, n_col, nz, Ti, Tj, Tx, Tz, Control)
-    @ccall libumfpack.umfpack_zi_report_triplet(n_row::Int32, n_col::Int32, nz::Int32, Ti::Ptr{Int32}, Tj::Ptr{Int32}, Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_report_triplet(n_row::Int32, n_col::Int32, nz::Int32,
+                                                Ti::Ptr{Int32}, Tj::Ptr{Int32},
+                                                Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_report_triplet(n_row, n_col, nz, Ti, Tj, Tx, Tz, Control)
-    @ccall libumfpack.umfpack_zl_report_triplet(n_row::Int64, n_col::Int64, nz::Int64, Ti::Ptr{Int64}, Tj::Ptr{Int64}, Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_report_triplet(n_row::Int64, n_col::Int64, nz::Int64,
+                                                Ti::Ptr{Int64}, Tj::Ptr{Int64},
+                                                Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_report_vector(n, X, Control)
-    @ccall libumfpack.umfpack_di_report_vector(n::Int32, X::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_report_vector(n::Int32, X::Ptr{Cdouble},
+                                               Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_report_vector(n, X, Control)
-    @ccall libumfpack.umfpack_dl_report_vector(n::Int64, X::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_report_vector(n::Int64, X::Ptr{Cdouble},
+                                               Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_report_vector(n, Xx, Xz, Control)
-    @ccall libumfpack.umfpack_zi_report_vector(n::Int32, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_report_vector(n::Int32, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble},
+                                               Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_report_vector(n, Xx, Xz, Control)
-    @ccall libumfpack.umfpack_zl_report_vector(n::Int64, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_report_vector(n::Int64, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble},
+                                               Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_report_symbolic(Symbolic, Control)
-    @ccall libumfpack.umfpack_di_report_symbolic(Symbolic::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_report_symbolic(Symbolic::Ptr{Cvoid},
+                                                 Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_report_symbolic(Symbolic, Control)
-    @ccall libumfpack.umfpack_dl_report_symbolic(Symbolic::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_report_symbolic(Symbolic::Ptr{Cvoid},
+                                                 Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_report_symbolic(Symbolic, Control)
-    @ccall libumfpack.umfpack_zi_report_symbolic(Symbolic::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_report_symbolic(Symbolic::Ptr{Cvoid},
+                                                 Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_report_symbolic(Symbolic, Control)
-    @ccall libumfpack.umfpack_zl_report_symbolic(Symbolic::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_report_symbolic(Symbolic::Ptr{Cvoid},
+                                                 Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_report_numeric(Numeric, Control)
-    @ccall libumfpack.umfpack_di_report_numeric(Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_report_numeric(Numeric::Ptr{Cvoid},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_report_numeric(Numeric, Control)
-    @ccall libumfpack.umfpack_dl_report_numeric(Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_report_numeric(Numeric::Ptr{Cvoid},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_report_numeric(Numeric, Control)
-    @ccall libumfpack.umfpack_zi_report_numeric(Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_report_numeric(Numeric::Ptr{Cvoid},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_report_numeric(Numeric, Control)
-    @ccall libumfpack.umfpack_zl_report_numeric(Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_report_numeric(Numeric::Ptr{Cvoid},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_report_perm(np, Perm, Control)
-    @ccall libumfpack.umfpack_di_report_perm(np::Int32, Perm::Ptr{Int32}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_report_perm(np::Int32, Perm::Ptr{Int32},
+                                             Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_report_perm(np, Perm, Control)
-    @ccall libumfpack.umfpack_dl_report_perm(np::Int64, Perm::Ptr{Int64}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_report_perm(np::Int64, Perm::Ptr{Int64},
+                                             Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_report_perm(np, Perm, Control)
-    @ccall libumfpack.umfpack_zi_report_perm(np::Int32, Perm::Ptr{Int32}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_report_perm(np::Int32, Perm::Ptr{Int32},
+                                             Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_report_perm(np, Perm, Control)
-    @ccall libumfpack.umfpack_zl_report_perm(np::Int64, Perm::Ptr{Int64}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_report_perm(np::Int64, Perm::Ptr{Int64},
+                                             Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_timer()
@@ -2395,13 +3219,13 @@ function umfpack_toc(stats)
     @ccall libumfpack.umfpack_toc(stats::Ptr{Cdouble})::Cvoid
 end
 
-const CHOLMOD_DATE = "Jan 17, 2023"
+const CHOLMOD_DATE = "June 16, 2023"
 
 const CHOLMOD_MAIN_VERSION = 4
 
 const CHOLMOD_SUB_VERSION = 0
 
-const CHOLMOD_SUBSUB_VERSION = 3
+const CHOLMOD_SUBSUB_VERSION = 4
 
 const _FILE_OFFSET_BITS = 64
 
@@ -2427,17 +3251,18 @@ const SUITESPARSE_COMPILER_MSC = 0
 
 const SUITESPARSE_COMPILER_XLC = 0
 
-const SUITESPARSE_DATE = "Jan 20, 2023"
+const SUITESPARSE_DATE = "June 29, 2023"
 
 const SUITESPARSE_MAIN_VERSION = 7
 
-const SUITESPARSE_SUB_VERSION = 0
+const SUITESPARSE_SUB_VERSION = 1
 
-const SUITESPARSE_SUBSUB_VERSION = 1
+const SUITESPARSE_SUBSUB_VERSION = 0
 
 SUITESPARSE_VER_CODE(main, sub) = main * 1000 + sub
 
-const SUITESPARSE_VERSION = SUITESPARSE_VER_CODE(SUITESPARSE_MAIN_VERSION, SUITESPARSE_SUB_VERSION)
+const SUITESPARSE_VERSION = SUITESPARSE_VER_CODE(SUITESPARSE_MAIN_VERSION,
+                                                 SUITESPARSE_SUB_VERSION)
 
 CHOLMOD_VER_CODE(main, sub) = main * 1000 + sub
 
@@ -2601,20 +3426,18 @@ const SPQR_RTX_EQUALS_B = 2
 
 const SPQR_RTX_EQUALS_ETB = 3
 
-const SPQR_DATE = "Jan 17, 2023"
+const SPQR_DATE = "July FIXME, 2023"
 
-const SPQR_MAIN_VERSION = 3
+const SPQR_MAIN_VERSION = 4
 
 const SPQR_SUB_VERSION = 0
 
-const SPQR_SUBSUB_VERSION = 3
+const SPQR_SUBSUB_VERSION = 0
 
 SPQR_VER_CODE(main, sub) = main * 1000 + sub
 
 const SPQR_VERSION = SPQR_VER_CODE(SPQR_MAIN_VERSION, SPQR_SUB_VERSION)
 
-const Complex = Float64
-
 const AMD_CONTROL = 5
 
 const AMD_INFO = 20
@@ -2663,172 +3486,29 @@ const AMD_INVALID = -2
 
 const AMD_OK_BUT_JUMBLED = 1
 
-const AMD_DATE = "Jan 17, 2023"
+const AMD_DATE = "June 16, 2023"
 
 const AMD_MAIN_VERSION = 3
 
 const AMD_SUB_VERSION = 0
 
-const AMD_SUBSUB_VERSION = 3
+const AMD_SUBSUB_VERSION = 4
 
 AMD_VERSION_CODE(main, sub) = main * 1000 + sub
 
 const AMD_VERSION = AMD_VERSION_CODE(AMD_MAIN_VERSION, AMD_SUB_VERSION)
 
-const COLAMD_DATE = "Jan 17, 2023"
-
-const COLAMD_MAIN_VERSION = 3
-
-const COLAMD_SUB_VERSION = 0
-
-const COLAMD_SUBSUB_VERSION = 3
-
-COLAMD_VERSION_CODE(main, sub) = main * 1000 + sub
-
-const COLAMD_VERSION = COLAMD_VERSION_CODE(COLAMD_MAIN_VERSION, COLAMD_SUB_VERSION)
-
-const COLAMD_KNOBS = 20
-
-const COLAMD_STATS = 20
-
-const COLAMD_DENSE_ROW = 0
-
-const COLAMD_DENSE_COL = 1
-
-const COLAMD_AGGRESSIVE = 2
-
-const COLAMD_DEFRAG_COUNT = 2
-
-const COLAMD_STATUS = 3
-
-const COLAMD_INFO1 = 4
-
-const COLAMD_INFO2 = 5
-
-const COLAMD_INFO3 = 6
-
-const COLAMD_OK = 0
-
-const COLAMD_OK_BUT_JUMBLED = 1
-
-const COLAMD_ERROR_A_not_present = -1
-
-const COLAMD_ERROR_p_not_present = -2
-
-const COLAMD_ERROR_nrow_negative = -3
-
-const COLAMD_ERROR_ncol_negative = -4
-
-const COLAMD_ERROR_nnz_negative = -5
-
-const COLAMD_ERROR_p0_nonzero = -6
-
-const COLAMD_ERROR_A_too_small = -7
-
-const COLAMD_ERROR_col_length_negative = -8
-
-const COLAMD_ERROR_row_index_out_of_bounds = -9
-
-const COLAMD_ERROR_out_of_memory = -10
-
-const COLAMD_ERROR_internal_error = -999
-
-const CCOLAMD_DATE = "Jan 17, 2023"
-
-const CCOLAMD_MAIN_VERSION = 3
-
-const CCOLAMD_SUB_VERSION = 0
-
-const CCOLAMD_SUBSUB_VERSION = 3
-
-CCOLAMD_VERSION_CODE(main, sub) = main * 1000 + sub
-
-const CCOLAMD_VERSION = CCOLAMD_VERSION_CODE(CCOLAMD_MAIN_VERSION, CCOLAMD_SUB_VERSION)
-
-const CCOLAMD_KNOBS = 20
-
-const CCOLAMD_STATS = 20
-
-const CCOLAMD_DENSE_ROW = 0
-
-const CCOLAMD_DENSE_COL = 1
-
-const CCOLAMD_AGGRESSIVE = 2
-
-const CCOLAMD_LU = 3
-
-const CCOLAMD_DEFRAG_COUNT = 2
-
-const CCOLAMD_STATUS = 3
-
-const CCOLAMD_INFO1 = 4
-
-const CCOLAMD_INFO2 = 5
-
-const CCOLAMD_INFO3 = 6
-
-const CCOLAMD_EMPTY_ROW = 7
-
-const CCOLAMD_EMPTY_COL = 8
-
-const CCOLAMD_NEWLY_EMPTY_ROW = 9
-
-const CCOLAMD_NEWLY_EMPTY_COL = 10
-
-const CCOLAMD_OK = 0
-
-const CCOLAMD_OK_BUT_JUMBLED = 1
-
-const CCOLAMD_ERROR_A_not_present = -1
-
-const CCOLAMD_ERROR_p_not_present = -2
-
-const CCOLAMD_ERROR_nrow_negative = -3
-
-const CCOLAMD_ERROR_ncol_negative = -4
-
-const CCOLAMD_ERROR_nnz_negative = -5
-
-const CCOLAMD_ERROR_p0_nonzero = -6
-
-const CCOLAMD_ERROR_A_too_small = -7
-
-const CCOLAMD_ERROR_col_length_negative = -8
-
-const CCOLAMD_ERROR_row_index_out_of_bounds = -9
-
-const CCOLAMD_ERROR_out_of_memory = -10
-
-const CCOLAMD_ERROR_invalid_cmember = -11
-
-const CCOLAMD_ERROR_internal_error = -999
-
 const UMFPACK_INFO = 90
 
 const UMFPACK_CONTROL = 20
 
-# Skipping MacroDefinition: UMFPACK_COPYRIGHT \
-#"UMFPACK:  Copyright (c) 2005-2023 by Timothy A. Davis.  All Rights Reserved.\n"
-
-# Skipping MacroDefinition: UMFPACK_LICENSE_PART1 \
-#"\nUMFPACK License: SPDX-License-Identifier: GPL-2.0+\n" \
-#"   UMFPACK is available under alternate licenses,\n" \
-#"   contact T. Davis for details.\n"
-
-const UMFPACK_LICENSE_PART2 = "\n"
-
-# Skipping MacroDefinition: UMFPACK_LICENSE_PART3 \
-#"\n" \
-#"Availability: http://www.suitesparse.com" \
-#"\n"
-
-const UMFPACK_DATE = "Jan 17, 2023"
+const UMFPACK_DATE = "June 16, 2023"
 
 const UMFPACK_MAIN_VERSION = 6
 
 const UMFPACK_SUB_VERSION = 1
 
-const UMFPACK_SUBSUB_VERSION = 0
+const UMFPACK_SUBSUB_VERSION = 1
 
 UMFPACK_VER_CODE(main, sub) = main * 1000 + sub
 
@@ -3169,4 +3849,3 @@ const UMFPACK_Q_Uat = 12
 const UMFPACK_Ut = 13
 
 const UMFPACK_Uat = 14
-
diff --git a/src/solvers/lib/x86_64-unknown-freebsd.jl b/src/solvers/lib/x86_64-unknown-freebsd.jl
index fcf756d2..a5aa4e44 100644
--- a/src/solvers/lib/x86_64-unknown-freebsd.jl
+++ b/src/solvers/lib/x86_64-unknown-freebsd.jl
@@ -1,137 +1,150 @@
 function SuiteSparse_config_printf_func_get()
-    @ccall libcholmod.SuiteSparse_config_printf_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_printf_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_malloc_func_get()
-    @ccall libcholmod.SuiteSparse_config_malloc_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_malloc_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_calloc_func_get()
-    @ccall libcholmod.SuiteSparse_config_calloc_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_calloc_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_realloc_func_get()
-    @ccall libcholmod.SuiteSparse_config_realloc_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_realloc_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_free_func_get()
-    @ccall libcholmod.SuiteSparse_config_free_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_free_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_hypot_func_get()
-    @ccall libcholmod.SuiteSparse_config_hypot_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_hypot_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_divcomplex_func_get()
-    @ccall libcholmod.SuiteSparse_config_divcomplex_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_divcomplex_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_malloc_func_set(malloc_func)
-    @ccall libcholmod.SuiteSparse_config_malloc_func_set(malloc_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_malloc_func_set(malloc_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_calloc_func_set(calloc_func)
-    @ccall libcholmod.SuiteSparse_config_calloc_func_set(calloc_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_calloc_func_set(calloc_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_realloc_func_set(realloc_func)
-    @ccall libcholmod.SuiteSparse_config_realloc_func_set(realloc_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_realloc_func_set(realloc_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_free_func_set(free_func)
-    @ccall libcholmod.SuiteSparse_config_free_func_set(free_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_free_func_set(free_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_printf_func_set(printf_func)
-    @ccall libcholmod.SuiteSparse_config_printf_func_set(printf_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_printf_func_set(printf_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_hypot_func_set(hypot_func)
-    @ccall libcholmod.SuiteSparse_config_hypot_func_set(hypot_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_hypot_func_set(hypot_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_divcomplex_func_set(divcomplex_func)
-    @ccall libcholmod.SuiteSparse_config_divcomplex_func_set(divcomplex_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_divcomplex_func_set(divcomplex_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_malloc(s)
-    @ccall libcholmod.SuiteSparse_config_malloc(s::Csize_t)::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_malloc(s::Csize_t)::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_calloc(n, s)
-    @ccall libcholmod.SuiteSparse_config_calloc(n::Csize_t, s::Csize_t)::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_calloc(n::Csize_t,
+                                                          s::Csize_t)::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_realloc(arg1, s)
-    @ccall libcholmod.SuiteSparse_config_realloc(arg1::Ptr{Cvoid}, s::Csize_t)::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_realloc(arg1::Ptr{Cvoid},
+                                                           s::Csize_t)::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_free(arg1)
-    @ccall libcholmod.SuiteSparse_config_free(arg1::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_free(arg1::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_hypot(x, y)
-    @ccall libcholmod.SuiteSparse_config_hypot(x::Cdouble, y::Cdouble)::Cdouble
+    @ccall libsuitesparseconfig.SuiteSparse_config_hypot(x::Cdouble, y::Cdouble)::Cdouble
 end
 
 function SuiteSparse_config_divcomplex(xr, xi, yr, yi, zr, zi)
-    @ccall libcholmod.SuiteSparse_config_divcomplex(xr::Cdouble, xi::Cdouble, yr::Cdouble, yi::Cdouble, zr::Ptr{Cdouble}, zi::Ptr{Cdouble})::Cint
+    @ccall libsuitesparseconfig.SuiteSparse_config_divcomplex(xr::Cdouble, xi::Cdouble,
+                                                              yr::Cdouble, yi::Cdouble,
+                                                              zr::Ptr{Cdouble},
+                                                              zi::Ptr{Cdouble})::Cint
 end
 
 function SuiteSparse_start()
-    @ccall libcholmod.SuiteSparse_start()::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_start()::Cvoid
 end
 
 function SuiteSparse_finish()
-    @ccall libcholmod.SuiteSparse_finish()::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_finish()::Cvoid
 end
 
 function SuiteSparse_malloc(nitems, size_of_item)
-    @ccall libcholmod.SuiteSparse_malloc(nitems::Csize_t, size_of_item::Csize_t)::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_malloc(nitems::Csize_t,
+                                                   size_of_item::Csize_t)::Ptr{Cvoid}
 end
 
 function SuiteSparse_calloc(nitems, size_of_item)
-    @ccall libcholmod.SuiteSparse_calloc(nitems::Csize_t, size_of_item::Csize_t)::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_calloc(nitems::Csize_t,
+                                                   size_of_item::Csize_t)::Ptr{Cvoid}
 end
 
 function SuiteSparse_realloc(nitems_new, nitems_old, size_of_item, p, ok)
-    @ccall libcholmod.SuiteSparse_realloc(nitems_new::Csize_t, nitems_old::Csize_t, size_of_item::Csize_t, p::Ptr{Cvoid}, ok::Ptr{Cint})::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_realloc(nitems_new::Csize_t,
+                                                    nitems_old::Csize_t,
+                                                    size_of_item::Csize_t, p::Ptr{Cvoid},
+                                                    ok::Ptr{Cint})::Ptr{Cvoid}
 end
 
 function SuiteSparse_free(p)
-    @ccall libcholmod.SuiteSparse_free(p::Ptr{Cvoid})::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_free(p::Ptr{Cvoid})::Ptr{Cvoid}
 end
 
 function SuiteSparse_tic(tic)
-    @ccall libcholmod.SuiteSparse_tic(tic::Ptr{Cdouble})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_tic(tic::Ptr{Cdouble})::Cvoid
 end
 
 function SuiteSparse_toc(tic)
-    @ccall libcholmod.SuiteSparse_toc(tic::Ptr{Cdouble})::Cdouble
+    @ccall libsuitesparseconfig.SuiteSparse_toc(tic::Ptr{Cdouble})::Cdouble
 end
 
 function SuiteSparse_time()
-    @ccall libcholmod.SuiteSparse_time()::Cdouble
+    @ccall libsuitesparseconfig.SuiteSparse_time()::Cdouble
 end
 
 function SuiteSparse_hypot(x, y)
-    @ccall libcholmod.SuiteSparse_hypot(x::Cdouble, y::Cdouble)::Cdouble
+    @ccall libsuitesparseconfig.SuiteSparse_hypot(x::Cdouble, y::Cdouble)::Cdouble
 end
 
 function SuiteSparse_divcomplex(ar, ai, br, bi, cr, ci)
-    @ccall libcholmod.SuiteSparse_divcomplex(ar::Cdouble, ai::Cdouble, br::Cdouble, bi::Cdouble, cr::Ptr{Cdouble}, ci::Ptr{Cdouble})::Cint
+    @ccall libsuitesparseconfig.SuiteSparse_divcomplex(ar::Cdouble, ai::Cdouble,
+                                                       br::Cdouble, bi::Cdouble,
+                                                       cr::Ptr{Cdouble},
+                                                       ci::Ptr{Cdouble})::Cint
 end
 
 function SuiteSparse_version(version)
-    @ccall libcholmod.SuiteSparse_version(version::Ptr{Cint})::Cint
+    @ccall libsuitesparseconfig.SuiteSparse_version(version::Ptr{Cint})::Cint
 end
 
 function SuiteSparse_BLAS_library()
-    @ccall libcholmod.SuiteSparse_BLAS_library()::Ptr{Cchar}
+    @ccall libsuitesparseconfig.SuiteSparse_BLAS_library()::Ptr{Cchar}
 end
 
 function SuiteSparse_BLAS_integer_size()
-    @ccall libcholmod.SuiteSparse_BLAS_integer_size()::Csize_t
+    @ccall libsuitesparseconfig.SuiteSparse_BLAS_integer_size()::Csize_t
 end
 
 struct cholmod_method_struct
@@ -140,16 +153,16 @@ struct cholmod_method_struct
     prune_dense::Cdouble
     prune_dense2::Cdouble
     nd_oksep::Cdouble
-    other_1::NTuple{4, Cdouble}
+    other_1::NTuple{4,Cdouble}
     nd_small::Csize_t
-    other_2::NTuple{4, Csize_t}
+    other_2::NTuple{4,Csize_t}
     aggressive::Cint
     order_for_lu::Cint
     nd_compress::Cint
     nd_camd::Cint
     nd_components::Cint
     ordering::Cint
-    other_3::NTuple{4, Csize_t}
+    other_3::NTuple{4,Csize_t}
 end
 
 mutable struct cholmod_common_struct
@@ -166,8 +179,8 @@ mutable struct cholmod_common_struct
     final_pack::Cint
     final_monotonic::Cint
     final_resymbol::Cint
-    zrelax::NTuple{3, Cdouble}
-    nrelax::NTuple{3, Csize_t}
+    zrelax::NTuple{3,Cdouble}
+    nrelax::NTuple{3,Csize_t}
     prefer_zomplex::Cint
     prefer_upper::Cint
     quick_return_if_not_posdef::Cint
@@ -179,7 +192,7 @@ mutable struct cholmod_common_struct
     nmethods::Cint
     current::Cint
     selected::Cint
-    method::NTuple{10, cholmod_method_struct}
+    method::NTuple{10,cholmod_method_struct}
     postorder::Cint
     default_nesdis::Cint
     metis_memory::Cdouble
@@ -222,7 +235,7 @@ mutable struct cholmod_common_struct
     SPQR_flopcount_bound::Cdouble
     SPQR_tol_used::Cdouble
     SPQR_norm_E_fro::Cdouble
-    SPQR_istat::NTuple{10, Int64}
+    SPQR_istat::NTuple{10,Int64}
     useGPU::Cint
     maxGpuMemBytes::Csize_t
     maxGpuMemFraction::Cdouble
@@ -231,10 +244,10 @@ mutable struct cholmod_common_struct
     gpuFlops::Int64
     gpuNumKernelLaunches::Cint
     cublasHandle::Ptr{Cvoid}
-    gpuStream::NTuple{8, Ptr{Cvoid}}
-    cublasEventPotrf::NTuple{3, Ptr{Cvoid}}
+    gpuStream::NTuple{8,Ptr{Cvoid}}
+    cublasEventPotrf::NTuple{3,Ptr{Cvoid}}
     updateCKernelsComplete::Ptr{Cvoid}
-    updateCBuffersFree::NTuple{8, Ptr{Cvoid}}
+    updateCBuffersFree::NTuple{8,Ptr{Cvoid}}
     dev_mempool::Ptr{Cvoid}
     dev_mempool_size::Csize_t
     host_pinned_mempool::Ptr{Cvoid}
@@ -300,11 +313,14 @@ function cholmod_l_maxrank(arg1, arg2)
 end
 
 function cholmod_allocate_work(nrow, iworksize, xworksize, Common)
-    @ccall libcholmod.cholmod_allocate_work(nrow::Csize_t, iworksize::Csize_t, xworksize::Csize_t, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_allocate_work(nrow::Csize_t, iworksize::Csize_t,
+                                            xworksize::Csize_t,
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_allocate_work(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_allocate_work(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_allocate_work(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t,
+                                              arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_free_work(Common)
@@ -324,11 +340,13 @@ function cholmod_l_clear_flag(arg1)
 end
 
 function cholmod_error(status, file, line, message, Common)
-    @ccall libcholmod.cholmod_error(status::Cint, file::Ptr{Cchar}, line::Cint, message::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_error(status::Cint, file::Ptr{Cchar}, line::Cint,
+                                    message::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_error(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_error(arg1::Cint, arg2::Ptr{Cchar}, arg3::Cint, arg4::Ptr{Cchar}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_error(arg1::Cint, arg2::Ptr{Cchar}, arg3::Cint,
+                                      arg4::Ptr{Cchar}, arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_dbound(dj, Common)
@@ -348,11 +366,14 @@ function cholmod_l_hypot(arg1, arg2)
 end
 
 function cholmod_divcomplex(ar, ai, br, bi, cr, ci)
-    @ccall libcholmod.cholmod_divcomplex(ar::Cdouble, ai::Cdouble, br::Cdouble, bi::Cdouble, cr::Ptr{Cdouble}, ci::Ptr{Cdouble})::Cint
+    @ccall libcholmod.cholmod_divcomplex(ar::Cdouble, ai::Cdouble, br::Cdouble, bi::Cdouble,
+                                         cr::Ptr{Cdouble}, ci::Ptr{Cdouble})::Cint
 end
 
 function cholmod_l_divcomplex(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_divcomplex(arg1::Cdouble, arg2::Cdouble, arg3::Cdouble, arg4::Cdouble, arg5::Ptr{Cdouble}, arg6::Ptr{Cdouble})::Cint
+    @ccall libcholmod.cholmod_l_divcomplex(arg1::Cdouble, arg2::Cdouble, arg3::Cdouble,
+                                           arg4::Cdouble, arg5::Ptr{Cdouble},
+                                           arg6::Ptr{Cdouble})::Cint
 end
 
 mutable struct cholmod_sparse_struct
@@ -384,155 +405,217 @@ end
 const descendantScore = cholmod_descendant_score_t
 
 function cholmod_score_comp(i, j)
-    @ccall libcholmod.cholmod_score_comp(i::Ptr{cholmod_descendant_score_t}, j::Ptr{cholmod_descendant_score_t})::Cint
+    @ccall libcholmod.cholmod_score_comp(i::Ptr{cholmod_descendant_score_t},
+                                         j::Ptr{cholmod_descendant_score_t})::Cint
 end
 
 function cholmod_l_score_comp(i, j)
-    @ccall libcholmod.cholmod_l_score_comp(i::Ptr{cholmod_descendant_score_t}, j::Ptr{cholmod_descendant_score_t})::Cint
+    @ccall libcholmod.cholmod_l_score_comp(i::Ptr{cholmod_descendant_score_t},
+                                           j::Ptr{cholmod_descendant_score_t})::Cint
 end
 
 function cholmod_allocate_sparse(nrow, ncol, nzmax, sorted, packed, stype, xtype, Common)
-    @ccall libcholmod.cholmod_allocate_sparse(nrow::Csize_t, ncol::Csize_t, nzmax::Csize_t, sorted::Cint, packed::Cint, stype::Cint, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_allocate_sparse(nrow::Csize_t, ncol::Csize_t, nzmax::Csize_t,
+                                              sorted::Cint, packed::Cint, stype::Cint,
+                                              xtype::Cint,
+                                              Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_allocate_sparse(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
-    @ccall libcholmod.cholmod_l_allocate_sparse(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t, arg4::Cint, arg5::Cint, arg6::Cint, arg7::Cint, arg8::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_allocate_sparse(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t,
+                                                arg4::Cint, arg5::Cint, arg6::Cint,
+                                                arg7::Cint,
+                                                arg8::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_free_sparse(A, Common)
-    @ccall libcholmod.cholmod_free_sparse(A::Ptr{Ptr{cholmod_sparse}}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_free_sparse(A::Ptr{Ptr{cholmod_sparse}},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_free_sparse(arg1, arg2)
-    @ccall libcholmod.cholmod_l_free_sparse(arg1::Ptr{Ptr{cholmod_sparse}}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_free_sparse(arg1::Ptr{Ptr{cholmod_sparse}},
+                                            arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_reallocate_sparse(nznew, A, Common)
-    @ccall libcholmod.cholmod_reallocate_sparse(nznew::Csize_t, A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_reallocate_sparse(nznew::Csize_t, A::Ptr{cholmod_sparse},
+                                                Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_reallocate_sparse(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_reallocate_sparse(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_reallocate_sparse(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                                  arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_nnz(A, Common)
-    @ccall libcholmod.cholmod_nnz(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_nnz(A::Ptr{cholmod_sparse},
+                                  Common::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_l_nnz(arg1, arg2)
-    @ccall libcholmod.cholmod_l_nnz(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_l_nnz(arg1::Ptr{cholmod_sparse},
+                                    arg2::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_speye(nrow, ncol, xtype, Common)
-    @ccall libcholmod.cholmod_speye(nrow::Csize_t, ncol::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_speye(nrow::Csize_t, ncol::Csize_t, xtype::Cint,
+                                    Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_speye(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_speye(arg1::Csize_t, arg2::Csize_t, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_speye(arg1::Csize_t, arg2::Csize_t, arg3::Cint,
+                                      arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_spzeros(nrow, ncol, nzmax, xtype, Common)
-    @ccall libcholmod.cholmod_spzeros(nrow::Csize_t, ncol::Csize_t, nzmax::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_spzeros(nrow::Csize_t, ncol::Csize_t, nzmax::Csize_t,
+                                      xtype::Cint,
+                                      Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_spzeros(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_spzeros(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t, arg4::Cint, arg5::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_spzeros(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t,
+                                        arg4::Cint,
+                                        arg5::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_transpose(A, values, Common)
-    @ccall libcholmod.cholmod_transpose(A::Ptr{cholmod_sparse}, values::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_transpose(A::Ptr{cholmod_sparse}, values::Cint,
+                                        Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_transpose(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_transpose(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_transpose(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                          arg3::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_transpose_unsym(A, values, Perm, fset, fsize, F, Common)
-    @ccall libcholmod.cholmod_transpose_unsym(A::Ptr{cholmod_sparse}, values::Cint, Perm::Ptr{Int32}, fset::Ptr{Int32}, fsize::Csize_t, F::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_transpose_unsym(A::Ptr{cholmod_sparse}, values::Cint,
+                                              Perm::Ptr{Int32}, fset::Ptr{Int32},
+                                              fsize::Csize_t, F::Ptr{cholmod_sparse},
+                                              Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_transpose_unsym(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_transpose_unsym(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Csize_t, arg6::Ptr{cholmod_sparse}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_transpose_unsym(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                                arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                                arg5::Csize_t, arg6::Ptr{cholmod_sparse},
+                                                arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_transpose_sym(A, values, Perm, F, Common)
-    @ccall libcholmod.cholmod_transpose_sym(A::Ptr{cholmod_sparse}, values::Cint, Perm::Ptr{Int32}, F::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_transpose_sym(A::Ptr{cholmod_sparse}, values::Cint,
+                                            Perm::Ptr{Int32}, F::Ptr{cholmod_sparse},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_transpose_sym(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_transpose_sym(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{Int64}, arg4::Ptr{cholmod_sparse}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_transpose_sym(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                              arg3::Ptr{Int64}, arg4::Ptr{cholmod_sparse},
+                                              arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_ptranspose(A, values, Perm, fset, fsize, Common)
-    @ccall libcholmod.cholmod_ptranspose(A::Ptr{cholmod_sparse}, values::Cint, Perm::Ptr{Int32}, fset::Ptr{Int32}, fsize::Csize_t, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_ptranspose(A::Ptr{cholmod_sparse}, values::Cint,
+                                         Perm::Ptr{Int32}, fset::Ptr{Int32}, fsize::Csize_t,
+                                         Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_ptranspose(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_ptranspose(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Csize_t, arg6::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_ptranspose(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                           arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                           arg5::Csize_t,
+                                           arg6::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_sort(A, Common)
-    @ccall libcholmod.cholmod_sort(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_sort(A::Ptr{cholmod_sparse},
+                                   Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_sort(arg1, arg2)
-    @ccall libcholmod.cholmod_l_sort(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_sort(arg1::Ptr{cholmod_sparse},
+                                     arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_band(A, k1, k2, mode, Common)
-    @ccall libcholmod.cholmod_band(A::Ptr{cholmod_sparse}, k1::Int64, k2::Int64, mode::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_band(A::Ptr{cholmod_sparse}, k1::Int64, k2::Int64, mode::Cint,
+                                   Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_band(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_band(arg1::Ptr{cholmod_sparse}, arg2::Int64, arg3::Int64, arg4::Cint, arg5::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_band(arg1::Ptr{cholmod_sparse}, arg2::Int64, arg3::Int64,
+                                     arg4::Cint,
+                                     arg5::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_band_inplace(k1, k2, mode, A, Common)
-    @ccall libcholmod.cholmod_band_inplace(k1::Int64, k2::Int64, mode::Cint, A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_band_inplace(k1::Int64, k2::Int64, mode::Cint,
+                                           A::Ptr{cholmod_sparse},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_band_inplace(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_band_inplace(arg1::Int64, arg2::Int64, arg3::Cint, arg4::Ptr{cholmod_sparse}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_band_inplace(arg1::Int64, arg2::Int64, arg3::Cint,
+                                             arg4::Ptr{cholmod_sparse},
+                                             arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_aat(A, fset, fsize, mode, Common)
-    @ccall libcholmod.cholmod_aat(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, mode::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_aat(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t,
+                                  mode::Cint,
+                                  Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_aat(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_aat(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Cint, arg5::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_aat(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                    arg3::Csize_t, arg4::Cint,
+                                    arg5::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_copy_sparse(A, Common)
-    @ccall libcholmod.cholmod_copy_sparse(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_copy_sparse(A::Ptr{cholmod_sparse},
+                                          Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_copy_sparse(arg1, arg2)
-    @ccall libcholmod.cholmod_l_copy_sparse(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_copy_sparse(arg1::Ptr{cholmod_sparse},
+                                            arg2::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_copy(A, stype, mode, Common)
-    @ccall libcholmod.cholmod_copy(A::Ptr{cholmod_sparse}, stype::Cint, mode::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_copy(A::Ptr{cholmod_sparse}, stype::Cint, mode::Cint,
+                                   Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_copy(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_copy(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_copy(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Cint,
+                                     arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_add(A, B, alpha, beta, values, sorted, Common)
-    @ccall libcholmod.cholmod_add(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse}, alpha::Ptr{Cdouble}, beta::Ptr{Cdouble}, values::Cint, sorted::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_add(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse},
+                                  alpha::Ptr{Cdouble}, beta::Ptr{Cdouble}, values::Cint,
+                                  sorted::Cint,
+                                  Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_add(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_add(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Ptr{Cdouble}, arg5::Cint, arg6::Cint, arg7::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_add(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse},
+                                    arg3::Ptr{Cdouble}, arg4::Ptr{Cdouble}, arg5::Cint,
+                                    arg6::Cint,
+                                    arg7::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_sparse_xtype(to_xtype, A, Common)
-    @ccall libcholmod.cholmod_sparse_xtype(to_xtype::Cint, A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_sparse_xtype(to_xtype::Cint, A::Ptr{cholmod_sparse},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_sparse_xtype(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_sparse_xtype(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_sparse_xtype(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                             arg3::Ptr{cholmod_common})::Cint
 end
 
 mutable struct cholmod_factor_struct
@@ -572,75 +655,100 @@ end
 const cholmod_factor = cholmod_factor_struct
 
 function cholmod_allocate_factor(n, Common)
-    @ccall libcholmod.cholmod_allocate_factor(n::Csize_t, Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_allocate_factor(n::Csize_t,
+                                              Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_l_allocate_factor(arg1, arg2)
-    @ccall libcholmod.cholmod_l_allocate_factor(arg1::Csize_t, arg2::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_l_allocate_factor(arg1::Csize_t,
+                                                arg2::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_free_factor(L, Common)
-    @ccall libcholmod.cholmod_free_factor(L::Ptr{Ptr{cholmod_factor}}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_free_factor(L::Ptr{Ptr{cholmod_factor}},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_free_factor(arg1, arg2)
-    @ccall libcholmod.cholmod_l_free_factor(arg1::Ptr{Ptr{cholmod_factor}}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_free_factor(arg1::Ptr{Ptr{cholmod_factor}},
+                                            arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_reallocate_factor(nznew, L, Common)
-    @ccall libcholmod.cholmod_reallocate_factor(nznew::Csize_t, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_reallocate_factor(nznew::Csize_t, L::Ptr{cholmod_factor},
+                                                Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_reallocate_factor(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_reallocate_factor(arg1::Csize_t, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_reallocate_factor(arg1::Csize_t, arg2::Ptr{cholmod_factor},
+                                                  arg3::Ptr{cholmod_common})::Cint
 end
 
-function cholmod_change_factor(to_xtype, to_ll, to_super, to_packed, to_monotonic, L, Common)
-    @ccall libcholmod.cholmod_change_factor(to_xtype::Cint, to_ll::Cint, to_super::Cint, to_packed::Cint, to_monotonic::Cint, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+function cholmod_change_factor(to_xtype, to_ll, to_super, to_packed, to_monotonic, L,
+                               Common)
+    @ccall libcholmod.cholmod_change_factor(to_xtype::Cint, to_ll::Cint, to_super::Cint,
+                                            to_packed::Cint, to_monotonic::Cint,
+                                            L::Ptr{cholmod_factor},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_change_factor(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_change_factor(arg1::Cint, arg2::Cint, arg3::Cint, arg4::Cint, arg5::Cint, arg6::Ptr{cholmod_factor}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_change_factor(arg1::Cint, arg2::Cint, arg3::Cint,
+                                              arg4::Cint, arg5::Cint,
+                                              arg6::Ptr{cholmod_factor},
+                                              arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_pack_factor(L, Common)
-    @ccall libcholmod.cholmod_pack_factor(L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_pack_factor(L::Ptr{cholmod_factor},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_pack_factor(arg1, arg2)
-    @ccall libcholmod.cholmod_l_pack_factor(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_pack_factor(arg1::Ptr{cholmod_factor},
+                                            arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_reallocate_column(j, need, L, Common)
-    @ccall libcholmod.cholmod_reallocate_column(j::Csize_t, need::Csize_t, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_reallocate_column(j::Csize_t, need::Csize_t,
+                                                L::Ptr{cholmod_factor},
+                                                Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_reallocate_column(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_reallocate_column(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{cholmod_factor}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_reallocate_column(arg1::Csize_t, arg2::Csize_t,
+                                                  arg3::Ptr{cholmod_factor},
+                                                  arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_factor_to_sparse(L, Common)
-    @ccall libcholmod.cholmod_factor_to_sparse(L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_factor_to_sparse(L::Ptr{cholmod_factor},
+                                               Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_factor_to_sparse(arg1, arg2)
-    @ccall libcholmod.cholmod_l_factor_to_sparse(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_factor_to_sparse(arg1::Ptr{cholmod_factor},
+                                                 arg2::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_copy_factor(L, Common)
-    @ccall libcholmod.cholmod_copy_factor(L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_copy_factor(L::Ptr{cholmod_factor},
+                                          Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_l_copy_factor(arg1, arg2)
-    @ccall libcholmod.cholmod_l_copy_factor(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_l_copy_factor(arg1::Ptr{cholmod_factor},
+                                            arg2::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_factor_xtype(to_xtype, L, Common)
-    @ccall libcholmod.cholmod_factor_xtype(to_xtype::Cint, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_factor_xtype(to_xtype::Cint, L::Ptr{cholmod_factor},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_factor_xtype(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_factor_xtype(arg1::Cint, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_factor_xtype(arg1::Cint, arg2::Ptr{cholmod_factor},
+                                             arg3::Ptr{cholmod_common})::Cint
 end
 
 mutable struct cholmod_dense_struct
@@ -658,91 +766,118 @@ end
 const cholmod_dense = cholmod_dense_struct
 
 function cholmod_allocate_dense(nrow, ncol, d, xtype, Common)
-    @ccall libcholmod.cholmod_allocate_dense(nrow::Csize_t, ncol::Csize_t, d::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_allocate_dense(nrow::Csize_t, ncol::Csize_t, d::Csize_t,
+                                             xtype::Cint,
+                                             Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_allocate_dense(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_allocate_dense(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t, arg4::Cint, arg5::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_allocate_dense(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t,
+                                               arg4::Cint,
+                                               arg5::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_zeros(nrow, ncol, xtype, Common)
-    @ccall libcholmod.cholmod_zeros(nrow::Csize_t, ncol::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_zeros(nrow::Csize_t, ncol::Csize_t, xtype::Cint,
+                                    Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_zeros(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_zeros(arg1::Csize_t, arg2::Csize_t, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_zeros(arg1::Csize_t, arg2::Csize_t, arg3::Cint,
+                                      arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_ones(nrow, ncol, xtype, Common)
-    @ccall libcholmod.cholmod_ones(nrow::Csize_t, ncol::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_ones(nrow::Csize_t, ncol::Csize_t, xtype::Cint,
+                                   Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_ones(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_ones(arg1::Csize_t, arg2::Csize_t, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_ones(arg1::Csize_t, arg2::Csize_t, arg3::Cint,
+                                     arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_eye(nrow, ncol, xtype, Common)
-    @ccall libcholmod.cholmod_eye(nrow::Csize_t, ncol::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_eye(nrow::Csize_t, ncol::Csize_t, xtype::Cint,
+                                  Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_eye(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_eye(arg1::Csize_t, arg2::Csize_t, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_eye(arg1::Csize_t, arg2::Csize_t, arg3::Cint,
+                                    arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_free_dense(X, Common)
-    @ccall libcholmod.cholmod_free_dense(X::Ptr{Ptr{cholmod_dense}}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_free_dense(X::Ptr{Ptr{cholmod_dense}},
+                                         Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_free_dense(arg1, arg2)
-    @ccall libcholmod.cholmod_l_free_dense(arg1::Ptr{Ptr{cholmod_dense}}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_free_dense(arg1::Ptr{Ptr{cholmod_dense}},
+                                           arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_ensure_dense(XHandle, nrow, ncol, d, xtype, Common)
-    @ccall libcholmod.cholmod_ensure_dense(XHandle::Ptr{Ptr{cholmod_dense}}, nrow::Csize_t, ncol::Csize_t, d::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_ensure_dense(XHandle::Ptr{Ptr{cholmod_dense}}, nrow::Csize_t,
+                                           ncol::Csize_t, d::Csize_t, xtype::Cint,
+                                           Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_ensure_dense(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_ensure_dense(arg1::Ptr{Ptr{cholmod_dense}}, arg2::Csize_t, arg3::Csize_t, arg4::Csize_t, arg5::Cint, arg6::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_ensure_dense(arg1::Ptr{Ptr{cholmod_dense}}, arg2::Csize_t,
+                                             arg3::Csize_t, arg4::Csize_t, arg5::Cint,
+                                             arg6::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_sparse_to_dense(A, Common)
-    @ccall libcholmod.cholmod_sparse_to_dense(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_sparse_to_dense(A::Ptr{cholmod_sparse},
+                                              Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_sparse_to_dense(arg1, arg2)
-    @ccall libcholmod.cholmod_l_sparse_to_dense(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_sparse_to_dense(arg1::Ptr{cholmod_sparse},
+                                                arg2::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_dense_to_sparse(X, values, Common)
-    @ccall libcholmod.cholmod_dense_to_sparse(X::Ptr{cholmod_dense}, values::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_dense_to_sparse(X::Ptr{cholmod_dense}, values::Cint,
+                                              Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_dense_to_sparse(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_dense_to_sparse(arg1::Ptr{cholmod_dense}, arg2::Cint, arg3::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_dense_to_sparse(arg1::Ptr{cholmod_dense}, arg2::Cint,
+                                                arg3::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_copy_dense(X, Common)
-    @ccall libcholmod.cholmod_copy_dense(X::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_copy_dense(X::Ptr{cholmod_dense},
+                                         Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_copy_dense(arg1, arg2)
-    @ccall libcholmod.cholmod_l_copy_dense(arg1::Ptr{cholmod_dense}, arg2::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_copy_dense(arg1::Ptr{cholmod_dense},
+                                           arg2::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_copy_dense2(X, Y, Common)
-    @ccall libcholmod.cholmod_copy_dense2(X::Ptr{cholmod_dense}, Y::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_copy_dense2(X::Ptr{cholmod_dense}, Y::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_copy_dense2(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_copy_dense2(arg1::Ptr{cholmod_dense}, arg2::Ptr{cholmod_dense}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_copy_dense2(arg1::Ptr{cholmod_dense},
+                                            arg2::Ptr{cholmod_dense},
+                                            arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_dense_xtype(to_xtype, X, Common)
-    @ccall libcholmod.cholmod_dense_xtype(to_xtype::Cint, X::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_dense_xtype(to_xtype::Cint, X::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_dense_xtype(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_dense_xtype(arg1::Cint, arg2::Ptr{cholmod_dense}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_dense_xtype(arg1::Cint, arg2::Ptr{cholmod_dense},
+                                            arg3::Ptr{cholmod_common})::Cint
 end
 
 mutable struct cholmod_triplet_struct
@@ -764,99 +899,137 @@ end
 const cholmod_triplet = cholmod_triplet_struct
 
 function cholmod_allocate_triplet(nrow, ncol, nzmax, stype, xtype, Common)
-    @ccall libcholmod.cholmod_allocate_triplet(nrow::Csize_t, ncol::Csize_t, nzmax::Csize_t, stype::Cint, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_allocate_triplet(nrow::Csize_t, ncol::Csize_t, nzmax::Csize_t,
+                                               stype::Cint, xtype::Cint,
+                                               Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_l_allocate_triplet(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_allocate_triplet(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t, arg4::Cint, arg5::Cint, arg6::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_l_allocate_triplet(arg1::Csize_t, arg2::Csize_t,
+                                                 arg3::Csize_t, arg4::Cint, arg5::Cint,
+                                                 arg6::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_free_triplet(T, Common)
-    @ccall libcholmod.cholmod_free_triplet(T::Ptr{Ptr{cholmod_triplet}}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_free_triplet(T::Ptr{Ptr{cholmod_triplet}},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_free_triplet(arg1, arg2)
-    @ccall libcholmod.cholmod_l_free_triplet(arg1::Ptr{Ptr{cholmod_triplet}}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_free_triplet(arg1::Ptr{Ptr{cholmod_triplet}},
+                                             arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_reallocate_triplet(nznew, T, Common)
-    @ccall libcholmod.cholmod_reallocate_triplet(nznew::Csize_t, T::Ptr{cholmod_triplet}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_reallocate_triplet(nznew::Csize_t, T::Ptr{cholmod_triplet},
+                                                 Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_reallocate_triplet(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_reallocate_triplet(arg1::Csize_t, arg2::Ptr{cholmod_triplet}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_reallocate_triplet(arg1::Csize_t,
+                                                   arg2::Ptr{cholmod_triplet},
+                                                   arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_sparse_to_triplet(A, Common)
-    @ccall libcholmod.cholmod_sparse_to_triplet(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_sparse_to_triplet(A::Ptr{cholmod_sparse},
+                                                Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_l_sparse_to_triplet(arg1, arg2)
-    @ccall libcholmod.cholmod_l_sparse_to_triplet(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_l_sparse_to_triplet(arg1::Ptr{cholmod_sparse},
+                                                  arg2::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_triplet_to_sparse(T, nzmax, Common)
-    @ccall libcholmod.cholmod_triplet_to_sparse(T::Ptr{cholmod_triplet}, nzmax::Csize_t, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_triplet_to_sparse(T::Ptr{cholmod_triplet}, nzmax::Csize_t,
+                                                Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_triplet_to_sparse(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_triplet_to_sparse(arg1::Ptr{cholmod_triplet}, arg2::Csize_t, arg3::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_triplet_to_sparse(arg1::Ptr{cholmod_triplet}, arg2::Csize_t,
+                                                  arg3::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_copy_triplet(T, Common)
-    @ccall libcholmod.cholmod_copy_triplet(T::Ptr{cholmod_triplet}, Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_copy_triplet(T::Ptr{cholmod_triplet},
+                                           Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_l_copy_triplet(arg1, arg2)
-    @ccall libcholmod.cholmod_l_copy_triplet(arg1::Ptr{cholmod_triplet}, arg2::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_l_copy_triplet(arg1::Ptr{cholmod_triplet},
+                                             arg2::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_triplet_xtype(to_xtype, T, Common)
-    @ccall libcholmod.cholmod_triplet_xtype(to_xtype::Cint, T::Ptr{cholmod_triplet}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_triplet_xtype(to_xtype::Cint, T::Ptr{cholmod_triplet},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_triplet_xtype(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_triplet_xtype(arg1::Cint, arg2::Ptr{cholmod_triplet}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_triplet_xtype(arg1::Cint, arg2::Ptr{cholmod_triplet},
+                                              arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_malloc(n, size, Common)
-    @ccall libcholmod.cholmod_malloc(n::Csize_t, size::Csize_t, Common::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_malloc(n::Csize_t, size::Csize_t,
+                                     Common::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_l_malloc(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_malloc(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_l_malloc(arg1::Csize_t, arg2::Csize_t,
+                                       arg3::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_calloc(n, size, Common)
-    @ccall libcholmod.cholmod_calloc(n::Csize_t, size::Csize_t, Common::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_calloc(n::Csize_t, size::Csize_t,
+                                     Common::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_l_calloc(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_calloc(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_l_calloc(arg1::Csize_t, arg2::Csize_t,
+                                       arg3::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_free(n, size, p, Common)
-    @ccall libcholmod.cholmod_free(n::Csize_t, size::Csize_t, p::Ptr{Cvoid}, Common::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_free(n::Csize_t, size::Csize_t, p::Ptr{Cvoid},
+                                   Common::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_l_free(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_free(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{Cvoid}, arg4::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_l_free(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{Cvoid},
+                                     arg4::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_realloc(nnew, size, p, n, Common)
-    @ccall libcholmod.cholmod_realloc(nnew::Csize_t, size::Csize_t, p::Ptr{Cvoid}, n::Ptr{Csize_t}, Common::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_realloc(nnew::Csize_t, size::Csize_t, p::Ptr{Cvoid},
+                                      n::Ptr{Csize_t},
+                                      Common::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_l_realloc(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_realloc(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{Cvoid}, arg4::Ptr{Csize_t}, arg5::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_l_realloc(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{Cvoid},
+                                        arg4::Ptr{Csize_t},
+                                        arg5::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
-function cholmod_realloc_multiple(nnew, nint, xtype, Iblock, Jblock, Xblock, Zblock, n, Common)
-    @ccall libcholmod.cholmod_realloc_multiple(nnew::Csize_t, nint::Cint, xtype::Cint, Iblock::Ptr{Ptr{Cvoid}}, Jblock::Ptr{Ptr{Cvoid}}, Xblock::Ptr{Ptr{Cvoid}}, Zblock::Ptr{Ptr{Cvoid}}, n::Ptr{Csize_t}, Common::Ptr{cholmod_common})::Cint
+function cholmod_realloc_multiple(nnew, nint, xtype, Iblock, Jblock, Xblock, Zblock, n,
+                                  Common)
+    @ccall libcholmod.cholmod_realloc_multiple(nnew::Csize_t, nint::Cint, xtype::Cint,
+                                               Iblock::Ptr{Ptr{Cvoid}},
+                                               Jblock::Ptr{Ptr{Cvoid}},
+                                               Xblock::Ptr{Ptr{Cvoid}},
+                                               Zblock::Ptr{Ptr{Cvoid}}, n::Ptr{Csize_t},
+                                               Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_realloc_multiple(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
-    @ccall libcholmod.cholmod_l_realloc_multiple(arg1::Csize_t, arg2::Cint, arg3::Cint, arg4::Ptr{Ptr{Cvoid}}, arg5::Ptr{Ptr{Cvoid}}, arg6::Ptr{Ptr{Cvoid}}, arg7::Ptr{Ptr{Cvoid}}, arg8::Ptr{Csize_t}, arg9::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_realloc_multiple(arg1::Csize_t, arg2::Cint, arg3::Cint,
+                                                 arg4::Ptr{Ptr{Cvoid}},
+                                                 arg5::Ptr{Ptr{Cvoid}},
+                                                 arg6::Ptr{Ptr{Cvoid}},
+                                                 arg7::Ptr{Ptr{Cvoid}}, arg8::Ptr{Csize_t},
+                                                 arg9::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_version(version)
@@ -876,11 +1049,13 @@ function cholmod_l_check_common(arg1)
 end
 
 function cholmod_print_common(name, Common)
-    @ccall libcholmod.cholmod_print_common(name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_common(name::Ptr{Cchar},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_common(arg1, arg2)
-    @ccall libcholmod.cholmod_l_print_common(arg1::Ptr{Cchar}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_common(arg1::Ptr{Cchar},
+                                             arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_gpu_stats(arg1)
@@ -892,643 +1067,1047 @@ function cholmod_l_gpu_stats(arg1)
 end
 
 function cholmod_check_sparse(A, Common)
-    @ccall libcholmod.cholmod_check_sparse(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_sparse(A::Ptr{cholmod_sparse},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_sparse(arg1, arg2)
-    @ccall libcholmod.cholmod_l_check_sparse(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_sparse(arg1::Ptr{cholmod_sparse},
+                                             arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_sparse(A, name, Common)
-    @ccall libcholmod.cholmod_print_sparse(A::Ptr{cholmod_sparse}, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_sparse(A::Ptr{cholmod_sparse}, name::Ptr{Cchar},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_sparse(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_print_sparse(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Cchar}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_sparse(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Cchar},
+                                             arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_check_dense(X, Common)
-    @ccall libcholmod.cholmod_check_dense(X::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_dense(X::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_dense(arg1, arg2)
-    @ccall libcholmod.cholmod_l_check_dense(arg1::Ptr{cholmod_dense}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_dense(arg1::Ptr{cholmod_dense},
+                                            arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_dense(X, name, Common)
-    @ccall libcholmod.cholmod_print_dense(X::Ptr{cholmod_dense}, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_dense(X::Ptr{cholmod_dense}, name::Ptr{Cchar},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_dense(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_print_dense(arg1::Ptr{cholmod_dense}, arg2::Ptr{Cchar}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_dense(arg1::Ptr{cholmod_dense}, arg2::Ptr{Cchar},
+                                            arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_check_factor(L, Common)
-    @ccall libcholmod.cholmod_check_factor(L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_factor(L::Ptr{cholmod_factor},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_factor(arg1, arg2)
-    @ccall libcholmod.cholmod_l_check_factor(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_factor(arg1::Ptr{cholmod_factor},
+                                             arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_factor(L, name, Common)
-    @ccall libcholmod.cholmod_print_factor(L::Ptr{cholmod_factor}, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_factor(L::Ptr{cholmod_factor}, name::Ptr{Cchar},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_factor(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_print_factor(arg1::Ptr{cholmod_factor}, arg2::Ptr{Cchar}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_factor(arg1::Ptr{cholmod_factor}, arg2::Ptr{Cchar},
+                                             arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_check_triplet(T, Common)
-    @ccall libcholmod.cholmod_check_triplet(T::Ptr{cholmod_triplet}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_triplet(T::Ptr{cholmod_triplet},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_triplet(arg1, arg2)
-    @ccall libcholmod.cholmod_l_check_triplet(arg1::Ptr{cholmod_triplet}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_triplet(arg1::Ptr{cholmod_triplet},
+                                              arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_triplet(T, name, Common)
-    @ccall libcholmod.cholmod_print_triplet(T::Ptr{cholmod_triplet}, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_triplet(T::Ptr{cholmod_triplet}, name::Ptr{Cchar},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_triplet(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_print_triplet(arg1::Ptr{cholmod_triplet}, arg2::Ptr{Cchar}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_triplet(arg1::Ptr{cholmod_triplet}, arg2::Ptr{Cchar},
+                                              arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_check_subset(Set, len, n, Common)
-    @ccall libcholmod.cholmod_check_subset(Set::Ptr{Int32}, len::Int64, n::Csize_t, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_subset(Set::Ptr{Int32}, len::Int64, n::Csize_t,
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_subset(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_check_subset(arg1::Ptr{Int64}, arg2::Int64, arg3::Csize_t, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_subset(arg1::Ptr{Int64}, arg2::Int64, arg3::Csize_t,
+                                             arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_subset(Set, len, n, name, Common)
-    @ccall libcholmod.cholmod_print_subset(Set::Ptr{Int32}, len::Int64, n::Csize_t, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_subset(Set::Ptr{Int32}, len::Int64, n::Csize_t,
+                                           name::Ptr{Cchar},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_subset(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_print_subset(arg1::Ptr{Int64}, arg2::Int64, arg3::Csize_t, arg4::Ptr{Cchar}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_subset(arg1::Ptr{Int64}, arg2::Int64, arg3::Csize_t,
+                                             arg4::Ptr{Cchar},
+                                             arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_check_perm(Perm, len, n, Common)
-    @ccall libcholmod.cholmod_check_perm(Perm::Ptr{Int32}, len::Csize_t, n::Csize_t, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_perm(Perm::Ptr{Int32}, len::Csize_t, n::Csize_t,
+                                         Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_perm(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_check_perm(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Csize_t, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_perm(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Csize_t,
+                                           arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_perm(Perm, len, n, name, Common)
-    @ccall libcholmod.cholmod_print_perm(Perm::Ptr{Int32}, len::Csize_t, n::Csize_t, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_perm(Perm::Ptr{Int32}, len::Csize_t, n::Csize_t,
+                                         name::Ptr{Cchar},
+                                         Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_perm(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_print_perm(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Csize_t, arg4::Ptr{Cchar}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_perm(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Csize_t,
+                                           arg4::Ptr{Cchar},
+                                           arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_check_parent(Parent, n, Common)
-    @ccall libcholmod.cholmod_check_parent(Parent::Ptr{Int32}, n::Csize_t, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_parent(Parent::Ptr{Int32}, n::Csize_t,
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_parent(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_check_parent(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_parent(arg1::Ptr{Int64}, arg2::Csize_t,
+                                             arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_parent(Parent, n, name, Common)
-    @ccall libcholmod.cholmod_print_parent(Parent::Ptr{Int32}, n::Csize_t, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_parent(Parent::Ptr{Int32}, n::Csize_t, name::Ptr{Cchar},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_parent(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_print_parent(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Ptr{Cchar}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_parent(arg1::Ptr{Int64}, arg2::Csize_t,
+                                             arg3::Ptr{Cchar},
+                                             arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_read_sparse(f, Common)
-    @ccall libcholmod.cholmod_read_sparse(f::Ptr{Libc.FILE}, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_read_sparse(f::Ptr{Libc.FILE},
+                                          Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_read_sparse(arg1, arg2)
-    @ccall libcholmod.cholmod_l_read_sparse(arg1::Ptr{Libc.FILE}, arg2::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_read_sparse(arg1::Ptr{Libc.FILE},
+                                            arg2::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_read_triplet(f, Common)
-    @ccall libcholmod.cholmod_read_triplet(f::Ptr{Libc.FILE}, Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_read_triplet(f::Ptr{Libc.FILE},
+                                           Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_l_read_triplet(arg1, arg2)
-    @ccall libcholmod.cholmod_l_read_triplet(arg1::Ptr{Libc.FILE}, arg2::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_l_read_triplet(arg1::Ptr{Libc.FILE},
+                                             arg2::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_read_dense(f, Common)
-    @ccall libcholmod.cholmod_read_dense(f::Ptr{Libc.FILE}, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_read_dense(f::Ptr{Libc.FILE},
+                                         Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_read_dense(arg1, arg2)
-    @ccall libcholmod.cholmod_l_read_dense(arg1::Ptr{Libc.FILE}, arg2::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_read_dense(arg1::Ptr{Libc.FILE},
+                                           arg2::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_read_matrix(f, prefer, mtype, Common)
-    @ccall libcholmod.cholmod_read_matrix(f::Ptr{Libc.FILE}, prefer::Cint, mtype::Ptr{Cint}, Common::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_read_matrix(f::Ptr{Libc.FILE}, prefer::Cint, mtype::Ptr{Cint},
+                                          Common::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_l_read_matrix(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_read_matrix(arg1::Ptr{Libc.FILE}, arg2::Cint, arg3::Ptr{Cint}, arg4::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_l_read_matrix(arg1::Ptr{Libc.FILE}, arg2::Cint,
+                                            arg3::Ptr{Cint},
+                                            arg4::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_write_sparse(f, A, Z, comments, Common)
-    @ccall libcholmod.cholmod_write_sparse(f::Ptr{Libc.FILE}, A::Ptr{cholmod_sparse}, Z::Ptr{cholmod_sparse}, comments::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_write_sparse(f::Ptr{Libc.FILE}, A::Ptr{cholmod_sparse},
+                                           Z::Ptr{cholmod_sparse}, comments::Ptr{Cchar},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_write_sparse(arg1, arg2, arg3, c, arg5)
-    @ccall libcholmod.cholmod_l_write_sparse(arg1::Ptr{Libc.FILE}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_sparse}, c::Ptr{Cchar}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_write_sparse(arg1::Ptr{Libc.FILE},
+                                             arg2::Ptr{cholmod_sparse},
+                                             arg3::Ptr{cholmod_sparse}, c::Ptr{Cchar},
+                                             arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_write_dense(f, X, comments, Common)
-    @ccall libcholmod.cholmod_write_dense(f::Ptr{Libc.FILE}, X::Ptr{cholmod_dense}, comments::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_write_dense(f::Ptr{Libc.FILE}, X::Ptr{cholmod_dense},
+                                          comments::Ptr{Cchar},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_write_dense(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_write_dense(arg1::Ptr{Libc.FILE}, arg2::Ptr{cholmod_dense}, arg3::Ptr{Cchar}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_write_dense(arg1::Ptr{Libc.FILE}, arg2::Ptr{cholmod_dense},
+                                            arg3::Ptr{Cchar},
+                                            arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_analyze(A, Common)
-    @ccall libcholmod.cholmod_analyze(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_analyze(A::Ptr{cholmod_sparse},
+                                      Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_l_analyze(arg1, arg2)
-    @ccall libcholmod.cholmod_l_analyze(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_l_analyze(arg1::Ptr{cholmod_sparse},
+                                        arg2::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_analyze_p(A, UserPerm, fset, fsize, Common)
-    @ccall libcholmod.cholmod_analyze_p(A::Ptr{cholmod_sparse}, UserPerm::Ptr{Int32}, fset::Ptr{Int32}, fsize::Csize_t, Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_analyze_p(A::Ptr{cholmod_sparse}, UserPerm::Ptr{Int32},
+                                        fset::Ptr{Int32}, fsize::Csize_t,
+                                        Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_l_analyze_p(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_analyze_p(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Ptr{Int64}, arg4::Csize_t, arg5::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_l_analyze_p(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                          arg3::Ptr{Int64}, arg4::Csize_t,
+                                          arg5::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_analyze_p2(for_whom, A, UserPerm, fset, fsize, Common)
-    @ccall libcholmod.cholmod_analyze_p2(for_whom::Cint, A::Ptr{cholmod_sparse}, UserPerm::Ptr{Int32}, fset::Ptr{Int32}, fsize::Csize_t, Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_analyze_p2(for_whom::Cint, A::Ptr{cholmod_sparse},
+                                         UserPerm::Ptr{Int32}, fset::Ptr{Int32},
+                                         fsize::Csize_t,
+                                         Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_l_analyze_p2(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_analyze_p2(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Csize_t, arg6::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_l_analyze_p2(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                           arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                           arg5::Csize_t,
+                                           arg6::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_factorize(A, L, Common)
-    @ccall libcholmod.cholmod_factorize(A::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_factorize(A::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor},
+                                        Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_factorize(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_factorize(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_factorize(arg1::Ptr{cholmod_sparse},
+                                          arg2::Ptr{cholmod_factor},
+                                          arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_factorize_p(A, beta, fset, fsize, L, Common)
-    @ccall libcholmod.cholmod_factorize_p(A::Ptr{cholmod_sparse}, beta::Ptr{Cdouble}, fset::Ptr{Int32}, fsize::Csize_t, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_factorize_p(A::Ptr{cholmod_sparse}, beta::Ptr{Cdouble},
+                                          fset::Ptr{Int32}, fsize::Csize_t,
+                                          L::Ptr{cholmod_factor},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_factorize_p(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_factorize_p(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Cdouble}, arg3::Ptr{Int64}, arg4::Csize_t, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_factorize_p(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Cdouble},
+                                            arg3::Ptr{Int64}, arg4::Csize_t,
+                                            arg5::Ptr{cholmod_factor},
+                                            arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_solve(sys, L, B, Common)
-    @ccall libcholmod.cholmod_solve(sys::Cint, L::Ptr{cholmod_factor}, B::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_solve(sys::Cint, L::Ptr{cholmod_factor},
+                                    B::Ptr{cholmod_dense},
+                                    Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_solve(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_solve(arg1::Cint, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_dense}, arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_solve(arg1::Cint, arg2::Ptr{cholmod_factor},
+                                      arg3::Ptr{cholmod_dense},
+                                      arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_solve2(sys, L, B, Bset, X_Handle, Xset_Handle, Y_Handle, E_Handle, Common)
-    @ccall libcholmod.cholmod_solve2(sys::Cint, L::Ptr{cholmod_factor}, B::Ptr{cholmod_dense}, Bset::Ptr{cholmod_sparse}, X_Handle::Ptr{Ptr{cholmod_dense}}, Xset_Handle::Ptr{Ptr{cholmod_sparse}}, Y_Handle::Ptr{Ptr{cholmod_dense}}, E_Handle::Ptr{Ptr{cholmod_dense}}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_solve2(sys::Cint, L::Ptr{cholmod_factor},
+                                     B::Ptr{cholmod_dense}, Bset::Ptr{cholmod_sparse},
+                                     X_Handle::Ptr{Ptr{cholmod_dense}},
+                                     Xset_Handle::Ptr{Ptr{cholmod_sparse}},
+                                     Y_Handle::Ptr{Ptr{cholmod_dense}},
+                                     E_Handle::Ptr{Ptr{cholmod_dense}},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_solve2(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
-    @ccall libcholmod.cholmod_l_solve2(arg1::Cint, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_dense}, arg4::Ptr{cholmod_sparse}, arg5::Ptr{Ptr{cholmod_dense}}, arg6::Ptr{Ptr{cholmod_sparse}}, arg7::Ptr{Ptr{cholmod_dense}}, arg8::Ptr{Ptr{cholmod_dense}}, arg9::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_solve2(arg1::Cint, arg2::Ptr{cholmod_factor},
+                                       arg3::Ptr{cholmod_dense}, arg4::Ptr{cholmod_sparse},
+                                       arg5::Ptr{Ptr{cholmod_dense}},
+                                       arg6::Ptr{Ptr{cholmod_sparse}},
+                                       arg7::Ptr{Ptr{cholmod_dense}},
+                                       arg8::Ptr{Ptr{cholmod_dense}},
+                                       arg9::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_spsolve(sys, L, B, Common)
-    @ccall libcholmod.cholmod_spsolve(sys::Cint, L::Ptr{cholmod_factor}, B::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_spsolve(sys::Cint, L::Ptr{cholmod_factor},
+                                      B::Ptr{cholmod_sparse},
+                                      Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_spsolve(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_spsolve(arg1::Cint, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_sparse}, arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_spsolve(arg1::Cint, arg2::Ptr{cholmod_factor},
+                                        arg3::Ptr{cholmod_sparse},
+                                        arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_etree(A, Parent, Common)
-    @ccall libcholmod.cholmod_etree(A::Ptr{cholmod_sparse}, Parent::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_etree(A::Ptr{cholmod_sparse}, Parent::Ptr{Int32},
+                                    Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_etree(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_etree(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_etree(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                      arg3::Ptr{cholmod_common})::Cint
 end
 
-function cholmod_rowcolcounts(A, fset, fsize, Parent, Post, RowCount, ColCount, First, Level, Common)
-    @ccall libcholmod.cholmod_rowcolcounts(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, Parent::Ptr{Int32}, Post::Ptr{Int32}, RowCount::Ptr{Int32}, ColCount::Ptr{Int32}, First::Ptr{Int32}, Level::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+function cholmod_rowcolcounts(A, fset, fsize, Parent, Post, RowCount, ColCount, First,
+                              Level, Common)
+    @ccall libcholmod.cholmod_rowcolcounts(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                           fsize::Csize_t, Parent::Ptr{Int32},
+                                           Post::Ptr{Int32}, RowCount::Ptr{Int32},
+                                           ColCount::Ptr{Int32}, First::Ptr{Int32},
+                                           Level::Ptr{Int32},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowcolcounts(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)
-    @ccall libcholmod.cholmod_l_rowcolcounts(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{Int64}, arg6::Ptr{Int64}, arg7::Ptr{Int64}, arg8::Ptr{Int64}, arg9::Ptr{Int64}, arg10::Ptr{cholmod_common})::Cint
-end
-
-function cholmod_analyze_ordering(A, ordering, Perm, fset, fsize, Parent, Post, ColCount, First, Level, Common)
-    @ccall libcholmod.cholmod_analyze_ordering(A::Ptr{cholmod_sparse}, ordering::Cint, Perm::Ptr{Int32}, fset::Ptr{Int32}, fsize::Csize_t, Parent::Ptr{Int32}, Post::Ptr{Int32}, ColCount::Ptr{Int32}, First::Ptr{Int32}, Level::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
-end
-
-function cholmod_l_analyze_ordering(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11)
-    @ccall libcholmod.cholmod_l_analyze_ordering(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Csize_t, arg6::Ptr{Int64}, arg7::Ptr{Int64}, arg8::Ptr{Int64}, arg9::Ptr{Int64}, arg10::Ptr{Int64}, arg11::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowcolcounts(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                             arg3::Csize_t, arg4::Ptr{Int64},
+                                             arg5::Ptr{Int64}, arg6::Ptr{Int64},
+                                             arg7::Ptr{Int64}, arg8::Ptr{Int64},
+                                             arg9::Ptr{Int64},
+                                             arg10::Ptr{cholmod_common})::Cint
+end
+
+function cholmod_analyze_ordering(A, ordering, Perm, fset, fsize, Parent, Post, ColCount,
+                                  First, Level, Common)
+    @ccall libcholmod.cholmod_analyze_ordering(A::Ptr{cholmod_sparse}, ordering::Cint,
+                                               Perm::Ptr{Int32}, fset::Ptr{Int32},
+                                               fsize::Csize_t, Parent::Ptr{Int32},
+                                               Post::Ptr{Int32}, ColCount::Ptr{Int32},
+                                               First::Ptr{Int32}, Level::Ptr{Int32},
+                                               Common::Ptr{cholmod_common})::Cint
+end
+
+function cholmod_l_analyze_ordering(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9,
+                                    arg10, arg11)
+    @ccall libcholmod.cholmod_l_analyze_ordering(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                                 arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                                 arg5::Csize_t, arg6::Ptr{Int64},
+                                                 arg7::Ptr{Int64}, arg8::Ptr{Int64},
+                                                 arg9::Ptr{Int64}, arg10::Ptr{Int64},
+                                                 arg11::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_amd(A, fset, fsize, Perm, Common)
-    @ccall libcholmod.cholmod_amd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_amd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t,
+                                  Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_amd(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_amd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_amd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                    arg3::Csize_t, arg4::Ptr{Int64},
+                                    arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_colamd(A, fset, fsize, postorder, Perm, Common)
-    @ccall libcholmod.cholmod_colamd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, postorder::Cint, Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_colamd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                     fsize::Csize_t, postorder::Cint, Perm::Ptr{Int32},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_colamd(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_colamd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Cint, arg5::Ptr{Int64}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_colamd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                       arg3::Csize_t, arg4::Cint, arg5::Ptr{Int64},
+                                       arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowfac(A, F, beta, kstart, kend, L, Common)
-    @ccall libcholmod.cholmod_rowfac(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, beta::Ptr{Cdouble}, kstart::Csize_t, kend::Csize_t, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowfac(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse},
+                                     beta::Ptr{Cdouble}, kstart::Csize_t, kend::Csize_t,
+                                     L::Ptr{cholmod_factor},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowfac(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_rowfac(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Csize_t, arg5::Csize_t, arg6::Ptr{cholmod_factor}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowfac(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse},
+                                       arg3::Ptr{Cdouble}, arg4::Csize_t, arg5::Csize_t,
+                                       arg6::Ptr{cholmod_factor},
+                                       arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowfac_mask(A, F, beta, kstart, kend, mask, RLinkUp, L, Common)
-    @ccall libcholmod.cholmod_rowfac_mask(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, beta::Ptr{Cdouble}, kstart::Csize_t, kend::Csize_t, mask::Ptr{Int32}, RLinkUp::Ptr{Int32}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowfac_mask(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse},
+                                          beta::Ptr{Cdouble}, kstart::Csize_t,
+                                          kend::Csize_t, mask::Ptr{Int32},
+                                          RLinkUp::Ptr{Int32}, L::Ptr{cholmod_factor},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowfac_mask(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
-    @ccall libcholmod.cholmod_l_rowfac_mask(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Csize_t, arg5::Csize_t, arg6::Ptr{Int64}, arg7::Ptr{Int64}, arg8::Ptr{cholmod_factor}, arg9::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowfac_mask(arg1::Ptr{cholmod_sparse},
+                                            arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble},
+                                            arg4::Csize_t, arg5::Csize_t, arg6::Ptr{Int64},
+                                            arg7::Ptr{Int64}, arg8::Ptr{cholmod_factor},
+                                            arg9::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowfac_mask2(A, F, beta, kstart, kend, mask, maskmark, RLinkUp, L, Common)
-    @ccall libcholmod.cholmod_rowfac_mask2(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, beta::Ptr{Cdouble}, kstart::Csize_t, kend::Csize_t, mask::Ptr{Int32}, maskmark::Int32, RLinkUp::Ptr{Int32}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowfac_mask2(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse},
+                                           beta::Ptr{Cdouble}, kstart::Csize_t,
+                                           kend::Csize_t, mask::Ptr{Int32}, maskmark::Int32,
+                                           RLinkUp::Ptr{Int32}, L::Ptr{cholmod_factor},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowfac_mask2(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)
-    @ccall libcholmod.cholmod_l_rowfac_mask2(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Csize_t, arg5::Csize_t, arg6::Ptr{Int64}, arg7::Int64, arg8::Ptr{Int64}, arg9::Ptr{cholmod_factor}, arg10::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowfac_mask2(arg1::Ptr{cholmod_sparse},
+                                             arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble},
+                                             arg4::Csize_t, arg5::Csize_t, arg6::Ptr{Int64},
+                                             arg7::Int64, arg8::Ptr{Int64},
+                                             arg9::Ptr{cholmod_factor},
+                                             arg10::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_row_subtree(A, F, k, Parent, R, Common)
-    @ccall libcholmod.cholmod_row_subtree(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, k::Csize_t, Parent::Ptr{Int32}, R::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_row_subtree(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse},
+                                          k::Csize_t, Parent::Ptr{Int32},
+                                          R::Ptr{cholmod_sparse},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_row_subtree(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_row_subtree(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{cholmod_sparse}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_row_subtree(arg1::Ptr{cholmod_sparse},
+                                            arg2::Ptr{cholmod_sparse}, arg3::Csize_t,
+                                            arg4::Ptr{Int64}, arg5::Ptr{cholmod_sparse},
+                                            arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_lsolve_pattern(B, L, X, Common)
-    @ccall libcholmod.cholmod_lsolve_pattern(B::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_lsolve_pattern(B::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor},
+                                             X::Ptr{cholmod_sparse},
+                                             Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_lsolve_pattern(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_lsolve_pattern(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_sparse}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_lsolve_pattern(arg1::Ptr{cholmod_sparse},
+                                               arg2::Ptr{cholmod_factor},
+                                               arg3::Ptr{cholmod_sparse},
+                                               arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_row_lsubtree(A, Fi, fnz, k, L, R, Common)
-    @ccall libcholmod.cholmod_row_lsubtree(A::Ptr{cholmod_sparse}, Fi::Ptr{Int32}, fnz::Csize_t, k::Csize_t, L::Ptr{cholmod_factor}, R::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_row_lsubtree(A::Ptr{cholmod_sparse}, Fi::Ptr{Int32},
+                                           fnz::Csize_t, k::Csize_t, L::Ptr{cholmod_factor},
+                                           R::Ptr{cholmod_sparse},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_row_lsubtree(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_row_lsubtree(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Csize_t, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_sparse}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_row_lsubtree(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                             arg3::Csize_t, arg4::Csize_t,
+                                             arg5::Ptr{cholmod_factor},
+                                             arg6::Ptr{cholmod_sparse},
+                                             arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_resymbol(A, fset, fsize, pack, L, Common)
-    @ccall libcholmod.cholmod_resymbol(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, pack::Cint, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_resymbol(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                       fsize::Csize_t, pack::Cint, L::Ptr{cholmod_factor},
+                                       Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_resymbol(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_resymbol(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Cint, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_resymbol(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                         arg3::Csize_t, arg4::Cint,
+                                         arg5::Ptr{cholmod_factor},
+                                         arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_resymbol_noperm(A, fset, fsize, pack, L, Common)
-    @ccall libcholmod.cholmod_resymbol_noperm(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, pack::Cint, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_resymbol_noperm(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                              fsize::Csize_t, pack::Cint,
+                                              L::Ptr{cholmod_factor},
+                                              Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_resymbol_noperm(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_resymbol_noperm(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Cint, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_resymbol_noperm(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                                arg3::Csize_t, arg4::Cint,
+                                                arg5::Ptr{cholmod_factor},
+                                                arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rcond(L, Common)
-    @ccall libcholmod.cholmod_rcond(L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cdouble
+    @ccall libcholmod.cholmod_rcond(L::Ptr{cholmod_factor},
+                                    Common::Ptr{cholmod_common})::Cdouble
 end
 
 function cholmod_l_rcond(arg1, arg2)
-    @ccall libcholmod.cholmod_l_rcond(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_common})::Cdouble
+    @ccall libcholmod.cholmod_l_rcond(arg1::Ptr{cholmod_factor},
+                                      arg2::Ptr{cholmod_common})::Cdouble
 end
 
 function cholmod_postorder(Parent, n, Weight_p, Post, Common)
-    @ccall libcholmod.cholmod_postorder(Parent::Ptr{Int32}, n::Csize_t, Weight_p::Ptr{Int32}, Post::Ptr{Int32}, Common::Ptr{cholmod_common})::Int32
+    @ccall libcholmod.cholmod_postorder(Parent::Ptr{Int32}, n::Csize_t,
+                                        Weight_p::Ptr{Int32}, Post::Ptr{Int32},
+                                        Common::Ptr{cholmod_common})::Int32
 end
 
 function cholmod_l_postorder(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_postorder(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_l_postorder(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Ptr{Int64},
+                                          arg4::Ptr{Int64},
+                                          arg5::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_drop(tol, A, Common)
-    @ccall libcholmod.cholmod_drop(tol::Cdouble, A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_drop(tol::Cdouble, A::Ptr{cholmod_sparse},
+                                   Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_drop(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_drop(arg1::Cdouble, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_drop(arg1::Cdouble, arg2::Ptr{cholmod_sparse},
+                                     arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_norm_dense(X, norm, Common)
-    @ccall libcholmod.cholmod_norm_dense(X::Ptr{cholmod_dense}, norm::Cint, Common::Ptr{cholmod_common})::Cdouble
+    @ccall libcholmod.cholmod_norm_dense(X::Ptr{cholmod_dense}, norm::Cint,
+                                         Common::Ptr{cholmod_common})::Cdouble
 end
 
 function cholmod_l_norm_dense(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_norm_dense(arg1::Ptr{cholmod_dense}, arg2::Cint, arg3::Ptr{cholmod_common})::Cdouble
+    @ccall libcholmod.cholmod_l_norm_dense(arg1::Ptr{cholmod_dense}, arg2::Cint,
+                                           arg3::Ptr{cholmod_common})::Cdouble
 end
 
 function cholmod_norm_sparse(A, norm, Common)
-    @ccall libcholmod.cholmod_norm_sparse(A::Ptr{cholmod_sparse}, norm::Cint, Common::Ptr{cholmod_common})::Cdouble
+    @ccall libcholmod.cholmod_norm_sparse(A::Ptr{cholmod_sparse}, norm::Cint,
+                                          Common::Ptr{cholmod_common})::Cdouble
 end
 
 function cholmod_l_norm_sparse(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_norm_sparse(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{cholmod_common})::Cdouble
+    @ccall libcholmod.cholmod_l_norm_sparse(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                            arg3::Ptr{cholmod_common})::Cdouble
 end
 
 function cholmod_horzcat(A, B, values, Common)
-    @ccall libcholmod.cholmod_horzcat(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse}, values::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_horzcat(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse},
+                                      values::Cint,
+                                      Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_horzcat(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_horzcat(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_horzcat(arg1::Ptr{cholmod_sparse},
+                                        arg2::Ptr{cholmod_sparse}, arg3::Cint,
+                                        arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_scale(S, scale, A, Common)
-    @ccall libcholmod.cholmod_scale(S::Ptr{cholmod_dense}, scale::Cint, A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_scale(S::Ptr{cholmod_dense}, scale::Cint,
+                                    A::Ptr{cholmod_sparse},
+                                    Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_scale(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_scale(arg1::Ptr{cholmod_dense}, arg2::Cint, arg3::Ptr{cholmod_sparse}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_scale(arg1::Ptr{cholmod_dense}, arg2::Cint,
+                                      arg3::Ptr{cholmod_sparse},
+                                      arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_sdmult(A, transpose, alpha, beta, X, Y, Common)
-    @ccall libcholmod.cholmod_sdmult(A::Ptr{cholmod_sparse}, transpose::Cint, alpha::Ptr{Cdouble}, beta::Ptr{Cdouble}, X::Ptr{cholmod_dense}, Y::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_sdmult(A::Ptr{cholmod_sparse}, transpose::Cint,
+                                     alpha::Ptr{Cdouble}, beta::Ptr{Cdouble},
+                                     X::Ptr{cholmod_dense}, Y::Ptr{cholmod_dense},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_sdmult(arg1, arg2, arg3, arg4, arg5, Y, arg7)
-    @ccall libcholmod.cholmod_l_sdmult(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{Cdouble}, arg4::Ptr{Cdouble}, arg5::Ptr{cholmod_dense}, Y::Ptr{cholmod_dense}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_sdmult(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                       arg3::Ptr{Cdouble}, arg4::Ptr{Cdouble},
+                                       arg5::Ptr{cholmod_dense}, Y::Ptr{cholmod_dense},
+                                       arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_ssmult(A, B, stype, values, sorted, Common)
-    @ccall libcholmod.cholmod_ssmult(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse}, stype::Cint, values::Cint, sorted::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_ssmult(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse},
+                                     stype::Cint, values::Cint, sorted::Cint,
+                                     Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_ssmult(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_ssmult(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Cint, arg4::Cint, arg5::Cint, arg6::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_ssmult(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse},
+                                       arg3::Cint, arg4::Cint, arg5::Cint,
+                                       arg6::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_submatrix(A, rset, rsize, cset, csize, values, sorted, Common)
-    @ccall libcholmod.cholmod_submatrix(A::Ptr{cholmod_sparse}, rset::Ptr{Int32}, rsize::Int64, cset::Ptr{Int32}, csize::Int64, values::Cint, sorted::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_submatrix(A::Ptr{cholmod_sparse}, rset::Ptr{Int32},
+                                        rsize::Int64, cset::Ptr{Int32}, csize::Int64,
+                                        values::Cint, sorted::Cint,
+                                        Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_submatrix(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
-    @ccall libcholmod.cholmod_l_submatrix(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Int64, arg4::Ptr{Int64}, arg5::Int64, arg6::Cint, arg7::Cint, arg8::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_submatrix(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                          arg3::Int64, arg4::Ptr{Int64}, arg5::Int64,
+                                          arg6::Cint, arg7::Cint,
+                                          arg8::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_vertcat(A, B, values, Common)
-    @ccall libcholmod.cholmod_vertcat(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse}, values::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_vertcat(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse},
+                                      values::Cint,
+                                      Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_vertcat(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_vertcat(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_vertcat(arg1::Ptr{cholmod_sparse},
+                                        arg2::Ptr{cholmod_sparse}, arg3::Cint,
+                                        arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_symmetry(A, option, xmatched, pmatched, nzoffdiag, nzdiag, Common)
-    @ccall libcholmod.cholmod_symmetry(A::Ptr{cholmod_sparse}, option::Cint, xmatched::Ptr{Int32}, pmatched::Ptr{Int32}, nzoffdiag::Ptr{Int32}, nzdiag::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_symmetry(A::Ptr{cholmod_sparse}, option::Cint,
+                                       xmatched::Ptr{Int32}, pmatched::Ptr{Int32},
+                                       nzoffdiag::Ptr{Int32}, nzdiag::Ptr{Int32},
+                                       Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_symmetry(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_symmetry(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Ptr{Int64}, arg6::Ptr{Int64}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_symmetry(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                         arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                         arg5::Ptr{Int64}, arg6::Ptr{Int64},
+                                         arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_updown(update, C, L, Common)
-    @ccall libcholmod.cholmod_updown(update::Cint, C::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_updown(update::Cint, C::Ptr{cholmod_sparse},
+                                     L::Ptr{cholmod_factor},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_updown(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_updown(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_factor}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_updown(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                       arg3::Ptr{cholmod_factor},
+                                       arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_updown_solve(update, C, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_updown_solve(update::Cint, C::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_updown_solve(update::Cint, C::Ptr{cholmod_sparse},
+                                           L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense},
+                                           DeltaB::Ptr{cholmod_dense},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_updown_solve(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_updown_solve(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_factor}, arg4::Ptr{cholmod_dense}, arg5::Ptr{cholmod_dense}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_updown_solve(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                             arg3::Ptr{cholmod_factor},
+                                             arg4::Ptr{cholmod_dense},
+                                             arg5::Ptr{cholmod_dense},
+                                             arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_updown_mark(update, C, colmark, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_updown_mark(update::Cint, C::Ptr{cholmod_sparse}, colmark::Ptr{Int32}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_updown_mark(update::Cint, C::Ptr{cholmod_sparse},
+                                          colmark::Ptr{Int32}, L::Ptr{cholmod_factor},
+                                          X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_updown_mark(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_updown_mark(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Int64}, arg4::Ptr{cholmod_factor}, arg5::Ptr{cholmod_dense}, arg6::Ptr{cholmod_dense}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_updown_mark(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                            arg3::Ptr{Int64}, arg4::Ptr{cholmod_factor},
+                                            arg5::Ptr{cholmod_dense},
+                                            arg6::Ptr{cholmod_dense},
+                                            arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_updown_mask(update, C, colmark, mask, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_updown_mask(update::Cint, C::Ptr{cholmod_sparse}, colmark::Ptr{Int32}, mask::Ptr{Int32}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_updown_mask(update::Cint, C::Ptr{cholmod_sparse},
+                                          colmark::Ptr{Int32}, mask::Ptr{Int32},
+                                          L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense},
+                                          DeltaB::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_updown_mask(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
-    @ccall libcholmod.cholmod_l_updown_mask(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_dense}, arg7::Ptr{cholmod_dense}, arg8::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_updown_mask(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                            arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                            arg5::Ptr{cholmod_factor},
+                                            arg6::Ptr{cholmod_dense},
+                                            arg7::Ptr{cholmod_dense},
+                                            arg8::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_updown_mask2(update, C, colmark, mask, maskmark, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_updown_mask2(update::Cint, C::Ptr{cholmod_sparse}, colmark::Ptr{Int32}, mask::Ptr{Int32}, maskmark::Int32, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_updown_mask2(update::Cint, C::Ptr{cholmod_sparse},
+                                           colmark::Ptr{Int32}, mask::Ptr{Int32},
+                                           maskmark::Int32, L::Ptr{cholmod_factor},
+                                           X::Ptr{cholmod_dense},
+                                           DeltaB::Ptr{cholmod_dense},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_updown_mask2(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
-    @ccall libcholmod.cholmod_l_updown_mask2(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Int64, arg6::Ptr{cholmod_factor}, arg7::Ptr{cholmod_dense}, arg8::Ptr{cholmod_dense}, arg9::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_updown_mask2(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                             arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                             arg5::Int64, arg6::Ptr{cholmod_factor},
+                                             arg7::Ptr{cholmod_dense},
+                                             arg8::Ptr{cholmod_dense},
+                                             arg9::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowadd(k, R, L, Common)
-    @ccall libcholmod.cholmod_rowadd(k::Csize_t, R::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowadd(k::Csize_t, R::Ptr{cholmod_sparse},
+                                     L::Ptr{cholmod_factor},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowadd(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_rowadd(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_factor}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowadd(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                       arg3::Ptr{cholmod_factor},
+                                       arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowadd_solve(k, R, bk, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_rowadd_solve(k::Csize_t, R::Ptr{cholmod_sparse}, bk::Ptr{Cdouble}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowadd_solve(k::Csize_t, R::Ptr{cholmod_sparse},
+                                           bk::Ptr{Cdouble}, L::Ptr{cholmod_factor},
+                                           X::Ptr{cholmod_dense},
+                                           DeltaB::Ptr{cholmod_dense},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowadd_solve(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_rowadd_solve(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Ptr{cholmod_factor}, arg5::Ptr{cholmod_dense}, arg6::Ptr{cholmod_dense}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowadd_solve(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                             arg3::Ptr{Cdouble}, arg4::Ptr{cholmod_factor},
+                                             arg5::Ptr{cholmod_dense},
+                                             arg6::Ptr{cholmod_dense},
+                                             arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowadd_mark(k, R, bk, colmark, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_rowadd_mark(k::Csize_t, R::Ptr{cholmod_sparse}, bk::Ptr{Cdouble}, colmark::Ptr{Int32}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowadd_mark(k::Csize_t, R::Ptr{cholmod_sparse},
+                                          bk::Ptr{Cdouble}, colmark::Ptr{Int32},
+                                          L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense},
+                                          DeltaB::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowadd_mark(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
-    @ccall libcholmod.cholmod_l_rowadd_mark(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Ptr{Int64}, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_dense}, arg7::Ptr{cholmod_dense}, arg8::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowadd_mark(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                            arg3::Ptr{Cdouble}, arg4::Ptr{Int64},
+                                            arg5::Ptr{cholmod_factor},
+                                            arg6::Ptr{cholmod_dense},
+                                            arg7::Ptr{cholmod_dense},
+                                            arg8::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowdel(k, R, L, Common)
-    @ccall libcholmod.cholmod_rowdel(k::Csize_t, R::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowdel(k::Csize_t, R::Ptr{cholmod_sparse},
+                                     L::Ptr{cholmod_factor},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowdel(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_rowdel(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_factor}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowdel(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                       arg3::Ptr{cholmod_factor},
+                                       arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowdel_solve(k, R, yk, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_rowdel_solve(k::Csize_t, R::Ptr{cholmod_sparse}, yk::Ptr{Cdouble}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowdel_solve(k::Csize_t, R::Ptr{cholmod_sparse},
+                                           yk::Ptr{Cdouble}, L::Ptr{cholmod_factor},
+                                           X::Ptr{cholmod_dense},
+                                           DeltaB::Ptr{cholmod_dense},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowdel_solve(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_rowdel_solve(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Ptr{cholmod_factor}, arg5::Ptr{cholmod_dense}, arg6::Ptr{cholmod_dense}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowdel_solve(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                             arg3::Ptr{Cdouble}, arg4::Ptr{cholmod_factor},
+                                             arg5::Ptr{cholmod_dense},
+                                             arg6::Ptr{cholmod_dense},
+                                             arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowdel_mark(k, R, yk, colmark, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_rowdel_mark(k::Csize_t, R::Ptr{cholmod_sparse}, yk::Ptr{Cdouble}, colmark::Ptr{Int32}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowdel_mark(k::Csize_t, R::Ptr{cholmod_sparse},
+                                          yk::Ptr{Cdouble}, colmark::Ptr{Int32},
+                                          L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense},
+                                          DeltaB::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowdel_mark(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
-    @ccall libcholmod.cholmod_l_rowdel_mark(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Ptr{Int64}, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_dense}, arg7::Ptr{cholmod_dense}, arg8::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowdel_mark(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                            arg3::Ptr{Cdouble}, arg4::Ptr{Int64},
+                                            arg5::Ptr{cholmod_factor},
+                                            arg6::Ptr{cholmod_dense},
+                                            arg7::Ptr{cholmod_dense},
+                                            arg8::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_ccolamd(A, fset, fsize, Cmember, Perm, Common)
-    @ccall libcholmod.cholmod_ccolamd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, Cmember::Ptr{Int32}, Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_ccolamd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                      fsize::Csize_t, Cmember::Ptr{Int32}, Perm::Ptr{Int32},
+                                      Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_ccolamd(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_ccolamd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{Int64}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_ccolamd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                        arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{Int64},
+                                        arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_csymamd(A, Cmember, Perm, Common)
-    @ccall libcholmod.cholmod_csymamd(A::Ptr{cholmod_sparse}, Cmember::Ptr{Int32}, Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_csymamd(A::Ptr{cholmod_sparse}, Cmember::Ptr{Int32},
+                                      Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_csymamd(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_csymamd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Ptr{Int64}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_csymamd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                        arg3::Ptr{Int64}, arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_camd(A, fset, fsize, Cmember, Perm, Common)
-    @ccall libcholmod.cholmod_camd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, Cmember::Ptr{Int32}, Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_camd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t,
+                                   Cmember::Ptr{Int32}, Perm::Ptr{Int32},
+                                   Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_camd(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_camd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{Int64}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_camd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                     arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{Int64},
+                                     arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_nested_dissection(A, fset, fsize, Perm, CParent, Cmember, Common)
-    @ccall libcholmod.cholmod_nested_dissection(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, Perm::Ptr{Int32}, CParent::Ptr{Int32}, Cmember::Ptr{Int32}, Common::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_nested_dissection(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                                fsize::Csize_t, Perm::Ptr{Int32},
+                                                CParent::Ptr{Int32}, Cmember::Ptr{Int32},
+                                                Common::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_l_nested_dissection(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_nested_dissection(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{Int64}, arg6::Ptr{Int64}, arg7::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_l_nested_dissection(arg1::Ptr{cholmod_sparse},
+                                                  arg2::Ptr{Int64}, arg3::Csize_t,
+                                                  arg4::Ptr{Int64}, arg5::Ptr{Int64},
+                                                  arg6::Ptr{Int64},
+                                                  arg7::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_metis(A, fset, fsize, postorder, Perm, Common)
-    @ccall libcholmod.cholmod_metis(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, postorder::Cint, Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_metis(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                    fsize::Csize_t, postorder::Cint, Perm::Ptr{Int32},
+                                    Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_metis(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_metis(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Cint, arg5::Ptr{Int64}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_metis(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                      arg3::Csize_t, arg4::Cint, arg5::Ptr{Int64},
+                                      arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_bisect(A, fset, fsize, compress, Partition, Common)
-    @ccall libcholmod.cholmod_bisect(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, compress::Cint, Partition::Ptr{Int32}, Common::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_bisect(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                     fsize::Csize_t, compress::Cint, Partition::Ptr{Int32},
+                                     Common::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_l_bisect(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_bisect(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Cint, arg5::Ptr{Int64}, arg6::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_l_bisect(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                       arg3::Csize_t, arg4::Cint, arg5::Ptr{Int64},
+                                       arg6::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_metis_bisector(A, Anw, Aew, Partition, Common)
-    @ccall libcholmod.cholmod_metis_bisector(A::Ptr{cholmod_sparse}, Anw::Ptr{Int32}, Aew::Ptr{Int32}, Partition::Ptr{Int32}, Common::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_metis_bisector(A::Ptr{cholmod_sparse}, Anw::Ptr{Int32},
+                                             Aew::Ptr{Int32}, Partition::Ptr{Int32},
+                                             Common::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_l_metis_bisector(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_metis_bisector(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_l_metis_bisector(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                               arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                               arg5::Ptr{cholmod_common})::Int64
 end
 
-function cholmod_collapse_septree(n, ncomponents, nd_oksep, nd_small, CParent, Cmember, Common)
-    @ccall libcholmod.cholmod_collapse_septree(n::Csize_t, ncomponents::Csize_t, nd_oksep::Cdouble, nd_small::Csize_t, CParent::Ptr{Int32}, Cmember::Ptr{Int32}, Common::Ptr{cholmod_common})::Int64
+function cholmod_collapse_septree(n, ncomponents, nd_oksep, nd_small, CParent, Cmember,
+                                  Common)
+    @ccall libcholmod.cholmod_collapse_septree(n::Csize_t, ncomponents::Csize_t,
+                                               nd_oksep::Cdouble, nd_small::Csize_t,
+                                               CParent::Ptr{Int32}, Cmember::Ptr{Int32},
+                                               Common::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_l_collapse_septree(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_collapse_septree(arg1::Csize_t, arg2::Csize_t, arg3::Cdouble, arg4::Csize_t, arg5::Ptr{Int64}, arg6::Ptr{Int64}, arg7::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_l_collapse_septree(arg1::Csize_t, arg2::Csize_t,
+                                                 arg3::Cdouble, arg4::Csize_t,
+                                                 arg5::Ptr{Int64}, arg6::Ptr{Int64},
+                                                 arg7::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_super_symbolic(A, F, Parent, L, Common)
-    @ccall libcholmod.cholmod_super_symbolic(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, Parent::Ptr{Int32}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_super_symbolic(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse},
+                                             Parent::Ptr{Int32}, L::Ptr{cholmod_factor},
+                                             Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_super_symbolic(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_super_symbolic(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Int64}, arg4::Ptr{cholmod_factor}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_super_symbolic(arg1::Ptr{cholmod_sparse},
+                                               arg2::Ptr{cholmod_sparse}, arg3::Ptr{Int64},
+                                               arg4::Ptr{cholmod_factor},
+                                               arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_super_symbolic2(for_whom, A, F, Parent, L, Common)
-    @ccall libcholmod.cholmod_super_symbolic2(for_whom::Cint, A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, Parent::Ptr{Int32}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_super_symbolic2(for_whom::Cint, A::Ptr{cholmod_sparse},
+                                              F::Ptr{cholmod_sparse}, Parent::Ptr{Int32},
+                                              L::Ptr{cholmod_factor},
+                                              Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_super_symbolic2(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_super_symbolic2(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_sparse}, arg4::Ptr{Int64}, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_super_symbolic2(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                                arg3::Ptr{cholmod_sparse}, arg4::Ptr{Int64},
+                                                arg5::Ptr{cholmod_factor},
+                                                arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_super_numeric(A, F, beta, L, Common)
-    @ccall libcholmod.cholmod_super_numeric(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, beta::Ptr{Cdouble}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_super_numeric(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse},
+                                            beta::Ptr{Cdouble}, L::Ptr{cholmod_factor},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_super_numeric(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_super_numeric(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Ptr{cholmod_factor}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_super_numeric(arg1::Ptr{cholmod_sparse},
+                                              arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble},
+                                              arg4::Ptr{cholmod_factor},
+                                              arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_super_lsolve(L, X, E, Common)
-    @ccall libcholmod.cholmod_super_lsolve(L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, E::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_super_lsolve(L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense},
+                                           E::Ptr{cholmod_dense},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_super_lsolve(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_super_lsolve(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_dense}, arg3::Ptr{cholmod_dense}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_super_lsolve(arg1::Ptr{cholmod_factor},
+                                             arg2::Ptr{cholmod_dense},
+                                             arg3::Ptr{cholmod_dense},
+                                             arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_super_ltsolve(L, X, E, Common)
-    @ccall libcholmod.cholmod_super_ltsolve(L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, E::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_super_ltsolve(L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense},
+                                            E::Ptr{cholmod_dense},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_super_ltsolve(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_super_ltsolve(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_dense}, arg3::Ptr{cholmod_dense}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_super_ltsolve(arg1::Ptr{cholmod_factor},
+                                              arg2::Ptr{cholmod_dense},
+                                              arg3::Ptr{cholmod_dense},
+                                              arg4::Ptr{cholmod_common})::Cint
+end
+
+function SuiteSparseQR_C(ordering, tol, econ, getCTX, A, Bsparse, Bdense, Zsparse, Zdense,
+                         R, E, H, HPinv, HTau, cc)
+    @ccall libspqr.SuiteSparseQR_C(ordering::Cint, tol::Cdouble, econ::Int64, getCTX::Cint,
+                                   A::Ptr{cholmod_sparse}, Bsparse::Ptr{cholmod_sparse},
+                                   Bdense::Ptr{cholmod_dense},
+                                   Zsparse::Ptr{Ptr{cholmod_sparse}},
+                                   Zdense::Ptr{Ptr{cholmod_dense}},
+                                   R::Ptr{Ptr{cholmod_sparse}}, E::Ptr{Ptr{Int64}},
+                                   H::Ptr{Ptr{cholmod_sparse}}, HPinv::Ptr{Ptr{Int64}},
+                                   HTau::Ptr{Ptr{cholmod_dense}},
+                                   cc::Ptr{cholmod_common})::Int64
+end
+
+function SuiteSparseQR_i_C(ordering, tol, econ, getCTX, A, Bsparse, Bdense, Zsparse, Zdense,
+                           R, E, H, HPinv, HTau, cc)
+    @ccall libspqr.SuiteSparseQR_i_C(ordering::Cint, tol::Cdouble, econ::Int32,
+                                     getCTX::Cint, A::Ptr{cholmod_sparse},
+                                     Bsparse::Ptr{cholmod_sparse},
+                                     Bdense::Ptr{cholmod_dense},
+                                     Zsparse::Ptr{Ptr{cholmod_sparse}},
+                                     Zdense::Ptr{Ptr{cholmod_dense}},
+                                     R::Ptr{Ptr{cholmod_sparse}}, E::Ptr{Ptr{Int32}},
+                                     H::Ptr{Ptr{cholmod_sparse}}, HPinv::Ptr{Ptr{Int32}},
+                                     HTau::Ptr{Ptr{cholmod_dense}},
+                                     cc::Ptr{cholmod_common})::Int32
 end
 
-function SuiteSparseQR_C(ordering, tol, econ, getCTX, A, Bsparse, Bdense, Zsparse, Zdense, R, E, H, HPinv, HTau, cc)
-    @ccall libspqr.SuiteSparseQR_C(ordering::Cint, tol::Cdouble, econ::Int64, getCTX::Cint, A::Ptr{cholmod_sparse}, Bsparse::Ptr{cholmod_sparse}, Bdense::Ptr{cholmod_dense}, Zsparse::Ptr{Ptr{cholmod_sparse}}, Zdense::Ptr{Ptr{cholmod_dense}}, R::Ptr{Ptr{cholmod_sparse}}, E::Ptr{Ptr{Int64}}, H::Ptr{Ptr{cholmod_sparse}}, HPinv::Ptr{Ptr{Int64}}, HTau::Ptr{Ptr{cholmod_dense}}, cc::Ptr{cholmod_common})::Int64
+function SuiteSparseQR_C_QR(ordering, tol, econ, A, Q, R, E, cc)
+    @ccall libspqr.SuiteSparseQR_C_QR(ordering::Cint, tol::Cdouble, econ::Int64,
+                                      A::Ptr{cholmod_sparse}, Q::Ptr{Ptr{cholmod_sparse}},
+                                      R::Ptr{Ptr{cholmod_sparse}}, E::Ptr{Ptr{Int64}},
+                                      cc::Ptr{cholmod_common})::Int64
 end
 
-function SuiteSparseQR_C_QR(ordering, tol, econ, A, Q, R, E, cc)
-    @ccall libspqr.SuiteSparseQR_C_QR(ordering::Cint, tol::Cdouble, econ::Int64, A::Ptr{cholmod_sparse}, Q::Ptr{Ptr{cholmod_sparse}}, R::Ptr{Ptr{cholmod_sparse}}, E::Ptr{Ptr{Int64}}, cc::Ptr{cholmod_common})::Int64
+function SuiteSparseQR_i_C_QR(ordering, tol, econ, A, Q, R, E, cc)
+    @ccall libspqr.SuiteSparseQR_i_C_QR(ordering::Cint, tol::Cdouble, econ::Int32,
+                                        A::Ptr{cholmod_sparse}, Q::Ptr{Ptr{cholmod_sparse}},
+                                        R::Ptr{Ptr{cholmod_sparse}}, E::Ptr{Ptr{Int32}},
+                                        cc::Ptr{cholmod_common})::Int32
 end
 
 function SuiteSparseQR_C_backslash(ordering, tol, A, B, cc)
-    @ccall libspqr.SuiteSparseQR_C_backslash(ordering::Cint, tol::Cdouble, A::Ptr{cholmod_sparse}, B::Ptr{cholmod_dense}, cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libspqr.SuiteSparseQR_C_backslash(ordering::Cint, tol::Cdouble,
+                                             A::Ptr{cholmod_sparse}, B::Ptr{cholmod_dense},
+                                             cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function SuiteSparseQR_C_backslash_default(A, B, cc)
-    @ccall libspqr.SuiteSparseQR_C_backslash_default(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_dense}, cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libspqr.SuiteSparseQR_C_backslash_default(A::Ptr{cholmod_sparse},
+                                                     B::Ptr{cholmod_dense},
+                                                     cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function SuiteSparseQR_C_backslash_sparse(ordering, tol, A, B, cc)
-    @ccall libspqr.SuiteSparseQR_C_backslash_sparse(ordering::Cint, tol::Cdouble, A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse}, cc::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libspqr.SuiteSparseQR_C_backslash_sparse(ordering::Cint, tol::Cdouble,
+                                                    A::Ptr{cholmod_sparse},
+                                                    B::Ptr{cholmod_sparse},
+                                                    cc::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 mutable struct SuiteSparseQR_C_factorization_struct
     xtype::Cint
+    itype::Cint
     factors::Ptr{Cvoid}
     SuiteSparseQR_C_factorization_struct() = new()
 end
@@ -1536,51 +2115,78 @@ end
 const SuiteSparseQR_C_factorization = SuiteSparseQR_C_factorization_struct
 
 function SuiteSparseQR_C_factorize(ordering, tol, A, cc)
-    @ccall libspqr.SuiteSparseQR_C_factorize(ordering::Cint, tol::Cdouble, A::Ptr{cholmod_sparse}, cc::Ptr{cholmod_common})::Ptr{SuiteSparseQR_C_factorization}
+    @ccall libspqr.SuiteSparseQR_C_factorize(ordering::Cint, tol::Cdouble,
+                                             A::Ptr{cholmod_sparse},
+                                             cc::Ptr{cholmod_common})::Ptr{SuiteSparseQR_C_factorization}
 end
 
 function SuiteSparseQR_C_symbolic(ordering, allow_tol, A, cc)
-    @ccall libspqr.SuiteSparseQR_C_symbolic(ordering::Cint, allow_tol::Cint, A::Ptr{cholmod_sparse}, cc::Ptr{cholmod_common})::Ptr{SuiteSparseQR_C_factorization}
+    @ccall libspqr.SuiteSparseQR_C_symbolic(ordering::Cint, allow_tol::Cint,
+                                            A::Ptr{cholmod_sparse},
+                                            cc::Ptr{cholmod_common})::Ptr{SuiteSparseQR_C_factorization}
 end
 
 function SuiteSparseQR_C_numeric(tol, A, QR, cc)
-    @ccall libspqr.SuiteSparseQR_C_numeric(tol::Cdouble, A::Ptr{cholmod_sparse}, QR::Ptr{SuiteSparseQR_C_factorization}, cc::Ptr{cholmod_common})::Cint
+    @ccall libspqr.SuiteSparseQR_C_numeric(tol::Cdouble, A::Ptr{cholmod_sparse},
+                                           QR::Ptr{SuiteSparseQR_C_factorization},
+                                           cc::Ptr{cholmod_common})::Cint
 end
 
 function SuiteSparseQR_C_free(QR, cc)
-    @ccall libspqr.SuiteSparseQR_C_free(QR::Ptr{Ptr{SuiteSparseQR_C_factorization}}, cc::Ptr{cholmod_common})::Cint
+    @ccall libspqr.SuiteSparseQR_C_free(QR::Ptr{Ptr{SuiteSparseQR_C_factorization}},
+                                        cc::Ptr{cholmod_common})::Cint
 end
 
 function SuiteSparseQR_C_solve(system, QR, B, cc)
-    @ccall libspqr.SuiteSparseQR_C_solve(system::Cint, QR::Ptr{SuiteSparseQR_C_factorization}, B::Ptr{cholmod_dense}, cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libspqr.SuiteSparseQR_C_solve(system::Cint,
+                                         QR::Ptr{SuiteSparseQR_C_factorization},
+                                         B::Ptr{cholmod_dense},
+                                         cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function SuiteSparseQR_C_qmult(method, QR, X, cc)
-    @ccall libspqr.SuiteSparseQR_C_qmult(method::Cint, QR::Ptr{SuiteSparseQR_C_factorization}, X::Ptr{cholmod_dense}, cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libspqr.SuiteSparseQR_C_qmult(method::Cint,
+                                         QR::Ptr{SuiteSparseQR_C_factorization},
+                                         X::Ptr{cholmod_dense},
+                                         cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function amd_order(n, Ap, Ai, P, Control, Info)
-    @ccall libamd.amd_order(n::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, P::Ptr{Int32}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libamd.amd_order(n::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, P::Ptr{Int32},
+                            Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function amd_l_order(n, Ap, Ai, P, Control, Info)
-    @ccall libamd.amd_l_order(n::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, P::Ptr{Int64}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libamd.amd_l_order(n::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, P::Ptr{Int64},
+                              Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
-function amd_2(n, Pe, Iw, Len, iwlen, pfree, Nv, Next, Last, Head, Elen, Degree, W, Control, Info)
-    @ccall libamd.amd_2(n::Int32, Pe::Ptr{Int32}, Iw::Ptr{Int32}, Len::Ptr{Int32}, iwlen::Int32, pfree::Int32, Nv::Ptr{Int32}, Next::Ptr{Int32}, Last::Ptr{Int32}, Head::Ptr{Int32}, Elen::Ptr{Int32}, Degree::Ptr{Int32}, W::Ptr{Int32}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cvoid
+function amd_2(n, Pe, Iw, Len, iwlen, pfree, Nv, Next, Last, Head, Elen, Degree, W, Control,
+               Info)
+    @ccall libamd.amd_2(n::Int32, Pe::Ptr{Int32}, Iw::Ptr{Int32}, Len::Ptr{Int32},
+                        iwlen::Int32, pfree::Int32, Nv::Ptr{Int32}, Next::Ptr{Int32},
+                        Last::Ptr{Int32}, Head::Ptr{Int32}, Elen::Ptr{Int32},
+                        Degree::Ptr{Int32}, W::Ptr{Int32}, Control::Ptr{Cdouble},
+                        Info::Ptr{Cdouble})::Cvoid
 end
 
-function amd_l2(n, Pe, Iw, Len, iwlen, pfree, Nv, Next, Last, Head, Elen, Degree, W, Control, Info)
-    @ccall libamd.amd_l2(n::Int64, Pe::Ptr{Int64}, Iw::Ptr{Int64}, Len::Ptr{Int64}, iwlen::Int64, pfree::Int64, Nv::Ptr{Int64}, Next::Ptr{Int64}, Last::Ptr{Int64}, Head::Ptr{Int64}, Elen::Ptr{Int64}, Degree::Ptr{Int64}, W::Ptr{Int64}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cvoid
+function amd_l2(n, Pe, Iw, Len, iwlen, pfree, Nv, Next, Last, Head, Elen, Degree, W,
+                Control, Info)
+    @ccall libamd.amd_l2(n::Int64, Pe::Ptr{Int64}, Iw::Ptr{Int64}, Len::Ptr{Int64},
+                         iwlen::Int64, pfree::Int64, Nv::Ptr{Int64}, Next::Ptr{Int64},
+                         Last::Ptr{Int64}, Head::Ptr{Int64}, Elen::Ptr{Int64},
+                         Degree::Ptr{Int64}, W::Ptr{Int64}, Control::Ptr{Cdouble},
+                         Info::Ptr{Cdouble})::Cvoid
 end
 
 function amd_valid(n_row, n_col, Ap, Ai)
-    @ccall libamd.amd_valid(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32})::Cint
+    @ccall libamd.amd_valid(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                            Ai::Ptr{Int32})::Cint
 end
 
 function amd_l_valid(n_row, n_col, Ap, Ai)
-    @ccall libamd.amd_l_valid(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64})::Cint
+    @ccall libamd.amd_l_valid(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                              Ai::Ptr{Int64})::Cint
 end
 
 function amd_defaults(Control)
@@ -1607,188 +2213,88 @@ function amd_l_info(Info)
     @ccall libamd.amd_l_info(Info::Ptr{Cdouble})::Cvoid
 end
 
-function colamd_recommended(nnz, n_row, n_col)
-    @ccall libcolamd.colamd_recommended(nnz::Int32, n_row::Int32, n_col::Int32)::Csize_t
-end
-
-function colamd_l_recommended(nnz, n_row, n_col)
-    @ccall libcolamd.colamd_l_recommended(nnz::Int64, n_row::Int64, n_col::Int64)::Csize_t
-end
-
-function colamd_set_defaults(knobs)
-    @ccall libcolamd.colamd_set_defaults(knobs::Ptr{Cdouble})::Cvoid
-end
-
-function colamd_l_set_defaults(knobs)
-    @ccall libcolamd.colamd_l_set_defaults(knobs::Ptr{Cdouble})::Cvoid
-end
-
-function colamd(n_row, n_col, Alen, A, p, knobs, stats)
-    @ccall libcolamd.colamd(n_row::Int32, n_col::Int32, Alen::Int32, A::Ptr{Int32}, p::Ptr{Int32}, knobs::Ptr{Cdouble}, stats::Ptr{Int32})::Cint
-end
-
-function colamd_l(n_row, n_col, Alen, A, p, knobs, stats)
-    @ccall libcolamd.colamd_l(n_row::Int64, n_col::Int64, Alen::Int64, A::Ptr{Int64}, p::Ptr{Int64}, knobs::Ptr{Cdouble}, stats::Ptr{Int64})::Cint
-end
-
-function symamd(n, A, p, perm, knobs, stats, allocate, release)
-    @ccall libcolamd.symamd(n::Int32, A::Ptr{Int32}, p::Ptr{Int32}, perm::Ptr{Int32}, knobs::Ptr{Cdouble}, stats::Ptr{Int32}, allocate::Ptr{Cvoid}, release::Ptr{Cvoid})::Cint
-end
-
-function symamd_l(n, A, p, perm, knobs, stats, allocate, release)
-    @ccall libcolamd.symamd_l(n::Int64, A::Ptr{Int64}, p::Ptr{Int64}, perm::Ptr{Int64}, knobs::Ptr{Cdouble}, stats::Ptr{Int64}, allocate::Ptr{Cvoid}, release::Ptr{Cvoid})::Cint
-end
-
-function colamd_report(stats)
-    @ccall libcolamd.colamd_report(stats::Ptr{Int32})::Cvoid
-end
-
-function colamd_l_report(stats)
-    @ccall libcolamd.colamd_l_report(stats::Ptr{Int64})::Cvoid
-end
-
-function symamd_report(stats)
-    @ccall libcolamd.symamd_report(stats::Ptr{Int32})::Cvoid
-end
-
-function symamd_l_report(stats)
-    @ccall libcolamd.symamd_l_report(stats::Ptr{Int64})::Cvoid
-end
-
-function ccolamd_recommended(nnz, n_row, n_col)
-    @ccall libcolamd.ccolamd_recommended(nnz::Cint, n_row::Cint, n_col::Cint)::Csize_t
-end
-
-function ccolamd_l_recommended(nnz, n_row, n_col)
-    @ccall libcolamd.ccolamd_l_recommended(nnz::Int64, n_row::Int64, n_col::Int64)::Csize_t
-end
-
-function ccolamd_set_defaults(knobs)
-    @ccall libcolamd.ccolamd_set_defaults(knobs::Ptr{Cdouble})::Cvoid
-end
-
-function ccolamd_l_set_defaults(knobs)
-    @ccall libcolamd.ccolamd_l_set_defaults(knobs::Ptr{Cdouble})::Cvoid
-end
-
-function ccolamd(n_row, n_col, Alen, A, p, knobs, stats, cmember)
-    @ccall libcolamd.ccolamd(n_row::Cint, n_col::Cint, Alen::Cint, A::Ptr{Cint}, p::Ptr{Cint}, knobs::Ptr{Cdouble}, stats::Ptr{Cint}, cmember::Ptr{Cint})::Cint
-end
-
-function ccolamd_l(n_row, n_col, Alen, A, p, knobs, stats, cmember)
-    @ccall libcolamd.ccolamd_l(n_row::Int64, n_col::Int64, Alen::Int64, A::Ptr{Int64}, p::Ptr{Int64}, knobs::Ptr{Cdouble}, stats::Ptr{Int64}, cmember::Ptr{Int64})::Cint
-end
-
-function csymamd(n, A, p, perm, knobs, stats, allocate, release, cmember, stype)
-    @ccall libcolamd.csymamd(n::Cint, A::Ptr{Cint}, p::Ptr{Cint}, perm::Ptr{Cint}, knobs::Ptr{Cdouble}, stats::Ptr{Cint}, allocate::Ptr{Cvoid}, release::Ptr{Cvoid}, cmember::Ptr{Cint}, stype::Cint)::Cint
-end
-
-function csymamd_l(n, A, p, perm, knobs, stats, allocate, release, cmember, stype)
-    @ccall libcolamd.csymamd_l(n::Int64, A::Ptr{Int64}, p::Ptr{Int64}, perm::Ptr{Int64}, knobs::Ptr{Cdouble}, stats::Ptr{Int64}, allocate::Ptr{Cvoid}, release::Ptr{Cvoid}, cmember::Ptr{Int64}, stype::Int64)::Cint
-end
-
-function ccolamd_report(stats)
-    @ccall libcolamd.ccolamd_report(stats::Ptr{Cint})::Cvoid
-end
-
-function ccolamd_l_report(stats)
-    @ccall libcolamd.ccolamd_l_report(stats::Ptr{Int64})::Cvoid
-end
-
-function csymamd_report(stats)
-    @ccall libcolamd.csymamd_report(stats::Ptr{Cint})::Cvoid
-end
-
-function csymamd_l_report(stats)
-    @ccall libcolamd.csymamd_l_report(stats::Ptr{Int64})::Cvoid
-end
-
-function ccolamd2(n_row, n_col, Alen, A, p, knobs, stats, Front_npivcol, Front_nrows, Front_ncols, Front_parent, Front_cols, p_nfr, InFront, cmember)
-    @ccall libcolamd.ccolamd2(n_row::Cint, n_col::Cint, Alen::Cint, A::Ptr{Cint}, p::Ptr{Cint}, knobs::Ptr{Cdouble}, stats::Ptr{Cint}, Front_npivcol::Ptr{Cint}, Front_nrows::Ptr{Cint}, Front_ncols::Ptr{Cint}, Front_parent::Ptr{Cint}, Front_cols::Ptr{Cint}, p_nfr::Ptr{Cint}, InFront::Ptr{Cint}, cmember::Ptr{Cint})::Cint
-end
-
-function ccolamd2_l(n_row, n_col, Alen, A, p, knobs, stats, Front_npivcol, Front_nrows, Front_ncols, Front_parent, Front_cols, p_nfr, InFront, cmember)
-    @ccall libcolamd.ccolamd2_l(n_row::Int64, n_col::Int64, Alen::Int64, A::Ptr{Int64}, p::Ptr{Int64}, knobs::Ptr{Cdouble}, stats::Ptr{Int64}, Front_npivcol::Ptr{Int64}, Front_nrows::Ptr{Int64}, Front_ncols::Ptr{Int64}, Front_parent::Ptr{Int64}, Front_cols::Ptr{Int64}, p_nfr::Ptr{Int64}, InFront::Ptr{Int64}, cmember::Ptr{Int64})::Cint
-end
-
-function ccolamd_apply_order(Front, Order, Temp, nn, nfr)
-    @ccall libcolamd.ccolamd_apply_order(Front::Ptr{Cint}, Order::Ptr{Cint}, Temp::Ptr{Cint}, nn::Cint, nfr::Cint)::Cvoid
-end
-
-function ccolamd_l_apply_order(Front, Order, Temp, nn, nfr)
-    @ccall libcolamd.ccolamd_l_apply_order(Front::Ptr{Int64}, Order::Ptr{Int64}, Temp::Ptr{Int64}, nn::Int64, nfr::Int64)::Cvoid
-end
-
-function ccolamd_fsize(nn, MaxFsize, Fnrows, Fncols, Parent, Npiv)
-    @ccall libcolamd.ccolamd_fsize(nn::Cint, MaxFsize::Ptr{Cint}, Fnrows::Ptr{Cint}, Fncols::Ptr{Cint}, Parent::Ptr{Cint}, Npiv::Ptr{Cint})::Cvoid
-end
-
-function ccolamd_l_fsize(nn, MaxFsize, Fnrows, Fncols, Parent, Npiv)
-    @ccall libcolamd.ccolamd_l_fsize(nn::Int64, MaxFsize::Ptr{Int64}, Fnrows::Ptr{Int64}, Fncols::Ptr{Int64}, Parent::Ptr{Int64}, Npiv::Ptr{Int64})::Cvoid
-end
-
-function ccolamd_postorder(nn, Parent, Npiv, Fsize, Order, Child, Sibling, Stack, Front_cols, cmember)
-    @ccall libcolamd.ccolamd_postorder(nn::Cint, Parent::Ptr{Cint}, Npiv::Ptr{Cint}, Fsize::Ptr{Cint}, Order::Ptr{Cint}, Child::Ptr{Cint}, Sibling::Ptr{Cint}, Stack::Ptr{Cint}, Front_cols::Ptr{Cint}, cmember::Ptr{Cint})::Cvoid
-end
-
-function ccolamd_l_postorder(nn, Parent, Npiv, Fsize, Order, Child, Sibling, Stack, Front_cols, cmember)
-    @ccall libcolamd.ccolamd_l_postorder(nn::Int64, Parent::Ptr{Int64}, Npiv::Ptr{Int64}, Fsize::Ptr{Int64}, Order::Ptr{Int64}, Child::Ptr{Int64}, Sibling::Ptr{Int64}, Stack::Ptr{Int64}, Front_cols::Ptr{Int64}, cmember::Ptr{Int64})::Cvoid
-end
-
-function ccolamd_post_tree(root, k, Child, Sibling, Order, Stack)
-    @ccall libcolamd.ccolamd_post_tree(root::Cint, k::Cint, Child::Ptr{Cint}, Sibling::Ptr{Cint}, Order::Ptr{Cint}, Stack::Ptr{Cint})::Cint
-end
-
-function ccolamd_l_post_tree(root, k, Child, Sibling, Order, Stack)
-    @ccall libcolamd.ccolamd_l_post_tree(root::Int64, k::Int64, Child::Ptr{Int64}, Sibling::Ptr{Int64}, Order::Ptr{Int64}, Stack::Ptr{Int64})::Int64
-end
-
 function umfpack_di_symbolic(n_row, n_col, Ap, Ai, Ax, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_di_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                          Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                          Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                          Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_symbolic(n_row, n_col, Ap, Ai, Ax, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_dl_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                          Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                          Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                          Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_symbolic(n_row, n_col, Ap, Ai, Ax, Az, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_zi_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                          Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                          Az::Ptr{Cdouble}, Symbolic::Ptr{Ptr{Cvoid}},
+                                          Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_symbolic(n_row, n_col, Ap, Ai, Ax, Az, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_zl_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                          Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                          Az::Ptr{Cdouble}, Symbolic::Ptr{Ptr{Cvoid}},
+                                          Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_numeric(Ap, Ai, Ax, Symbolic, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_di_numeric(Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Symbolic::Ptr{Cvoid}, Numeric::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_numeric(Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                         Symbolic::Ptr{Cvoid}, Numeric::Ptr{Ptr{Cvoid}},
+                                         Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_numeric(Ap, Ai, Ax, Symbolic, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_dl_numeric(Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Symbolic::Ptr{Cvoid}, Numeric::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_numeric(Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                         Symbolic::Ptr{Cvoid}, Numeric::Ptr{Ptr{Cvoid}},
+                                         Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_numeric(Ap, Ai, Ax, Az, Symbolic, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_zi_numeric(Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Symbolic::Ptr{Cvoid}, Numeric::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_numeric(Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                         Az::Ptr{Cdouble}, Symbolic::Ptr{Cvoid},
+                                         Numeric::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                         Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_numeric(Ap, Ai, Ax, Az, Symbolic, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_zl_numeric(Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Symbolic::Ptr{Cvoid}, Numeric::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_numeric(Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                         Az::Ptr{Cdouble}, Symbolic::Ptr{Cvoid},
+                                         Numeric::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                         Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_solve(sys, Ap, Ai, Ax, X, B, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_di_solve(sys::Cint, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_solve(sys::Cint, Ap::Ptr{Int32}, Ai::Ptr{Int32},
+                                       Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble},
+                                       Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                       Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_solve(sys, Ap, Ai, Ax, X, B, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_dl_solve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_solve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64},
+                                       Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble},
+                                       Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                       Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_solve(sys, Ap, Ai, Ax, Az, Xx, Xz, Bx, Bz, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_zi_solve(sys::Cint, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_solve(sys::Cint, Ap::Ptr{Int32}, Ai::Ptr{Int32},
+                                       Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Xx::Ptr{Cdouble},
+                                       Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble},
+                                       Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                       Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_solve(sys, Ap, Ai, Ax, Az, Xx, Xz, Bx, Bz, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_zl_solve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_solve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64},
+                                       Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Xx::Ptr{Cdouble},
+                                       Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble},
+                                       Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                       Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_free_symbolic(Symbolic)
@@ -1840,51 +2346,119 @@ function umfpack_zl_defaults(Control)
 end
 
 function umfpack_di_qsymbolic(n_row, n_col, Ap, Ai, Ax, Qinit, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_di_qsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Qinit::Ptr{Int32}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_qsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                           Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                           Qinit::Ptr{Int32}, Symbolic::Ptr{Ptr{Cvoid}},
+                                           Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_qsymbolic(n_row, n_col, Ap, Ai, Ax, Qinit, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_dl_qsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Qinit::Ptr{Int64}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_qsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                           Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                           Qinit::Ptr{Int64}, Symbolic::Ptr{Ptr{Cvoid}},
+                                           Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_qsymbolic(n_row, n_col, Ap, Ai, Ax, Az, Qinit, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_zi_qsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Qinit::Ptr{Int32}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_qsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                           Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                           Az::Ptr{Cdouble}, Qinit::Ptr{Int32},
+                                           Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                           Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_qsymbolic(n_row, n_col, Ap, Ai, Ax, Az, Qinit, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_zl_qsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Qinit::Ptr{Int64}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_di_fsymbolic(n_row, n_col, Ap, Ai, Ax, user_ordering, user_params, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_di_fsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_dl_fsymbolic(n_row, n_col, Ap, Ai, Ax, user_ordering, user_params, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_dl_fsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_zi_fsymbolic(n_row, n_col, Ap, Ai, Ax, Az, user_ordering, user_params, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_zi_fsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_zl_fsymbolic(n_row, n_col, Ap, Ai, Ax, Az, user_ordering, user_params, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_zl_fsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_di_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Qinit, user_ordering, user_params, Symbolic, SW, Control, Info)
-    @ccall libumfpack.umfpack_di_paru_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Qinit::Ptr{Int32}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_dl_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Qinit, user_ordering, user_params, Symbolic, SW, Control, Info)
-    @ccall libumfpack.umfpack_dl_paru_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Qinit::Ptr{Int64}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_zi_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Az, Qinit, user_ordering, user_params, Symbolic, SW, Control, Info)
-    @ccall libumfpack.umfpack_zi_paru_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Qinit::Ptr{Int32}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_zl_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Az, Qinit, user_ordering, user_params, Symbolic, SW, Control, Info)
-    @ccall libumfpack.umfpack_zl_paru_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Qinit::Ptr{Int64}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_qsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                           Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                           Az::Ptr{Cdouble}, Qinit::Ptr{Int64},
+                                           Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                           Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_di_fsymbolic(n_row, n_col, Ap, Ai, Ax, user_ordering, user_params,
+                              Symbolic, Control, Info)
+    @ccall libumfpack.umfpack_di_fsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                           Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                           user_ordering::Ptr{Cvoid},
+                                           user_params::Ptr{Cvoid},
+                                           Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                           Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_dl_fsymbolic(n_row, n_col, Ap, Ai, Ax, user_ordering, user_params,
+                              Symbolic, Control, Info)
+    @ccall libumfpack.umfpack_dl_fsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                           Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                           user_ordering::Ptr{Cvoid},
+                                           user_params::Ptr{Cvoid},
+                                           Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                           Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_zi_fsymbolic(n_row, n_col, Ap, Ai, Ax, Az, user_ordering, user_params,
+                              Symbolic, Control, Info)
+    @ccall libumfpack.umfpack_zi_fsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                           Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                           Az::Ptr{Cdouble}, user_ordering::Ptr{Cvoid},
+                                           user_params::Ptr{Cvoid},
+                                           Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                           Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_zl_fsymbolic(n_row, n_col, Ap, Ai, Ax, Az, user_ordering, user_params,
+                              Symbolic, Control, Info)
+    @ccall libumfpack.umfpack_zl_fsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                           Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                           Az::Ptr{Cdouble}, user_ordering::Ptr{Cvoid},
+                                           user_params::Ptr{Cvoid},
+                                           Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                           Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_di_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Qinit, user_ordering,
+                                  user_params, Symbolic, SW, Control, Info)
+    @ccall libumfpack.umfpack_di_paru_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                               Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                               Qinit::Ptr{Int32}, user_ordering::Ptr{Cvoid},
+                                               user_params::Ptr{Cvoid},
+                                               Symbolic::Ptr{Ptr{Cvoid}},
+                                               SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                               Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_dl_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Qinit, user_ordering,
+                                  user_params, Symbolic, SW, Control, Info)
+    @ccall libumfpack.umfpack_dl_paru_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                               Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                               Qinit::Ptr{Int64}, user_ordering::Ptr{Cvoid},
+                                               user_params::Ptr{Cvoid},
+                                               Symbolic::Ptr{Ptr{Cvoid}},
+                                               SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                               Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_zi_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Az, Qinit, user_ordering,
+                                  user_params, Symbolic, SW, Control, Info)
+    @ccall libumfpack.umfpack_zi_paru_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                               Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                               Az::Ptr{Cdouble}, Qinit::Ptr{Int32},
+                                               user_ordering::Ptr{Cvoid},
+                                               user_params::Ptr{Cvoid},
+                                               Symbolic::Ptr{Ptr{Cvoid}},
+                                               SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                               Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_zl_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Az, Qinit, user_ordering,
+                                  user_params, Symbolic, SW, Control, Info)
+    @ccall libumfpack.umfpack_zl_paru_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                               Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                               Az::Ptr{Cdouble}, Qinit::Ptr{Int64},
+                                               user_ordering::Ptr{Cvoid},
+                                               user_params::Ptr{Cvoid},
+                                               Symbolic::Ptr{Ptr{Cvoid}},
+                                               SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                               Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_paru_free_sw(SW)
@@ -1904,339 +2478,547 @@ function umfpack_zl_paru_free_sw(SW)
 end
 
 function umfpack_di_wsolve(sys, Ap, Ai, Ax, X, B, Numeric, Control, Info, Wi, W)
-    @ccall libumfpack.umfpack_di_wsolve(sys::Cint, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble}, Wi::Ptr{Int32}, W::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_wsolve(sys::Cint, Ap::Ptr{Int32}, Ai::Ptr{Int32},
+                                        Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble},
+                                        Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                        Info::Ptr{Cdouble}, Wi::Ptr{Int32},
+                                        W::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_wsolve(sys, Ap, Ai, Ax, X, B, Numeric, Control, Info, Wi, W)
-    @ccall libumfpack.umfpack_dl_wsolve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble}, Wi::Ptr{Int64}, W::Ptr{Cdouble})::Cint
-end
-
-function umfpack_zi_wsolve(sys, Ap, Ai, Ax, Az, Xx, Xz, Bx, Bz, Numeric, Control, Info, Wi, W)
-    @ccall libumfpack.umfpack_zi_wsolve(sys::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble}, Wi::Ptr{Int32}, W::Ptr{Cdouble})::Cint
-end
-
-function umfpack_zl_wsolve(sys, Ap, Ai, Ax, Az, Xx, Xz, Bx, Bz, Numeric, Control, Info, Wi, W)
-    @ccall libumfpack.umfpack_zl_wsolve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble}, Wi::Ptr{Int64}, W::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_wsolve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64},
+                                        Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble},
+                                        Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                        Info::Ptr{Cdouble}, Wi::Ptr{Int64},
+                                        W::Ptr{Cdouble})::Cint
+end
+
+function umfpack_zi_wsolve(sys, Ap, Ai, Ax, Az, Xx, Xz, Bx, Bz, Numeric, Control, Info, Wi,
+                           W)
+    @ccall libumfpack.umfpack_zi_wsolve(sys::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32},
+                                        Ax::Ptr{Cdouble}, Az::Ptr{Cdouble},
+                                        Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble},
+                                        Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble},
+                                        Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                        Info::Ptr{Cdouble}, Wi::Ptr{Int32},
+                                        W::Ptr{Cdouble})::Cint
+end
+
+function umfpack_zl_wsolve(sys, Ap, Ai, Ax, Az, Xx, Xz, Bx, Bz, Numeric, Control, Info, Wi,
+                           W)
+    @ccall libumfpack.umfpack_zl_wsolve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64},
+                                        Ax::Ptr{Cdouble}, Az::Ptr{Cdouble},
+                                        Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble},
+                                        Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble},
+                                        Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                        Info::Ptr{Cdouble}, Wi::Ptr{Int64},
+                                        W::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_triplet_to_col(n_row, n_col, nz, Ti, Tj, Tx, Ap, Ai, Ax, Map)
-    @ccall libumfpack.umfpack_di_triplet_to_col(n_row::Int32, n_col::Int32, nz::Int32, Ti::Ptr{Int32}, Tj::Ptr{Int32}, Tx::Ptr{Cdouble}, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Map::Ptr{Int32})::Cint
+    @ccall libumfpack.umfpack_di_triplet_to_col(n_row::Int32, n_col::Int32, nz::Int32,
+                                                Ti::Ptr{Int32}, Tj::Ptr{Int32},
+                                                Tx::Ptr{Cdouble}, Ap::Ptr{Int32},
+                                                Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                                Map::Ptr{Int32})::Cint
 end
 
 function umfpack_dl_triplet_to_col(n_row, n_col, nz, Ti, Tj, Tx, Ap, Ai, Ax, Map)
-    @ccall libumfpack.umfpack_dl_triplet_to_col(n_row::Int64, n_col::Int64, nz::Int64, Ti::Ptr{Int64}, Tj::Ptr{Int64}, Tx::Ptr{Cdouble}, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Map::Ptr{Int64})::Cint
+    @ccall libumfpack.umfpack_dl_triplet_to_col(n_row::Int64, n_col::Int64, nz::Int64,
+                                                Ti::Ptr{Int64}, Tj::Ptr{Int64},
+                                                Tx::Ptr{Cdouble}, Ap::Ptr{Int64},
+                                                Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                                Map::Ptr{Int64})::Cint
 end
 
 function umfpack_zi_triplet_to_col(n_row, n_col, nz, Ti, Tj, Tx, Tz, Ap, Ai, Ax, Az, Map)
-    @ccall libumfpack.umfpack_zi_triplet_to_col(n_row::Int32, n_col::Int32, nz::Int32, Ti::Ptr{Int32}, Tj::Ptr{Int32}, Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble}, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Map::Ptr{Int32})::Cint
+    @ccall libumfpack.umfpack_zi_triplet_to_col(n_row::Int32, n_col::Int32, nz::Int32,
+                                                Ti::Ptr{Int32}, Tj::Ptr{Int32},
+                                                Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble},
+                                                Ap::Ptr{Int32}, Ai::Ptr{Int32},
+                                                Ax::Ptr{Cdouble}, Az::Ptr{Cdouble},
+                                                Map::Ptr{Int32})::Cint
 end
 
 function umfpack_zl_triplet_to_col(n_row, n_col, nz, Ti, Tj, Tx, Tz, Ap, Ai, Ax, Az, Map)
-    @ccall libumfpack.umfpack_zl_triplet_to_col(n_row::Int64, n_col::Int64, nz::Int64, Ti::Ptr{Int64}, Tj::Ptr{Int64}, Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble}, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Map::Ptr{Int64})::Cint
+    @ccall libumfpack.umfpack_zl_triplet_to_col(n_row::Int64, n_col::Int64, nz::Int64,
+                                                Ti::Ptr{Int64}, Tj::Ptr{Int64},
+                                                Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble},
+                                                Ap::Ptr{Int64}, Ai::Ptr{Int64},
+                                                Ax::Ptr{Cdouble}, Az::Ptr{Cdouble},
+                                                Map::Ptr{Int64})::Cint
 end
 
 function umfpack_di_col_to_triplet(n_col, Ap, Tj)
-    @ccall libumfpack.umfpack_di_col_to_triplet(n_col::Int32, Ap::Ptr{Int32}, Tj::Ptr{Int32})::Cint
+    @ccall libumfpack.umfpack_di_col_to_triplet(n_col::Int32, Ap::Ptr{Int32},
+                                                Tj::Ptr{Int32})::Cint
 end
 
 function umfpack_dl_col_to_triplet(n_col, Ap, Tj)
-    @ccall libumfpack.umfpack_dl_col_to_triplet(n_col::Int64, Ap::Ptr{Int64}, Tj::Ptr{Int64})::Cint
+    @ccall libumfpack.umfpack_dl_col_to_triplet(n_col::Int64, Ap::Ptr{Int64},
+                                                Tj::Ptr{Int64})::Cint
 end
 
 function umfpack_zi_col_to_triplet(n_col, Ap, Tj)
-    @ccall libumfpack.umfpack_zi_col_to_triplet(n_col::Int32, Ap::Ptr{Int32}, Tj::Ptr{Int32})::Cint
+    @ccall libumfpack.umfpack_zi_col_to_triplet(n_col::Int32, Ap::Ptr{Int32},
+                                                Tj::Ptr{Int32})::Cint
 end
 
 function umfpack_zl_col_to_triplet(n_col, Ap, Tj)
-    @ccall libumfpack.umfpack_zl_col_to_triplet(n_col::Int64, Ap::Ptr{Int64}, Tj::Ptr{Int64})::Cint
+    @ccall libumfpack.umfpack_zl_col_to_triplet(n_col::Int64, Ap::Ptr{Int64},
+                                                Tj::Ptr{Int64})::Cint
 end
 
 function umfpack_di_transpose(n_row, n_col, Ap, Ai, Ax, P, Q, Rp, Ri, Rx)
-    @ccall libumfpack.umfpack_di_transpose(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, P::Ptr{Int32}, Q::Ptr{Int32}, Rp::Ptr{Int32}, Ri::Ptr{Int32}, Rx::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_transpose(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                           Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, P::Ptr{Int32},
+                                           Q::Ptr{Int32}, Rp::Ptr{Int32}, Ri::Ptr{Int32},
+                                           Rx::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_transpose(n_row, n_col, Ap, Ai, Ax, P, Q, Rp, Ri, Rx)
-    @ccall libumfpack.umfpack_dl_transpose(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, P::Ptr{Int64}, Q::Ptr{Int64}, Rp::Ptr{Int64}, Ri::Ptr{Int64}, Rx::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_transpose(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                           Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, P::Ptr{Int64},
+                                           Q::Ptr{Int64}, Rp::Ptr{Int64}, Ri::Ptr{Int64},
+                                           Rx::Ptr{Cdouble})::Cint
 end
 
-function umfpack_zi_transpose(n_row, n_col, Ap, Ai, Ax, Az, P, Q, Rp, Ri, Rx, Rz, do_conjugate)
-    @ccall libumfpack.umfpack_zi_transpose(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, P::Ptr{Int32}, Q::Ptr{Int32}, Rp::Ptr{Int32}, Ri::Ptr{Int32}, Rx::Ptr{Cdouble}, Rz::Ptr{Cdouble}, do_conjugate::Cint)::Cint
+function umfpack_zi_transpose(n_row, n_col, Ap, Ai, Ax, Az, P, Q, Rp, Ri, Rx, Rz,
+                              do_conjugate)
+    @ccall libumfpack.umfpack_zi_transpose(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                           Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                           Az::Ptr{Cdouble}, P::Ptr{Int32}, Q::Ptr{Int32},
+                                           Rp::Ptr{Int32}, Ri::Ptr{Int32}, Rx::Ptr{Cdouble},
+                                           Rz::Ptr{Cdouble}, do_conjugate::Cint)::Cint
 end
 
-function umfpack_zl_transpose(n_row, n_col, Ap, Ai, Ax, Az, P, Q, Rp, Ri, Rx, Rz, do_conjugate)
-    @ccall libumfpack.umfpack_zl_transpose(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, P::Ptr{Int64}, Q::Ptr{Int64}, Rp::Ptr{Int64}, Ri::Ptr{Int64}, Rx::Ptr{Cdouble}, Rz::Ptr{Cdouble}, do_conjugate::Cint)::Cint
+function umfpack_zl_transpose(n_row, n_col, Ap, Ai, Ax, Az, P, Q, Rp, Ri, Rx, Rz,
+                              do_conjugate)
+    @ccall libumfpack.umfpack_zl_transpose(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                           Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                           Az::Ptr{Cdouble}, P::Ptr{Int64}, Q::Ptr{Int64},
+                                           Rp::Ptr{Int64}, Ri::Ptr{Int64}, Rx::Ptr{Cdouble},
+                                           Rz::Ptr{Cdouble}, do_conjugate::Cint)::Cint
 end
 
 function umfpack_di_scale(X, B, Numeric)
-    @ccall libumfpack.umfpack_di_scale(X::Ptr{Cdouble}, B::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_scale(X::Ptr{Cdouble}, B::Ptr{Cdouble},
+                                       Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_scale(X, B, Numeric)
-    @ccall libumfpack.umfpack_dl_scale(X::Ptr{Cdouble}, B::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_scale(X::Ptr{Cdouble}, B::Ptr{Cdouble},
+                                       Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_scale(Xx, Xz, Bx, Bz, Numeric)
-    @ccall libumfpack.umfpack_zi_scale(Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_scale(Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble},
+                                       Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_scale(Xx, Xz, Bx, Bz, Numeric)
-    @ccall libumfpack.umfpack_zl_scale(Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_scale(Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble},
+                                       Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_get_lunz(lnz, unz, n_row, n_col, nz_udiag, Numeric)
-    @ccall libumfpack.umfpack_di_get_lunz(lnz::Ptr{Int32}, unz::Ptr{Int32}, n_row::Ptr{Int32}, n_col::Ptr{Int32}, nz_udiag::Ptr{Int32}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_get_lunz(lnz::Ptr{Int32}, unz::Ptr{Int32},
+                                          n_row::Ptr{Int32}, n_col::Ptr{Int32},
+                                          nz_udiag::Ptr{Int32}, Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_get_lunz(lnz, unz, n_row, n_col, nz_udiag, Numeric)
-    @ccall libumfpack.umfpack_dl_get_lunz(lnz::Ptr{Int64}, unz::Ptr{Int64}, n_row::Ptr{Int64}, n_col::Ptr{Int64}, nz_udiag::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_get_lunz(lnz::Ptr{Int64}, unz::Ptr{Int64},
+                                          n_row::Ptr{Int64}, n_col::Ptr{Int64},
+                                          nz_udiag::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_get_lunz(lnz, unz, n_row, n_col, nz_udiag, Numeric)
-    @ccall libumfpack.umfpack_zi_get_lunz(lnz::Ptr{Int32}, unz::Ptr{Int32}, n_row::Ptr{Int32}, n_col::Ptr{Int32}, nz_udiag::Ptr{Int32}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_get_lunz(lnz::Ptr{Int32}, unz::Ptr{Int32},
+                                          n_row::Ptr{Int32}, n_col::Ptr{Int32},
+                                          nz_udiag::Ptr{Int32}, Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_get_lunz(lnz, unz, n_row, n_col, nz_udiag, Numeric)
-    @ccall libumfpack.umfpack_zl_get_lunz(lnz::Ptr{Int64}, unz::Ptr{Int64}, n_row::Ptr{Int64}, n_col::Ptr{Int64}, nz_udiag::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_get_lunz(lnz::Ptr{Int64}, unz::Ptr{Int64},
+                                          n_row::Ptr{Int64}, n_col::Ptr{Int64},
+                                          nz_udiag::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_get_numeric(Lp, Lj, Lx, Up, Ui, Ux, P, Q, Dx, do_recip, Rs, Numeric)
-    @ccall libumfpack.umfpack_di_get_numeric(Lp::Ptr{Int32}, Lj::Ptr{Int32}, Lx::Ptr{Cdouble}, Up::Ptr{Int32}, Ui::Ptr{Int32}, Ux::Ptr{Cdouble}, P::Ptr{Int32}, Q::Ptr{Int32}, Dx::Ptr{Cdouble}, do_recip::Ptr{Int32}, Rs::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_get_numeric(Lp::Ptr{Int32}, Lj::Ptr{Int32},
+                                             Lx::Ptr{Cdouble}, Up::Ptr{Int32},
+                                             Ui::Ptr{Int32}, Ux::Ptr{Cdouble},
+                                             P::Ptr{Int32}, Q::Ptr{Int32}, Dx::Ptr{Cdouble},
+                                             do_recip::Ptr{Int32}, Rs::Ptr{Cdouble},
+                                             Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_get_numeric(Lp, Lj, Lx, Up, Ui, Ux, P, Q, Dx, do_recip, Rs, Numeric)
-    @ccall libumfpack.umfpack_dl_get_numeric(Lp::Ptr{Int64}, Lj::Ptr{Int64}, Lx::Ptr{Cdouble}, Up::Ptr{Int64}, Ui::Ptr{Int64}, Ux::Ptr{Cdouble}, P::Ptr{Int64}, Q::Ptr{Int64}, Dx::Ptr{Cdouble}, do_recip::Ptr{Int64}, Rs::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
-end
-
-function umfpack_zi_get_numeric(Lp, Lj, Lx, Lz, Up, Ui, Ux, Uz, P, Q, Dx, Dz, do_recip, Rs, Numeric)
-    @ccall libumfpack.umfpack_zi_get_numeric(Lp::Ptr{Int32}, Lj::Ptr{Int32}, Lx::Ptr{Cdouble}, Lz::Ptr{Cdouble}, Up::Ptr{Int32}, Ui::Ptr{Int32}, Ux::Ptr{Cdouble}, Uz::Ptr{Cdouble}, P::Ptr{Int32}, Q::Ptr{Int32}, Dx::Ptr{Cdouble}, Dz::Ptr{Cdouble}, do_recip::Ptr{Int32}, Rs::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
-end
-
-function umfpack_zl_get_numeric(Lp, Lj, Lx, Lz, Up, Ui, Ux, Uz, P, Q, Dx, Dz, do_recip, Rs, Numeric)
-    @ccall libumfpack.umfpack_zl_get_numeric(Lp::Ptr{Int64}, Lj::Ptr{Int64}, Lx::Ptr{Cdouble}, Lz::Ptr{Cdouble}, Up::Ptr{Int64}, Ui::Ptr{Int64}, Ux::Ptr{Cdouble}, Uz::Ptr{Cdouble}, P::Ptr{Int64}, Q::Ptr{Int64}, Dx::Ptr{Cdouble}, Dz::Ptr{Cdouble}, do_recip::Ptr{Int64}, Rs::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
-end
-
-function umfpack_di_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol, Front_parent, Front_1strow, Front_leftmostdesc, Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
-    @ccall libumfpack.umfpack_di_get_symbolic(n_row::Ptr{Int32}, n_col::Ptr{Int32}, n1::Ptr{Int32}, nz::Ptr{Int32}, nfr::Ptr{Int32}, nchains::Ptr{Int32}, P::Ptr{Int32}, Q::Ptr{Int32}, Front_npivcol::Ptr{Int32}, Front_parent::Ptr{Int32}, Front_1strow::Ptr{Int32}, Front_leftmostdesc::Ptr{Int32}, Chain_start::Ptr{Int32}, Chain_maxrows::Ptr{Int32}, Chain_maxcols::Ptr{Int32}, Dmap::Ptr{Int32}, Symbolic::Ptr{Cvoid})::Cint
-end
-
-function umfpack_dl_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol, Front_parent, Front_1strow, Front_leftmostdesc, Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
-    @ccall libumfpack.umfpack_dl_get_symbolic(n_row::Ptr{Int64}, n_col::Ptr{Int64}, n1::Ptr{Int64}, nz::Ptr{Int64}, nfr::Ptr{Int64}, nchains::Ptr{Int64}, P::Ptr{Int64}, Q::Ptr{Int64}, Front_npivcol::Ptr{Int64}, Front_parent::Ptr{Int64}, Front_1strow::Ptr{Int64}, Front_leftmostdesc::Ptr{Int64}, Chain_start::Ptr{Int64}, Chain_maxrows::Ptr{Int64}, Chain_maxcols::Ptr{Int64}, Dmap::Ptr{Int64}, Symbolic::Ptr{Cvoid})::Cint
-end
-
-function umfpack_zi_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol, Front_parent, Front_1strow, Front_leftmostdesc, Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
-    @ccall libumfpack.umfpack_zi_get_symbolic(n_row::Ptr{Int32}, n_col::Ptr{Int32}, n1::Ptr{Int32}, nz::Ptr{Int32}, nfr::Ptr{Int32}, nchains::Ptr{Int32}, P::Ptr{Int32}, Q::Ptr{Int32}, Front_npivcol::Ptr{Int32}, Front_parent::Ptr{Int32}, Front_1strow::Ptr{Int32}, Front_leftmostdesc::Ptr{Int32}, Chain_start::Ptr{Int32}, Chain_maxrows::Ptr{Int32}, Chain_maxcols::Ptr{Int32}, Dmap::Ptr{Int32}, Symbolic::Ptr{Cvoid})::Cint
-end
-
-function umfpack_zl_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol, Front_parent, Front_1strow, Front_leftmostdesc, Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
-    @ccall libumfpack.umfpack_zl_get_symbolic(n_row::Ptr{Int64}, n_col::Ptr{Int64}, n1::Ptr{Int64}, nz::Ptr{Int64}, nfr::Ptr{Int64}, nchains::Ptr{Int64}, P::Ptr{Int64}, Q::Ptr{Int64}, Front_npivcol::Ptr{Int64}, Front_parent::Ptr{Int64}, Front_1strow::Ptr{Int64}, Front_leftmostdesc::Ptr{Int64}, Chain_start::Ptr{Int64}, Chain_maxrows::Ptr{Int64}, Chain_maxcols::Ptr{Int64}, Dmap::Ptr{Int64}, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_get_numeric(Lp::Ptr{Int64}, Lj::Ptr{Int64},
+                                             Lx::Ptr{Cdouble}, Up::Ptr{Int64},
+                                             Ui::Ptr{Int64}, Ux::Ptr{Cdouble},
+                                             P::Ptr{Int64}, Q::Ptr{Int64}, Dx::Ptr{Cdouble},
+                                             do_recip::Ptr{Int64}, Rs::Ptr{Cdouble},
+                                             Numeric::Ptr{Cvoid})::Cint
+end
+
+function umfpack_zi_get_numeric(Lp, Lj, Lx, Lz, Up, Ui, Ux, Uz, P, Q, Dx, Dz, do_recip, Rs,
+                                Numeric)
+    @ccall libumfpack.umfpack_zi_get_numeric(Lp::Ptr{Int32}, Lj::Ptr{Int32},
+                                             Lx::Ptr{Cdouble}, Lz::Ptr{Cdouble},
+                                             Up::Ptr{Int32}, Ui::Ptr{Int32},
+                                             Ux::Ptr{Cdouble}, Uz::Ptr{Cdouble},
+                                             P::Ptr{Int32}, Q::Ptr{Int32}, Dx::Ptr{Cdouble},
+                                             Dz::Ptr{Cdouble}, do_recip::Ptr{Int32},
+                                             Rs::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+end
+
+function umfpack_zl_get_numeric(Lp, Lj, Lx, Lz, Up, Ui, Ux, Uz, P, Q, Dx, Dz, do_recip, Rs,
+                                Numeric)
+    @ccall libumfpack.umfpack_zl_get_numeric(Lp::Ptr{Int64}, Lj::Ptr{Int64},
+                                             Lx::Ptr{Cdouble}, Lz::Ptr{Cdouble},
+                                             Up::Ptr{Int64}, Ui::Ptr{Int64},
+                                             Ux::Ptr{Cdouble}, Uz::Ptr{Cdouble},
+                                             P::Ptr{Int64}, Q::Ptr{Int64}, Dx::Ptr{Cdouble},
+                                             Dz::Ptr{Cdouble}, do_recip::Ptr{Int64},
+                                             Rs::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+end
+
+function umfpack_di_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol,
+                                 Front_parent, Front_1strow, Front_leftmostdesc,
+                                 Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
+    @ccall libumfpack.umfpack_di_get_symbolic(n_row::Ptr{Int32}, n_col::Ptr{Int32},
+                                              n1::Ptr{Int32}, nz::Ptr{Int32},
+                                              nfr::Ptr{Int32}, nchains::Ptr{Int32},
+                                              P::Ptr{Int32}, Q::Ptr{Int32},
+                                              Front_npivcol::Ptr{Int32},
+                                              Front_parent::Ptr{Int32},
+                                              Front_1strow::Ptr{Int32},
+                                              Front_leftmostdesc::Ptr{Int32},
+                                              Chain_start::Ptr{Int32},
+                                              Chain_maxrows::Ptr{Int32},
+                                              Chain_maxcols::Ptr{Int32}, Dmap::Ptr{Int32},
+                                              Symbolic::Ptr{Cvoid})::Cint
+end
+
+function umfpack_dl_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol,
+                                 Front_parent, Front_1strow, Front_leftmostdesc,
+                                 Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
+    @ccall libumfpack.umfpack_dl_get_symbolic(n_row::Ptr{Int64}, n_col::Ptr{Int64},
+                                              n1::Ptr{Int64}, nz::Ptr{Int64},
+                                              nfr::Ptr{Int64}, nchains::Ptr{Int64},
+                                              P::Ptr{Int64}, Q::Ptr{Int64},
+                                              Front_npivcol::Ptr{Int64},
+                                              Front_parent::Ptr{Int64},
+                                              Front_1strow::Ptr{Int64},
+                                              Front_leftmostdesc::Ptr{Int64},
+                                              Chain_start::Ptr{Int64},
+                                              Chain_maxrows::Ptr{Int64},
+                                              Chain_maxcols::Ptr{Int64}, Dmap::Ptr{Int64},
+                                              Symbolic::Ptr{Cvoid})::Cint
+end
+
+function umfpack_zi_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol,
+                                 Front_parent, Front_1strow, Front_leftmostdesc,
+                                 Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
+    @ccall libumfpack.umfpack_zi_get_symbolic(n_row::Ptr{Int32}, n_col::Ptr{Int32},
+                                              n1::Ptr{Int32}, nz::Ptr{Int32},
+                                              nfr::Ptr{Int32}, nchains::Ptr{Int32},
+                                              P::Ptr{Int32}, Q::Ptr{Int32},
+                                              Front_npivcol::Ptr{Int32},
+                                              Front_parent::Ptr{Int32},
+                                              Front_1strow::Ptr{Int32},
+                                              Front_leftmostdesc::Ptr{Int32},
+                                              Chain_start::Ptr{Int32},
+                                              Chain_maxrows::Ptr{Int32},
+                                              Chain_maxcols::Ptr{Int32}, Dmap::Ptr{Int32},
+                                              Symbolic::Ptr{Cvoid})::Cint
+end
+
+function umfpack_zl_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol,
+                                 Front_parent, Front_1strow, Front_leftmostdesc,
+                                 Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
+    @ccall libumfpack.umfpack_zl_get_symbolic(n_row::Ptr{Int64}, n_col::Ptr{Int64},
+                                              n1::Ptr{Int64}, nz::Ptr{Int64},
+                                              nfr::Ptr{Int64}, nchains::Ptr{Int64},
+                                              P::Ptr{Int64}, Q::Ptr{Int64},
+                                              Front_npivcol::Ptr{Int64},
+                                              Front_parent::Ptr{Int64},
+                                              Front_1strow::Ptr{Int64},
+                                              Front_leftmostdesc::Ptr{Int64},
+                                              Chain_start::Ptr{Int64},
+                                              Chain_maxrows::Ptr{Int64},
+                                              Chain_maxcols::Ptr{Int64}, Dmap::Ptr{Int64},
+                                              Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_save_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_di_save_numeric(Numeric::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_di_save_numeric(Numeric::Ptr{Cvoid},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_dl_save_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_dl_save_numeric(Numeric::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_dl_save_numeric(Numeric::Ptr{Cvoid},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zi_save_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_zi_save_numeric(Numeric::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zi_save_numeric(Numeric::Ptr{Cvoid},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zl_save_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_zl_save_numeric(Numeric::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zl_save_numeric(Numeric::Ptr{Cvoid},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_di_load_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_di_load_numeric(Numeric::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_di_load_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_dl_load_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_dl_load_numeric(Numeric::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_dl_load_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zi_load_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_zi_load_numeric(Numeric::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zi_load_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zl_load_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_zl_load_numeric(Numeric::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zl_load_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_di_copy_numeric(Numeric, Original)
-    @ccall libumfpack.umfpack_di_copy_numeric(Numeric::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_copy_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_copy_numeric(Numeric, Original)
-    @ccall libumfpack.umfpack_dl_copy_numeric(Numeric::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_copy_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_copy_numeric(Numeric, Original)
-    @ccall libumfpack.umfpack_zi_copy_numeric(Numeric::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_copy_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_copy_numeric(Numeric, Original)
-    @ccall libumfpack.umfpack_zl_copy_numeric(Numeric::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_copy_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_serialize_numeric_size(blobsize, Numeric)
-    @ccall libumfpack.umfpack_di_serialize_numeric_size(blobsize::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_serialize_numeric_size(blobsize::Ptr{Int64},
+                                                        Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_serialize_numeric_size(blobsize, Numeric)
-    @ccall libumfpack.umfpack_dl_serialize_numeric_size(blobsize::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_serialize_numeric_size(blobsize::Ptr{Int64},
+                                                        Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_serialize_numeric_size(blobsize, Numeric)
-    @ccall libumfpack.umfpack_zi_serialize_numeric_size(blobsize::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_serialize_numeric_size(blobsize::Ptr{Int64},
+                                                        Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_serialize_numeric_size(blobsize, Numeric)
-    @ccall libumfpack.umfpack_zl_serialize_numeric_size(blobsize::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_serialize_numeric_size(blobsize::Ptr{Int64},
+                                                        Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_serialize_numeric(blob, blobsize, Numeric)
-    @ccall libumfpack.umfpack_di_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64,
+                                                   Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_serialize_numeric(blob, blobsize, Numeric)
-    @ccall libumfpack.umfpack_dl_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64,
+                                                   Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_serialize_numeric(blob, blobsize, Numeric)
-    @ccall libumfpack.umfpack_zi_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64,
+                                                   Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_serialize_numeric(blob, blobsize, Numeric)
-    @ccall libumfpack.umfpack_zl_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64,
+                                                   Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_deserialize_numeric(Numeric, blob, blobsize)
-    @ccall libumfpack.umfpack_di_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_di_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                                     blob::Ptr{Int8}, blobsize::Int64)::Cint
 end
 
 function umfpack_dl_deserialize_numeric(Numeric, blob, blobsize)
-    @ccall libumfpack.umfpack_dl_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_dl_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                                     blob::Ptr{Int8}, blobsize::Int64)::Cint
 end
 
 function umfpack_zi_deserialize_numeric(Numeric, blob, blobsize)
-    @ccall libumfpack.umfpack_zi_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_zi_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                                     blob::Ptr{Int8}, blobsize::Int64)::Cint
 end
 
 function umfpack_zl_deserialize_numeric(Numeric, blob, blobsize)
-    @ccall libumfpack.umfpack_zl_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_zl_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                                     blob::Ptr{Int8}, blobsize::Int64)::Cint
 end
 
 function umfpack_di_save_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_di_save_symbolic(Symbolic::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_di_save_symbolic(Symbolic::Ptr{Cvoid},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_dl_save_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_dl_save_symbolic(Symbolic::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_dl_save_symbolic(Symbolic::Ptr{Cvoid},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zi_save_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_zi_save_symbolic(Symbolic::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zi_save_symbolic(Symbolic::Ptr{Cvoid},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zl_save_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_zl_save_symbolic(Symbolic::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zl_save_symbolic(Symbolic::Ptr{Cvoid},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_di_load_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_di_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_di_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_dl_load_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_dl_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_dl_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zi_load_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_zi_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zi_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zl_load_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_zl_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zl_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_di_copy_symbolic(Symbolic, Original)
-    @ccall libumfpack.umfpack_di_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_copy_symbolic(Symbolic, Original)
-    @ccall libumfpack.umfpack_dl_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_copy_symbolic(Symbolic, Original)
-    @ccall libumfpack.umfpack_zi_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_copy_symbolic(Symbolic, Original)
-    @ccall libumfpack.umfpack_zl_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_serialize_symbolic_size(blobsize, Symbolic)
-    @ccall libumfpack.umfpack_di_serialize_symbolic_size(blobsize::Ptr{Int64}, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_serialize_symbolic_size(blobsize::Ptr{Int64},
+                                                         Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_serialize_symbolic_size(blobsize, Symbolic)
-    @ccall libumfpack.umfpack_dl_serialize_symbolic_size(blobsize::Ptr{Int64}, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_serialize_symbolic_size(blobsize::Ptr{Int64},
+                                                         Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_serialize_symbolic_size(blobsize, Symbolic)
-    @ccall libumfpack.umfpack_zi_serialize_symbolic_size(blobsize::Ptr{Int64}, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_serialize_symbolic_size(blobsize::Ptr{Int64},
+                                                         Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_serialize_symbolic_size(blobsize, Symbolic)
-    @ccall libumfpack.umfpack_zl_serialize_symbolic_size(blobsize::Ptr{Int64}, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_serialize_symbolic_size(blobsize::Ptr{Int64},
+                                                         Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_serialize_symbolic(blob, blobsize, Symbolic)
-    @ccall libumfpack.umfpack_di_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64,
+                                                    Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_serialize_symbolic(blob, blobsize, Symbolic)
-    @ccall libumfpack.umfpack_dl_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64,
+                                                    Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_serialize_symbolic(blob, blobsize, Symbolic)
-    @ccall libumfpack.umfpack_zi_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64,
+                                                    Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_serialize_symbolic(blob, blobsize, Symbolic)
-    @ccall libumfpack.umfpack_zl_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64,
+                                                    Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_deserialize_symbolic(Symbolic, blob, blobsize)
-    @ccall libumfpack.umfpack_di_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_di_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                                      blob::Ptr{Int8},
+                                                      blobsize::Int64)::Cint
 end
 
 function umfpack_dl_deserialize_symbolic(Symbolic, blob, blobsize)
-    @ccall libumfpack.umfpack_dl_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_dl_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                                      blob::Ptr{Int8},
+                                                      blobsize::Int64)::Cint
 end
 
 function umfpack_zi_deserialize_symbolic(Symbolic, blob, blobsize)
-    @ccall libumfpack.umfpack_zi_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_zi_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                                      blob::Ptr{Int8},
+                                                      blobsize::Int64)::Cint
 end
 
 function umfpack_zl_deserialize_symbolic(Symbolic, blob, blobsize)
-    @ccall libumfpack.umfpack_zl_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_zl_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                                      blob::Ptr{Int8},
+                                                      blobsize::Int64)::Cint
 end
 
 function umfpack_di_get_determinant(Mx, Ex, Numeric, User_Info)
-    @ccall libumfpack.umfpack_di_get_determinant(Mx::Ptr{Cdouble}, Ex::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, User_Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_get_determinant(Mx::Ptr{Cdouble}, Ex::Ptr{Cdouble},
+                                                 Numeric::Ptr{Cvoid},
+                                                 User_Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_get_determinant(Mx, Ex, Numeric, User_Info)
-    @ccall libumfpack.umfpack_dl_get_determinant(Mx::Ptr{Cdouble}, Ex::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, User_Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_get_determinant(Mx::Ptr{Cdouble}, Ex::Ptr{Cdouble},
+                                                 Numeric::Ptr{Cvoid},
+                                                 User_Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_get_determinant(Mx, Mz, Ex, Numeric, User_Info)
-    @ccall libumfpack.umfpack_zi_get_determinant(Mx::Ptr{Cdouble}, Mz::Ptr{Cdouble}, Ex::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, User_Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_get_determinant(Mx::Ptr{Cdouble}, Mz::Ptr{Cdouble},
+                                                 Ex::Ptr{Cdouble}, Numeric::Ptr{Cvoid},
+                                                 User_Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_get_determinant(Mx, Mz, Ex, Numeric, User_Info)
-    @ccall libumfpack.umfpack_zl_get_determinant(Mx::Ptr{Cdouble}, Mz::Ptr{Cdouble}, Ex::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, User_Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_get_determinant(Mx::Ptr{Cdouble}, Mz::Ptr{Cdouble},
+                                                 Ex::Ptr{Cdouble}, Numeric::Ptr{Cvoid},
+                                                 User_Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_report_status(Control, status)
@@ -2256,19 +3038,23 @@ function umfpack_zl_report_status(Control, status)
 end
 
 function umfpack_di_report_info(Control, Info)
-    @ccall libumfpack.umfpack_di_report_info(Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cvoid
+    @ccall libumfpack.umfpack_di_report_info(Control::Ptr{Cdouble},
+                                             Info::Ptr{Cdouble})::Cvoid
 end
 
 function umfpack_dl_report_info(Control, Info)
-    @ccall libumfpack.umfpack_dl_report_info(Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cvoid
+    @ccall libumfpack.umfpack_dl_report_info(Control::Ptr{Cdouble},
+                                             Info::Ptr{Cdouble})::Cvoid
 end
 
 function umfpack_zi_report_info(Control, Info)
-    @ccall libumfpack.umfpack_zi_report_info(Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cvoid
+    @ccall libumfpack.umfpack_zi_report_info(Control::Ptr{Cdouble},
+                                             Info::Ptr{Cdouble})::Cvoid
 end
 
 function umfpack_zl_report_info(Control, Info)
-    @ccall libumfpack.umfpack_zl_report_info(Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cvoid
+    @ccall libumfpack.umfpack_zl_report_info(Control::Ptr{Cdouble},
+                                             Info::Ptr{Cdouble})::Cvoid
 end
 
 function umfpack_di_report_control(Control)
@@ -2288,99 +3074,137 @@ function umfpack_zl_report_control(Control)
 end
 
 function umfpack_di_report_matrix(n_row, n_col, Ap, Ai, Ax, col_form, Control)
-    @ccall libumfpack.umfpack_di_report_matrix(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, col_form::Cint, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_report_matrix(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                               Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                               col_form::Cint, Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_report_matrix(n_row, n_col, Ap, Ai, Ax, col_form, Control)
-    @ccall libumfpack.umfpack_dl_report_matrix(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, col_form::Cint, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_report_matrix(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                               Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                               col_form::Cint, Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_report_matrix(n_row, n_col, Ap, Ai, Ax, Az, col_form, Control)
-    @ccall libumfpack.umfpack_zi_report_matrix(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, col_form::Cint, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_report_matrix(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                               Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                               Az::Ptr{Cdouble}, col_form::Cint,
+                                               Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_report_matrix(n_row, n_col, Ap, Ai, Ax, Az, col_form, Control)
-    @ccall libumfpack.umfpack_zl_report_matrix(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, col_form::Cint, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_report_matrix(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                               Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                               Az::Ptr{Cdouble}, col_form::Cint,
+                                               Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_report_triplet(n_row, n_col, nz, Ti, Tj, Tx, Control)
-    @ccall libumfpack.umfpack_di_report_triplet(n_row::Int32, n_col::Int32, nz::Int32, Ti::Ptr{Int32}, Tj::Ptr{Int32}, Tx::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_report_triplet(n_row::Int32, n_col::Int32, nz::Int32,
+                                                Ti::Ptr{Int32}, Tj::Ptr{Int32},
+                                                Tx::Ptr{Cdouble},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_report_triplet(n_row, n_col, nz, Ti, Tj, Tx, Control)
-    @ccall libumfpack.umfpack_dl_report_triplet(n_row::Int64, n_col::Int64, nz::Int64, Ti::Ptr{Int64}, Tj::Ptr{Int64}, Tx::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_report_triplet(n_row::Int64, n_col::Int64, nz::Int64,
+                                                Ti::Ptr{Int64}, Tj::Ptr{Int64},
+                                                Tx::Ptr{Cdouble},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_report_triplet(n_row, n_col, nz, Ti, Tj, Tx, Tz, Control)
-    @ccall libumfpack.umfpack_zi_report_triplet(n_row::Int32, n_col::Int32, nz::Int32, Ti::Ptr{Int32}, Tj::Ptr{Int32}, Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_report_triplet(n_row::Int32, n_col::Int32, nz::Int32,
+                                                Ti::Ptr{Int32}, Tj::Ptr{Int32},
+                                                Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_report_triplet(n_row, n_col, nz, Ti, Tj, Tx, Tz, Control)
-    @ccall libumfpack.umfpack_zl_report_triplet(n_row::Int64, n_col::Int64, nz::Int64, Ti::Ptr{Int64}, Tj::Ptr{Int64}, Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_report_triplet(n_row::Int64, n_col::Int64, nz::Int64,
+                                                Ti::Ptr{Int64}, Tj::Ptr{Int64},
+                                                Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_report_vector(n, X, Control)
-    @ccall libumfpack.umfpack_di_report_vector(n::Int32, X::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_report_vector(n::Int32, X::Ptr{Cdouble},
+                                               Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_report_vector(n, X, Control)
-    @ccall libumfpack.umfpack_dl_report_vector(n::Int64, X::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_report_vector(n::Int64, X::Ptr{Cdouble},
+                                               Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_report_vector(n, Xx, Xz, Control)
-    @ccall libumfpack.umfpack_zi_report_vector(n::Int32, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_report_vector(n::Int32, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble},
+                                               Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_report_vector(n, Xx, Xz, Control)
-    @ccall libumfpack.umfpack_zl_report_vector(n::Int64, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_report_vector(n::Int64, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble},
+                                               Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_report_symbolic(Symbolic, Control)
-    @ccall libumfpack.umfpack_di_report_symbolic(Symbolic::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_report_symbolic(Symbolic::Ptr{Cvoid},
+                                                 Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_report_symbolic(Symbolic, Control)
-    @ccall libumfpack.umfpack_dl_report_symbolic(Symbolic::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_report_symbolic(Symbolic::Ptr{Cvoid},
+                                                 Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_report_symbolic(Symbolic, Control)
-    @ccall libumfpack.umfpack_zi_report_symbolic(Symbolic::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_report_symbolic(Symbolic::Ptr{Cvoid},
+                                                 Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_report_symbolic(Symbolic, Control)
-    @ccall libumfpack.umfpack_zl_report_symbolic(Symbolic::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_report_symbolic(Symbolic::Ptr{Cvoid},
+                                                 Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_report_numeric(Numeric, Control)
-    @ccall libumfpack.umfpack_di_report_numeric(Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_report_numeric(Numeric::Ptr{Cvoid},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_report_numeric(Numeric, Control)
-    @ccall libumfpack.umfpack_dl_report_numeric(Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_report_numeric(Numeric::Ptr{Cvoid},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_report_numeric(Numeric, Control)
-    @ccall libumfpack.umfpack_zi_report_numeric(Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_report_numeric(Numeric::Ptr{Cvoid},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_report_numeric(Numeric, Control)
-    @ccall libumfpack.umfpack_zl_report_numeric(Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_report_numeric(Numeric::Ptr{Cvoid},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_report_perm(np, Perm, Control)
-    @ccall libumfpack.umfpack_di_report_perm(np::Int32, Perm::Ptr{Int32}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_report_perm(np::Int32, Perm::Ptr{Int32},
+                                             Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_report_perm(np, Perm, Control)
-    @ccall libumfpack.umfpack_dl_report_perm(np::Int64, Perm::Ptr{Int64}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_report_perm(np::Int64, Perm::Ptr{Int64},
+                                             Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_report_perm(np, Perm, Control)
-    @ccall libumfpack.umfpack_zi_report_perm(np::Int32, Perm::Ptr{Int32}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_report_perm(np::Int32, Perm::Ptr{Int32},
+                                             Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_report_perm(np, Perm, Control)
-    @ccall libumfpack.umfpack_zl_report_perm(np::Int64, Perm::Ptr{Int64}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_report_perm(np::Int64, Perm::Ptr{Int64},
+                                             Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_timer()
@@ -2395,13 +3219,13 @@ function umfpack_toc(stats)
     @ccall libumfpack.umfpack_toc(stats::Ptr{Cdouble})::Cvoid
 end
 
-const CHOLMOD_DATE = "Jan 17, 2023"
+const CHOLMOD_DATE = "June 16, 2023"
 
 const CHOLMOD_MAIN_VERSION = 4
 
 const CHOLMOD_SUB_VERSION = 0
 
-const CHOLMOD_SUBSUB_VERSION = 3
+const CHOLMOD_SUBSUB_VERSION = 4
 
 const _FILE_OFFSET_BITS = 64
 
@@ -2427,17 +3251,18 @@ const SUITESPARSE_COMPILER_MSC = 0
 
 const SUITESPARSE_COMPILER_XLC = 0
 
-const SUITESPARSE_DATE = "Jan 20, 2023"
+const SUITESPARSE_DATE = "June 29, 2023"
 
 const SUITESPARSE_MAIN_VERSION = 7
 
-const SUITESPARSE_SUB_VERSION = 0
+const SUITESPARSE_SUB_VERSION = 1
 
-const SUITESPARSE_SUBSUB_VERSION = 1
+const SUITESPARSE_SUBSUB_VERSION = 0
 
 SUITESPARSE_VER_CODE(main, sub) = main * 1000 + sub
 
-const SUITESPARSE_VERSION = SUITESPARSE_VER_CODE(SUITESPARSE_MAIN_VERSION, SUITESPARSE_SUB_VERSION)
+const SUITESPARSE_VERSION = SUITESPARSE_VER_CODE(SUITESPARSE_MAIN_VERSION,
+                                                 SUITESPARSE_SUB_VERSION)
 
 CHOLMOD_VER_CODE(main, sub) = main * 1000 + sub
 
@@ -2601,20 +3426,18 @@ const SPQR_RTX_EQUALS_B = 2
 
 const SPQR_RTX_EQUALS_ETB = 3
 
-const SPQR_DATE = "Jan 17, 2023"
+const SPQR_DATE = "July FIXME, 2023"
 
-const SPQR_MAIN_VERSION = 3
+const SPQR_MAIN_VERSION = 4
 
 const SPQR_SUB_VERSION = 0
 
-const SPQR_SUBSUB_VERSION = 3
+const SPQR_SUBSUB_VERSION = 0
 
 SPQR_VER_CODE(main, sub) = main * 1000 + sub
 
 const SPQR_VERSION = SPQR_VER_CODE(SPQR_MAIN_VERSION, SPQR_SUB_VERSION)
 
-const Complex = Float64
-
 const AMD_CONTROL = 5
 
 const AMD_INFO = 20
@@ -2663,172 +3486,29 @@ const AMD_INVALID = -2
 
 const AMD_OK_BUT_JUMBLED = 1
 
-const AMD_DATE = "Jan 17, 2023"
+const AMD_DATE = "June 16, 2023"
 
 const AMD_MAIN_VERSION = 3
 
 const AMD_SUB_VERSION = 0
 
-const AMD_SUBSUB_VERSION = 3
+const AMD_SUBSUB_VERSION = 4
 
 AMD_VERSION_CODE(main, sub) = main * 1000 + sub
 
 const AMD_VERSION = AMD_VERSION_CODE(AMD_MAIN_VERSION, AMD_SUB_VERSION)
 
-const COLAMD_DATE = "Jan 17, 2023"
-
-const COLAMD_MAIN_VERSION = 3
-
-const COLAMD_SUB_VERSION = 0
-
-const COLAMD_SUBSUB_VERSION = 3
-
-COLAMD_VERSION_CODE(main, sub) = main * 1000 + sub
-
-const COLAMD_VERSION = COLAMD_VERSION_CODE(COLAMD_MAIN_VERSION, COLAMD_SUB_VERSION)
-
-const COLAMD_KNOBS = 20
-
-const COLAMD_STATS = 20
-
-const COLAMD_DENSE_ROW = 0
-
-const COLAMD_DENSE_COL = 1
-
-const COLAMD_AGGRESSIVE = 2
-
-const COLAMD_DEFRAG_COUNT = 2
-
-const COLAMD_STATUS = 3
-
-const COLAMD_INFO1 = 4
-
-const COLAMD_INFO2 = 5
-
-const COLAMD_INFO3 = 6
-
-const COLAMD_OK = 0
-
-const COLAMD_OK_BUT_JUMBLED = 1
-
-const COLAMD_ERROR_A_not_present = -1
-
-const COLAMD_ERROR_p_not_present = -2
-
-const COLAMD_ERROR_nrow_negative = -3
-
-const COLAMD_ERROR_ncol_negative = -4
-
-const COLAMD_ERROR_nnz_negative = -5
-
-const COLAMD_ERROR_p0_nonzero = -6
-
-const COLAMD_ERROR_A_too_small = -7
-
-const COLAMD_ERROR_col_length_negative = -8
-
-const COLAMD_ERROR_row_index_out_of_bounds = -9
-
-const COLAMD_ERROR_out_of_memory = -10
-
-const COLAMD_ERROR_internal_error = -999
-
-const CCOLAMD_DATE = "Jan 17, 2023"
-
-const CCOLAMD_MAIN_VERSION = 3
-
-const CCOLAMD_SUB_VERSION = 0
-
-const CCOLAMD_SUBSUB_VERSION = 3
-
-CCOLAMD_VERSION_CODE(main, sub) = main * 1000 + sub
-
-const CCOLAMD_VERSION = CCOLAMD_VERSION_CODE(CCOLAMD_MAIN_VERSION, CCOLAMD_SUB_VERSION)
-
-const CCOLAMD_KNOBS = 20
-
-const CCOLAMD_STATS = 20
-
-const CCOLAMD_DENSE_ROW = 0
-
-const CCOLAMD_DENSE_COL = 1
-
-const CCOLAMD_AGGRESSIVE = 2
-
-const CCOLAMD_LU = 3
-
-const CCOLAMD_DEFRAG_COUNT = 2
-
-const CCOLAMD_STATUS = 3
-
-const CCOLAMD_INFO1 = 4
-
-const CCOLAMD_INFO2 = 5
-
-const CCOLAMD_INFO3 = 6
-
-const CCOLAMD_EMPTY_ROW = 7
-
-const CCOLAMD_EMPTY_COL = 8
-
-const CCOLAMD_NEWLY_EMPTY_ROW = 9
-
-const CCOLAMD_NEWLY_EMPTY_COL = 10
-
-const CCOLAMD_OK = 0
-
-const CCOLAMD_OK_BUT_JUMBLED = 1
-
-const CCOLAMD_ERROR_A_not_present = -1
-
-const CCOLAMD_ERROR_p_not_present = -2
-
-const CCOLAMD_ERROR_nrow_negative = -3
-
-const CCOLAMD_ERROR_ncol_negative = -4
-
-const CCOLAMD_ERROR_nnz_negative = -5
-
-const CCOLAMD_ERROR_p0_nonzero = -6
-
-const CCOLAMD_ERROR_A_too_small = -7
-
-const CCOLAMD_ERROR_col_length_negative = -8
-
-const CCOLAMD_ERROR_row_index_out_of_bounds = -9
-
-const CCOLAMD_ERROR_out_of_memory = -10
-
-const CCOLAMD_ERROR_invalid_cmember = -11
-
-const CCOLAMD_ERROR_internal_error = -999
-
 const UMFPACK_INFO = 90
 
 const UMFPACK_CONTROL = 20
 
-# Skipping MacroDefinition: UMFPACK_COPYRIGHT \
-#"UMFPACK:  Copyright (c) 2005-2023 by Timothy A. Davis.  All Rights Reserved.\n"
-
-# Skipping MacroDefinition: UMFPACK_LICENSE_PART1 \
-#"\nUMFPACK License: SPDX-License-Identifier: GPL-2.0+\n" \
-#"   UMFPACK is available under alternate licenses,\n" \
-#"   contact T. Davis for details.\n"
-
-const UMFPACK_LICENSE_PART2 = "\n"
-
-# Skipping MacroDefinition: UMFPACK_LICENSE_PART3 \
-#"\n" \
-#"Availability: http://www.suitesparse.com" \
-#"\n"
-
-const UMFPACK_DATE = "Jan 17, 2023"
+const UMFPACK_DATE = "June 16, 2023"
 
 const UMFPACK_MAIN_VERSION = 6
 
 const UMFPACK_SUB_VERSION = 1
 
-const UMFPACK_SUBSUB_VERSION = 0
+const UMFPACK_SUBSUB_VERSION = 1
 
 UMFPACK_VER_CODE(main, sub) = main * 1000 + sub
 
@@ -3169,4 +3849,3 @@ const UMFPACK_Q_Uat = 12
 const UMFPACK_Ut = 13
 
 const UMFPACK_Uat = 14
-
diff --git a/src/solvers/lib/x86_64-w64-mingw32.jl b/src/solvers/lib/x86_64-w64-mingw32.jl
index fcf756d2..a5aa4e44 100644
--- a/src/solvers/lib/x86_64-w64-mingw32.jl
+++ b/src/solvers/lib/x86_64-w64-mingw32.jl
@@ -1,137 +1,150 @@
 function SuiteSparse_config_printf_func_get()
-    @ccall libcholmod.SuiteSparse_config_printf_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_printf_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_malloc_func_get()
-    @ccall libcholmod.SuiteSparse_config_malloc_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_malloc_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_calloc_func_get()
-    @ccall libcholmod.SuiteSparse_config_calloc_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_calloc_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_realloc_func_get()
-    @ccall libcholmod.SuiteSparse_config_realloc_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_realloc_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_free_func_get()
-    @ccall libcholmod.SuiteSparse_config_free_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_free_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_hypot_func_get()
-    @ccall libcholmod.SuiteSparse_config_hypot_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_hypot_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_divcomplex_func_get()
-    @ccall libcholmod.SuiteSparse_config_divcomplex_func_get()::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_divcomplex_func_get()::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_malloc_func_set(malloc_func)
-    @ccall libcholmod.SuiteSparse_config_malloc_func_set(malloc_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_malloc_func_set(malloc_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_calloc_func_set(calloc_func)
-    @ccall libcholmod.SuiteSparse_config_calloc_func_set(calloc_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_calloc_func_set(calloc_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_realloc_func_set(realloc_func)
-    @ccall libcholmod.SuiteSparse_config_realloc_func_set(realloc_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_realloc_func_set(realloc_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_free_func_set(free_func)
-    @ccall libcholmod.SuiteSparse_config_free_func_set(free_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_free_func_set(free_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_printf_func_set(printf_func)
-    @ccall libcholmod.SuiteSparse_config_printf_func_set(printf_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_printf_func_set(printf_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_hypot_func_set(hypot_func)
-    @ccall libcholmod.SuiteSparse_config_hypot_func_set(hypot_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_hypot_func_set(hypot_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_divcomplex_func_set(divcomplex_func)
-    @ccall libcholmod.SuiteSparse_config_divcomplex_func_set(divcomplex_func::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_divcomplex_func_set(divcomplex_func::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_malloc(s)
-    @ccall libcholmod.SuiteSparse_config_malloc(s::Csize_t)::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_malloc(s::Csize_t)::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_calloc(n, s)
-    @ccall libcholmod.SuiteSparse_config_calloc(n::Csize_t, s::Csize_t)::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_calloc(n::Csize_t,
+                                                          s::Csize_t)::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_realloc(arg1, s)
-    @ccall libcholmod.SuiteSparse_config_realloc(arg1::Ptr{Cvoid}, s::Csize_t)::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_config_realloc(arg1::Ptr{Cvoid},
+                                                           s::Csize_t)::Ptr{Cvoid}
 end
 
 function SuiteSparse_config_free(arg1)
-    @ccall libcholmod.SuiteSparse_config_free(arg1::Ptr{Cvoid})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_config_free(arg1::Ptr{Cvoid})::Cvoid
 end
 
 function SuiteSparse_config_hypot(x, y)
-    @ccall libcholmod.SuiteSparse_config_hypot(x::Cdouble, y::Cdouble)::Cdouble
+    @ccall libsuitesparseconfig.SuiteSparse_config_hypot(x::Cdouble, y::Cdouble)::Cdouble
 end
 
 function SuiteSparse_config_divcomplex(xr, xi, yr, yi, zr, zi)
-    @ccall libcholmod.SuiteSparse_config_divcomplex(xr::Cdouble, xi::Cdouble, yr::Cdouble, yi::Cdouble, zr::Ptr{Cdouble}, zi::Ptr{Cdouble})::Cint
+    @ccall libsuitesparseconfig.SuiteSparse_config_divcomplex(xr::Cdouble, xi::Cdouble,
+                                                              yr::Cdouble, yi::Cdouble,
+                                                              zr::Ptr{Cdouble},
+                                                              zi::Ptr{Cdouble})::Cint
 end
 
 function SuiteSparse_start()
-    @ccall libcholmod.SuiteSparse_start()::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_start()::Cvoid
 end
 
 function SuiteSparse_finish()
-    @ccall libcholmod.SuiteSparse_finish()::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_finish()::Cvoid
 end
 
 function SuiteSparse_malloc(nitems, size_of_item)
-    @ccall libcholmod.SuiteSparse_malloc(nitems::Csize_t, size_of_item::Csize_t)::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_malloc(nitems::Csize_t,
+                                                   size_of_item::Csize_t)::Ptr{Cvoid}
 end
 
 function SuiteSparse_calloc(nitems, size_of_item)
-    @ccall libcholmod.SuiteSparse_calloc(nitems::Csize_t, size_of_item::Csize_t)::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_calloc(nitems::Csize_t,
+                                                   size_of_item::Csize_t)::Ptr{Cvoid}
 end
 
 function SuiteSparse_realloc(nitems_new, nitems_old, size_of_item, p, ok)
-    @ccall libcholmod.SuiteSparse_realloc(nitems_new::Csize_t, nitems_old::Csize_t, size_of_item::Csize_t, p::Ptr{Cvoid}, ok::Ptr{Cint})::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_realloc(nitems_new::Csize_t,
+                                                    nitems_old::Csize_t,
+                                                    size_of_item::Csize_t, p::Ptr{Cvoid},
+                                                    ok::Ptr{Cint})::Ptr{Cvoid}
 end
 
 function SuiteSparse_free(p)
-    @ccall libcholmod.SuiteSparse_free(p::Ptr{Cvoid})::Ptr{Cvoid}
+    @ccall libsuitesparseconfig.SuiteSparse_free(p::Ptr{Cvoid})::Ptr{Cvoid}
 end
 
 function SuiteSparse_tic(tic)
-    @ccall libcholmod.SuiteSparse_tic(tic::Ptr{Cdouble})::Cvoid
+    @ccall libsuitesparseconfig.SuiteSparse_tic(tic::Ptr{Cdouble})::Cvoid
 end
 
 function SuiteSparse_toc(tic)
-    @ccall libcholmod.SuiteSparse_toc(tic::Ptr{Cdouble})::Cdouble
+    @ccall libsuitesparseconfig.SuiteSparse_toc(tic::Ptr{Cdouble})::Cdouble
 end
 
 function SuiteSparse_time()
-    @ccall libcholmod.SuiteSparse_time()::Cdouble
+    @ccall libsuitesparseconfig.SuiteSparse_time()::Cdouble
 end
 
 function SuiteSparse_hypot(x, y)
-    @ccall libcholmod.SuiteSparse_hypot(x::Cdouble, y::Cdouble)::Cdouble
+    @ccall libsuitesparseconfig.SuiteSparse_hypot(x::Cdouble, y::Cdouble)::Cdouble
 end
 
 function SuiteSparse_divcomplex(ar, ai, br, bi, cr, ci)
-    @ccall libcholmod.SuiteSparse_divcomplex(ar::Cdouble, ai::Cdouble, br::Cdouble, bi::Cdouble, cr::Ptr{Cdouble}, ci::Ptr{Cdouble})::Cint
+    @ccall libsuitesparseconfig.SuiteSparse_divcomplex(ar::Cdouble, ai::Cdouble,
+                                                       br::Cdouble, bi::Cdouble,
+                                                       cr::Ptr{Cdouble},
+                                                       ci::Ptr{Cdouble})::Cint
 end
 
 function SuiteSparse_version(version)
-    @ccall libcholmod.SuiteSparse_version(version::Ptr{Cint})::Cint
+    @ccall libsuitesparseconfig.SuiteSparse_version(version::Ptr{Cint})::Cint
 end
 
 function SuiteSparse_BLAS_library()
-    @ccall libcholmod.SuiteSparse_BLAS_library()::Ptr{Cchar}
+    @ccall libsuitesparseconfig.SuiteSparse_BLAS_library()::Ptr{Cchar}
 end
 
 function SuiteSparse_BLAS_integer_size()
-    @ccall libcholmod.SuiteSparse_BLAS_integer_size()::Csize_t
+    @ccall libsuitesparseconfig.SuiteSparse_BLAS_integer_size()::Csize_t
 end
 
 struct cholmod_method_struct
@@ -140,16 +153,16 @@ struct cholmod_method_struct
     prune_dense::Cdouble
     prune_dense2::Cdouble
     nd_oksep::Cdouble
-    other_1::NTuple{4, Cdouble}
+    other_1::NTuple{4,Cdouble}
     nd_small::Csize_t
-    other_2::NTuple{4, Csize_t}
+    other_2::NTuple{4,Csize_t}
     aggressive::Cint
     order_for_lu::Cint
     nd_compress::Cint
     nd_camd::Cint
     nd_components::Cint
     ordering::Cint
-    other_3::NTuple{4, Csize_t}
+    other_3::NTuple{4,Csize_t}
 end
 
 mutable struct cholmod_common_struct
@@ -166,8 +179,8 @@ mutable struct cholmod_common_struct
     final_pack::Cint
     final_monotonic::Cint
     final_resymbol::Cint
-    zrelax::NTuple{3, Cdouble}
-    nrelax::NTuple{3, Csize_t}
+    zrelax::NTuple{3,Cdouble}
+    nrelax::NTuple{3,Csize_t}
     prefer_zomplex::Cint
     prefer_upper::Cint
     quick_return_if_not_posdef::Cint
@@ -179,7 +192,7 @@ mutable struct cholmod_common_struct
     nmethods::Cint
     current::Cint
     selected::Cint
-    method::NTuple{10, cholmod_method_struct}
+    method::NTuple{10,cholmod_method_struct}
     postorder::Cint
     default_nesdis::Cint
     metis_memory::Cdouble
@@ -222,7 +235,7 @@ mutable struct cholmod_common_struct
     SPQR_flopcount_bound::Cdouble
     SPQR_tol_used::Cdouble
     SPQR_norm_E_fro::Cdouble
-    SPQR_istat::NTuple{10, Int64}
+    SPQR_istat::NTuple{10,Int64}
     useGPU::Cint
     maxGpuMemBytes::Csize_t
     maxGpuMemFraction::Cdouble
@@ -231,10 +244,10 @@ mutable struct cholmod_common_struct
     gpuFlops::Int64
     gpuNumKernelLaunches::Cint
     cublasHandle::Ptr{Cvoid}
-    gpuStream::NTuple{8, Ptr{Cvoid}}
-    cublasEventPotrf::NTuple{3, Ptr{Cvoid}}
+    gpuStream::NTuple{8,Ptr{Cvoid}}
+    cublasEventPotrf::NTuple{3,Ptr{Cvoid}}
     updateCKernelsComplete::Ptr{Cvoid}
-    updateCBuffersFree::NTuple{8, Ptr{Cvoid}}
+    updateCBuffersFree::NTuple{8,Ptr{Cvoid}}
     dev_mempool::Ptr{Cvoid}
     dev_mempool_size::Csize_t
     host_pinned_mempool::Ptr{Cvoid}
@@ -300,11 +313,14 @@ function cholmod_l_maxrank(arg1, arg2)
 end
 
 function cholmod_allocate_work(nrow, iworksize, xworksize, Common)
-    @ccall libcholmod.cholmod_allocate_work(nrow::Csize_t, iworksize::Csize_t, xworksize::Csize_t, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_allocate_work(nrow::Csize_t, iworksize::Csize_t,
+                                            xworksize::Csize_t,
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_allocate_work(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_allocate_work(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_allocate_work(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t,
+                                              arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_free_work(Common)
@@ -324,11 +340,13 @@ function cholmod_l_clear_flag(arg1)
 end
 
 function cholmod_error(status, file, line, message, Common)
-    @ccall libcholmod.cholmod_error(status::Cint, file::Ptr{Cchar}, line::Cint, message::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_error(status::Cint, file::Ptr{Cchar}, line::Cint,
+                                    message::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_error(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_error(arg1::Cint, arg2::Ptr{Cchar}, arg3::Cint, arg4::Ptr{Cchar}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_error(arg1::Cint, arg2::Ptr{Cchar}, arg3::Cint,
+                                      arg4::Ptr{Cchar}, arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_dbound(dj, Common)
@@ -348,11 +366,14 @@ function cholmod_l_hypot(arg1, arg2)
 end
 
 function cholmod_divcomplex(ar, ai, br, bi, cr, ci)
-    @ccall libcholmod.cholmod_divcomplex(ar::Cdouble, ai::Cdouble, br::Cdouble, bi::Cdouble, cr::Ptr{Cdouble}, ci::Ptr{Cdouble})::Cint
+    @ccall libcholmod.cholmod_divcomplex(ar::Cdouble, ai::Cdouble, br::Cdouble, bi::Cdouble,
+                                         cr::Ptr{Cdouble}, ci::Ptr{Cdouble})::Cint
 end
 
 function cholmod_l_divcomplex(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_divcomplex(arg1::Cdouble, arg2::Cdouble, arg3::Cdouble, arg4::Cdouble, arg5::Ptr{Cdouble}, arg6::Ptr{Cdouble})::Cint
+    @ccall libcholmod.cholmod_l_divcomplex(arg1::Cdouble, arg2::Cdouble, arg3::Cdouble,
+                                           arg4::Cdouble, arg5::Ptr{Cdouble},
+                                           arg6::Ptr{Cdouble})::Cint
 end
 
 mutable struct cholmod_sparse_struct
@@ -384,155 +405,217 @@ end
 const descendantScore = cholmod_descendant_score_t
 
 function cholmod_score_comp(i, j)
-    @ccall libcholmod.cholmod_score_comp(i::Ptr{cholmod_descendant_score_t}, j::Ptr{cholmod_descendant_score_t})::Cint
+    @ccall libcholmod.cholmod_score_comp(i::Ptr{cholmod_descendant_score_t},
+                                         j::Ptr{cholmod_descendant_score_t})::Cint
 end
 
 function cholmod_l_score_comp(i, j)
-    @ccall libcholmod.cholmod_l_score_comp(i::Ptr{cholmod_descendant_score_t}, j::Ptr{cholmod_descendant_score_t})::Cint
+    @ccall libcholmod.cholmod_l_score_comp(i::Ptr{cholmod_descendant_score_t},
+                                           j::Ptr{cholmod_descendant_score_t})::Cint
 end
 
 function cholmod_allocate_sparse(nrow, ncol, nzmax, sorted, packed, stype, xtype, Common)
-    @ccall libcholmod.cholmod_allocate_sparse(nrow::Csize_t, ncol::Csize_t, nzmax::Csize_t, sorted::Cint, packed::Cint, stype::Cint, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_allocate_sparse(nrow::Csize_t, ncol::Csize_t, nzmax::Csize_t,
+                                              sorted::Cint, packed::Cint, stype::Cint,
+                                              xtype::Cint,
+                                              Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_allocate_sparse(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
-    @ccall libcholmod.cholmod_l_allocate_sparse(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t, arg4::Cint, arg5::Cint, arg6::Cint, arg7::Cint, arg8::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_allocate_sparse(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t,
+                                                arg4::Cint, arg5::Cint, arg6::Cint,
+                                                arg7::Cint,
+                                                arg8::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_free_sparse(A, Common)
-    @ccall libcholmod.cholmod_free_sparse(A::Ptr{Ptr{cholmod_sparse}}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_free_sparse(A::Ptr{Ptr{cholmod_sparse}},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_free_sparse(arg1, arg2)
-    @ccall libcholmod.cholmod_l_free_sparse(arg1::Ptr{Ptr{cholmod_sparse}}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_free_sparse(arg1::Ptr{Ptr{cholmod_sparse}},
+                                            arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_reallocate_sparse(nznew, A, Common)
-    @ccall libcholmod.cholmod_reallocate_sparse(nznew::Csize_t, A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_reallocate_sparse(nznew::Csize_t, A::Ptr{cholmod_sparse},
+                                                Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_reallocate_sparse(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_reallocate_sparse(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_reallocate_sparse(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                                  arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_nnz(A, Common)
-    @ccall libcholmod.cholmod_nnz(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_nnz(A::Ptr{cholmod_sparse},
+                                  Common::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_l_nnz(arg1, arg2)
-    @ccall libcholmod.cholmod_l_nnz(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_l_nnz(arg1::Ptr{cholmod_sparse},
+                                    arg2::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_speye(nrow, ncol, xtype, Common)
-    @ccall libcholmod.cholmod_speye(nrow::Csize_t, ncol::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_speye(nrow::Csize_t, ncol::Csize_t, xtype::Cint,
+                                    Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_speye(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_speye(arg1::Csize_t, arg2::Csize_t, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_speye(arg1::Csize_t, arg2::Csize_t, arg3::Cint,
+                                      arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_spzeros(nrow, ncol, nzmax, xtype, Common)
-    @ccall libcholmod.cholmod_spzeros(nrow::Csize_t, ncol::Csize_t, nzmax::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_spzeros(nrow::Csize_t, ncol::Csize_t, nzmax::Csize_t,
+                                      xtype::Cint,
+                                      Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_spzeros(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_spzeros(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t, arg4::Cint, arg5::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_spzeros(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t,
+                                        arg4::Cint,
+                                        arg5::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_transpose(A, values, Common)
-    @ccall libcholmod.cholmod_transpose(A::Ptr{cholmod_sparse}, values::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_transpose(A::Ptr{cholmod_sparse}, values::Cint,
+                                        Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_transpose(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_transpose(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_transpose(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                          arg3::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_transpose_unsym(A, values, Perm, fset, fsize, F, Common)
-    @ccall libcholmod.cholmod_transpose_unsym(A::Ptr{cholmod_sparse}, values::Cint, Perm::Ptr{Int32}, fset::Ptr{Int32}, fsize::Csize_t, F::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_transpose_unsym(A::Ptr{cholmod_sparse}, values::Cint,
+                                              Perm::Ptr{Int32}, fset::Ptr{Int32},
+                                              fsize::Csize_t, F::Ptr{cholmod_sparse},
+                                              Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_transpose_unsym(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_transpose_unsym(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Csize_t, arg6::Ptr{cholmod_sparse}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_transpose_unsym(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                                arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                                arg5::Csize_t, arg6::Ptr{cholmod_sparse},
+                                                arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_transpose_sym(A, values, Perm, F, Common)
-    @ccall libcholmod.cholmod_transpose_sym(A::Ptr{cholmod_sparse}, values::Cint, Perm::Ptr{Int32}, F::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_transpose_sym(A::Ptr{cholmod_sparse}, values::Cint,
+                                            Perm::Ptr{Int32}, F::Ptr{cholmod_sparse},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_transpose_sym(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_transpose_sym(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{Int64}, arg4::Ptr{cholmod_sparse}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_transpose_sym(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                              arg3::Ptr{Int64}, arg4::Ptr{cholmod_sparse},
+                                              arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_ptranspose(A, values, Perm, fset, fsize, Common)
-    @ccall libcholmod.cholmod_ptranspose(A::Ptr{cholmod_sparse}, values::Cint, Perm::Ptr{Int32}, fset::Ptr{Int32}, fsize::Csize_t, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_ptranspose(A::Ptr{cholmod_sparse}, values::Cint,
+                                         Perm::Ptr{Int32}, fset::Ptr{Int32}, fsize::Csize_t,
+                                         Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_ptranspose(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_ptranspose(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Csize_t, arg6::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_ptranspose(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                           arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                           arg5::Csize_t,
+                                           arg6::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_sort(A, Common)
-    @ccall libcholmod.cholmod_sort(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_sort(A::Ptr{cholmod_sparse},
+                                   Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_sort(arg1, arg2)
-    @ccall libcholmod.cholmod_l_sort(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_sort(arg1::Ptr{cholmod_sparse},
+                                     arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_band(A, k1, k2, mode, Common)
-    @ccall libcholmod.cholmod_band(A::Ptr{cholmod_sparse}, k1::Int64, k2::Int64, mode::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_band(A::Ptr{cholmod_sparse}, k1::Int64, k2::Int64, mode::Cint,
+                                   Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_band(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_band(arg1::Ptr{cholmod_sparse}, arg2::Int64, arg3::Int64, arg4::Cint, arg5::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_band(arg1::Ptr{cholmod_sparse}, arg2::Int64, arg3::Int64,
+                                     arg4::Cint,
+                                     arg5::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_band_inplace(k1, k2, mode, A, Common)
-    @ccall libcholmod.cholmod_band_inplace(k1::Int64, k2::Int64, mode::Cint, A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_band_inplace(k1::Int64, k2::Int64, mode::Cint,
+                                           A::Ptr{cholmod_sparse},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_band_inplace(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_band_inplace(arg1::Int64, arg2::Int64, arg3::Cint, arg4::Ptr{cholmod_sparse}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_band_inplace(arg1::Int64, arg2::Int64, arg3::Cint,
+                                             arg4::Ptr{cholmod_sparse},
+                                             arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_aat(A, fset, fsize, mode, Common)
-    @ccall libcholmod.cholmod_aat(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, mode::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_aat(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t,
+                                  mode::Cint,
+                                  Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_aat(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_aat(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Cint, arg5::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_aat(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                    arg3::Csize_t, arg4::Cint,
+                                    arg5::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_copy_sparse(A, Common)
-    @ccall libcholmod.cholmod_copy_sparse(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_copy_sparse(A::Ptr{cholmod_sparse},
+                                          Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_copy_sparse(arg1, arg2)
-    @ccall libcholmod.cholmod_l_copy_sparse(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_copy_sparse(arg1::Ptr{cholmod_sparse},
+                                            arg2::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_copy(A, stype, mode, Common)
-    @ccall libcholmod.cholmod_copy(A::Ptr{cholmod_sparse}, stype::Cint, mode::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_copy(A::Ptr{cholmod_sparse}, stype::Cint, mode::Cint,
+                                   Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_copy(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_copy(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_copy(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Cint,
+                                     arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_add(A, B, alpha, beta, values, sorted, Common)
-    @ccall libcholmod.cholmod_add(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse}, alpha::Ptr{Cdouble}, beta::Ptr{Cdouble}, values::Cint, sorted::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_add(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse},
+                                  alpha::Ptr{Cdouble}, beta::Ptr{Cdouble}, values::Cint,
+                                  sorted::Cint,
+                                  Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_add(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_add(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Ptr{Cdouble}, arg5::Cint, arg6::Cint, arg7::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_add(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse},
+                                    arg3::Ptr{Cdouble}, arg4::Ptr{Cdouble}, arg5::Cint,
+                                    arg6::Cint,
+                                    arg7::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_sparse_xtype(to_xtype, A, Common)
-    @ccall libcholmod.cholmod_sparse_xtype(to_xtype::Cint, A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_sparse_xtype(to_xtype::Cint, A::Ptr{cholmod_sparse},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_sparse_xtype(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_sparse_xtype(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_sparse_xtype(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                             arg3::Ptr{cholmod_common})::Cint
 end
 
 mutable struct cholmod_factor_struct
@@ -572,75 +655,100 @@ end
 const cholmod_factor = cholmod_factor_struct
 
 function cholmod_allocate_factor(n, Common)
-    @ccall libcholmod.cholmod_allocate_factor(n::Csize_t, Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_allocate_factor(n::Csize_t,
+                                              Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_l_allocate_factor(arg1, arg2)
-    @ccall libcholmod.cholmod_l_allocate_factor(arg1::Csize_t, arg2::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_l_allocate_factor(arg1::Csize_t,
+                                                arg2::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_free_factor(L, Common)
-    @ccall libcholmod.cholmod_free_factor(L::Ptr{Ptr{cholmod_factor}}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_free_factor(L::Ptr{Ptr{cholmod_factor}},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_free_factor(arg1, arg2)
-    @ccall libcholmod.cholmod_l_free_factor(arg1::Ptr{Ptr{cholmod_factor}}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_free_factor(arg1::Ptr{Ptr{cholmod_factor}},
+                                            arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_reallocate_factor(nznew, L, Common)
-    @ccall libcholmod.cholmod_reallocate_factor(nznew::Csize_t, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_reallocate_factor(nznew::Csize_t, L::Ptr{cholmod_factor},
+                                                Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_reallocate_factor(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_reallocate_factor(arg1::Csize_t, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_reallocate_factor(arg1::Csize_t, arg2::Ptr{cholmod_factor},
+                                                  arg3::Ptr{cholmod_common})::Cint
 end
 
-function cholmod_change_factor(to_xtype, to_ll, to_super, to_packed, to_monotonic, L, Common)
-    @ccall libcholmod.cholmod_change_factor(to_xtype::Cint, to_ll::Cint, to_super::Cint, to_packed::Cint, to_monotonic::Cint, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+function cholmod_change_factor(to_xtype, to_ll, to_super, to_packed, to_monotonic, L,
+                               Common)
+    @ccall libcholmod.cholmod_change_factor(to_xtype::Cint, to_ll::Cint, to_super::Cint,
+                                            to_packed::Cint, to_monotonic::Cint,
+                                            L::Ptr{cholmod_factor},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_change_factor(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_change_factor(arg1::Cint, arg2::Cint, arg3::Cint, arg4::Cint, arg5::Cint, arg6::Ptr{cholmod_factor}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_change_factor(arg1::Cint, arg2::Cint, arg3::Cint,
+                                              arg4::Cint, arg5::Cint,
+                                              arg6::Ptr{cholmod_factor},
+                                              arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_pack_factor(L, Common)
-    @ccall libcholmod.cholmod_pack_factor(L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_pack_factor(L::Ptr{cholmod_factor},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_pack_factor(arg1, arg2)
-    @ccall libcholmod.cholmod_l_pack_factor(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_pack_factor(arg1::Ptr{cholmod_factor},
+                                            arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_reallocate_column(j, need, L, Common)
-    @ccall libcholmod.cholmod_reallocate_column(j::Csize_t, need::Csize_t, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_reallocate_column(j::Csize_t, need::Csize_t,
+                                                L::Ptr{cholmod_factor},
+                                                Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_reallocate_column(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_reallocate_column(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{cholmod_factor}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_reallocate_column(arg1::Csize_t, arg2::Csize_t,
+                                                  arg3::Ptr{cholmod_factor},
+                                                  arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_factor_to_sparse(L, Common)
-    @ccall libcholmod.cholmod_factor_to_sparse(L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_factor_to_sparse(L::Ptr{cholmod_factor},
+                                               Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_factor_to_sparse(arg1, arg2)
-    @ccall libcholmod.cholmod_l_factor_to_sparse(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_factor_to_sparse(arg1::Ptr{cholmod_factor},
+                                                 arg2::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_copy_factor(L, Common)
-    @ccall libcholmod.cholmod_copy_factor(L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_copy_factor(L::Ptr{cholmod_factor},
+                                          Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_l_copy_factor(arg1, arg2)
-    @ccall libcholmod.cholmod_l_copy_factor(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_l_copy_factor(arg1::Ptr{cholmod_factor},
+                                            arg2::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_factor_xtype(to_xtype, L, Common)
-    @ccall libcholmod.cholmod_factor_xtype(to_xtype::Cint, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_factor_xtype(to_xtype::Cint, L::Ptr{cholmod_factor},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_factor_xtype(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_factor_xtype(arg1::Cint, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_factor_xtype(arg1::Cint, arg2::Ptr{cholmod_factor},
+                                             arg3::Ptr{cholmod_common})::Cint
 end
 
 mutable struct cholmod_dense_struct
@@ -658,91 +766,118 @@ end
 const cholmod_dense = cholmod_dense_struct
 
 function cholmod_allocate_dense(nrow, ncol, d, xtype, Common)
-    @ccall libcholmod.cholmod_allocate_dense(nrow::Csize_t, ncol::Csize_t, d::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_allocate_dense(nrow::Csize_t, ncol::Csize_t, d::Csize_t,
+                                             xtype::Cint,
+                                             Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_allocate_dense(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_allocate_dense(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t, arg4::Cint, arg5::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_allocate_dense(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t,
+                                               arg4::Cint,
+                                               arg5::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_zeros(nrow, ncol, xtype, Common)
-    @ccall libcholmod.cholmod_zeros(nrow::Csize_t, ncol::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_zeros(nrow::Csize_t, ncol::Csize_t, xtype::Cint,
+                                    Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_zeros(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_zeros(arg1::Csize_t, arg2::Csize_t, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_zeros(arg1::Csize_t, arg2::Csize_t, arg3::Cint,
+                                      arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_ones(nrow, ncol, xtype, Common)
-    @ccall libcholmod.cholmod_ones(nrow::Csize_t, ncol::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_ones(nrow::Csize_t, ncol::Csize_t, xtype::Cint,
+                                   Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_ones(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_ones(arg1::Csize_t, arg2::Csize_t, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_ones(arg1::Csize_t, arg2::Csize_t, arg3::Cint,
+                                     arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_eye(nrow, ncol, xtype, Common)
-    @ccall libcholmod.cholmod_eye(nrow::Csize_t, ncol::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_eye(nrow::Csize_t, ncol::Csize_t, xtype::Cint,
+                                  Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_eye(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_eye(arg1::Csize_t, arg2::Csize_t, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_eye(arg1::Csize_t, arg2::Csize_t, arg3::Cint,
+                                    arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_free_dense(X, Common)
-    @ccall libcholmod.cholmod_free_dense(X::Ptr{Ptr{cholmod_dense}}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_free_dense(X::Ptr{Ptr{cholmod_dense}},
+                                         Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_free_dense(arg1, arg2)
-    @ccall libcholmod.cholmod_l_free_dense(arg1::Ptr{Ptr{cholmod_dense}}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_free_dense(arg1::Ptr{Ptr{cholmod_dense}},
+                                           arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_ensure_dense(XHandle, nrow, ncol, d, xtype, Common)
-    @ccall libcholmod.cholmod_ensure_dense(XHandle::Ptr{Ptr{cholmod_dense}}, nrow::Csize_t, ncol::Csize_t, d::Csize_t, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_ensure_dense(XHandle::Ptr{Ptr{cholmod_dense}}, nrow::Csize_t,
+                                           ncol::Csize_t, d::Csize_t, xtype::Cint,
+                                           Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_ensure_dense(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_ensure_dense(arg1::Ptr{Ptr{cholmod_dense}}, arg2::Csize_t, arg3::Csize_t, arg4::Csize_t, arg5::Cint, arg6::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_ensure_dense(arg1::Ptr{Ptr{cholmod_dense}}, arg2::Csize_t,
+                                             arg3::Csize_t, arg4::Csize_t, arg5::Cint,
+                                             arg6::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_sparse_to_dense(A, Common)
-    @ccall libcholmod.cholmod_sparse_to_dense(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_sparse_to_dense(A::Ptr{cholmod_sparse},
+                                              Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_sparse_to_dense(arg1, arg2)
-    @ccall libcholmod.cholmod_l_sparse_to_dense(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_sparse_to_dense(arg1::Ptr{cholmod_sparse},
+                                                arg2::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_dense_to_sparse(X, values, Common)
-    @ccall libcholmod.cholmod_dense_to_sparse(X::Ptr{cholmod_dense}, values::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_dense_to_sparse(X::Ptr{cholmod_dense}, values::Cint,
+                                              Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_dense_to_sparse(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_dense_to_sparse(arg1::Ptr{cholmod_dense}, arg2::Cint, arg3::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_dense_to_sparse(arg1::Ptr{cholmod_dense}, arg2::Cint,
+                                                arg3::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_copy_dense(X, Common)
-    @ccall libcholmod.cholmod_copy_dense(X::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_copy_dense(X::Ptr{cholmod_dense},
+                                         Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_copy_dense(arg1, arg2)
-    @ccall libcholmod.cholmod_l_copy_dense(arg1::Ptr{cholmod_dense}, arg2::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_copy_dense(arg1::Ptr{cholmod_dense},
+                                           arg2::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_copy_dense2(X, Y, Common)
-    @ccall libcholmod.cholmod_copy_dense2(X::Ptr{cholmod_dense}, Y::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_copy_dense2(X::Ptr{cholmod_dense}, Y::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_copy_dense2(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_copy_dense2(arg1::Ptr{cholmod_dense}, arg2::Ptr{cholmod_dense}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_copy_dense2(arg1::Ptr{cholmod_dense},
+                                            arg2::Ptr{cholmod_dense},
+                                            arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_dense_xtype(to_xtype, X, Common)
-    @ccall libcholmod.cholmod_dense_xtype(to_xtype::Cint, X::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_dense_xtype(to_xtype::Cint, X::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_dense_xtype(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_dense_xtype(arg1::Cint, arg2::Ptr{cholmod_dense}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_dense_xtype(arg1::Cint, arg2::Ptr{cholmod_dense},
+                                            arg3::Ptr{cholmod_common})::Cint
 end
 
 mutable struct cholmod_triplet_struct
@@ -764,99 +899,137 @@ end
 const cholmod_triplet = cholmod_triplet_struct
 
 function cholmod_allocate_triplet(nrow, ncol, nzmax, stype, xtype, Common)
-    @ccall libcholmod.cholmod_allocate_triplet(nrow::Csize_t, ncol::Csize_t, nzmax::Csize_t, stype::Cint, xtype::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_allocate_triplet(nrow::Csize_t, ncol::Csize_t, nzmax::Csize_t,
+                                               stype::Cint, xtype::Cint,
+                                               Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_l_allocate_triplet(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_allocate_triplet(arg1::Csize_t, arg2::Csize_t, arg3::Csize_t, arg4::Cint, arg5::Cint, arg6::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_l_allocate_triplet(arg1::Csize_t, arg2::Csize_t,
+                                                 arg3::Csize_t, arg4::Cint, arg5::Cint,
+                                                 arg6::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_free_triplet(T, Common)
-    @ccall libcholmod.cholmod_free_triplet(T::Ptr{Ptr{cholmod_triplet}}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_free_triplet(T::Ptr{Ptr{cholmod_triplet}},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_free_triplet(arg1, arg2)
-    @ccall libcholmod.cholmod_l_free_triplet(arg1::Ptr{Ptr{cholmod_triplet}}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_free_triplet(arg1::Ptr{Ptr{cholmod_triplet}},
+                                             arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_reallocate_triplet(nznew, T, Common)
-    @ccall libcholmod.cholmod_reallocate_triplet(nznew::Csize_t, T::Ptr{cholmod_triplet}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_reallocate_triplet(nznew::Csize_t, T::Ptr{cholmod_triplet},
+                                                 Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_reallocate_triplet(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_reallocate_triplet(arg1::Csize_t, arg2::Ptr{cholmod_triplet}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_reallocate_triplet(arg1::Csize_t,
+                                                   arg2::Ptr{cholmod_triplet},
+                                                   arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_sparse_to_triplet(A, Common)
-    @ccall libcholmod.cholmod_sparse_to_triplet(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_sparse_to_triplet(A::Ptr{cholmod_sparse},
+                                                Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_l_sparse_to_triplet(arg1, arg2)
-    @ccall libcholmod.cholmod_l_sparse_to_triplet(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_l_sparse_to_triplet(arg1::Ptr{cholmod_sparse},
+                                                  arg2::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_triplet_to_sparse(T, nzmax, Common)
-    @ccall libcholmod.cholmod_triplet_to_sparse(T::Ptr{cholmod_triplet}, nzmax::Csize_t, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_triplet_to_sparse(T::Ptr{cholmod_triplet}, nzmax::Csize_t,
+                                                Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_triplet_to_sparse(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_triplet_to_sparse(arg1::Ptr{cholmod_triplet}, arg2::Csize_t, arg3::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_triplet_to_sparse(arg1::Ptr{cholmod_triplet}, arg2::Csize_t,
+                                                  arg3::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_copy_triplet(T, Common)
-    @ccall libcholmod.cholmod_copy_triplet(T::Ptr{cholmod_triplet}, Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_copy_triplet(T::Ptr{cholmod_triplet},
+                                           Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_l_copy_triplet(arg1, arg2)
-    @ccall libcholmod.cholmod_l_copy_triplet(arg1::Ptr{cholmod_triplet}, arg2::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_l_copy_triplet(arg1::Ptr{cholmod_triplet},
+                                             arg2::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_triplet_xtype(to_xtype, T, Common)
-    @ccall libcholmod.cholmod_triplet_xtype(to_xtype::Cint, T::Ptr{cholmod_triplet}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_triplet_xtype(to_xtype::Cint, T::Ptr{cholmod_triplet},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_triplet_xtype(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_triplet_xtype(arg1::Cint, arg2::Ptr{cholmod_triplet}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_triplet_xtype(arg1::Cint, arg2::Ptr{cholmod_triplet},
+                                              arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_malloc(n, size, Common)
-    @ccall libcholmod.cholmod_malloc(n::Csize_t, size::Csize_t, Common::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_malloc(n::Csize_t, size::Csize_t,
+                                     Common::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_l_malloc(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_malloc(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_l_malloc(arg1::Csize_t, arg2::Csize_t,
+                                       arg3::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_calloc(n, size, Common)
-    @ccall libcholmod.cholmod_calloc(n::Csize_t, size::Csize_t, Common::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_calloc(n::Csize_t, size::Csize_t,
+                                     Common::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_l_calloc(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_calloc(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_l_calloc(arg1::Csize_t, arg2::Csize_t,
+                                       arg3::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_free(n, size, p, Common)
-    @ccall libcholmod.cholmod_free(n::Csize_t, size::Csize_t, p::Ptr{Cvoid}, Common::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_free(n::Csize_t, size::Csize_t, p::Ptr{Cvoid},
+                                   Common::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_l_free(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_free(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{Cvoid}, arg4::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_l_free(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{Cvoid},
+                                     arg4::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_realloc(nnew, size, p, n, Common)
-    @ccall libcholmod.cholmod_realloc(nnew::Csize_t, size::Csize_t, p::Ptr{Cvoid}, n::Ptr{Csize_t}, Common::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_realloc(nnew::Csize_t, size::Csize_t, p::Ptr{Cvoid},
+                                      n::Ptr{Csize_t},
+                                      Common::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_l_realloc(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_realloc(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{Cvoid}, arg4::Ptr{Csize_t}, arg5::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_l_realloc(arg1::Csize_t, arg2::Csize_t, arg3::Ptr{Cvoid},
+                                        arg4::Ptr{Csize_t},
+                                        arg5::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
-function cholmod_realloc_multiple(nnew, nint, xtype, Iblock, Jblock, Xblock, Zblock, n, Common)
-    @ccall libcholmod.cholmod_realloc_multiple(nnew::Csize_t, nint::Cint, xtype::Cint, Iblock::Ptr{Ptr{Cvoid}}, Jblock::Ptr{Ptr{Cvoid}}, Xblock::Ptr{Ptr{Cvoid}}, Zblock::Ptr{Ptr{Cvoid}}, n::Ptr{Csize_t}, Common::Ptr{cholmod_common})::Cint
+function cholmod_realloc_multiple(nnew, nint, xtype, Iblock, Jblock, Xblock, Zblock, n,
+                                  Common)
+    @ccall libcholmod.cholmod_realloc_multiple(nnew::Csize_t, nint::Cint, xtype::Cint,
+                                               Iblock::Ptr{Ptr{Cvoid}},
+                                               Jblock::Ptr{Ptr{Cvoid}},
+                                               Xblock::Ptr{Ptr{Cvoid}},
+                                               Zblock::Ptr{Ptr{Cvoid}}, n::Ptr{Csize_t},
+                                               Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_realloc_multiple(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
-    @ccall libcholmod.cholmod_l_realloc_multiple(arg1::Csize_t, arg2::Cint, arg3::Cint, arg4::Ptr{Ptr{Cvoid}}, arg5::Ptr{Ptr{Cvoid}}, arg6::Ptr{Ptr{Cvoid}}, arg7::Ptr{Ptr{Cvoid}}, arg8::Ptr{Csize_t}, arg9::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_realloc_multiple(arg1::Csize_t, arg2::Cint, arg3::Cint,
+                                                 arg4::Ptr{Ptr{Cvoid}},
+                                                 arg5::Ptr{Ptr{Cvoid}},
+                                                 arg6::Ptr{Ptr{Cvoid}},
+                                                 arg7::Ptr{Ptr{Cvoid}}, arg8::Ptr{Csize_t},
+                                                 arg9::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_version(version)
@@ -876,11 +1049,13 @@ function cholmod_l_check_common(arg1)
 end
 
 function cholmod_print_common(name, Common)
-    @ccall libcholmod.cholmod_print_common(name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_common(name::Ptr{Cchar},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_common(arg1, arg2)
-    @ccall libcholmod.cholmod_l_print_common(arg1::Ptr{Cchar}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_common(arg1::Ptr{Cchar},
+                                             arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_gpu_stats(arg1)
@@ -892,643 +1067,1047 @@ function cholmod_l_gpu_stats(arg1)
 end
 
 function cholmod_check_sparse(A, Common)
-    @ccall libcholmod.cholmod_check_sparse(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_sparse(A::Ptr{cholmod_sparse},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_sparse(arg1, arg2)
-    @ccall libcholmod.cholmod_l_check_sparse(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_sparse(arg1::Ptr{cholmod_sparse},
+                                             arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_sparse(A, name, Common)
-    @ccall libcholmod.cholmod_print_sparse(A::Ptr{cholmod_sparse}, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_sparse(A::Ptr{cholmod_sparse}, name::Ptr{Cchar},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_sparse(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_print_sparse(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Cchar}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_sparse(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Cchar},
+                                             arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_check_dense(X, Common)
-    @ccall libcholmod.cholmod_check_dense(X::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_dense(X::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_dense(arg1, arg2)
-    @ccall libcholmod.cholmod_l_check_dense(arg1::Ptr{cholmod_dense}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_dense(arg1::Ptr{cholmod_dense},
+                                            arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_dense(X, name, Common)
-    @ccall libcholmod.cholmod_print_dense(X::Ptr{cholmod_dense}, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_dense(X::Ptr{cholmod_dense}, name::Ptr{Cchar},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_dense(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_print_dense(arg1::Ptr{cholmod_dense}, arg2::Ptr{Cchar}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_dense(arg1::Ptr{cholmod_dense}, arg2::Ptr{Cchar},
+                                            arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_check_factor(L, Common)
-    @ccall libcholmod.cholmod_check_factor(L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_factor(L::Ptr{cholmod_factor},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_factor(arg1, arg2)
-    @ccall libcholmod.cholmod_l_check_factor(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_factor(arg1::Ptr{cholmod_factor},
+                                             arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_factor(L, name, Common)
-    @ccall libcholmod.cholmod_print_factor(L::Ptr{cholmod_factor}, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_factor(L::Ptr{cholmod_factor}, name::Ptr{Cchar},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_factor(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_print_factor(arg1::Ptr{cholmod_factor}, arg2::Ptr{Cchar}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_factor(arg1::Ptr{cholmod_factor}, arg2::Ptr{Cchar},
+                                             arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_check_triplet(T, Common)
-    @ccall libcholmod.cholmod_check_triplet(T::Ptr{cholmod_triplet}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_triplet(T::Ptr{cholmod_triplet},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_triplet(arg1, arg2)
-    @ccall libcholmod.cholmod_l_check_triplet(arg1::Ptr{cholmod_triplet}, arg2::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_triplet(arg1::Ptr{cholmod_triplet},
+                                              arg2::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_triplet(T, name, Common)
-    @ccall libcholmod.cholmod_print_triplet(T::Ptr{cholmod_triplet}, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_triplet(T::Ptr{cholmod_triplet}, name::Ptr{Cchar},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_triplet(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_print_triplet(arg1::Ptr{cholmod_triplet}, arg2::Ptr{Cchar}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_triplet(arg1::Ptr{cholmod_triplet}, arg2::Ptr{Cchar},
+                                              arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_check_subset(Set, len, n, Common)
-    @ccall libcholmod.cholmod_check_subset(Set::Ptr{Int32}, len::Int64, n::Csize_t, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_subset(Set::Ptr{Int32}, len::Int64, n::Csize_t,
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_subset(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_check_subset(arg1::Ptr{Int64}, arg2::Int64, arg3::Csize_t, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_subset(arg1::Ptr{Int64}, arg2::Int64, arg3::Csize_t,
+                                             arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_subset(Set, len, n, name, Common)
-    @ccall libcholmod.cholmod_print_subset(Set::Ptr{Int32}, len::Int64, n::Csize_t, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_subset(Set::Ptr{Int32}, len::Int64, n::Csize_t,
+                                           name::Ptr{Cchar},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_subset(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_print_subset(arg1::Ptr{Int64}, arg2::Int64, arg3::Csize_t, arg4::Ptr{Cchar}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_subset(arg1::Ptr{Int64}, arg2::Int64, arg3::Csize_t,
+                                             arg4::Ptr{Cchar},
+                                             arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_check_perm(Perm, len, n, Common)
-    @ccall libcholmod.cholmod_check_perm(Perm::Ptr{Int32}, len::Csize_t, n::Csize_t, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_perm(Perm::Ptr{Int32}, len::Csize_t, n::Csize_t,
+                                         Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_perm(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_check_perm(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Csize_t, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_perm(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Csize_t,
+                                           arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_perm(Perm, len, n, name, Common)
-    @ccall libcholmod.cholmod_print_perm(Perm::Ptr{Int32}, len::Csize_t, n::Csize_t, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_perm(Perm::Ptr{Int32}, len::Csize_t, n::Csize_t,
+                                         name::Ptr{Cchar},
+                                         Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_perm(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_print_perm(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Csize_t, arg4::Ptr{Cchar}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_perm(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Csize_t,
+                                           arg4::Ptr{Cchar},
+                                           arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_check_parent(Parent, n, Common)
-    @ccall libcholmod.cholmod_check_parent(Parent::Ptr{Int32}, n::Csize_t, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_check_parent(Parent::Ptr{Int32}, n::Csize_t,
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_check_parent(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_check_parent(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_check_parent(arg1::Ptr{Int64}, arg2::Csize_t,
+                                             arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_print_parent(Parent, n, name, Common)
-    @ccall libcholmod.cholmod_print_parent(Parent::Ptr{Int32}, n::Csize_t, name::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_print_parent(Parent::Ptr{Int32}, n::Csize_t, name::Ptr{Cchar},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_print_parent(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_print_parent(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Ptr{Cchar}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_print_parent(arg1::Ptr{Int64}, arg2::Csize_t,
+                                             arg3::Ptr{Cchar},
+                                             arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_read_sparse(f, Common)
-    @ccall libcholmod.cholmod_read_sparse(f::Ptr{Libc.FILE}, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_read_sparse(f::Ptr{Libc.FILE},
+                                          Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_read_sparse(arg1, arg2)
-    @ccall libcholmod.cholmod_l_read_sparse(arg1::Ptr{Libc.FILE}, arg2::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_read_sparse(arg1::Ptr{Libc.FILE},
+                                            arg2::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_read_triplet(f, Common)
-    @ccall libcholmod.cholmod_read_triplet(f::Ptr{Libc.FILE}, Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_read_triplet(f::Ptr{Libc.FILE},
+                                           Common::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_l_read_triplet(arg1, arg2)
-    @ccall libcholmod.cholmod_l_read_triplet(arg1::Ptr{Libc.FILE}, arg2::Ptr{cholmod_common})::Ptr{cholmod_triplet}
+    @ccall libcholmod.cholmod_l_read_triplet(arg1::Ptr{Libc.FILE},
+                                             arg2::Ptr{cholmod_common})::Ptr{cholmod_triplet}
 end
 
 function cholmod_read_dense(f, Common)
-    @ccall libcholmod.cholmod_read_dense(f::Ptr{Libc.FILE}, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_read_dense(f::Ptr{Libc.FILE},
+                                         Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_read_dense(arg1, arg2)
-    @ccall libcholmod.cholmod_l_read_dense(arg1::Ptr{Libc.FILE}, arg2::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_read_dense(arg1::Ptr{Libc.FILE},
+                                           arg2::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_read_matrix(f, prefer, mtype, Common)
-    @ccall libcholmod.cholmod_read_matrix(f::Ptr{Libc.FILE}, prefer::Cint, mtype::Ptr{Cint}, Common::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_read_matrix(f::Ptr{Libc.FILE}, prefer::Cint, mtype::Ptr{Cint},
+                                          Common::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_l_read_matrix(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_read_matrix(arg1::Ptr{Libc.FILE}, arg2::Cint, arg3::Ptr{Cint}, arg4::Ptr{cholmod_common})::Ptr{Cvoid}
+    @ccall libcholmod.cholmod_l_read_matrix(arg1::Ptr{Libc.FILE}, arg2::Cint,
+                                            arg3::Ptr{Cint},
+                                            arg4::Ptr{cholmod_common})::Ptr{Cvoid}
 end
 
 function cholmod_write_sparse(f, A, Z, comments, Common)
-    @ccall libcholmod.cholmod_write_sparse(f::Ptr{Libc.FILE}, A::Ptr{cholmod_sparse}, Z::Ptr{cholmod_sparse}, comments::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_write_sparse(f::Ptr{Libc.FILE}, A::Ptr{cholmod_sparse},
+                                           Z::Ptr{cholmod_sparse}, comments::Ptr{Cchar},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_write_sparse(arg1, arg2, arg3, c, arg5)
-    @ccall libcholmod.cholmod_l_write_sparse(arg1::Ptr{Libc.FILE}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_sparse}, c::Ptr{Cchar}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_write_sparse(arg1::Ptr{Libc.FILE},
+                                             arg2::Ptr{cholmod_sparse},
+                                             arg3::Ptr{cholmod_sparse}, c::Ptr{Cchar},
+                                             arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_write_dense(f, X, comments, Common)
-    @ccall libcholmod.cholmod_write_dense(f::Ptr{Libc.FILE}, X::Ptr{cholmod_dense}, comments::Ptr{Cchar}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_write_dense(f::Ptr{Libc.FILE}, X::Ptr{cholmod_dense},
+                                          comments::Ptr{Cchar},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_write_dense(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_write_dense(arg1::Ptr{Libc.FILE}, arg2::Ptr{cholmod_dense}, arg3::Ptr{Cchar}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_write_dense(arg1::Ptr{Libc.FILE}, arg2::Ptr{cholmod_dense},
+                                            arg3::Ptr{Cchar},
+                                            arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_analyze(A, Common)
-    @ccall libcholmod.cholmod_analyze(A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_analyze(A::Ptr{cholmod_sparse},
+                                      Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_l_analyze(arg1, arg2)
-    @ccall libcholmod.cholmod_l_analyze(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_l_analyze(arg1::Ptr{cholmod_sparse},
+                                        arg2::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_analyze_p(A, UserPerm, fset, fsize, Common)
-    @ccall libcholmod.cholmod_analyze_p(A::Ptr{cholmod_sparse}, UserPerm::Ptr{Int32}, fset::Ptr{Int32}, fsize::Csize_t, Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_analyze_p(A::Ptr{cholmod_sparse}, UserPerm::Ptr{Int32},
+                                        fset::Ptr{Int32}, fsize::Csize_t,
+                                        Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_l_analyze_p(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_analyze_p(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Ptr{Int64}, arg4::Csize_t, arg5::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_l_analyze_p(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                          arg3::Ptr{Int64}, arg4::Csize_t,
+                                          arg5::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_analyze_p2(for_whom, A, UserPerm, fset, fsize, Common)
-    @ccall libcholmod.cholmod_analyze_p2(for_whom::Cint, A::Ptr{cholmod_sparse}, UserPerm::Ptr{Int32}, fset::Ptr{Int32}, fsize::Csize_t, Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_analyze_p2(for_whom::Cint, A::Ptr{cholmod_sparse},
+                                         UserPerm::Ptr{Int32}, fset::Ptr{Int32},
+                                         fsize::Csize_t,
+                                         Common::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_l_analyze_p2(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_analyze_p2(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Csize_t, arg6::Ptr{cholmod_common})::Ptr{cholmod_factor}
+    @ccall libcholmod.cholmod_l_analyze_p2(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                           arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                           arg5::Csize_t,
+                                           arg6::Ptr{cholmod_common})::Ptr{cholmod_factor}
 end
 
 function cholmod_factorize(A, L, Common)
-    @ccall libcholmod.cholmod_factorize(A::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_factorize(A::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor},
+                                        Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_factorize(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_factorize(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_factorize(arg1::Ptr{cholmod_sparse},
+                                          arg2::Ptr{cholmod_factor},
+                                          arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_factorize_p(A, beta, fset, fsize, L, Common)
-    @ccall libcholmod.cholmod_factorize_p(A::Ptr{cholmod_sparse}, beta::Ptr{Cdouble}, fset::Ptr{Int32}, fsize::Csize_t, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_factorize_p(A::Ptr{cholmod_sparse}, beta::Ptr{Cdouble},
+                                          fset::Ptr{Int32}, fsize::Csize_t,
+                                          L::Ptr{cholmod_factor},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_factorize_p(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_factorize_p(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Cdouble}, arg3::Ptr{Int64}, arg4::Csize_t, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_factorize_p(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Cdouble},
+                                            arg3::Ptr{Int64}, arg4::Csize_t,
+                                            arg5::Ptr{cholmod_factor},
+                                            arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_solve(sys, L, B, Common)
-    @ccall libcholmod.cholmod_solve(sys::Cint, L::Ptr{cholmod_factor}, B::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_solve(sys::Cint, L::Ptr{cholmod_factor},
+                                    B::Ptr{cholmod_dense},
+                                    Common::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_l_solve(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_solve(arg1::Cint, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_dense}, arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libcholmod.cholmod_l_solve(arg1::Cint, arg2::Ptr{cholmod_factor},
+                                      arg3::Ptr{cholmod_dense},
+                                      arg4::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function cholmod_solve2(sys, L, B, Bset, X_Handle, Xset_Handle, Y_Handle, E_Handle, Common)
-    @ccall libcholmod.cholmod_solve2(sys::Cint, L::Ptr{cholmod_factor}, B::Ptr{cholmod_dense}, Bset::Ptr{cholmod_sparse}, X_Handle::Ptr{Ptr{cholmod_dense}}, Xset_Handle::Ptr{Ptr{cholmod_sparse}}, Y_Handle::Ptr{Ptr{cholmod_dense}}, E_Handle::Ptr{Ptr{cholmod_dense}}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_solve2(sys::Cint, L::Ptr{cholmod_factor},
+                                     B::Ptr{cholmod_dense}, Bset::Ptr{cholmod_sparse},
+                                     X_Handle::Ptr{Ptr{cholmod_dense}},
+                                     Xset_Handle::Ptr{Ptr{cholmod_sparse}},
+                                     Y_Handle::Ptr{Ptr{cholmod_dense}},
+                                     E_Handle::Ptr{Ptr{cholmod_dense}},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_solve2(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
-    @ccall libcholmod.cholmod_l_solve2(arg1::Cint, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_dense}, arg4::Ptr{cholmod_sparse}, arg5::Ptr{Ptr{cholmod_dense}}, arg6::Ptr{Ptr{cholmod_sparse}}, arg7::Ptr{Ptr{cholmod_dense}}, arg8::Ptr{Ptr{cholmod_dense}}, arg9::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_solve2(arg1::Cint, arg2::Ptr{cholmod_factor},
+                                       arg3::Ptr{cholmod_dense}, arg4::Ptr{cholmod_sparse},
+                                       arg5::Ptr{Ptr{cholmod_dense}},
+                                       arg6::Ptr{Ptr{cholmod_sparse}},
+                                       arg7::Ptr{Ptr{cholmod_dense}},
+                                       arg8::Ptr{Ptr{cholmod_dense}},
+                                       arg9::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_spsolve(sys, L, B, Common)
-    @ccall libcholmod.cholmod_spsolve(sys::Cint, L::Ptr{cholmod_factor}, B::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_spsolve(sys::Cint, L::Ptr{cholmod_factor},
+                                      B::Ptr{cholmod_sparse},
+                                      Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_spsolve(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_spsolve(arg1::Cint, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_sparse}, arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_spsolve(arg1::Cint, arg2::Ptr{cholmod_factor},
+                                        arg3::Ptr{cholmod_sparse},
+                                        arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_etree(A, Parent, Common)
-    @ccall libcholmod.cholmod_etree(A::Ptr{cholmod_sparse}, Parent::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_etree(A::Ptr{cholmod_sparse}, Parent::Ptr{Int32},
+                                    Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_etree(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_etree(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_etree(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                      arg3::Ptr{cholmod_common})::Cint
 end
 
-function cholmod_rowcolcounts(A, fset, fsize, Parent, Post, RowCount, ColCount, First, Level, Common)
-    @ccall libcholmod.cholmod_rowcolcounts(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, Parent::Ptr{Int32}, Post::Ptr{Int32}, RowCount::Ptr{Int32}, ColCount::Ptr{Int32}, First::Ptr{Int32}, Level::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+function cholmod_rowcolcounts(A, fset, fsize, Parent, Post, RowCount, ColCount, First,
+                              Level, Common)
+    @ccall libcholmod.cholmod_rowcolcounts(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                           fsize::Csize_t, Parent::Ptr{Int32},
+                                           Post::Ptr{Int32}, RowCount::Ptr{Int32},
+                                           ColCount::Ptr{Int32}, First::Ptr{Int32},
+                                           Level::Ptr{Int32},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowcolcounts(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)
-    @ccall libcholmod.cholmod_l_rowcolcounts(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{Int64}, arg6::Ptr{Int64}, arg7::Ptr{Int64}, arg8::Ptr{Int64}, arg9::Ptr{Int64}, arg10::Ptr{cholmod_common})::Cint
-end
-
-function cholmod_analyze_ordering(A, ordering, Perm, fset, fsize, Parent, Post, ColCount, First, Level, Common)
-    @ccall libcholmod.cholmod_analyze_ordering(A::Ptr{cholmod_sparse}, ordering::Cint, Perm::Ptr{Int32}, fset::Ptr{Int32}, fsize::Csize_t, Parent::Ptr{Int32}, Post::Ptr{Int32}, ColCount::Ptr{Int32}, First::Ptr{Int32}, Level::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
-end
-
-function cholmod_l_analyze_ordering(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11)
-    @ccall libcholmod.cholmod_l_analyze_ordering(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Csize_t, arg6::Ptr{Int64}, arg7::Ptr{Int64}, arg8::Ptr{Int64}, arg9::Ptr{Int64}, arg10::Ptr{Int64}, arg11::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowcolcounts(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                             arg3::Csize_t, arg4::Ptr{Int64},
+                                             arg5::Ptr{Int64}, arg6::Ptr{Int64},
+                                             arg7::Ptr{Int64}, arg8::Ptr{Int64},
+                                             arg9::Ptr{Int64},
+                                             arg10::Ptr{cholmod_common})::Cint
+end
+
+function cholmod_analyze_ordering(A, ordering, Perm, fset, fsize, Parent, Post, ColCount,
+                                  First, Level, Common)
+    @ccall libcholmod.cholmod_analyze_ordering(A::Ptr{cholmod_sparse}, ordering::Cint,
+                                               Perm::Ptr{Int32}, fset::Ptr{Int32},
+                                               fsize::Csize_t, Parent::Ptr{Int32},
+                                               Post::Ptr{Int32}, ColCount::Ptr{Int32},
+                                               First::Ptr{Int32}, Level::Ptr{Int32},
+                                               Common::Ptr{cholmod_common})::Cint
+end
+
+function cholmod_l_analyze_ordering(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9,
+                                    arg10, arg11)
+    @ccall libcholmod.cholmod_l_analyze_ordering(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                                 arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                                 arg5::Csize_t, arg6::Ptr{Int64},
+                                                 arg7::Ptr{Int64}, arg8::Ptr{Int64},
+                                                 arg9::Ptr{Int64}, arg10::Ptr{Int64},
+                                                 arg11::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_amd(A, fset, fsize, Perm, Common)
-    @ccall libcholmod.cholmod_amd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_amd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t,
+                                  Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_amd(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_amd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_amd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                    arg3::Csize_t, arg4::Ptr{Int64},
+                                    arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_colamd(A, fset, fsize, postorder, Perm, Common)
-    @ccall libcholmod.cholmod_colamd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, postorder::Cint, Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_colamd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                     fsize::Csize_t, postorder::Cint, Perm::Ptr{Int32},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_colamd(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_colamd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Cint, arg5::Ptr{Int64}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_colamd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                       arg3::Csize_t, arg4::Cint, arg5::Ptr{Int64},
+                                       arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowfac(A, F, beta, kstart, kend, L, Common)
-    @ccall libcholmod.cholmod_rowfac(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, beta::Ptr{Cdouble}, kstart::Csize_t, kend::Csize_t, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowfac(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse},
+                                     beta::Ptr{Cdouble}, kstart::Csize_t, kend::Csize_t,
+                                     L::Ptr{cholmod_factor},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowfac(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_rowfac(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Csize_t, arg5::Csize_t, arg6::Ptr{cholmod_factor}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowfac(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse},
+                                       arg3::Ptr{Cdouble}, arg4::Csize_t, arg5::Csize_t,
+                                       arg6::Ptr{cholmod_factor},
+                                       arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowfac_mask(A, F, beta, kstart, kend, mask, RLinkUp, L, Common)
-    @ccall libcholmod.cholmod_rowfac_mask(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, beta::Ptr{Cdouble}, kstart::Csize_t, kend::Csize_t, mask::Ptr{Int32}, RLinkUp::Ptr{Int32}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowfac_mask(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse},
+                                          beta::Ptr{Cdouble}, kstart::Csize_t,
+                                          kend::Csize_t, mask::Ptr{Int32},
+                                          RLinkUp::Ptr{Int32}, L::Ptr{cholmod_factor},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowfac_mask(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
-    @ccall libcholmod.cholmod_l_rowfac_mask(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Csize_t, arg5::Csize_t, arg6::Ptr{Int64}, arg7::Ptr{Int64}, arg8::Ptr{cholmod_factor}, arg9::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowfac_mask(arg1::Ptr{cholmod_sparse},
+                                            arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble},
+                                            arg4::Csize_t, arg5::Csize_t, arg6::Ptr{Int64},
+                                            arg7::Ptr{Int64}, arg8::Ptr{cholmod_factor},
+                                            arg9::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowfac_mask2(A, F, beta, kstart, kend, mask, maskmark, RLinkUp, L, Common)
-    @ccall libcholmod.cholmod_rowfac_mask2(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, beta::Ptr{Cdouble}, kstart::Csize_t, kend::Csize_t, mask::Ptr{Int32}, maskmark::Int32, RLinkUp::Ptr{Int32}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowfac_mask2(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse},
+                                           beta::Ptr{Cdouble}, kstart::Csize_t,
+                                           kend::Csize_t, mask::Ptr{Int32}, maskmark::Int32,
+                                           RLinkUp::Ptr{Int32}, L::Ptr{cholmod_factor},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowfac_mask2(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)
-    @ccall libcholmod.cholmod_l_rowfac_mask2(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Csize_t, arg5::Csize_t, arg6::Ptr{Int64}, arg7::Int64, arg8::Ptr{Int64}, arg9::Ptr{cholmod_factor}, arg10::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowfac_mask2(arg1::Ptr{cholmod_sparse},
+                                             arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble},
+                                             arg4::Csize_t, arg5::Csize_t, arg6::Ptr{Int64},
+                                             arg7::Int64, arg8::Ptr{Int64},
+                                             arg9::Ptr{cholmod_factor},
+                                             arg10::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_row_subtree(A, F, k, Parent, R, Common)
-    @ccall libcholmod.cholmod_row_subtree(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, k::Csize_t, Parent::Ptr{Int32}, R::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_row_subtree(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse},
+                                          k::Csize_t, Parent::Ptr{Int32},
+                                          R::Ptr{cholmod_sparse},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_row_subtree(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_row_subtree(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{cholmod_sparse}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_row_subtree(arg1::Ptr{cholmod_sparse},
+                                            arg2::Ptr{cholmod_sparse}, arg3::Csize_t,
+                                            arg4::Ptr{Int64}, arg5::Ptr{cholmod_sparse},
+                                            arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_lsolve_pattern(B, L, X, Common)
-    @ccall libcholmod.cholmod_lsolve_pattern(B::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_lsolve_pattern(B::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor},
+                                             X::Ptr{cholmod_sparse},
+                                             Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_lsolve_pattern(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_lsolve_pattern(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_factor}, arg3::Ptr{cholmod_sparse}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_lsolve_pattern(arg1::Ptr{cholmod_sparse},
+                                               arg2::Ptr{cholmod_factor},
+                                               arg3::Ptr{cholmod_sparse},
+                                               arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_row_lsubtree(A, Fi, fnz, k, L, R, Common)
-    @ccall libcholmod.cholmod_row_lsubtree(A::Ptr{cholmod_sparse}, Fi::Ptr{Int32}, fnz::Csize_t, k::Csize_t, L::Ptr{cholmod_factor}, R::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_row_lsubtree(A::Ptr{cholmod_sparse}, Fi::Ptr{Int32},
+                                           fnz::Csize_t, k::Csize_t, L::Ptr{cholmod_factor},
+                                           R::Ptr{cholmod_sparse},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_row_lsubtree(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_row_lsubtree(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Csize_t, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_sparse}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_row_lsubtree(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                             arg3::Csize_t, arg4::Csize_t,
+                                             arg5::Ptr{cholmod_factor},
+                                             arg6::Ptr{cholmod_sparse},
+                                             arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_resymbol(A, fset, fsize, pack, L, Common)
-    @ccall libcholmod.cholmod_resymbol(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, pack::Cint, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_resymbol(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                       fsize::Csize_t, pack::Cint, L::Ptr{cholmod_factor},
+                                       Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_resymbol(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_resymbol(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Cint, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_resymbol(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                         arg3::Csize_t, arg4::Cint,
+                                         arg5::Ptr{cholmod_factor},
+                                         arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_resymbol_noperm(A, fset, fsize, pack, L, Common)
-    @ccall libcholmod.cholmod_resymbol_noperm(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, pack::Cint, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_resymbol_noperm(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                              fsize::Csize_t, pack::Cint,
+                                              L::Ptr{cholmod_factor},
+                                              Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_resymbol_noperm(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_resymbol_noperm(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Cint, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_resymbol_noperm(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                                arg3::Csize_t, arg4::Cint,
+                                                arg5::Ptr{cholmod_factor},
+                                                arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rcond(L, Common)
-    @ccall libcholmod.cholmod_rcond(L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cdouble
+    @ccall libcholmod.cholmod_rcond(L::Ptr{cholmod_factor},
+                                    Common::Ptr{cholmod_common})::Cdouble
 end
 
 function cholmod_l_rcond(arg1, arg2)
-    @ccall libcholmod.cholmod_l_rcond(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_common})::Cdouble
+    @ccall libcholmod.cholmod_l_rcond(arg1::Ptr{cholmod_factor},
+                                      arg2::Ptr{cholmod_common})::Cdouble
 end
 
 function cholmod_postorder(Parent, n, Weight_p, Post, Common)
-    @ccall libcholmod.cholmod_postorder(Parent::Ptr{Int32}, n::Csize_t, Weight_p::Ptr{Int32}, Post::Ptr{Int32}, Common::Ptr{cholmod_common})::Int32
+    @ccall libcholmod.cholmod_postorder(Parent::Ptr{Int32}, n::Csize_t,
+                                        Weight_p::Ptr{Int32}, Post::Ptr{Int32},
+                                        Common::Ptr{cholmod_common})::Int32
 end
 
 function cholmod_l_postorder(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_postorder(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_l_postorder(arg1::Ptr{Int64}, arg2::Csize_t, arg3::Ptr{Int64},
+                                          arg4::Ptr{Int64},
+                                          arg5::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_drop(tol, A, Common)
-    @ccall libcholmod.cholmod_drop(tol::Cdouble, A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_drop(tol::Cdouble, A::Ptr{cholmod_sparse},
+                                   Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_drop(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_drop(arg1::Cdouble, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_drop(arg1::Cdouble, arg2::Ptr{cholmod_sparse},
+                                     arg3::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_norm_dense(X, norm, Common)
-    @ccall libcholmod.cholmod_norm_dense(X::Ptr{cholmod_dense}, norm::Cint, Common::Ptr{cholmod_common})::Cdouble
+    @ccall libcholmod.cholmod_norm_dense(X::Ptr{cholmod_dense}, norm::Cint,
+                                         Common::Ptr{cholmod_common})::Cdouble
 end
 
 function cholmod_l_norm_dense(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_norm_dense(arg1::Ptr{cholmod_dense}, arg2::Cint, arg3::Ptr{cholmod_common})::Cdouble
+    @ccall libcholmod.cholmod_l_norm_dense(arg1::Ptr{cholmod_dense}, arg2::Cint,
+                                           arg3::Ptr{cholmod_common})::Cdouble
 end
 
 function cholmod_norm_sparse(A, norm, Common)
-    @ccall libcholmod.cholmod_norm_sparse(A::Ptr{cholmod_sparse}, norm::Cint, Common::Ptr{cholmod_common})::Cdouble
+    @ccall libcholmod.cholmod_norm_sparse(A::Ptr{cholmod_sparse}, norm::Cint,
+                                          Common::Ptr{cholmod_common})::Cdouble
 end
 
 function cholmod_l_norm_sparse(arg1, arg2, arg3)
-    @ccall libcholmod.cholmod_l_norm_sparse(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{cholmod_common})::Cdouble
+    @ccall libcholmod.cholmod_l_norm_sparse(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                            arg3::Ptr{cholmod_common})::Cdouble
 end
 
 function cholmod_horzcat(A, B, values, Common)
-    @ccall libcholmod.cholmod_horzcat(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse}, values::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_horzcat(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse},
+                                      values::Cint,
+                                      Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_horzcat(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_horzcat(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_horzcat(arg1::Ptr{cholmod_sparse},
+                                        arg2::Ptr{cholmod_sparse}, arg3::Cint,
+                                        arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_scale(S, scale, A, Common)
-    @ccall libcholmod.cholmod_scale(S::Ptr{cholmod_dense}, scale::Cint, A::Ptr{cholmod_sparse}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_scale(S::Ptr{cholmod_dense}, scale::Cint,
+                                    A::Ptr{cholmod_sparse},
+                                    Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_scale(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_scale(arg1::Ptr{cholmod_dense}, arg2::Cint, arg3::Ptr{cholmod_sparse}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_scale(arg1::Ptr{cholmod_dense}, arg2::Cint,
+                                      arg3::Ptr{cholmod_sparse},
+                                      arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_sdmult(A, transpose, alpha, beta, X, Y, Common)
-    @ccall libcholmod.cholmod_sdmult(A::Ptr{cholmod_sparse}, transpose::Cint, alpha::Ptr{Cdouble}, beta::Ptr{Cdouble}, X::Ptr{cholmod_dense}, Y::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_sdmult(A::Ptr{cholmod_sparse}, transpose::Cint,
+                                     alpha::Ptr{Cdouble}, beta::Ptr{Cdouble},
+                                     X::Ptr{cholmod_dense}, Y::Ptr{cholmod_dense},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_sdmult(arg1, arg2, arg3, arg4, arg5, Y, arg7)
-    @ccall libcholmod.cholmod_l_sdmult(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{Cdouble}, arg4::Ptr{Cdouble}, arg5::Ptr{cholmod_dense}, Y::Ptr{cholmod_dense}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_sdmult(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                       arg3::Ptr{Cdouble}, arg4::Ptr{Cdouble},
+                                       arg5::Ptr{cholmod_dense}, Y::Ptr{cholmod_dense},
+                                       arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_ssmult(A, B, stype, values, sorted, Common)
-    @ccall libcholmod.cholmod_ssmult(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse}, stype::Cint, values::Cint, sorted::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_ssmult(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse},
+                                     stype::Cint, values::Cint, sorted::Cint,
+                                     Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_ssmult(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_ssmult(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Cint, arg4::Cint, arg5::Cint, arg6::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_ssmult(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse},
+                                       arg3::Cint, arg4::Cint, arg5::Cint,
+                                       arg6::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_submatrix(A, rset, rsize, cset, csize, values, sorted, Common)
-    @ccall libcholmod.cholmod_submatrix(A::Ptr{cholmod_sparse}, rset::Ptr{Int32}, rsize::Int64, cset::Ptr{Int32}, csize::Int64, values::Cint, sorted::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_submatrix(A::Ptr{cholmod_sparse}, rset::Ptr{Int32},
+                                        rsize::Int64, cset::Ptr{Int32}, csize::Int64,
+                                        values::Cint, sorted::Cint,
+                                        Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_submatrix(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
-    @ccall libcholmod.cholmod_l_submatrix(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Int64, arg4::Ptr{Int64}, arg5::Int64, arg6::Cint, arg7::Cint, arg8::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_submatrix(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                          arg3::Int64, arg4::Ptr{Int64}, arg5::Int64,
+                                          arg6::Cint, arg7::Cint,
+                                          arg8::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_vertcat(A, B, values, Common)
-    @ccall libcholmod.cholmod_vertcat(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse}, values::Cint, Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_vertcat(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse},
+                                      values::Cint,
+                                      Common::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_l_vertcat(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_vertcat(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Cint, arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libcholmod.cholmod_l_vertcat(arg1::Ptr{cholmod_sparse},
+                                        arg2::Ptr{cholmod_sparse}, arg3::Cint,
+                                        arg4::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 function cholmod_symmetry(A, option, xmatched, pmatched, nzoffdiag, nzdiag, Common)
-    @ccall libcholmod.cholmod_symmetry(A::Ptr{cholmod_sparse}, option::Cint, xmatched::Ptr{Int32}, pmatched::Ptr{Int32}, nzoffdiag::Ptr{Int32}, nzdiag::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_symmetry(A::Ptr{cholmod_sparse}, option::Cint,
+                                       xmatched::Ptr{Int32}, pmatched::Ptr{Int32},
+                                       nzoffdiag::Ptr{Int32}, nzdiag::Ptr{Int32},
+                                       Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_symmetry(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_symmetry(arg1::Ptr{cholmod_sparse}, arg2::Cint, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Ptr{Int64}, arg6::Ptr{Int64}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_symmetry(arg1::Ptr{cholmod_sparse}, arg2::Cint,
+                                         arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                         arg5::Ptr{Int64}, arg6::Ptr{Int64},
+                                         arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_updown(update, C, L, Common)
-    @ccall libcholmod.cholmod_updown(update::Cint, C::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_updown(update::Cint, C::Ptr{cholmod_sparse},
+                                     L::Ptr{cholmod_factor},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_updown(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_updown(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_factor}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_updown(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                       arg3::Ptr{cholmod_factor},
+                                       arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_updown_solve(update, C, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_updown_solve(update::Cint, C::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_updown_solve(update::Cint, C::Ptr{cholmod_sparse},
+                                           L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense},
+                                           DeltaB::Ptr{cholmod_dense},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_updown_solve(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_updown_solve(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_factor}, arg4::Ptr{cholmod_dense}, arg5::Ptr{cholmod_dense}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_updown_solve(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                             arg3::Ptr{cholmod_factor},
+                                             arg4::Ptr{cholmod_dense},
+                                             arg5::Ptr{cholmod_dense},
+                                             arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_updown_mark(update, C, colmark, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_updown_mark(update::Cint, C::Ptr{cholmod_sparse}, colmark::Ptr{Int32}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_updown_mark(update::Cint, C::Ptr{cholmod_sparse},
+                                          colmark::Ptr{Int32}, L::Ptr{cholmod_factor},
+                                          X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_updown_mark(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_updown_mark(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Int64}, arg4::Ptr{cholmod_factor}, arg5::Ptr{cholmod_dense}, arg6::Ptr{cholmod_dense}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_updown_mark(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                            arg3::Ptr{Int64}, arg4::Ptr{cholmod_factor},
+                                            arg5::Ptr{cholmod_dense},
+                                            arg6::Ptr{cholmod_dense},
+                                            arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_updown_mask(update, C, colmark, mask, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_updown_mask(update::Cint, C::Ptr{cholmod_sparse}, colmark::Ptr{Int32}, mask::Ptr{Int32}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_updown_mask(update::Cint, C::Ptr{cholmod_sparse},
+                                          colmark::Ptr{Int32}, mask::Ptr{Int32},
+                                          L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense},
+                                          DeltaB::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_updown_mask(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
-    @ccall libcholmod.cholmod_l_updown_mask(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_dense}, arg7::Ptr{cholmod_dense}, arg8::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_updown_mask(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                            arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                            arg5::Ptr{cholmod_factor},
+                                            arg6::Ptr{cholmod_dense},
+                                            arg7::Ptr{cholmod_dense},
+                                            arg8::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_updown_mask2(update, C, colmark, mask, maskmark, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_updown_mask2(update::Cint, C::Ptr{cholmod_sparse}, colmark::Ptr{Int32}, mask::Ptr{Int32}, maskmark::Int32, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_updown_mask2(update::Cint, C::Ptr{cholmod_sparse},
+                                           colmark::Ptr{Int32}, mask::Ptr{Int32},
+                                           maskmark::Int32, L::Ptr{cholmod_factor},
+                                           X::Ptr{cholmod_dense},
+                                           DeltaB::Ptr{cholmod_dense},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_updown_mask2(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)
-    @ccall libcholmod.cholmod_l_updown_mask2(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Int64, arg6::Ptr{cholmod_factor}, arg7::Ptr{cholmod_dense}, arg8::Ptr{cholmod_dense}, arg9::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_updown_mask2(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                             arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                             arg5::Int64, arg6::Ptr{cholmod_factor},
+                                             arg7::Ptr{cholmod_dense},
+                                             arg8::Ptr{cholmod_dense},
+                                             arg9::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowadd(k, R, L, Common)
-    @ccall libcholmod.cholmod_rowadd(k::Csize_t, R::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowadd(k::Csize_t, R::Ptr{cholmod_sparse},
+                                     L::Ptr{cholmod_factor},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowadd(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_rowadd(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_factor}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowadd(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                       arg3::Ptr{cholmod_factor},
+                                       arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowadd_solve(k, R, bk, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_rowadd_solve(k::Csize_t, R::Ptr{cholmod_sparse}, bk::Ptr{Cdouble}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowadd_solve(k::Csize_t, R::Ptr{cholmod_sparse},
+                                           bk::Ptr{Cdouble}, L::Ptr{cholmod_factor},
+                                           X::Ptr{cholmod_dense},
+                                           DeltaB::Ptr{cholmod_dense},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowadd_solve(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_rowadd_solve(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Ptr{cholmod_factor}, arg5::Ptr{cholmod_dense}, arg6::Ptr{cholmod_dense}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowadd_solve(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                             arg3::Ptr{Cdouble}, arg4::Ptr{cholmod_factor},
+                                             arg5::Ptr{cholmod_dense},
+                                             arg6::Ptr{cholmod_dense},
+                                             arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowadd_mark(k, R, bk, colmark, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_rowadd_mark(k::Csize_t, R::Ptr{cholmod_sparse}, bk::Ptr{Cdouble}, colmark::Ptr{Int32}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowadd_mark(k::Csize_t, R::Ptr{cholmod_sparse},
+                                          bk::Ptr{Cdouble}, colmark::Ptr{Int32},
+                                          L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense},
+                                          DeltaB::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowadd_mark(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
-    @ccall libcholmod.cholmod_l_rowadd_mark(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Ptr{Int64}, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_dense}, arg7::Ptr{cholmod_dense}, arg8::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowadd_mark(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                            arg3::Ptr{Cdouble}, arg4::Ptr{Int64},
+                                            arg5::Ptr{cholmod_factor},
+                                            arg6::Ptr{cholmod_dense},
+                                            arg7::Ptr{cholmod_dense},
+                                            arg8::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowdel(k, R, L, Common)
-    @ccall libcholmod.cholmod_rowdel(k::Csize_t, R::Ptr{cholmod_sparse}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowdel(k::Csize_t, R::Ptr{cholmod_sparse},
+                                     L::Ptr{cholmod_factor},
+                                     Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowdel(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_rowdel(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_factor}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowdel(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                       arg3::Ptr{cholmod_factor},
+                                       arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowdel_solve(k, R, yk, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_rowdel_solve(k::Csize_t, R::Ptr{cholmod_sparse}, yk::Ptr{Cdouble}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowdel_solve(k::Csize_t, R::Ptr{cholmod_sparse},
+                                           yk::Ptr{Cdouble}, L::Ptr{cholmod_factor},
+                                           X::Ptr{cholmod_dense},
+                                           DeltaB::Ptr{cholmod_dense},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowdel_solve(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_rowdel_solve(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Ptr{cholmod_factor}, arg5::Ptr{cholmod_dense}, arg6::Ptr{cholmod_dense}, arg7::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowdel_solve(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                             arg3::Ptr{Cdouble}, arg4::Ptr{cholmod_factor},
+                                             arg5::Ptr{cholmod_dense},
+                                             arg6::Ptr{cholmod_dense},
+                                             arg7::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_rowdel_mark(k, R, yk, colmark, L, X, DeltaB, Common)
-    @ccall libcholmod.cholmod_rowdel_mark(k::Csize_t, R::Ptr{cholmod_sparse}, yk::Ptr{Cdouble}, colmark::Ptr{Int32}, L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, DeltaB::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_rowdel_mark(k::Csize_t, R::Ptr{cholmod_sparse},
+                                          yk::Ptr{Cdouble}, colmark::Ptr{Int32},
+                                          L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense},
+                                          DeltaB::Ptr{cholmod_dense},
+                                          Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_rowdel_mark(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
-    @ccall libcholmod.cholmod_l_rowdel_mark(arg1::Csize_t, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Ptr{Int64}, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_dense}, arg7::Ptr{cholmod_dense}, arg8::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_rowdel_mark(arg1::Csize_t, arg2::Ptr{cholmod_sparse},
+                                            arg3::Ptr{Cdouble}, arg4::Ptr{Int64},
+                                            arg5::Ptr{cholmod_factor},
+                                            arg6::Ptr{cholmod_dense},
+                                            arg7::Ptr{cholmod_dense},
+                                            arg8::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_ccolamd(A, fset, fsize, Cmember, Perm, Common)
-    @ccall libcholmod.cholmod_ccolamd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, Cmember::Ptr{Int32}, Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_ccolamd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                      fsize::Csize_t, Cmember::Ptr{Int32}, Perm::Ptr{Int32},
+                                      Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_ccolamd(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_ccolamd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{Int64}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_ccolamd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                        arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{Int64},
+                                        arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_csymamd(A, Cmember, Perm, Common)
-    @ccall libcholmod.cholmod_csymamd(A::Ptr{cholmod_sparse}, Cmember::Ptr{Int32}, Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_csymamd(A::Ptr{cholmod_sparse}, Cmember::Ptr{Int32},
+                                      Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_csymamd(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_csymamd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Ptr{Int64}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_csymamd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                        arg3::Ptr{Int64}, arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_camd(A, fset, fsize, Cmember, Perm, Common)
-    @ccall libcholmod.cholmod_camd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, Cmember::Ptr{Int32}, Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_camd(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t,
+                                   Cmember::Ptr{Int32}, Perm::Ptr{Int32},
+                                   Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_camd(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_camd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{Int64}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_camd(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                     arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{Int64},
+                                     arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_nested_dissection(A, fset, fsize, Perm, CParent, Cmember, Common)
-    @ccall libcholmod.cholmod_nested_dissection(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, Perm::Ptr{Int32}, CParent::Ptr{Int32}, Cmember::Ptr{Int32}, Common::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_nested_dissection(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                                fsize::Csize_t, Perm::Ptr{Int32},
+                                                CParent::Ptr{Int32}, Cmember::Ptr{Int32},
+                                                Common::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_l_nested_dissection(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_nested_dissection(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Ptr{Int64}, arg5::Ptr{Int64}, arg6::Ptr{Int64}, arg7::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_l_nested_dissection(arg1::Ptr{cholmod_sparse},
+                                                  arg2::Ptr{Int64}, arg3::Csize_t,
+                                                  arg4::Ptr{Int64}, arg5::Ptr{Int64},
+                                                  arg6::Ptr{Int64},
+                                                  arg7::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_metis(A, fset, fsize, postorder, Perm, Common)
-    @ccall libcholmod.cholmod_metis(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, postorder::Cint, Perm::Ptr{Int32}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_metis(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                    fsize::Csize_t, postorder::Cint, Perm::Ptr{Int32},
+                                    Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_metis(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_metis(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Cint, arg5::Ptr{Int64}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_metis(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                      arg3::Csize_t, arg4::Cint, arg5::Ptr{Int64},
+                                      arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_bisect(A, fset, fsize, compress, Partition, Common)
-    @ccall libcholmod.cholmod_bisect(A::Ptr{cholmod_sparse}, fset::Ptr{Int32}, fsize::Csize_t, compress::Cint, Partition::Ptr{Int32}, Common::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_bisect(A::Ptr{cholmod_sparse}, fset::Ptr{Int32},
+                                     fsize::Csize_t, compress::Cint, Partition::Ptr{Int32},
+                                     Common::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_l_bisect(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_bisect(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Csize_t, arg4::Cint, arg5::Ptr{Int64}, arg6::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_l_bisect(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                       arg3::Csize_t, arg4::Cint, arg5::Ptr{Int64},
+                                       arg6::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_metis_bisector(A, Anw, Aew, Partition, Common)
-    @ccall libcholmod.cholmod_metis_bisector(A::Ptr{cholmod_sparse}, Anw::Ptr{Int32}, Aew::Ptr{Int32}, Partition::Ptr{Int32}, Common::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_metis_bisector(A::Ptr{cholmod_sparse}, Anw::Ptr{Int32},
+                                             Aew::Ptr{Int32}, Partition::Ptr{Int32},
+                                             Common::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_l_metis_bisector(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_metis_bisector(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64}, arg3::Ptr{Int64}, arg4::Ptr{Int64}, arg5::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_l_metis_bisector(arg1::Ptr{cholmod_sparse}, arg2::Ptr{Int64},
+                                               arg3::Ptr{Int64}, arg4::Ptr{Int64},
+                                               arg5::Ptr{cholmod_common})::Int64
 end
 
-function cholmod_collapse_septree(n, ncomponents, nd_oksep, nd_small, CParent, Cmember, Common)
-    @ccall libcholmod.cholmod_collapse_septree(n::Csize_t, ncomponents::Csize_t, nd_oksep::Cdouble, nd_small::Csize_t, CParent::Ptr{Int32}, Cmember::Ptr{Int32}, Common::Ptr{cholmod_common})::Int64
+function cholmod_collapse_septree(n, ncomponents, nd_oksep, nd_small, CParent, Cmember,
+                                  Common)
+    @ccall libcholmod.cholmod_collapse_septree(n::Csize_t, ncomponents::Csize_t,
+                                               nd_oksep::Cdouble, nd_small::Csize_t,
+                                               CParent::Ptr{Int32}, Cmember::Ptr{Int32},
+                                               Common::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_l_collapse_septree(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
-    @ccall libcholmod.cholmod_l_collapse_septree(arg1::Csize_t, arg2::Csize_t, arg3::Cdouble, arg4::Csize_t, arg5::Ptr{Int64}, arg6::Ptr{Int64}, arg7::Ptr{cholmod_common})::Int64
+    @ccall libcholmod.cholmod_l_collapse_septree(arg1::Csize_t, arg2::Csize_t,
+                                                 arg3::Cdouble, arg4::Csize_t,
+                                                 arg5::Ptr{Int64}, arg6::Ptr{Int64},
+                                                 arg7::Ptr{cholmod_common})::Int64
 end
 
 function cholmod_super_symbolic(A, F, Parent, L, Common)
-    @ccall libcholmod.cholmod_super_symbolic(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, Parent::Ptr{Int32}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_super_symbolic(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse},
+                                             Parent::Ptr{Int32}, L::Ptr{cholmod_factor},
+                                             Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_super_symbolic(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_super_symbolic(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Int64}, arg4::Ptr{cholmod_factor}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_super_symbolic(arg1::Ptr{cholmod_sparse},
+                                               arg2::Ptr{cholmod_sparse}, arg3::Ptr{Int64},
+                                               arg4::Ptr{cholmod_factor},
+                                               arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_super_symbolic2(for_whom, A, F, Parent, L, Common)
-    @ccall libcholmod.cholmod_super_symbolic2(for_whom::Cint, A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, Parent::Ptr{Int32}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_super_symbolic2(for_whom::Cint, A::Ptr{cholmod_sparse},
+                                              F::Ptr{cholmod_sparse}, Parent::Ptr{Int32},
+                                              L::Ptr{cholmod_factor},
+                                              Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_super_symbolic2(arg1, arg2, arg3, arg4, arg5, arg6)
-    @ccall libcholmod.cholmod_l_super_symbolic2(arg1::Cint, arg2::Ptr{cholmod_sparse}, arg3::Ptr{cholmod_sparse}, arg4::Ptr{Int64}, arg5::Ptr{cholmod_factor}, arg6::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_super_symbolic2(arg1::Cint, arg2::Ptr{cholmod_sparse},
+                                                arg3::Ptr{cholmod_sparse}, arg4::Ptr{Int64},
+                                                arg5::Ptr{cholmod_factor},
+                                                arg6::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_super_numeric(A, F, beta, L, Common)
-    @ccall libcholmod.cholmod_super_numeric(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse}, beta::Ptr{Cdouble}, L::Ptr{cholmod_factor}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_super_numeric(A::Ptr{cholmod_sparse}, F::Ptr{cholmod_sparse},
+                                            beta::Ptr{Cdouble}, L::Ptr{cholmod_factor},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_super_numeric(arg1, arg2, arg3, arg4, arg5)
-    @ccall libcholmod.cholmod_l_super_numeric(arg1::Ptr{cholmod_sparse}, arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble}, arg4::Ptr{cholmod_factor}, arg5::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_super_numeric(arg1::Ptr{cholmod_sparse},
+                                              arg2::Ptr{cholmod_sparse}, arg3::Ptr{Cdouble},
+                                              arg4::Ptr{cholmod_factor},
+                                              arg5::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_super_lsolve(L, X, E, Common)
-    @ccall libcholmod.cholmod_super_lsolve(L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, E::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_super_lsolve(L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense},
+                                           E::Ptr{cholmod_dense},
+                                           Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_super_lsolve(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_super_lsolve(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_dense}, arg3::Ptr{cholmod_dense}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_super_lsolve(arg1::Ptr{cholmod_factor},
+                                             arg2::Ptr{cholmod_dense},
+                                             arg3::Ptr{cholmod_dense},
+                                             arg4::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_super_ltsolve(L, X, E, Common)
-    @ccall libcholmod.cholmod_super_ltsolve(L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense}, E::Ptr{cholmod_dense}, Common::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_super_ltsolve(L::Ptr{cholmod_factor}, X::Ptr{cholmod_dense},
+                                            E::Ptr{cholmod_dense},
+                                            Common::Ptr{cholmod_common})::Cint
 end
 
 function cholmod_l_super_ltsolve(arg1, arg2, arg3, arg4)
-    @ccall libcholmod.cholmod_l_super_ltsolve(arg1::Ptr{cholmod_factor}, arg2::Ptr{cholmod_dense}, arg3::Ptr{cholmod_dense}, arg4::Ptr{cholmod_common})::Cint
+    @ccall libcholmod.cholmod_l_super_ltsolve(arg1::Ptr{cholmod_factor},
+                                              arg2::Ptr{cholmod_dense},
+                                              arg3::Ptr{cholmod_dense},
+                                              arg4::Ptr{cholmod_common})::Cint
+end
+
+function SuiteSparseQR_C(ordering, tol, econ, getCTX, A, Bsparse, Bdense, Zsparse, Zdense,
+                         R, E, H, HPinv, HTau, cc)
+    @ccall libspqr.SuiteSparseQR_C(ordering::Cint, tol::Cdouble, econ::Int64, getCTX::Cint,
+                                   A::Ptr{cholmod_sparse}, Bsparse::Ptr{cholmod_sparse},
+                                   Bdense::Ptr{cholmod_dense},
+                                   Zsparse::Ptr{Ptr{cholmod_sparse}},
+                                   Zdense::Ptr{Ptr{cholmod_dense}},
+                                   R::Ptr{Ptr{cholmod_sparse}}, E::Ptr{Ptr{Int64}},
+                                   H::Ptr{Ptr{cholmod_sparse}}, HPinv::Ptr{Ptr{Int64}},
+                                   HTau::Ptr{Ptr{cholmod_dense}},
+                                   cc::Ptr{cholmod_common})::Int64
+end
+
+function SuiteSparseQR_i_C(ordering, tol, econ, getCTX, A, Bsparse, Bdense, Zsparse, Zdense,
+                           R, E, H, HPinv, HTau, cc)
+    @ccall libspqr.SuiteSparseQR_i_C(ordering::Cint, tol::Cdouble, econ::Int32,
+                                     getCTX::Cint, A::Ptr{cholmod_sparse},
+                                     Bsparse::Ptr{cholmod_sparse},
+                                     Bdense::Ptr{cholmod_dense},
+                                     Zsparse::Ptr{Ptr{cholmod_sparse}},
+                                     Zdense::Ptr{Ptr{cholmod_dense}},
+                                     R::Ptr{Ptr{cholmod_sparse}}, E::Ptr{Ptr{Int32}},
+                                     H::Ptr{Ptr{cholmod_sparse}}, HPinv::Ptr{Ptr{Int32}},
+                                     HTau::Ptr{Ptr{cholmod_dense}},
+                                     cc::Ptr{cholmod_common})::Int32
 end
 
-function SuiteSparseQR_C(ordering, tol, econ, getCTX, A, Bsparse, Bdense, Zsparse, Zdense, R, E, H, HPinv, HTau, cc)
-    @ccall libspqr.SuiteSparseQR_C(ordering::Cint, tol::Cdouble, econ::Int64, getCTX::Cint, A::Ptr{cholmod_sparse}, Bsparse::Ptr{cholmod_sparse}, Bdense::Ptr{cholmod_dense}, Zsparse::Ptr{Ptr{cholmod_sparse}}, Zdense::Ptr{Ptr{cholmod_dense}}, R::Ptr{Ptr{cholmod_sparse}}, E::Ptr{Ptr{Int64}}, H::Ptr{Ptr{cholmod_sparse}}, HPinv::Ptr{Ptr{Int64}}, HTau::Ptr{Ptr{cholmod_dense}}, cc::Ptr{cholmod_common})::Int64
+function SuiteSparseQR_C_QR(ordering, tol, econ, A, Q, R, E, cc)
+    @ccall libspqr.SuiteSparseQR_C_QR(ordering::Cint, tol::Cdouble, econ::Int64,
+                                      A::Ptr{cholmod_sparse}, Q::Ptr{Ptr{cholmod_sparse}},
+                                      R::Ptr{Ptr{cholmod_sparse}}, E::Ptr{Ptr{Int64}},
+                                      cc::Ptr{cholmod_common})::Int64
 end
 
-function SuiteSparseQR_C_QR(ordering, tol, econ, A, Q, R, E, cc)
-    @ccall libspqr.SuiteSparseQR_C_QR(ordering::Cint, tol::Cdouble, econ::Int64, A::Ptr{cholmod_sparse}, Q::Ptr{Ptr{cholmod_sparse}}, R::Ptr{Ptr{cholmod_sparse}}, E::Ptr{Ptr{Int64}}, cc::Ptr{cholmod_common})::Int64
+function SuiteSparseQR_i_C_QR(ordering, tol, econ, A, Q, R, E, cc)
+    @ccall libspqr.SuiteSparseQR_i_C_QR(ordering::Cint, tol::Cdouble, econ::Int32,
+                                        A::Ptr{cholmod_sparse}, Q::Ptr{Ptr{cholmod_sparse}},
+                                        R::Ptr{Ptr{cholmod_sparse}}, E::Ptr{Ptr{Int32}},
+                                        cc::Ptr{cholmod_common})::Int32
 end
 
 function SuiteSparseQR_C_backslash(ordering, tol, A, B, cc)
-    @ccall libspqr.SuiteSparseQR_C_backslash(ordering::Cint, tol::Cdouble, A::Ptr{cholmod_sparse}, B::Ptr{cholmod_dense}, cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libspqr.SuiteSparseQR_C_backslash(ordering::Cint, tol::Cdouble,
+                                             A::Ptr{cholmod_sparse}, B::Ptr{cholmod_dense},
+                                             cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function SuiteSparseQR_C_backslash_default(A, B, cc)
-    @ccall libspqr.SuiteSparseQR_C_backslash_default(A::Ptr{cholmod_sparse}, B::Ptr{cholmod_dense}, cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libspqr.SuiteSparseQR_C_backslash_default(A::Ptr{cholmod_sparse},
+                                                     B::Ptr{cholmod_dense},
+                                                     cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function SuiteSparseQR_C_backslash_sparse(ordering, tol, A, B, cc)
-    @ccall libspqr.SuiteSparseQR_C_backslash_sparse(ordering::Cint, tol::Cdouble, A::Ptr{cholmod_sparse}, B::Ptr{cholmod_sparse}, cc::Ptr{cholmod_common})::Ptr{cholmod_sparse}
+    @ccall libspqr.SuiteSparseQR_C_backslash_sparse(ordering::Cint, tol::Cdouble,
+                                                    A::Ptr{cholmod_sparse},
+                                                    B::Ptr{cholmod_sparse},
+                                                    cc::Ptr{cholmod_common})::Ptr{cholmod_sparse}
 end
 
 mutable struct SuiteSparseQR_C_factorization_struct
     xtype::Cint
+    itype::Cint
     factors::Ptr{Cvoid}
     SuiteSparseQR_C_factorization_struct() = new()
 end
@@ -1536,51 +2115,78 @@ end
 const SuiteSparseQR_C_factorization = SuiteSparseQR_C_factorization_struct
 
 function SuiteSparseQR_C_factorize(ordering, tol, A, cc)
-    @ccall libspqr.SuiteSparseQR_C_factorize(ordering::Cint, tol::Cdouble, A::Ptr{cholmod_sparse}, cc::Ptr{cholmod_common})::Ptr{SuiteSparseQR_C_factorization}
+    @ccall libspqr.SuiteSparseQR_C_factorize(ordering::Cint, tol::Cdouble,
+                                             A::Ptr{cholmod_sparse},
+                                             cc::Ptr{cholmod_common})::Ptr{SuiteSparseQR_C_factorization}
 end
 
 function SuiteSparseQR_C_symbolic(ordering, allow_tol, A, cc)
-    @ccall libspqr.SuiteSparseQR_C_symbolic(ordering::Cint, allow_tol::Cint, A::Ptr{cholmod_sparse}, cc::Ptr{cholmod_common})::Ptr{SuiteSparseQR_C_factorization}
+    @ccall libspqr.SuiteSparseQR_C_symbolic(ordering::Cint, allow_tol::Cint,
+                                            A::Ptr{cholmod_sparse},
+                                            cc::Ptr{cholmod_common})::Ptr{SuiteSparseQR_C_factorization}
 end
 
 function SuiteSparseQR_C_numeric(tol, A, QR, cc)
-    @ccall libspqr.SuiteSparseQR_C_numeric(tol::Cdouble, A::Ptr{cholmod_sparse}, QR::Ptr{SuiteSparseQR_C_factorization}, cc::Ptr{cholmod_common})::Cint
+    @ccall libspqr.SuiteSparseQR_C_numeric(tol::Cdouble, A::Ptr{cholmod_sparse},
+                                           QR::Ptr{SuiteSparseQR_C_factorization},
+                                           cc::Ptr{cholmod_common})::Cint
 end
 
 function SuiteSparseQR_C_free(QR, cc)
-    @ccall libspqr.SuiteSparseQR_C_free(QR::Ptr{Ptr{SuiteSparseQR_C_factorization}}, cc::Ptr{cholmod_common})::Cint
+    @ccall libspqr.SuiteSparseQR_C_free(QR::Ptr{Ptr{SuiteSparseQR_C_factorization}},
+                                        cc::Ptr{cholmod_common})::Cint
 end
 
 function SuiteSparseQR_C_solve(system, QR, B, cc)
-    @ccall libspqr.SuiteSparseQR_C_solve(system::Cint, QR::Ptr{SuiteSparseQR_C_factorization}, B::Ptr{cholmod_dense}, cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libspqr.SuiteSparseQR_C_solve(system::Cint,
+                                         QR::Ptr{SuiteSparseQR_C_factorization},
+                                         B::Ptr{cholmod_dense},
+                                         cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function SuiteSparseQR_C_qmult(method, QR, X, cc)
-    @ccall libspqr.SuiteSparseQR_C_qmult(method::Cint, QR::Ptr{SuiteSparseQR_C_factorization}, X::Ptr{cholmod_dense}, cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
+    @ccall libspqr.SuiteSparseQR_C_qmult(method::Cint,
+                                         QR::Ptr{SuiteSparseQR_C_factorization},
+                                         X::Ptr{cholmod_dense},
+                                         cc::Ptr{cholmod_common})::Ptr{cholmod_dense}
 end
 
 function amd_order(n, Ap, Ai, P, Control, Info)
-    @ccall libamd.amd_order(n::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, P::Ptr{Int32}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libamd.amd_order(n::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, P::Ptr{Int32},
+                            Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function amd_l_order(n, Ap, Ai, P, Control, Info)
-    @ccall libamd.amd_l_order(n::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, P::Ptr{Int64}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libamd.amd_l_order(n::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, P::Ptr{Int64},
+                              Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
-function amd_2(n, Pe, Iw, Len, iwlen, pfree, Nv, Next, Last, Head, Elen, Degree, W, Control, Info)
-    @ccall libamd.amd_2(n::Int32, Pe::Ptr{Int32}, Iw::Ptr{Int32}, Len::Ptr{Int32}, iwlen::Int32, pfree::Int32, Nv::Ptr{Int32}, Next::Ptr{Int32}, Last::Ptr{Int32}, Head::Ptr{Int32}, Elen::Ptr{Int32}, Degree::Ptr{Int32}, W::Ptr{Int32}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cvoid
+function amd_2(n, Pe, Iw, Len, iwlen, pfree, Nv, Next, Last, Head, Elen, Degree, W, Control,
+               Info)
+    @ccall libamd.amd_2(n::Int32, Pe::Ptr{Int32}, Iw::Ptr{Int32}, Len::Ptr{Int32},
+                        iwlen::Int32, pfree::Int32, Nv::Ptr{Int32}, Next::Ptr{Int32},
+                        Last::Ptr{Int32}, Head::Ptr{Int32}, Elen::Ptr{Int32},
+                        Degree::Ptr{Int32}, W::Ptr{Int32}, Control::Ptr{Cdouble},
+                        Info::Ptr{Cdouble})::Cvoid
 end
 
-function amd_l2(n, Pe, Iw, Len, iwlen, pfree, Nv, Next, Last, Head, Elen, Degree, W, Control, Info)
-    @ccall libamd.amd_l2(n::Int64, Pe::Ptr{Int64}, Iw::Ptr{Int64}, Len::Ptr{Int64}, iwlen::Int64, pfree::Int64, Nv::Ptr{Int64}, Next::Ptr{Int64}, Last::Ptr{Int64}, Head::Ptr{Int64}, Elen::Ptr{Int64}, Degree::Ptr{Int64}, W::Ptr{Int64}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cvoid
+function amd_l2(n, Pe, Iw, Len, iwlen, pfree, Nv, Next, Last, Head, Elen, Degree, W,
+                Control, Info)
+    @ccall libamd.amd_l2(n::Int64, Pe::Ptr{Int64}, Iw::Ptr{Int64}, Len::Ptr{Int64},
+                         iwlen::Int64, pfree::Int64, Nv::Ptr{Int64}, Next::Ptr{Int64},
+                         Last::Ptr{Int64}, Head::Ptr{Int64}, Elen::Ptr{Int64},
+                         Degree::Ptr{Int64}, W::Ptr{Int64}, Control::Ptr{Cdouble},
+                         Info::Ptr{Cdouble})::Cvoid
 end
 
 function amd_valid(n_row, n_col, Ap, Ai)
-    @ccall libamd.amd_valid(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32})::Cint
+    @ccall libamd.amd_valid(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                            Ai::Ptr{Int32})::Cint
 end
 
 function amd_l_valid(n_row, n_col, Ap, Ai)
-    @ccall libamd.amd_l_valid(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64})::Cint
+    @ccall libamd.amd_l_valid(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                              Ai::Ptr{Int64})::Cint
 end
 
 function amd_defaults(Control)
@@ -1607,188 +2213,88 @@ function amd_l_info(Info)
     @ccall libamd.amd_l_info(Info::Ptr{Cdouble})::Cvoid
 end
 
-function colamd_recommended(nnz, n_row, n_col)
-    @ccall libcolamd.colamd_recommended(nnz::Int32, n_row::Int32, n_col::Int32)::Csize_t
-end
-
-function colamd_l_recommended(nnz, n_row, n_col)
-    @ccall libcolamd.colamd_l_recommended(nnz::Int64, n_row::Int64, n_col::Int64)::Csize_t
-end
-
-function colamd_set_defaults(knobs)
-    @ccall libcolamd.colamd_set_defaults(knobs::Ptr{Cdouble})::Cvoid
-end
-
-function colamd_l_set_defaults(knobs)
-    @ccall libcolamd.colamd_l_set_defaults(knobs::Ptr{Cdouble})::Cvoid
-end
-
-function colamd(n_row, n_col, Alen, A, p, knobs, stats)
-    @ccall libcolamd.colamd(n_row::Int32, n_col::Int32, Alen::Int32, A::Ptr{Int32}, p::Ptr{Int32}, knobs::Ptr{Cdouble}, stats::Ptr{Int32})::Cint
-end
-
-function colamd_l(n_row, n_col, Alen, A, p, knobs, stats)
-    @ccall libcolamd.colamd_l(n_row::Int64, n_col::Int64, Alen::Int64, A::Ptr{Int64}, p::Ptr{Int64}, knobs::Ptr{Cdouble}, stats::Ptr{Int64})::Cint
-end
-
-function symamd(n, A, p, perm, knobs, stats, allocate, release)
-    @ccall libcolamd.symamd(n::Int32, A::Ptr{Int32}, p::Ptr{Int32}, perm::Ptr{Int32}, knobs::Ptr{Cdouble}, stats::Ptr{Int32}, allocate::Ptr{Cvoid}, release::Ptr{Cvoid})::Cint
-end
-
-function symamd_l(n, A, p, perm, knobs, stats, allocate, release)
-    @ccall libcolamd.symamd_l(n::Int64, A::Ptr{Int64}, p::Ptr{Int64}, perm::Ptr{Int64}, knobs::Ptr{Cdouble}, stats::Ptr{Int64}, allocate::Ptr{Cvoid}, release::Ptr{Cvoid})::Cint
-end
-
-function colamd_report(stats)
-    @ccall libcolamd.colamd_report(stats::Ptr{Int32})::Cvoid
-end
-
-function colamd_l_report(stats)
-    @ccall libcolamd.colamd_l_report(stats::Ptr{Int64})::Cvoid
-end
-
-function symamd_report(stats)
-    @ccall libcolamd.symamd_report(stats::Ptr{Int32})::Cvoid
-end
-
-function symamd_l_report(stats)
-    @ccall libcolamd.symamd_l_report(stats::Ptr{Int64})::Cvoid
-end
-
-function ccolamd_recommended(nnz, n_row, n_col)
-    @ccall libcolamd.ccolamd_recommended(nnz::Cint, n_row::Cint, n_col::Cint)::Csize_t
-end
-
-function ccolamd_l_recommended(nnz, n_row, n_col)
-    @ccall libcolamd.ccolamd_l_recommended(nnz::Int64, n_row::Int64, n_col::Int64)::Csize_t
-end
-
-function ccolamd_set_defaults(knobs)
-    @ccall libcolamd.ccolamd_set_defaults(knobs::Ptr{Cdouble})::Cvoid
-end
-
-function ccolamd_l_set_defaults(knobs)
-    @ccall libcolamd.ccolamd_l_set_defaults(knobs::Ptr{Cdouble})::Cvoid
-end
-
-function ccolamd(n_row, n_col, Alen, A, p, knobs, stats, cmember)
-    @ccall libcolamd.ccolamd(n_row::Cint, n_col::Cint, Alen::Cint, A::Ptr{Cint}, p::Ptr{Cint}, knobs::Ptr{Cdouble}, stats::Ptr{Cint}, cmember::Ptr{Cint})::Cint
-end
-
-function ccolamd_l(n_row, n_col, Alen, A, p, knobs, stats, cmember)
-    @ccall libcolamd.ccolamd_l(n_row::Int64, n_col::Int64, Alen::Int64, A::Ptr{Int64}, p::Ptr{Int64}, knobs::Ptr{Cdouble}, stats::Ptr{Int64}, cmember::Ptr{Int64})::Cint
-end
-
-function csymamd(n, A, p, perm, knobs, stats, allocate, release, cmember, stype)
-    @ccall libcolamd.csymamd(n::Cint, A::Ptr{Cint}, p::Ptr{Cint}, perm::Ptr{Cint}, knobs::Ptr{Cdouble}, stats::Ptr{Cint}, allocate::Ptr{Cvoid}, release::Ptr{Cvoid}, cmember::Ptr{Cint}, stype::Cint)::Cint
-end
-
-function csymamd_l(n, A, p, perm, knobs, stats, allocate, release, cmember, stype)
-    @ccall libcolamd.csymamd_l(n::Int64, A::Ptr{Int64}, p::Ptr{Int64}, perm::Ptr{Int64}, knobs::Ptr{Cdouble}, stats::Ptr{Int64}, allocate::Ptr{Cvoid}, release::Ptr{Cvoid}, cmember::Ptr{Int64}, stype::Int64)::Cint
-end
-
-function ccolamd_report(stats)
-    @ccall libcolamd.ccolamd_report(stats::Ptr{Cint})::Cvoid
-end
-
-function ccolamd_l_report(stats)
-    @ccall libcolamd.ccolamd_l_report(stats::Ptr{Int64})::Cvoid
-end
-
-function csymamd_report(stats)
-    @ccall libcolamd.csymamd_report(stats::Ptr{Cint})::Cvoid
-end
-
-function csymamd_l_report(stats)
-    @ccall libcolamd.csymamd_l_report(stats::Ptr{Int64})::Cvoid
-end
-
-function ccolamd2(n_row, n_col, Alen, A, p, knobs, stats, Front_npivcol, Front_nrows, Front_ncols, Front_parent, Front_cols, p_nfr, InFront, cmember)
-    @ccall libcolamd.ccolamd2(n_row::Cint, n_col::Cint, Alen::Cint, A::Ptr{Cint}, p::Ptr{Cint}, knobs::Ptr{Cdouble}, stats::Ptr{Cint}, Front_npivcol::Ptr{Cint}, Front_nrows::Ptr{Cint}, Front_ncols::Ptr{Cint}, Front_parent::Ptr{Cint}, Front_cols::Ptr{Cint}, p_nfr::Ptr{Cint}, InFront::Ptr{Cint}, cmember::Ptr{Cint})::Cint
-end
-
-function ccolamd2_l(n_row, n_col, Alen, A, p, knobs, stats, Front_npivcol, Front_nrows, Front_ncols, Front_parent, Front_cols, p_nfr, InFront, cmember)
-    @ccall libcolamd.ccolamd2_l(n_row::Int64, n_col::Int64, Alen::Int64, A::Ptr{Int64}, p::Ptr{Int64}, knobs::Ptr{Cdouble}, stats::Ptr{Int64}, Front_npivcol::Ptr{Int64}, Front_nrows::Ptr{Int64}, Front_ncols::Ptr{Int64}, Front_parent::Ptr{Int64}, Front_cols::Ptr{Int64}, p_nfr::Ptr{Int64}, InFront::Ptr{Int64}, cmember::Ptr{Int64})::Cint
-end
-
-function ccolamd_apply_order(Front, Order, Temp, nn, nfr)
-    @ccall libcolamd.ccolamd_apply_order(Front::Ptr{Cint}, Order::Ptr{Cint}, Temp::Ptr{Cint}, nn::Cint, nfr::Cint)::Cvoid
-end
-
-function ccolamd_l_apply_order(Front, Order, Temp, nn, nfr)
-    @ccall libcolamd.ccolamd_l_apply_order(Front::Ptr{Int64}, Order::Ptr{Int64}, Temp::Ptr{Int64}, nn::Int64, nfr::Int64)::Cvoid
-end
-
-function ccolamd_fsize(nn, MaxFsize, Fnrows, Fncols, Parent, Npiv)
-    @ccall libcolamd.ccolamd_fsize(nn::Cint, MaxFsize::Ptr{Cint}, Fnrows::Ptr{Cint}, Fncols::Ptr{Cint}, Parent::Ptr{Cint}, Npiv::Ptr{Cint})::Cvoid
-end
-
-function ccolamd_l_fsize(nn, MaxFsize, Fnrows, Fncols, Parent, Npiv)
-    @ccall libcolamd.ccolamd_l_fsize(nn::Int64, MaxFsize::Ptr{Int64}, Fnrows::Ptr{Int64}, Fncols::Ptr{Int64}, Parent::Ptr{Int64}, Npiv::Ptr{Int64})::Cvoid
-end
-
-function ccolamd_postorder(nn, Parent, Npiv, Fsize, Order, Child, Sibling, Stack, Front_cols, cmember)
-    @ccall libcolamd.ccolamd_postorder(nn::Cint, Parent::Ptr{Cint}, Npiv::Ptr{Cint}, Fsize::Ptr{Cint}, Order::Ptr{Cint}, Child::Ptr{Cint}, Sibling::Ptr{Cint}, Stack::Ptr{Cint}, Front_cols::Ptr{Cint}, cmember::Ptr{Cint})::Cvoid
-end
-
-function ccolamd_l_postorder(nn, Parent, Npiv, Fsize, Order, Child, Sibling, Stack, Front_cols, cmember)
-    @ccall libcolamd.ccolamd_l_postorder(nn::Int64, Parent::Ptr{Int64}, Npiv::Ptr{Int64}, Fsize::Ptr{Int64}, Order::Ptr{Int64}, Child::Ptr{Int64}, Sibling::Ptr{Int64}, Stack::Ptr{Int64}, Front_cols::Ptr{Int64}, cmember::Ptr{Int64})::Cvoid
-end
-
-function ccolamd_post_tree(root, k, Child, Sibling, Order, Stack)
-    @ccall libcolamd.ccolamd_post_tree(root::Cint, k::Cint, Child::Ptr{Cint}, Sibling::Ptr{Cint}, Order::Ptr{Cint}, Stack::Ptr{Cint})::Cint
-end
-
-function ccolamd_l_post_tree(root, k, Child, Sibling, Order, Stack)
-    @ccall libcolamd.ccolamd_l_post_tree(root::Int64, k::Int64, Child::Ptr{Int64}, Sibling::Ptr{Int64}, Order::Ptr{Int64}, Stack::Ptr{Int64})::Int64
-end
-
 function umfpack_di_symbolic(n_row, n_col, Ap, Ai, Ax, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_di_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                          Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                          Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                          Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_symbolic(n_row, n_col, Ap, Ai, Ax, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_dl_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                          Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                          Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                          Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_symbolic(n_row, n_col, Ap, Ai, Ax, Az, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_zi_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                          Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                          Az::Ptr{Cdouble}, Symbolic::Ptr{Ptr{Cvoid}},
+                                          Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_symbolic(n_row, n_col, Ap, Ai, Ax, Az, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_zl_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                          Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                          Az::Ptr{Cdouble}, Symbolic::Ptr{Ptr{Cvoid}},
+                                          Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_numeric(Ap, Ai, Ax, Symbolic, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_di_numeric(Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Symbolic::Ptr{Cvoid}, Numeric::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_numeric(Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                         Symbolic::Ptr{Cvoid}, Numeric::Ptr{Ptr{Cvoid}},
+                                         Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_numeric(Ap, Ai, Ax, Symbolic, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_dl_numeric(Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Symbolic::Ptr{Cvoid}, Numeric::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_numeric(Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                         Symbolic::Ptr{Cvoid}, Numeric::Ptr{Ptr{Cvoid}},
+                                         Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_numeric(Ap, Ai, Ax, Az, Symbolic, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_zi_numeric(Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Symbolic::Ptr{Cvoid}, Numeric::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_numeric(Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                         Az::Ptr{Cdouble}, Symbolic::Ptr{Cvoid},
+                                         Numeric::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                         Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_numeric(Ap, Ai, Ax, Az, Symbolic, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_zl_numeric(Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Symbolic::Ptr{Cvoid}, Numeric::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_numeric(Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                         Az::Ptr{Cdouble}, Symbolic::Ptr{Cvoid},
+                                         Numeric::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                         Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_solve(sys, Ap, Ai, Ax, X, B, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_di_solve(sys::Cint, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_solve(sys::Cint, Ap::Ptr{Int32}, Ai::Ptr{Int32},
+                                       Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble},
+                                       Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                       Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_solve(sys, Ap, Ai, Ax, X, B, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_dl_solve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_solve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64},
+                                       Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble},
+                                       Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                       Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_solve(sys, Ap, Ai, Ax, Az, Xx, Xz, Bx, Bz, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_zi_solve(sys::Cint, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_solve(sys::Cint, Ap::Ptr{Int32}, Ai::Ptr{Int32},
+                                       Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Xx::Ptr{Cdouble},
+                                       Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble},
+                                       Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                       Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_solve(sys, Ap, Ai, Ax, Az, Xx, Xz, Bx, Bz, Numeric, Control, Info)
-    @ccall libumfpack.umfpack_zl_solve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_solve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64},
+                                       Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Xx::Ptr{Cdouble},
+                                       Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble},
+                                       Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                       Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_free_symbolic(Symbolic)
@@ -1840,51 +2346,119 @@ function umfpack_zl_defaults(Control)
 end
 
 function umfpack_di_qsymbolic(n_row, n_col, Ap, Ai, Ax, Qinit, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_di_qsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Qinit::Ptr{Int32}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_qsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                           Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                           Qinit::Ptr{Int32}, Symbolic::Ptr{Ptr{Cvoid}},
+                                           Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_qsymbolic(n_row, n_col, Ap, Ai, Ax, Qinit, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_dl_qsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Qinit::Ptr{Int64}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_qsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                           Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                           Qinit::Ptr{Int64}, Symbolic::Ptr{Ptr{Cvoid}},
+                                           Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_qsymbolic(n_row, n_col, Ap, Ai, Ax, Az, Qinit, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_zi_qsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Qinit::Ptr{Int32}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_qsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                           Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                           Az::Ptr{Cdouble}, Qinit::Ptr{Int32},
+                                           Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                           Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_qsymbolic(n_row, n_col, Ap, Ai, Ax, Az, Qinit, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_zl_qsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Qinit::Ptr{Int64}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_di_fsymbolic(n_row, n_col, Ap, Ai, Ax, user_ordering, user_params, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_di_fsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_dl_fsymbolic(n_row, n_col, Ap, Ai, Ax, user_ordering, user_params, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_dl_fsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_zi_fsymbolic(n_row, n_col, Ap, Ai, Ax, Az, user_ordering, user_params, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_zi_fsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_zl_fsymbolic(n_row, n_col, Ap, Ai, Ax, Az, user_ordering, user_params, Symbolic, Control, Info)
-    @ccall libumfpack.umfpack_zl_fsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_di_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Qinit, user_ordering, user_params, Symbolic, SW, Control, Info)
-    @ccall libumfpack.umfpack_di_paru_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Qinit::Ptr{Int32}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_dl_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Qinit, user_ordering, user_params, Symbolic, SW, Control, Info)
-    @ccall libumfpack.umfpack_dl_paru_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Qinit::Ptr{Int64}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_zi_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Az, Qinit, user_ordering, user_params, Symbolic, SW, Control, Info)
-    @ccall libumfpack.umfpack_zi_paru_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Qinit::Ptr{Int32}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
-end
-
-function umfpack_zl_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Az, Qinit, user_ordering, user_params, Symbolic, SW, Control, Info)
-    @ccall libumfpack.umfpack_zl_paru_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Qinit::Ptr{Int64}, user_ordering::Ptr{Cvoid}, user_params::Ptr{Cvoid}, Symbolic::Ptr{Ptr{Cvoid}}, SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_qsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                           Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                           Az::Ptr{Cdouble}, Qinit::Ptr{Int64},
+                                           Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                           Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_di_fsymbolic(n_row, n_col, Ap, Ai, Ax, user_ordering, user_params,
+                              Symbolic, Control, Info)
+    @ccall libumfpack.umfpack_di_fsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                           Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                           user_ordering::Ptr{Cvoid},
+                                           user_params::Ptr{Cvoid},
+                                           Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                           Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_dl_fsymbolic(n_row, n_col, Ap, Ai, Ax, user_ordering, user_params,
+                              Symbolic, Control, Info)
+    @ccall libumfpack.umfpack_dl_fsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                           Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                           user_ordering::Ptr{Cvoid},
+                                           user_params::Ptr{Cvoid},
+                                           Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                           Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_zi_fsymbolic(n_row, n_col, Ap, Ai, Ax, Az, user_ordering, user_params,
+                              Symbolic, Control, Info)
+    @ccall libumfpack.umfpack_zi_fsymbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                           Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                           Az::Ptr{Cdouble}, user_ordering::Ptr{Cvoid},
+                                           user_params::Ptr{Cvoid},
+                                           Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                           Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_zl_fsymbolic(n_row, n_col, Ap, Ai, Ax, Az, user_ordering, user_params,
+                              Symbolic, Control, Info)
+    @ccall libumfpack.umfpack_zl_fsymbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                           Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                           Az::Ptr{Cdouble}, user_ordering::Ptr{Cvoid},
+                                           user_params::Ptr{Cvoid},
+                                           Symbolic::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                           Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_di_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Qinit, user_ordering,
+                                  user_params, Symbolic, SW, Control, Info)
+    @ccall libumfpack.umfpack_di_paru_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                               Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                               Qinit::Ptr{Int32}, user_ordering::Ptr{Cvoid},
+                                               user_params::Ptr{Cvoid},
+                                               Symbolic::Ptr{Ptr{Cvoid}},
+                                               SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                               Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_dl_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Qinit, user_ordering,
+                                  user_params, Symbolic, SW, Control, Info)
+    @ccall libumfpack.umfpack_dl_paru_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                               Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                               Qinit::Ptr{Int64}, user_ordering::Ptr{Cvoid},
+                                               user_params::Ptr{Cvoid},
+                                               Symbolic::Ptr{Ptr{Cvoid}},
+                                               SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                               Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_zi_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Az, Qinit, user_ordering,
+                                  user_params, Symbolic, SW, Control, Info)
+    @ccall libumfpack.umfpack_zi_paru_symbolic(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                               Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                               Az::Ptr{Cdouble}, Qinit::Ptr{Int32},
+                                               user_ordering::Ptr{Cvoid},
+                                               user_params::Ptr{Cvoid},
+                                               Symbolic::Ptr{Ptr{Cvoid}},
+                                               SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                               Info::Ptr{Cdouble})::Cint
+end
+
+function umfpack_zl_paru_symbolic(n_row, n_col, Ap, Ai, Ax, Az, Qinit, user_ordering,
+                                  user_params, Symbolic, SW, Control, Info)
+    @ccall libumfpack.umfpack_zl_paru_symbolic(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                               Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                               Az::Ptr{Cdouble}, Qinit::Ptr{Int64},
+                                               user_ordering::Ptr{Cvoid},
+                                               user_params::Ptr{Cvoid},
+                                               Symbolic::Ptr{Ptr{Cvoid}},
+                                               SW::Ptr{Ptr{Cvoid}}, Control::Ptr{Cdouble},
+                                               Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_paru_free_sw(SW)
@@ -1904,339 +2478,547 @@ function umfpack_zl_paru_free_sw(SW)
 end
 
 function umfpack_di_wsolve(sys, Ap, Ai, Ax, X, B, Numeric, Control, Info, Wi, W)
-    @ccall libumfpack.umfpack_di_wsolve(sys::Cint, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble}, Wi::Ptr{Int32}, W::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_wsolve(sys::Cint, Ap::Ptr{Int32}, Ai::Ptr{Int32},
+                                        Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble},
+                                        Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                        Info::Ptr{Cdouble}, Wi::Ptr{Int32},
+                                        W::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_wsolve(sys, Ap, Ai, Ax, X, B, Numeric, Control, Info, Wi, W)
-    @ccall libumfpack.umfpack_dl_wsolve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble}, Wi::Ptr{Int64}, W::Ptr{Cdouble})::Cint
-end
-
-function umfpack_zi_wsolve(sys, Ap, Ai, Ax, Az, Xx, Xz, Bx, Bz, Numeric, Control, Info, Wi, W)
-    @ccall libumfpack.umfpack_zi_wsolve(sys::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble}, Wi::Ptr{Int32}, W::Ptr{Cdouble})::Cint
-end
-
-function umfpack_zl_wsolve(sys, Ap, Ai, Ax, Az, Xx, Xz, Bx, Bz, Numeric, Control, Info, Wi, W)
-    @ccall libumfpack.umfpack_zl_wsolve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble}, Info::Ptr{Cdouble}, Wi::Ptr{Int64}, W::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_wsolve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64},
+                                        Ax::Ptr{Cdouble}, X::Ptr{Cdouble}, B::Ptr{Cdouble},
+                                        Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                        Info::Ptr{Cdouble}, Wi::Ptr{Int64},
+                                        W::Ptr{Cdouble})::Cint
+end
+
+function umfpack_zi_wsolve(sys, Ap, Ai, Ax, Az, Xx, Xz, Bx, Bz, Numeric, Control, Info, Wi,
+                           W)
+    @ccall libumfpack.umfpack_zi_wsolve(sys::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32},
+                                        Ax::Ptr{Cdouble}, Az::Ptr{Cdouble},
+                                        Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble},
+                                        Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble},
+                                        Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                        Info::Ptr{Cdouble}, Wi::Ptr{Int32},
+                                        W::Ptr{Cdouble})::Cint
+end
+
+function umfpack_zl_wsolve(sys, Ap, Ai, Ax, Az, Xx, Xz, Bx, Bz, Numeric, Control, Info, Wi,
+                           W)
+    @ccall libumfpack.umfpack_zl_wsolve(sys::Cint, Ap::Ptr{Int64}, Ai::Ptr{Int64},
+                                        Ax::Ptr{Cdouble}, Az::Ptr{Cdouble},
+                                        Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble},
+                                        Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble},
+                                        Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble},
+                                        Info::Ptr{Cdouble}, Wi::Ptr{Int64},
+                                        W::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_triplet_to_col(n_row, n_col, nz, Ti, Tj, Tx, Ap, Ai, Ax, Map)
-    @ccall libumfpack.umfpack_di_triplet_to_col(n_row::Int32, n_col::Int32, nz::Int32, Ti::Ptr{Int32}, Tj::Ptr{Int32}, Tx::Ptr{Cdouble}, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Map::Ptr{Int32})::Cint
+    @ccall libumfpack.umfpack_di_triplet_to_col(n_row::Int32, n_col::Int32, nz::Int32,
+                                                Ti::Ptr{Int32}, Tj::Ptr{Int32},
+                                                Tx::Ptr{Cdouble}, Ap::Ptr{Int32},
+                                                Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                                Map::Ptr{Int32})::Cint
 end
 
 function umfpack_dl_triplet_to_col(n_row, n_col, nz, Ti, Tj, Tx, Ap, Ai, Ax, Map)
-    @ccall libumfpack.umfpack_dl_triplet_to_col(n_row::Int64, n_col::Int64, nz::Int64, Ti::Ptr{Int64}, Tj::Ptr{Int64}, Tx::Ptr{Cdouble}, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Map::Ptr{Int64})::Cint
+    @ccall libumfpack.umfpack_dl_triplet_to_col(n_row::Int64, n_col::Int64, nz::Int64,
+                                                Ti::Ptr{Int64}, Tj::Ptr{Int64},
+                                                Tx::Ptr{Cdouble}, Ap::Ptr{Int64},
+                                                Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                                Map::Ptr{Int64})::Cint
 end
 
 function umfpack_zi_triplet_to_col(n_row, n_col, nz, Ti, Tj, Tx, Tz, Ap, Ai, Ax, Az, Map)
-    @ccall libumfpack.umfpack_zi_triplet_to_col(n_row::Int32, n_col::Int32, nz::Int32, Ti::Ptr{Int32}, Tj::Ptr{Int32}, Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble}, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Map::Ptr{Int32})::Cint
+    @ccall libumfpack.umfpack_zi_triplet_to_col(n_row::Int32, n_col::Int32, nz::Int32,
+                                                Ti::Ptr{Int32}, Tj::Ptr{Int32},
+                                                Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble},
+                                                Ap::Ptr{Int32}, Ai::Ptr{Int32},
+                                                Ax::Ptr{Cdouble}, Az::Ptr{Cdouble},
+                                                Map::Ptr{Int32})::Cint
 end
 
 function umfpack_zl_triplet_to_col(n_row, n_col, nz, Ti, Tj, Tx, Tz, Ap, Ai, Ax, Az, Map)
-    @ccall libumfpack.umfpack_zl_triplet_to_col(n_row::Int64, n_col::Int64, nz::Int64, Ti::Ptr{Int64}, Tj::Ptr{Int64}, Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble}, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, Map::Ptr{Int64})::Cint
+    @ccall libumfpack.umfpack_zl_triplet_to_col(n_row::Int64, n_col::Int64, nz::Int64,
+                                                Ti::Ptr{Int64}, Tj::Ptr{Int64},
+                                                Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble},
+                                                Ap::Ptr{Int64}, Ai::Ptr{Int64},
+                                                Ax::Ptr{Cdouble}, Az::Ptr{Cdouble},
+                                                Map::Ptr{Int64})::Cint
 end
 
 function umfpack_di_col_to_triplet(n_col, Ap, Tj)
-    @ccall libumfpack.umfpack_di_col_to_triplet(n_col::Int32, Ap::Ptr{Int32}, Tj::Ptr{Int32})::Cint
+    @ccall libumfpack.umfpack_di_col_to_triplet(n_col::Int32, Ap::Ptr{Int32},
+                                                Tj::Ptr{Int32})::Cint
 end
 
 function umfpack_dl_col_to_triplet(n_col, Ap, Tj)
-    @ccall libumfpack.umfpack_dl_col_to_triplet(n_col::Int64, Ap::Ptr{Int64}, Tj::Ptr{Int64})::Cint
+    @ccall libumfpack.umfpack_dl_col_to_triplet(n_col::Int64, Ap::Ptr{Int64},
+                                                Tj::Ptr{Int64})::Cint
 end
 
 function umfpack_zi_col_to_triplet(n_col, Ap, Tj)
-    @ccall libumfpack.umfpack_zi_col_to_triplet(n_col::Int32, Ap::Ptr{Int32}, Tj::Ptr{Int32})::Cint
+    @ccall libumfpack.umfpack_zi_col_to_triplet(n_col::Int32, Ap::Ptr{Int32},
+                                                Tj::Ptr{Int32})::Cint
 end
 
 function umfpack_zl_col_to_triplet(n_col, Ap, Tj)
-    @ccall libumfpack.umfpack_zl_col_to_triplet(n_col::Int64, Ap::Ptr{Int64}, Tj::Ptr{Int64})::Cint
+    @ccall libumfpack.umfpack_zl_col_to_triplet(n_col::Int64, Ap::Ptr{Int64},
+                                                Tj::Ptr{Int64})::Cint
 end
 
 function umfpack_di_transpose(n_row, n_col, Ap, Ai, Ax, P, Q, Rp, Ri, Rx)
-    @ccall libumfpack.umfpack_di_transpose(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, P::Ptr{Int32}, Q::Ptr{Int32}, Rp::Ptr{Int32}, Ri::Ptr{Int32}, Rx::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_transpose(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                           Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, P::Ptr{Int32},
+                                           Q::Ptr{Int32}, Rp::Ptr{Int32}, Ri::Ptr{Int32},
+                                           Rx::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_transpose(n_row, n_col, Ap, Ai, Ax, P, Q, Rp, Ri, Rx)
-    @ccall libumfpack.umfpack_dl_transpose(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, P::Ptr{Int64}, Q::Ptr{Int64}, Rp::Ptr{Int64}, Ri::Ptr{Int64}, Rx::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_transpose(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                           Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, P::Ptr{Int64},
+                                           Q::Ptr{Int64}, Rp::Ptr{Int64}, Ri::Ptr{Int64},
+                                           Rx::Ptr{Cdouble})::Cint
 end
 
-function umfpack_zi_transpose(n_row, n_col, Ap, Ai, Ax, Az, P, Q, Rp, Ri, Rx, Rz, do_conjugate)
-    @ccall libumfpack.umfpack_zi_transpose(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, P::Ptr{Int32}, Q::Ptr{Int32}, Rp::Ptr{Int32}, Ri::Ptr{Int32}, Rx::Ptr{Cdouble}, Rz::Ptr{Cdouble}, do_conjugate::Cint)::Cint
+function umfpack_zi_transpose(n_row, n_col, Ap, Ai, Ax, Az, P, Q, Rp, Ri, Rx, Rz,
+                              do_conjugate)
+    @ccall libumfpack.umfpack_zi_transpose(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                           Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                           Az::Ptr{Cdouble}, P::Ptr{Int32}, Q::Ptr{Int32},
+                                           Rp::Ptr{Int32}, Ri::Ptr{Int32}, Rx::Ptr{Cdouble},
+                                           Rz::Ptr{Cdouble}, do_conjugate::Cint)::Cint
 end
 
-function umfpack_zl_transpose(n_row, n_col, Ap, Ai, Ax, Az, P, Q, Rp, Ri, Rx, Rz, do_conjugate)
-    @ccall libumfpack.umfpack_zl_transpose(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, P::Ptr{Int64}, Q::Ptr{Int64}, Rp::Ptr{Int64}, Ri::Ptr{Int64}, Rx::Ptr{Cdouble}, Rz::Ptr{Cdouble}, do_conjugate::Cint)::Cint
+function umfpack_zl_transpose(n_row, n_col, Ap, Ai, Ax, Az, P, Q, Rp, Ri, Rx, Rz,
+                              do_conjugate)
+    @ccall libumfpack.umfpack_zl_transpose(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                           Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                           Az::Ptr{Cdouble}, P::Ptr{Int64}, Q::Ptr{Int64},
+                                           Rp::Ptr{Int64}, Ri::Ptr{Int64}, Rx::Ptr{Cdouble},
+                                           Rz::Ptr{Cdouble}, do_conjugate::Cint)::Cint
 end
 
 function umfpack_di_scale(X, B, Numeric)
-    @ccall libumfpack.umfpack_di_scale(X::Ptr{Cdouble}, B::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_scale(X::Ptr{Cdouble}, B::Ptr{Cdouble},
+                                       Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_scale(X, B, Numeric)
-    @ccall libumfpack.umfpack_dl_scale(X::Ptr{Cdouble}, B::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_scale(X::Ptr{Cdouble}, B::Ptr{Cdouble},
+                                       Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_scale(Xx, Xz, Bx, Bz, Numeric)
-    @ccall libumfpack.umfpack_zi_scale(Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_scale(Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble},
+                                       Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_scale(Xx, Xz, Bx, Bz, Numeric)
-    @ccall libumfpack.umfpack_zl_scale(Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble}, Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_scale(Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Bx::Ptr{Cdouble},
+                                       Bz::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_get_lunz(lnz, unz, n_row, n_col, nz_udiag, Numeric)
-    @ccall libumfpack.umfpack_di_get_lunz(lnz::Ptr{Int32}, unz::Ptr{Int32}, n_row::Ptr{Int32}, n_col::Ptr{Int32}, nz_udiag::Ptr{Int32}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_get_lunz(lnz::Ptr{Int32}, unz::Ptr{Int32},
+                                          n_row::Ptr{Int32}, n_col::Ptr{Int32},
+                                          nz_udiag::Ptr{Int32}, Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_get_lunz(lnz, unz, n_row, n_col, nz_udiag, Numeric)
-    @ccall libumfpack.umfpack_dl_get_lunz(lnz::Ptr{Int64}, unz::Ptr{Int64}, n_row::Ptr{Int64}, n_col::Ptr{Int64}, nz_udiag::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_get_lunz(lnz::Ptr{Int64}, unz::Ptr{Int64},
+                                          n_row::Ptr{Int64}, n_col::Ptr{Int64},
+                                          nz_udiag::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_get_lunz(lnz, unz, n_row, n_col, nz_udiag, Numeric)
-    @ccall libumfpack.umfpack_zi_get_lunz(lnz::Ptr{Int32}, unz::Ptr{Int32}, n_row::Ptr{Int32}, n_col::Ptr{Int32}, nz_udiag::Ptr{Int32}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_get_lunz(lnz::Ptr{Int32}, unz::Ptr{Int32},
+                                          n_row::Ptr{Int32}, n_col::Ptr{Int32},
+                                          nz_udiag::Ptr{Int32}, Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_get_lunz(lnz, unz, n_row, n_col, nz_udiag, Numeric)
-    @ccall libumfpack.umfpack_zl_get_lunz(lnz::Ptr{Int64}, unz::Ptr{Int64}, n_row::Ptr{Int64}, n_col::Ptr{Int64}, nz_udiag::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_get_lunz(lnz::Ptr{Int64}, unz::Ptr{Int64},
+                                          n_row::Ptr{Int64}, n_col::Ptr{Int64},
+                                          nz_udiag::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_get_numeric(Lp, Lj, Lx, Up, Ui, Ux, P, Q, Dx, do_recip, Rs, Numeric)
-    @ccall libumfpack.umfpack_di_get_numeric(Lp::Ptr{Int32}, Lj::Ptr{Int32}, Lx::Ptr{Cdouble}, Up::Ptr{Int32}, Ui::Ptr{Int32}, Ux::Ptr{Cdouble}, P::Ptr{Int32}, Q::Ptr{Int32}, Dx::Ptr{Cdouble}, do_recip::Ptr{Int32}, Rs::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_get_numeric(Lp::Ptr{Int32}, Lj::Ptr{Int32},
+                                             Lx::Ptr{Cdouble}, Up::Ptr{Int32},
+                                             Ui::Ptr{Int32}, Ux::Ptr{Cdouble},
+                                             P::Ptr{Int32}, Q::Ptr{Int32}, Dx::Ptr{Cdouble},
+                                             do_recip::Ptr{Int32}, Rs::Ptr{Cdouble},
+                                             Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_get_numeric(Lp, Lj, Lx, Up, Ui, Ux, P, Q, Dx, do_recip, Rs, Numeric)
-    @ccall libumfpack.umfpack_dl_get_numeric(Lp::Ptr{Int64}, Lj::Ptr{Int64}, Lx::Ptr{Cdouble}, Up::Ptr{Int64}, Ui::Ptr{Int64}, Ux::Ptr{Cdouble}, P::Ptr{Int64}, Q::Ptr{Int64}, Dx::Ptr{Cdouble}, do_recip::Ptr{Int64}, Rs::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
-end
-
-function umfpack_zi_get_numeric(Lp, Lj, Lx, Lz, Up, Ui, Ux, Uz, P, Q, Dx, Dz, do_recip, Rs, Numeric)
-    @ccall libumfpack.umfpack_zi_get_numeric(Lp::Ptr{Int32}, Lj::Ptr{Int32}, Lx::Ptr{Cdouble}, Lz::Ptr{Cdouble}, Up::Ptr{Int32}, Ui::Ptr{Int32}, Ux::Ptr{Cdouble}, Uz::Ptr{Cdouble}, P::Ptr{Int32}, Q::Ptr{Int32}, Dx::Ptr{Cdouble}, Dz::Ptr{Cdouble}, do_recip::Ptr{Int32}, Rs::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
-end
-
-function umfpack_zl_get_numeric(Lp, Lj, Lx, Lz, Up, Ui, Ux, Uz, P, Q, Dx, Dz, do_recip, Rs, Numeric)
-    @ccall libumfpack.umfpack_zl_get_numeric(Lp::Ptr{Int64}, Lj::Ptr{Int64}, Lx::Ptr{Cdouble}, Lz::Ptr{Cdouble}, Up::Ptr{Int64}, Ui::Ptr{Int64}, Ux::Ptr{Cdouble}, Uz::Ptr{Cdouble}, P::Ptr{Int64}, Q::Ptr{Int64}, Dx::Ptr{Cdouble}, Dz::Ptr{Cdouble}, do_recip::Ptr{Int64}, Rs::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
-end
-
-function umfpack_di_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol, Front_parent, Front_1strow, Front_leftmostdesc, Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
-    @ccall libumfpack.umfpack_di_get_symbolic(n_row::Ptr{Int32}, n_col::Ptr{Int32}, n1::Ptr{Int32}, nz::Ptr{Int32}, nfr::Ptr{Int32}, nchains::Ptr{Int32}, P::Ptr{Int32}, Q::Ptr{Int32}, Front_npivcol::Ptr{Int32}, Front_parent::Ptr{Int32}, Front_1strow::Ptr{Int32}, Front_leftmostdesc::Ptr{Int32}, Chain_start::Ptr{Int32}, Chain_maxrows::Ptr{Int32}, Chain_maxcols::Ptr{Int32}, Dmap::Ptr{Int32}, Symbolic::Ptr{Cvoid})::Cint
-end
-
-function umfpack_dl_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol, Front_parent, Front_1strow, Front_leftmostdesc, Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
-    @ccall libumfpack.umfpack_dl_get_symbolic(n_row::Ptr{Int64}, n_col::Ptr{Int64}, n1::Ptr{Int64}, nz::Ptr{Int64}, nfr::Ptr{Int64}, nchains::Ptr{Int64}, P::Ptr{Int64}, Q::Ptr{Int64}, Front_npivcol::Ptr{Int64}, Front_parent::Ptr{Int64}, Front_1strow::Ptr{Int64}, Front_leftmostdesc::Ptr{Int64}, Chain_start::Ptr{Int64}, Chain_maxrows::Ptr{Int64}, Chain_maxcols::Ptr{Int64}, Dmap::Ptr{Int64}, Symbolic::Ptr{Cvoid})::Cint
-end
-
-function umfpack_zi_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol, Front_parent, Front_1strow, Front_leftmostdesc, Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
-    @ccall libumfpack.umfpack_zi_get_symbolic(n_row::Ptr{Int32}, n_col::Ptr{Int32}, n1::Ptr{Int32}, nz::Ptr{Int32}, nfr::Ptr{Int32}, nchains::Ptr{Int32}, P::Ptr{Int32}, Q::Ptr{Int32}, Front_npivcol::Ptr{Int32}, Front_parent::Ptr{Int32}, Front_1strow::Ptr{Int32}, Front_leftmostdesc::Ptr{Int32}, Chain_start::Ptr{Int32}, Chain_maxrows::Ptr{Int32}, Chain_maxcols::Ptr{Int32}, Dmap::Ptr{Int32}, Symbolic::Ptr{Cvoid})::Cint
-end
-
-function umfpack_zl_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol, Front_parent, Front_1strow, Front_leftmostdesc, Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
-    @ccall libumfpack.umfpack_zl_get_symbolic(n_row::Ptr{Int64}, n_col::Ptr{Int64}, n1::Ptr{Int64}, nz::Ptr{Int64}, nfr::Ptr{Int64}, nchains::Ptr{Int64}, P::Ptr{Int64}, Q::Ptr{Int64}, Front_npivcol::Ptr{Int64}, Front_parent::Ptr{Int64}, Front_1strow::Ptr{Int64}, Front_leftmostdesc::Ptr{Int64}, Chain_start::Ptr{Int64}, Chain_maxrows::Ptr{Int64}, Chain_maxcols::Ptr{Int64}, Dmap::Ptr{Int64}, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_get_numeric(Lp::Ptr{Int64}, Lj::Ptr{Int64},
+                                             Lx::Ptr{Cdouble}, Up::Ptr{Int64},
+                                             Ui::Ptr{Int64}, Ux::Ptr{Cdouble},
+                                             P::Ptr{Int64}, Q::Ptr{Int64}, Dx::Ptr{Cdouble},
+                                             do_recip::Ptr{Int64}, Rs::Ptr{Cdouble},
+                                             Numeric::Ptr{Cvoid})::Cint
+end
+
+function umfpack_zi_get_numeric(Lp, Lj, Lx, Lz, Up, Ui, Ux, Uz, P, Q, Dx, Dz, do_recip, Rs,
+                                Numeric)
+    @ccall libumfpack.umfpack_zi_get_numeric(Lp::Ptr{Int32}, Lj::Ptr{Int32},
+                                             Lx::Ptr{Cdouble}, Lz::Ptr{Cdouble},
+                                             Up::Ptr{Int32}, Ui::Ptr{Int32},
+                                             Ux::Ptr{Cdouble}, Uz::Ptr{Cdouble},
+                                             P::Ptr{Int32}, Q::Ptr{Int32}, Dx::Ptr{Cdouble},
+                                             Dz::Ptr{Cdouble}, do_recip::Ptr{Int32},
+                                             Rs::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+end
+
+function umfpack_zl_get_numeric(Lp, Lj, Lx, Lz, Up, Ui, Ux, Uz, P, Q, Dx, Dz, do_recip, Rs,
+                                Numeric)
+    @ccall libumfpack.umfpack_zl_get_numeric(Lp::Ptr{Int64}, Lj::Ptr{Int64},
+                                             Lx::Ptr{Cdouble}, Lz::Ptr{Cdouble},
+                                             Up::Ptr{Int64}, Ui::Ptr{Int64},
+                                             Ux::Ptr{Cdouble}, Uz::Ptr{Cdouble},
+                                             P::Ptr{Int64}, Q::Ptr{Int64}, Dx::Ptr{Cdouble},
+                                             Dz::Ptr{Cdouble}, do_recip::Ptr{Int64},
+                                             Rs::Ptr{Cdouble}, Numeric::Ptr{Cvoid})::Cint
+end
+
+function umfpack_di_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol,
+                                 Front_parent, Front_1strow, Front_leftmostdesc,
+                                 Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
+    @ccall libumfpack.umfpack_di_get_symbolic(n_row::Ptr{Int32}, n_col::Ptr{Int32},
+                                              n1::Ptr{Int32}, nz::Ptr{Int32},
+                                              nfr::Ptr{Int32}, nchains::Ptr{Int32},
+                                              P::Ptr{Int32}, Q::Ptr{Int32},
+                                              Front_npivcol::Ptr{Int32},
+                                              Front_parent::Ptr{Int32},
+                                              Front_1strow::Ptr{Int32},
+                                              Front_leftmostdesc::Ptr{Int32},
+                                              Chain_start::Ptr{Int32},
+                                              Chain_maxrows::Ptr{Int32},
+                                              Chain_maxcols::Ptr{Int32}, Dmap::Ptr{Int32},
+                                              Symbolic::Ptr{Cvoid})::Cint
+end
+
+function umfpack_dl_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol,
+                                 Front_parent, Front_1strow, Front_leftmostdesc,
+                                 Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
+    @ccall libumfpack.umfpack_dl_get_symbolic(n_row::Ptr{Int64}, n_col::Ptr{Int64},
+                                              n1::Ptr{Int64}, nz::Ptr{Int64},
+                                              nfr::Ptr{Int64}, nchains::Ptr{Int64},
+                                              P::Ptr{Int64}, Q::Ptr{Int64},
+                                              Front_npivcol::Ptr{Int64},
+                                              Front_parent::Ptr{Int64},
+                                              Front_1strow::Ptr{Int64},
+                                              Front_leftmostdesc::Ptr{Int64},
+                                              Chain_start::Ptr{Int64},
+                                              Chain_maxrows::Ptr{Int64},
+                                              Chain_maxcols::Ptr{Int64}, Dmap::Ptr{Int64},
+                                              Symbolic::Ptr{Cvoid})::Cint
+end
+
+function umfpack_zi_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol,
+                                 Front_parent, Front_1strow, Front_leftmostdesc,
+                                 Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
+    @ccall libumfpack.umfpack_zi_get_symbolic(n_row::Ptr{Int32}, n_col::Ptr{Int32},
+                                              n1::Ptr{Int32}, nz::Ptr{Int32},
+                                              nfr::Ptr{Int32}, nchains::Ptr{Int32},
+                                              P::Ptr{Int32}, Q::Ptr{Int32},
+                                              Front_npivcol::Ptr{Int32},
+                                              Front_parent::Ptr{Int32},
+                                              Front_1strow::Ptr{Int32},
+                                              Front_leftmostdesc::Ptr{Int32},
+                                              Chain_start::Ptr{Int32},
+                                              Chain_maxrows::Ptr{Int32},
+                                              Chain_maxcols::Ptr{Int32}, Dmap::Ptr{Int32},
+                                              Symbolic::Ptr{Cvoid})::Cint
+end
+
+function umfpack_zl_get_symbolic(n_row, n_col, n1, nz, nfr, nchains, P, Q, Front_npivcol,
+                                 Front_parent, Front_1strow, Front_leftmostdesc,
+                                 Chain_start, Chain_maxrows, Chain_maxcols, Dmap, Symbolic)
+    @ccall libumfpack.umfpack_zl_get_symbolic(n_row::Ptr{Int64}, n_col::Ptr{Int64},
+                                              n1::Ptr{Int64}, nz::Ptr{Int64},
+                                              nfr::Ptr{Int64}, nchains::Ptr{Int64},
+                                              P::Ptr{Int64}, Q::Ptr{Int64},
+                                              Front_npivcol::Ptr{Int64},
+                                              Front_parent::Ptr{Int64},
+                                              Front_1strow::Ptr{Int64},
+                                              Front_leftmostdesc::Ptr{Int64},
+                                              Chain_start::Ptr{Int64},
+                                              Chain_maxrows::Ptr{Int64},
+                                              Chain_maxcols::Ptr{Int64}, Dmap::Ptr{Int64},
+                                              Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_save_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_di_save_numeric(Numeric::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_di_save_numeric(Numeric::Ptr{Cvoid},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_dl_save_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_dl_save_numeric(Numeric::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_dl_save_numeric(Numeric::Ptr{Cvoid},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zi_save_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_zi_save_numeric(Numeric::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zi_save_numeric(Numeric::Ptr{Cvoid},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zl_save_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_zl_save_numeric(Numeric::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zl_save_numeric(Numeric::Ptr{Cvoid},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_di_load_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_di_load_numeric(Numeric::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_di_load_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_dl_load_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_dl_load_numeric(Numeric::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_dl_load_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zi_load_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_zi_load_numeric(Numeric::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zi_load_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zl_load_numeric(Numeric, filename)
-    @ccall libumfpack.umfpack_zl_load_numeric(Numeric::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zl_load_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_di_copy_numeric(Numeric, Original)
-    @ccall libumfpack.umfpack_di_copy_numeric(Numeric::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_copy_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_copy_numeric(Numeric, Original)
-    @ccall libumfpack.umfpack_dl_copy_numeric(Numeric::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_copy_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_copy_numeric(Numeric, Original)
-    @ccall libumfpack.umfpack_zi_copy_numeric(Numeric::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_copy_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_copy_numeric(Numeric, Original)
-    @ccall libumfpack.umfpack_zl_copy_numeric(Numeric::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_copy_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                              Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_serialize_numeric_size(blobsize, Numeric)
-    @ccall libumfpack.umfpack_di_serialize_numeric_size(blobsize::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_serialize_numeric_size(blobsize::Ptr{Int64},
+                                                        Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_serialize_numeric_size(blobsize, Numeric)
-    @ccall libumfpack.umfpack_dl_serialize_numeric_size(blobsize::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_serialize_numeric_size(blobsize::Ptr{Int64},
+                                                        Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_serialize_numeric_size(blobsize, Numeric)
-    @ccall libumfpack.umfpack_zi_serialize_numeric_size(blobsize::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_serialize_numeric_size(blobsize::Ptr{Int64},
+                                                        Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_serialize_numeric_size(blobsize, Numeric)
-    @ccall libumfpack.umfpack_zl_serialize_numeric_size(blobsize::Ptr{Int64}, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_serialize_numeric_size(blobsize::Ptr{Int64},
+                                                        Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_serialize_numeric(blob, blobsize, Numeric)
-    @ccall libumfpack.umfpack_di_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64,
+                                                   Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_serialize_numeric(blob, blobsize, Numeric)
-    @ccall libumfpack.umfpack_dl_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64,
+                                                   Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_serialize_numeric(blob, blobsize, Numeric)
-    @ccall libumfpack.umfpack_zi_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64,
+                                                   Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_serialize_numeric(blob, blobsize, Numeric)
-    @ccall libumfpack.umfpack_zl_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64, Numeric::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_serialize_numeric(blob::Ptr{Int8}, blobsize::Int64,
+                                                   Numeric::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_deserialize_numeric(Numeric, blob, blobsize)
-    @ccall libumfpack.umfpack_di_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_di_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                                     blob::Ptr{Int8}, blobsize::Int64)::Cint
 end
 
 function umfpack_dl_deserialize_numeric(Numeric, blob, blobsize)
-    @ccall libumfpack.umfpack_dl_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_dl_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                                     blob::Ptr{Int8}, blobsize::Int64)::Cint
 end
 
 function umfpack_zi_deserialize_numeric(Numeric, blob, blobsize)
-    @ccall libumfpack.umfpack_zi_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_zi_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                                     blob::Ptr{Int8}, blobsize::Int64)::Cint
 end
 
 function umfpack_zl_deserialize_numeric(Numeric, blob, blobsize)
-    @ccall libumfpack.umfpack_zl_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_zl_deserialize_numeric(Numeric::Ptr{Ptr{Cvoid}},
+                                                     blob::Ptr{Int8}, blobsize::Int64)::Cint
 end
 
 function umfpack_di_save_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_di_save_symbolic(Symbolic::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_di_save_symbolic(Symbolic::Ptr{Cvoid},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_dl_save_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_dl_save_symbolic(Symbolic::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_dl_save_symbolic(Symbolic::Ptr{Cvoid},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zi_save_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_zi_save_symbolic(Symbolic::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zi_save_symbolic(Symbolic::Ptr{Cvoid},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zl_save_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_zl_save_symbolic(Symbolic::Ptr{Cvoid}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zl_save_symbolic(Symbolic::Ptr{Cvoid},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_di_load_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_di_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_di_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_dl_load_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_dl_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_dl_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zi_load_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_zi_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zi_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_zl_load_symbolic(Symbolic, filename)
-    @ccall libumfpack.umfpack_zl_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, filename::Ptr{Cchar})::Cint
+    @ccall libumfpack.umfpack_zl_load_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               filename::Ptr{Cchar})::Cint
 end
 
 function umfpack_di_copy_symbolic(Symbolic, Original)
-    @ccall libumfpack.umfpack_di_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_copy_symbolic(Symbolic, Original)
-    @ccall libumfpack.umfpack_dl_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_copy_symbolic(Symbolic, Original)
-    @ccall libumfpack.umfpack_zi_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_copy_symbolic(Symbolic, Original)
-    @ccall libumfpack.umfpack_zl_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, Original::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_copy_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                               Original::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_serialize_symbolic_size(blobsize, Symbolic)
-    @ccall libumfpack.umfpack_di_serialize_symbolic_size(blobsize::Ptr{Int64}, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_serialize_symbolic_size(blobsize::Ptr{Int64},
+                                                         Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_serialize_symbolic_size(blobsize, Symbolic)
-    @ccall libumfpack.umfpack_dl_serialize_symbolic_size(blobsize::Ptr{Int64}, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_serialize_symbolic_size(blobsize::Ptr{Int64},
+                                                         Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_serialize_symbolic_size(blobsize, Symbolic)
-    @ccall libumfpack.umfpack_zi_serialize_symbolic_size(blobsize::Ptr{Int64}, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_serialize_symbolic_size(blobsize::Ptr{Int64},
+                                                         Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_serialize_symbolic_size(blobsize, Symbolic)
-    @ccall libumfpack.umfpack_zl_serialize_symbolic_size(blobsize::Ptr{Int64}, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_serialize_symbolic_size(blobsize::Ptr{Int64},
+                                                         Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_serialize_symbolic(blob, blobsize, Symbolic)
-    @ccall libumfpack.umfpack_di_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_di_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64,
+                                                    Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_dl_serialize_symbolic(blob, blobsize, Symbolic)
-    @ccall libumfpack.umfpack_dl_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_dl_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64,
+                                                    Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zi_serialize_symbolic(blob, blobsize, Symbolic)
-    @ccall libumfpack.umfpack_zi_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zi_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64,
+                                                    Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_zl_serialize_symbolic(blob, blobsize, Symbolic)
-    @ccall libumfpack.umfpack_zl_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64, Symbolic::Ptr{Cvoid})::Cint
+    @ccall libumfpack.umfpack_zl_serialize_symbolic(blob::Ptr{Int8}, blobsize::Int64,
+                                                    Symbolic::Ptr{Cvoid})::Cint
 end
 
 function umfpack_di_deserialize_symbolic(Symbolic, blob, blobsize)
-    @ccall libumfpack.umfpack_di_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_di_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                                      blob::Ptr{Int8},
+                                                      blobsize::Int64)::Cint
 end
 
 function umfpack_dl_deserialize_symbolic(Symbolic, blob, blobsize)
-    @ccall libumfpack.umfpack_dl_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_dl_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                                      blob::Ptr{Int8},
+                                                      blobsize::Int64)::Cint
 end
 
 function umfpack_zi_deserialize_symbolic(Symbolic, blob, blobsize)
-    @ccall libumfpack.umfpack_zi_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_zi_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                                      blob::Ptr{Int8},
+                                                      blobsize::Int64)::Cint
 end
 
 function umfpack_zl_deserialize_symbolic(Symbolic, blob, blobsize)
-    @ccall libumfpack.umfpack_zl_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}}, blob::Ptr{Int8}, blobsize::Int64)::Cint
+    @ccall libumfpack.umfpack_zl_deserialize_symbolic(Symbolic::Ptr{Ptr{Cvoid}},
+                                                      blob::Ptr{Int8},
+                                                      blobsize::Int64)::Cint
 end
 
 function umfpack_di_get_determinant(Mx, Ex, Numeric, User_Info)
-    @ccall libumfpack.umfpack_di_get_determinant(Mx::Ptr{Cdouble}, Ex::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, User_Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_get_determinant(Mx::Ptr{Cdouble}, Ex::Ptr{Cdouble},
+                                                 Numeric::Ptr{Cvoid},
+                                                 User_Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_get_determinant(Mx, Ex, Numeric, User_Info)
-    @ccall libumfpack.umfpack_dl_get_determinant(Mx::Ptr{Cdouble}, Ex::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, User_Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_get_determinant(Mx::Ptr{Cdouble}, Ex::Ptr{Cdouble},
+                                                 Numeric::Ptr{Cvoid},
+                                                 User_Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_get_determinant(Mx, Mz, Ex, Numeric, User_Info)
-    @ccall libumfpack.umfpack_zi_get_determinant(Mx::Ptr{Cdouble}, Mz::Ptr{Cdouble}, Ex::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, User_Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_get_determinant(Mx::Ptr{Cdouble}, Mz::Ptr{Cdouble},
+                                                 Ex::Ptr{Cdouble}, Numeric::Ptr{Cvoid},
+                                                 User_Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_get_determinant(Mx, Mz, Ex, Numeric, User_Info)
-    @ccall libumfpack.umfpack_zl_get_determinant(Mx::Ptr{Cdouble}, Mz::Ptr{Cdouble}, Ex::Ptr{Cdouble}, Numeric::Ptr{Cvoid}, User_Info::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_get_determinant(Mx::Ptr{Cdouble}, Mz::Ptr{Cdouble},
+                                                 Ex::Ptr{Cdouble}, Numeric::Ptr{Cvoid},
+                                                 User_Info::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_report_status(Control, status)
@@ -2256,19 +3038,23 @@ function umfpack_zl_report_status(Control, status)
 end
 
 function umfpack_di_report_info(Control, Info)
-    @ccall libumfpack.umfpack_di_report_info(Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cvoid
+    @ccall libumfpack.umfpack_di_report_info(Control::Ptr{Cdouble},
+                                             Info::Ptr{Cdouble})::Cvoid
 end
 
 function umfpack_dl_report_info(Control, Info)
-    @ccall libumfpack.umfpack_dl_report_info(Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cvoid
+    @ccall libumfpack.umfpack_dl_report_info(Control::Ptr{Cdouble},
+                                             Info::Ptr{Cdouble})::Cvoid
 end
 
 function umfpack_zi_report_info(Control, Info)
-    @ccall libumfpack.umfpack_zi_report_info(Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cvoid
+    @ccall libumfpack.umfpack_zi_report_info(Control::Ptr{Cdouble},
+                                             Info::Ptr{Cdouble})::Cvoid
 end
 
 function umfpack_zl_report_info(Control, Info)
-    @ccall libumfpack.umfpack_zl_report_info(Control::Ptr{Cdouble}, Info::Ptr{Cdouble})::Cvoid
+    @ccall libumfpack.umfpack_zl_report_info(Control::Ptr{Cdouble},
+                                             Info::Ptr{Cdouble})::Cvoid
 end
 
 function umfpack_di_report_control(Control)
@@ -2288,99 +3074,137 @@ function umfpack_zl_report_control(Control)
 end
 
 function umfpack_di_report_matrix(n_row, n_col, Ap, Ai, Ax, col_form, Control)
-    @ccall libumfpack.umfpack_di_report_matrix(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, col_form::Cint, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_report_matrix(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                               Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                               col_form::Cint, Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_report_matrix(n_row, n_col, Ap, Ai, Ax, col_form, Control)
-    @ccall libumfpack.umfpack_dl_report_matrix(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, col_form::Cint, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_report_matrix(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                               Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                               col_form::Cint, Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_report_matrix(n_row, n_col, Ap, Ai, Ax, Az, col_form, Control)
-    @ccall libumfpack.umfpack_zi_report_matrix(n_row::Int32, n_col::Int32, Ap::Ptr{Int32}, Ai::Ptr{Int32}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, col_form::Cint, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_report_matrix(n_row::Int32, n_col::Int32, Ap::Ptr{Int32},
+                                               Ai::Ptr{Int32}, Ax::Ptr{Cdouble},
+                                               Az::Ptr{Cdouble}, col_form::Cint,
+                                               Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_report_matrix(n_row, n_col, Ap, Ai, Ax, Az, col_form, Control)
-    @ccall libumfpack.umfpack_zl_report_matrix(n_row::Int64, n_col::Int64, Ap::Ptr{Int64}, Ai::Ptr{Int64}, Ax::Ptr{Cdouble}, Az::Ptr{Cdouble}, col_form::Cint, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_report_matrix(n_row::Int64, n_col::Int64, Ap::Ptr{Int64},
+                                               Ai::Ptr{Int64}, Ax::Ptr{Cdouble},
+                                               Az::Ptr{Cdouble}, col_form::Cint,
+                                               Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_report_triplet(n_row, n_col, nz, Ti, Tj, Tx, Control)
-    @ccall libumfpack.umfpack_di_report_triplet(n_row::Int32, n_col::Int32, nz::Int32, Ti::Ptr{Int32}, Tj::Ptr{Int32}, Tx::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_report_triplet(n_row::Int32, n_col::Int32, nz::Int32,
+                                                Ti::Ptr{Int32}, Tj::Ptr{Int32},
+                                                Tx::Ptr{Cdouble},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_report_triplet(n_row, n_col, nz, Ti, Tj, Tx, Control)
-    @ccall libumfpack.umfpack_dl_report_triplet(n_row::Int64, n_col::Int64, nz::Int64, Ti::Ptr{Int64}, Tj::Ptr{Int64}, Tx::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_report_triplet(n_row::Int64, n_col::Int64, nz::Int64,
+                                                Ti::Ptr{Int64}, Tj::Ptr{Int64},
+                                                Tx::Ptr{Cdouble},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_report_triplet(n_row, n_col, nz, Ti, Tj, Tx, Tz, Control)
-    @ccall libumfpack.umfpack_zi_report_triplet(n_row::Int32, n_col::Int32, nz::Int32, Ti::Ptr{Int32}, Tj::Ptr{Int32}, Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_report_triplet(n_row::Int32, n_col::Int32, nz::Int32,
+                                                Ti::Ptr{Int32}, Tj::Ptr{Int32},
+                                                Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_report_triplet(n_row, n_col, nz, Ti, Tj, Tx, Tz, Control)
-    @ccall libumfpack.umfpack_zl_report_triplet(n_row::Int64, n_col::Int64, nz::Int64, Ti::Ptr{Int64}, Tj::Ptr{Int64}, Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_report_triplet(n_row::Int64, n_col::Int64, nz::Int64,
+                                                Ti::Ptr{Int64}, Tj::Ptr{Int64},
+                                                Tx::Ptr{Cdouble}, Tz::Ptr{Cdouble},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_report_vector(n, X, Control)
-    @ccall libumfpack.umfpack_di_report_vector(n::Int32, X::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_report_vector(n::Int32, X::Ptr{Cdouble},
+                                               Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_report_vector(n, X, Control)
-    @ccall libumfpack.umfpack_dl_report_vector(n::Int64, X::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_report_vector(n::Int64, X::Ptr{Cdouble},
+                                               Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_report_vector(n, Xx, Xz, Control)
-    @ccall libumfpack.umfpack_zi_report_vector(n::Int32, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_report_vector(n::Int32, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble},
+                                               Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_report_vector(n, Xx, Xz, Control)
-    @ccall libumfpack.umfpack_zl_report_vector(n::Int64, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_report_vector(n::Int64, Xx::Ptr{Cdouble}, Xz::Ptr{Cdouble},
+                                               Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_report_symbolic(Symbolic, Control)
-    @ccall libumfpack.umfpack_di_report_symbolic(Symbolic::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_report_symbolic(Symbolic::Ptr{Cvoid},
+                                                 Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_report_symbolic(Symbolic, Control)
-    @ccall libumfpack.umfpack_dl_report_symbolic(Symbolic::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_report_symbolic(Symbolic::Ptr{Cvoid},
+                                                 Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_report_symbolic(Symbolic, Control)
-    @ccall libumfpack.umfpack_zi_report_symbolic(Symbolic::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_report_symbolic(Symbolic::Ptr{Cvoid},
+                                                 Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_report_symbolic(Symbolic, Control)
-    @ccall libumfpack.umfpack_zl_report_symbolic(Symbolic::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_report_symbolic(Symbolic::Ptr{Cvoid},
+                                                 Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_report_numeric(Numeric, Control)
-    @ccall libumfpack.umfpack_di_report_numeric(Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_report_numeric(Numeric::Ptr{Cvoid},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_report_numeric(Numeric, Control)
-    @ccall libumfpack.umfpack_dl_report_numeric(Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_report_numeric(Numeric::Ptr{Cvoid},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_report_numeric(Numeric, Control)
-    @ccall libumfpack.umfpack_zi_report_numeric(Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_report_numeric(Numeric::Ptr{Cvoid},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_report_numeric(Numeric, Control)
-    @ccall libumfpack.umfpack_zl_report_numeric(Numeric::Ptr{Cvoid}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_report_numeric(Numeric::Ptr{Cvoid},
+                                                Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_di_report_perm(np, Perm, Control)
-    @ccall libumfpack.umfpack_di_report_perm(np::Int32, Perm::Ptr{Int32}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_di_report_perm(np::Int32, Perm::Ptr{Int32},
+                                             Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_dl_report_perm(np, Perm, Control)
-    @ccall libumfpack.umfpack_dl_report_perm(np::Int64, Perm::Ptr{Int64}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_dl_report_perm(np::Int64, Perm::Ptr{Int64},
+                                             Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zi_report_perm(np, Perm, Control)
-    @ccall libumfpack.umfpack_zi_report_perm(np::Int32, Perm::Ptr{Int32}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zi_report_perm(np::Int32, Perm::Ptr{Int32},
+                                             Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_zl_report_perm(np, Perm, Control)
-    @ccall libumfpack.umfpack_zl_report_perm(np::Int64, Perm::Ptr{Int64}, Control::Ptr{Cdouble})::Cint
+    @ccall libumfpack.umfpack_zl_report_perm(np::Int64, Perm::Ptr{Int64},
+                                             Control::Ptr{Cdouble})::Cint
 end
 
 function umfpack_timer()
@@ -2395,13 +3219,13 @@ function umfpack_toc(stats)
     @ccall libumfpack.umfpack_toc(stats::Ptr{Cdouble})::Cvoid
 end
 
-const CHOLMOD_DATE = "Jan 17, 2023"
+const CHOLMOD_DATE = "June 16, 2023"
 
 const CHOLMOD_MAIN_VERSION = 4
 
 const CHOLMOD_SUB_VERSION = 0
 
-const CHOLMOD_SUBSUB_VERSION = 3
+const CHOLMOD_SUBSUB_VERSION = 4
 
 const _FILE_OFFSET_BITS = 64
 
@@ -2427,17 +3251,18 @@ const SUITESPARSE_COMPILER_MSC = 0
 
 const SUITESPARSE_COMPILER_XLC = 0
 
-const SUITESPARSE_DATE = "Jan 20, 2023"
+const SUITESPARSE_DATE = "June 29, 2023"
 
 const SUITESPARSE_MAIN_VERSION = 7
 
-const SUITESPARSE_SUB_VERSION = 0
+const SUITESPARSE_SUB_VERSION = 1
 
-const SUITESPARSE_SUBSUB_VERSION = 1
+const SUITESPARSE_SUBSUB_VERSION = 0
 
 SUITESPARSE_VER_CODE(main, sub) = main * 1000 + sub
 
-const SUITESPARSE_VERSION = SUITESPARSE_VER_CODE(SUITESPARSE_MAIN_VERSION, SUITESPARSE_SUB_VERSION)
+const SUITESPARSE_VERSION = SUITESPARSE_VER_CODE(SUITESPARSE_MAIN_VERSION,
+                                                 SUITESPARSE_SUB_VERSION)
 
 CHOLMOD_VER_CODE(main, sub) = main * 1000 + sub
 
@@ -2601,20 +3426,18 @@ const SPQR_RTX_EQUALS_B = 2
 
 const SPQR_RTX_EQUALS_ETB = 3
 
-const SPQR_DATE = "Jan 17, 2023"
+const SPQR_DATE = "July FIXME, 2023"
 
-const SPQR_MAIN_VERSION = 3
+const SPQR_MAIN_VERSION = 4
 
 const SPQR_SUB_VERSION = 0
 
-const SPQR_SUBSUB_VERSION = 3
+const SPQR_SUBSUB_VERSION = 0
 
 SPQR_VER_CODE(main, sub) = main * 1000 + sub
 
 const SPQR_VERSION = SPQR_VER_CODE(SPQR_MAIN_VERSION, SPQR_SUB_VERSION)
 
-const Complex = Float64
-
 const AMD_CONTROL = 5
 
 const AMD_INFO = 20
@@ -2663,172 +3486,29 @@ const AMD_INVALID = -2
 
 const AMD_OK_BUT_JUMBLED = 1
 
-const AMD_DATE = "Jan 17, 2023"
+const AMD_DATE = "June 16, 2023"
 
 const AMD_MAIN_VERSION = 3
 
 const AMD_SUB_VERSION = 0
 
-const AMD_SUBSUB_VERSION = 3
+const AMD_SUBSUB_VERSION = 4
 
 AMD_VERSION_CODE(main, sub) = main * 1000 + sub
 
 const AMD_VERSION = AMD_VERSION_CODE(AMD_MAIN_VERSION, AMD_SUB_VERSION)
 
-const COLAMD_DATE = "Jan 17, 2023"
-
-const COLAMD_MAIN_VERSION = 3
-
-const COLAMD_SUB_VERSION = 0
-
-const COLAMD_SUBSUB_VERSION = 3
-
-COLAMD_VERSION_CODE(main, sub) = main * 1000 + sub
-
-const COLAMD_VERSION = COLAMD_VERSION_CODE(COLAMD_MAIN_VERSION, COLAMD_SUB_VERSION)
-
-const COLAMD_KNOBS = 20
-
-const COLAMD_STATS = 20
-
-const COLAMD_DENSE_ROW = 0
-
-const COLAMD_DENSE_COL = 1
-
-const COLAMD_AGGRESSIVE = 2
-
-const COLAMD_DEFRAG_COUNT = 2
-
-const COLAMD_STATUS = 3
-
-const COLAMD_INFO1 = 4
-
-const COLAMD_INFO2 = 5
-
-const COLAMD_INFO3 = 6
-
-const COLAMD_OK = 0
-
-const COLAMD_OK_BUT_JUMBLED = 1
-
-const COLAMD_ERROR_A_not_present = -1
-
-const COLAMD_ERROR_p_not_present = -2
-
-const COLAMD_ERROR_nrow_negative = -3
-
-const COLAMD_ERROR_ncol_negative = -4
-
-const COLAMD_ERROR_nnz_negative = -5
-
-const COLAMD_ERROR_p0_nonzero = -6
-
-const COLAMD_ERROR_A_too_small = -7
-
-const COLAMD_ERROR_col_length_negative = -8
-
-const COLAMD_ERROR_row_index_out_of_bounds = -9
-
-const COLAMD_ERROR_out_of_memory = -10
-
-const COLAMD_ERROR_internal_error = -999
-
-const CCOLAMD_DATE = "Jan 17, 2023"
-
-const CCOLAMD_MAIN_VERSION = 3
-
-const CCOLAMD_SUB_VERSION = 0
-
-const CCOLAMD_SUBSUB_VERSION = 3
-
-CCOLAMD_VERSION_CODE(main, sub) = main * 1000 + sub
-
-const CCOLAMD_VERSION = CCOLAMD_VERSION_CODE(CCOLAMD_MAIN_VERSION, CCOLAMD_SUB_VERSION)
-
-const CCOLAMD_KNOBS = 20
-
-const CCOLAMD_STATS = 20
-
-const CCOLAMD_DENSE_ROW = 0
-
-const CCOLAMD_DENSE_COL = 1
-
-const CCOLAMD_AGGRESSIVE = 2
-
-const CCOLAMD_LU = 3
-
-const CCOLAMD_DEFRAG_COUNT = 2
-
-const CCOLAMD_STATUS = 3
-
-const CCOLAMD_INFO1 = 4
-
-const CCOLAMD_INFO2 = 5
-
-const CCOLAMD_INFO3 = 6
-
-const CCOLAMD_EMPTY_ROW = 7
-
-const CCOLAMD_EMPTY_COL = 8
-
-const CCOLAMD_NEWLY_EMPTY_ROW = 9
-
-const CCOLAMD_NEWLY_EMPTY_COL = 10
-
-const CCOLAMD_OK = 0
-
-const CCOLAMD_OK_BUT_JUMBLED = 1
-
-const CCOLAMD_ERROR_A_not_present = -1
-
-const CCOLAMD_ERROR_p_not_present = -2
-
-const CCOLAMD_ERROR_nrow_negative = -3
-
-const CCOLAMD_ERROR_ncol_negative = -4
-
-const CCOLAMD_ERROR_nnz_negative = -5
-
-const CCOLAMD_ERROR_p0_nonzero = -6
-
-const CCOLAMD_ERROR_A_too_small = -7
-
-const CCOLAMD_ERROR_col_length_negative = -8
-
-const CCOLAMD_ERROR_row_index_out_of_bounds = -9
-
-const CCOLAMD_ERROR_out_of_memory = -10
-
-const CCOLAMD_ERROR_invalid_cmember = -11
-
-const CCOLAMD_ERROR_internal_error = -999
-
 const UMFPACK_INFO = 90
 
 const UMFPACK_CONTROL = 20
 
-# Skipping MacroDefinition: UMFPACK_COPYRIGHT \
-#"UMFPACK:  Copyright (c) 2005-2023 by Timothy A. Davis.  All Rights Reserved.\n"
-
-# Skipping MacroDefinition: UMFPACK_LICENSE_PART1 \
-#"\nUMFPACK License: SPDX-License-Identifier: GPL-2.0+\n" \
-#"   UMFPACK is available under alternate licenses,\n" \
-#"   contact T. Davis for details.\n"
-
-const UMFPACK_LICENSE_PART2 = "\n"
-
-# Skipping MacroDefinition: UMFPACK_LICENSE_PART3 \
-#"\n" \
-#"Availability: http://www.suitesparse.com" \
-#"\n"
-
-const UMFPACK_DATE = "Jan 17, 2023"
+const UMFPACK_DATE = "June 16, 2023"
 
 const UMFPACK_MAIN_VERSION = 6
 
 const UMFPACK_SUB_VERSION = 1
 
-const UMFPACK_SUBSUB_VERSION = 0
+const UMFPACK_SUBSUB_VERSION = 1
 
 UMFPACK_VER_CODE(main, sub) = main * 1000 + sub
 
@@ -3169,4 +3849,3 @@ const UMFPACK_Q_Uat = 12
 const UMFPACK_Ut = 13
 
 const UMFPACK_Uat = 14
-
diff --git a/src/solvers/solvers.jl b/src/solvers/solvers.jl
deleted file mode 100644
index 54d061ac..00000000
--- a/src/solvers/solvers.jl
+++ /dev/null
@@ -1,14 +0,0 @@
-# This file is a part of Julia. License is MIT: https://julialang.org/license
-
-module Solvers
-
-include("LibSuiteSparse.jl")
-using .LibSuiteSparse
-
-if Base.USE_GPL_LIBS
-    include("umfpack.jl")
-    include("cholmod.jl")
-    include("spqr.jl")
-end
-
-end # module Solvers
diff --git a/src/solvers/spqr.jl b/src/solvers/spqr.jl
index 023074e9..d1a09f90 100644
--- a/src/solvers/spqr.jl
+++ b/src/solvers/spqr.jl
@@ -6,7 +6,7 @@ import Base: \, *
 using Base: require_one_based_indexing
 using LinearAlgebra
 using LinearAlgebra: AbstractQ, AdjointQ, AdjointAbsVec, copy_similar
-using ..LibSuiteSparse: SuiteSparseQR_C
+using ..LibSuiteSparse: SuiteSparseQR_C, SuiteSparseQR_i_C
 
 # ordering options */
 const ORDERING_FIXED   = Int32(0)
@@ -33,25 +33,26 @@ using ..SparseArrays: getcolptr, FixedSparseCSC, AbstractSparseMatrixCSC, _unsaf
 using ..CHOLMOD
 using ..CHOLMOD: change_stype!, free!
 
-import ..LibSuiteSparse: cholmod_l_free
+import ..LibSuiteSparse: cholmod_l_free, cholmod_free
 
 function _qr!(ordering::Integer, tol::Real, econ::Integer, getCTX::Integer,
-        A::Sparse{Tv},
-        Bsparse::Union{Sparse{Tv}                      , Ptr{Cvoid}} = C_NULL,
+        A::Sparse{Tv, Ti},
+        Bsparse::Union{Sparse{Tv, Ti}                      , Ptr{Cvoid}} = C_NULL,
         Bdense::Union{Dense{Tv}                        , Ptr{Cvoid}} = C_NULL,
         Zsparse::Union{Ref{Ptr{CHOLMOD.cholmod_sparse}}  , Ptr{Cvoid}} = C_NULL,
         Zdense::Union{Ref{Ptr{CHOLMOD.cholmod_dense}}  , Ptr{Cvoid}} = C_NULL,
         R::Union{Ref{Ptr{CHOLMOD.cholmod_sparse}}        , Ptr{Cvoid}} = C_NULL,
-        E::Union{Ref{Ptr{CHOLMOD.SuiteSparse_long}}    , Ptr{Cvoid}} = C_NULL,
+        E::Union{Ref{Ptr{Ti}}    , Ptr{Cvoid}} = C_NULL,
         H::Union{Ref{Ptr{CHOLMOD.cholmod_sparse}}        , Ptr{Cvoid}} = C_NULL,
-        HPinv::Union{Ref{Ptr{CHOLMOD.SuiteSparse_long}}, Ptr{Cvoid}} = C_NULL,
-        HTau::Union{Ref{Ptr{CHOLMOD.cholmod_dense}}    , Ptr{Cvoid}} = C_NULL) where {Tv<:CHOLMOD.VTypes}
+        HPinv::Union{Ref{Ptr{Ti}}, Ptr{Cvoid}} = C_NULL,
+        HTau::Union{Ref{Ptr{CHOLMOD.cholmod_dense}}    , Ptr{Cvoid}} = C_NULL) where {Ti<:CHOLMOD.ITypes, Tv<:CHOLMOD.VTypes}
 
     ordering ∈ ORDERINGS || error("unknown ordering $ordering")
 
+    spqr_call = Ti === Int32 ? SuiteSparseQR_i_C : SuiteSparseQR_C
     AA   = unsafe_load(pointer(A))
     m, n = AA.nrow, AA.ncol
-    rnk  = SuiteSparseQR_C(
+    rnk  = spqr_call(
         ordering,       # all, except 3:given treated as 0:fixed
         tol,            # columns with 2-norm <= tol treated as 0
         econ,           # e = max(min(m,econ),rank(A))
@@ -67,7 +68,7 @@ function _qr!(ordering::Integer, tol::Real, econ::Integer, getCTX::Integer,
         H,              # m-by-nh Householder vectors
         HPinv,          # size m row permutation
         HTau,           # 1-by-nh Householder coefficients
-        CHOLMOD.getcommon()) # /* workspace and parameters */
+        CHOLMOD.getcommon(Ti)) # /* workspace and parameters */
 
     if rnk < 0
         error("Sparse QR factorization failed")
@@ -75,29 +76,33 @@ function _qr!(ordering::Integer, tol::Real, econ::Integer, getCTX::Integer,
 
     e = E[]
     if e == C_NULL
-        _E = Vector{CHOLMOD.SuiteSparse_long}()
+        _E = Vector{Ti}()
     else
-        _E = Vector{CHOLMOD.SuiteSparse_long}(undef, n)
+        _E = Vector{Ti}(undef, n)
         for i in 1:n
             @inbounds _E[i] = unsafe_load(e, i) + 1
         end
         # Free memory allocated by SPQR. This call will make sure that the
         # correct deallocator function is called and that the memory count in
         # the common struct is updated
-        cholmod_l_free(n, sizeof(CHOLMOD.SuiteSparse_long), e, CHOLMOD.getcommon())
+        Ti === Int64 ? 
+            cholmod_l_free(n, sizeof(Ti), e, CHOLMOD.getcommon(Ti)) :
+            cholmod_free(n, sizeof(Ti), e, CHOLMOD.getcommon(Ti))
     end
     hpinv = HPinv[]
     if hpinv == C_NULL
-        _HPinv = Vector{CHOLMOD.SuiteSparse_long}()
+        _HPinv = Vector{Ti}()
     else
-        _HPinv = Vector{CHOLMOD.SuiteSparse_long}(undef, m)
+        _HPinv = Vector{Ti}(undef, m)
         for i in 1:m
             @inbounds _HPinv[i] = unsafe_load(hpinv, i) + 1
         end
         # Free memory allocated by SPQR. This call will make sure that the
         # correct deallocator function is called and that the memory count in
         # the common struct is updated
-        cholmod_l_free(m, sizeof(CHOLMOD.SuiteSparse_long), hpinv, CHOLMOD.getcommon())
+        Ti === Int64 ? 
+            cholmod_l_free(m, sizeof(Ti), hpinv, CHOLMOD.getcommon(Ti)) :
+            cholmod_free(m, sizeof(Ti), hpinv, CHOLMOD.getcommon(Ti))
     end
 
     return rnk, _E, _HPinv
@@ -187,11 +192,11 @@ Column permutation:
 
 [^ACM933]: Foster, L. V., & Davis, T. A. (2013). Algorithm 933: Reliable Calculation of Numerical Rank, Null Space Bases, Pseudoinverse Solutions, and Basic Solutions Using SuitesparseQR. ACM Trans. Math. Softw., 40(1). [doi:10.1145/2513109.2513116](https://doi.org/10.1145/2513109.2513116)
 """
-function LinearAlgebra.qr(A::SparseMatrixCSC{Tv}; tol=_default_tol(A), ordering=ORDERING_DEFAULT) where {Tv <: CHOLMOD.VTypes}
+function LinearAlgebra.qr(A::SparseMatrixCSC{Tv, Ti}; tol=_default_tol(A), ordering=ORDERING_DEFAULT) where {Ti<:CHOLMOD.ITypes, Tv<:CHOLMOD.VTypes}
     R     = Ref{Ptr{CHOLMOD.cholmod_sparse}}()
-    E     = Ref{Ptr{CHOLMOD.SuiteSparse_long}}()
+    E     = Ref{Ptr{Ti}}()
     H     = Ref{Ptr{CHOLMOD.cholmod_sparse}}()
-    HPinv = Ref{Ptr{CHOLMOD.SuiteSparse_long}}()
+    HPinv = Ref{Ptr{Ti}}()
     HTau  = Ref{Ptr{CHOLMOD.cholmod_dense}}(C_NULL)
 
     # SPQR doesn't accept symmetric matrices so we explicitly set the stype
diff --git a/test/cholmod.jl b/test/cholmod.jl
index 6d1f9b70..01254ed9 100644
--- a/test/cholmod.jl
+++ b/test/cholmod.jl
@@ -4,6 +4,7 @@ module CHOLMODTests
 
 using Test
 using SparseArrays.CHOLMOD
+using SparseArrays.CHOLMOD: getcommon
 using Random
 using Serialization
 using LinearAlgebra:
@@ -13,14 +14,16 @@ using LinearAlgebra:
 using SparseArrays
 using SparseArrays: getcolptr
 using SparseArrays.LibSuiteSparse
-using SparseArrays.LibSuiteSparse: SuiteSparse_long
+using SparseArrays.LibSuiteSparse: cholmod_l_allocate_sparse, cholmod_allocate_sparse
 
 if Base.USE_GPL_LIBS
 
 # CHOLMOD tests
+itypes = sizeof(Int) == 4 ? (Int32,) : (Int32, Int64)
+for Ti ∈ itypes
 Random.seed!(123)
 
-@testset "based on deps/SuiteSparse-4.0.2/CHOLMOD/Demo/" begin
+@testset "based on deps/SuiteSparse-4.0.2/CHOLMOD/Demo/ index type $Ti" begin
 
 # chm_rdsp(joinpath(Sys.BINDIR, "../../deps/SuiteSparse-4.0.2/CHOLMOD/Demo/Matrix/bcsstk01.tri"))
 # because the file may not exist in binary distributions and when a system suitesparse library
@@ -53,10 +56,10 @@ Random.seed!(123)
 
     n = 48
     A = CHOLMOD.Sparse(n, n,
-        SuiteSparse_long[0,1,2,3,6,9,12,15,18,20,25,30,34,36,39,43,47,52,58,
+        Ti[0,1,2,3,6,9,12,15,18,20,25,30,34,36,39,43,47,52,58,
         62,67,71,77,84,90,93,95,98,103,106,110,115,119,123,130,136,142,146,150,155,
         161,167,174,182,189,197,207,215,224], # zero-based column pointers
-        SuiteSparse_long[0,1,2,1,2,3,0,2,4,0,1,5,0,4,6,1,3,7,2,8,1,3,7,8,9,
+        Ti[0,1,2,1,2,3,0,2,4,0,1,5,0,4,6,1,3,7,2,8,1,3,7,8,9,
         0,4,6,8,10,5,6,7,11,6,12,7,11,13,8,10,13,14,9,13,14,15,8,10,12,14,16,7,11,
         12,13,16,17,0,12,16,18,1,5,13,15,19,2,4,14,20,3,13,15,19,20,21,2,4,12,16,18,
         20,22,1,5,17,18,19,23,0,5,24,1,25,2,3,26,2,3,25,26,27,4,24,28,0,5,24,29,6,
@@ -147,12 +150,12 @@ Random.seed!(123)
     end
 end
 
-@testset "lp_afiro example" begin
+@testset "lp_afiro example $Ti" begin
     afiro = CHOLMOD.Sparse(27, 51,
-        SuiteSparse_long[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,
+        Ti[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,
         23,25,27,29,33,37,41,45,47,49,51,53,55,57,59,63,65,67,69,71,75,79,83,87,89,
         91,93,95,97,99,101,102],
-        SuiteSparse_long[2,3,6,7,8,9,12,13,16,17,18,19,20,21,22,23,24,25,26,
+        Ti[2,3,6,7,8,9,12,13,16,17,18,19,20,21,22,23,24,25,26,
         0,1,2,23,0,3,0,21,1,25,4,5,6,24,4,5,7,24,4,5,8,24,4,5,9,24,6,20,7,20,8,20,9,
         20,3,4,4,22,5,26,10,11,12,21,10,13,10,23,10,20,11,25,14,15,16,22,14,15,17,
         22,14,15,18,22,14,15,19,22,16,20,17,20,18,20,19,20,13,15,15,24,14,26,15],
@@ -163,7 +166,7 @@ end
         0.109,1.0,-1.0,1.0,-1.0,1.0,-1.0,1.0,1.0,-0.43,1.0,1.0,0.109,-0.43,1.0,1.0,
         0.108,-0.39,1.0,1.0,0.108,-0.37,1.0,1.0,0.107,-1.0,2.191,-1.0,2.219,-1.0,
         2.249,-1.0,2.279,1.4,-1.0,1.0,-1.0,1.0,1.0,1.0], 0)
-    afiro2 = CHOLMOD.aat(afiro, SuiteSparse_long[0:50;], SuiteSparse_long(1))
+    afiro2 = CHOLMOD.aat(afiro, Ti[0:50;], Ti(1))
     CHOLMOD.change_stype!(afiro2, -1)
     chmaf = cholesky(afiro2)
     y = afiro'*fill(1., size(afiro,1))
@@ -173,14 +176,14 @@ end
     @test norm(afiro * (convert(Matrix, y) - convert(Matrix, pred))) < 1e-8
 end
 
-@testset "Issue 9160" begin
+@testset "Issue 9160 $Ti" begin
     local A, B
     A = sprand(10, 10, 0.1)
-    A = convert(SparseMatrixCSC{Float64,SuiteSparse_long}, A)
+    A = convert(SparseMatrixCSC{Float64,Ti}, A)
     cmA = CHOLMOD.Sparse(A)
 
     B = sprand(10, 10, 0.1)
-    B = convert(SparseMatrixCSC{Float64,SuiteSparse_long}, B)
+    B = convert(SparseMatrixCSC{Float64,Ti}, B)
     cmB = CHOLMOD.Sparse(B)
 
     # Ac_mul_B
@@ -201,6 +204,80 @@ end
     @test sparse(cmA*cmA') ≈ A*A'
 end
 
+@testset "Check inputs to Sparse. Related to #20024" for t_ in (
+    (2, 2, [1, 2], Ti[], Float64[]),
+    (2, 2, [1, 2, 3], Ti[1], Float64[]),
+    (2, 2, [1, 2, 3], Ti[], Float64[1.0]),
+    (2, 2, [1, 2, 3], Ti[1], Float64[1.0]))
+    @test_throws ArgumentError SparseMatrixCSC(t_...)
+    @test_throws ArgumentError CHOLMOD.Sparse(t_[1], t_[2], t_[3] .- 1, t_[4] .- 1, t_[5])
+end
+
+## The struct pointer must be constructed by the library constructor and then modified afterwards to checks that the method throws
+@testset "illegal dtype (for now but should be supported at some point)" begin
+    p = Ti == Int64 ? cholmod_l_allocate_sparse(1, 1, 1, true, true, 0, CHOLMOD_REAL, getcommon(Ti)) :
+        cholmod_allocate_sparse(1, 1, 1, true, true, 0, CHOLMOD_REAL, getcommon(Ti))
+    puint = convert(Ptr{UInt32}, p)
+    unsafe_store!(puint, CHOLMOD_SINGLE, 3*div(sizeof(Csize_t), 4) + 5*div(sizeof(Ptr{Cvoid}), 4) + 4)
+    @test_throws CHOLMOD.CHOLMODException CHOLMOD.Sparse(p)
+end
+
+@testset "illegal dtype" begin
+    p = Ti == Int64 ? cholmod_l_allocate_sparse(1, 1, 1, true, true, 0, CHOLMOD_REAL, getcommon(Ti)) :
+        cholmod_allocate_sparse(1, 1, 1, true, true, 0, CHOLMOD_REAL, getcommon(Ti))
+    puint = convert(Ptr{UInt32}, p)
+    unsafe_store!(puint, 5, 3*div(sizeof(Csize_t), 4) + 5*div(sizeof(Ptr{Cvoid}), 4) + 4)
+    @test_throws CHOLMOD.CHOLMODException CHOLMOD.Sparse(p)
+end
+
+@testset "illegal xtype" begin
+    p = Ti == Int64 ? cholmod_l_allocate_sparse(1, 1, 1, true, true, 0, CHOLMOD_REAL, getcommon(Ti)) :
+        cholmod_allocate_sparse(1, 1, 1, true, true, 0, CHOLMOD_REAL, getcommon(Ti))
+    puint = convert(Ptr{UInt32}, p)
+    unsafe_store!(puint, 3, 3*div(sizeof(Csize_t), 4) + 5*div(sizeof(Ptr{Cvoid}), 4) + 3)
+    @test_throws CHOLMOD.CHOLMODException CHOLMOD.Sparse(p)
+end
+
+@testset "illegal itype I" begin
+    p = Ti == Int64 ? cholmod_l_allocate_sparse(1, 1, 1, true, true, 0, CHOLMOD_REAL, getcommon(Ti)) :
+        cholmod_allocate_sparse(1, 1, 1, true, true, 0, CHOLMOD_REAL, getcommon(Ti))
+    puint = convert(Ptr{UInt32}, p)
+    unsafe_store!(puint, CHOLMOD_INTLONG, 3*div(sizeof(Csize_t), 4) + 5*div(sizeof(Ptr{Cvoid}), 4) + 2)
+    @test_throws CHOLMOD.CHOLMODException CHOLMOD.Sparse(p)
+end
+
+@testset "illegal itype II" begin
+    p = Ti == Int64 ? cholmod_l_allocate_sparse(1, 1, 1, true, true, 0, CHOLMOD_REAL, getcommon(Ti)) :
+        cholmod_allocate_sparse(1, 1, 1, true, true, 0, CHOLMOD_REAL, getcommon(Ti))
+    puint = convert(Ptr{UInt32}, p)
+    unsafe_store!(puint,  5, 3*div(sizeof(Csize_t), 4) + 5*div(sizeof(Ptr{Cvoid}), 4) + 2)
+    @test_throws CHOLMOD.CHOLMODException CHOLMOD.Sparse(p)
+end
+@testset "test free! $Ti" begin
+    p = Ti == Int64 ? cholmod_l_allocate_sparse(1, 1, 1, true, true, 0, CHOLMOD_REAL, getcommon(Ti)) :
+        cholmod_allocate_sparse(1, 1, 1, true, true, 0, CHOLMOD_REAL, getcommon(Ti))
+    @test CHOLMOD.free!(p, Ti)
+end
+
+@testset "Check common is still in default state" begin
+    # This test intentionally depends on all the above tests!
+    current_common = CHOLMOD.getcommon(Ti)
+    default_common = Ref(cholmod_common())
+    result = Ti === Int64 ? cholmod_l_start(default_common) : cholmod_start(default_common)
+    @test result == CHOLMOD.TRUE
+    @test current_common[].print == 0
+    for name in (
+        :nmethods,
+        :postorder,
+        :final_ll,
+        :supernodal,
+    )
+        @test getproperty(current_common[], name) == getproperty(default_common[], name)
+    end
+end
+
+end #end for Ti ∈ itypes
+
 @testset "Issue #9915" begin
     sparseI = sparse(1.0I, 2, 2)
     @test sparseI \ sparseI == sparseI
@@ -243,42 +320,6 @@ end
     end
 end
 
-## The struct pointer must be constructed by the library constructor and then modified afterwards to checks that the method throws
-@testset "illegal dtype (for now but should be supported at some point)" begin
-    p = cholmod_l_allocate_sparse(1, 1, 1, true, true, 0, CHOLMOD_REAL, CHOLMOD.getcommon())
-    puint = convert(Ptr{UInt32}, p)
-    unsafe_store!(puint, CHOLMOD_SINGLE, 3*div(sizeof(Csize_t), 4) + 5*div(sizeof(Ptr{Cvoid}), 4) + 4)
-    @test_throws CHOLMOD.CHOLMODException CHOLMOD.Sparse(p)
-end
-
-@testset "illegal dtype" begin
-    p = cholmod_l_allocate_sparse(1, 1, 1, true, true, 0, CHOLMOD_REAL, CHOLMOD.getcommon())
-    puint = convert(Ptr{UInt32}, p)
-    unsafe_store!(puint, 5, 3*div(sizeof(Csize_t), 4) + 5*div(sizeof(Ptr{Cvoid}), 4) + 4)
-    @test_throws CHOLMOD.CHOLMODException CHOLMOD.Sparse(p)
-end
-
-@testset "illegal xtype" begin
-    p = cholmod_l_allocate_sparse(1, 1, 1, true, true, 0, CHOLMOD_REAL, CHOLMOD.getcommon())
-    puint = convert(Ptr{UInt32}, p)
-    unsafe_store!(puint, 3, 3*div(sizeof(Csize_t), 4) + 5*div(sizeof(Ptr{Cvoid}), 4) + 3)
-    @test_throws CHOLMOD.CHOLMODException CHOLMOD.Sparse(p)
-end
-
-@testset "illegal itype I" begin
-    p = cholmod_l_allocate_sparse(1, 1, 1, true, true, 0, CHOLMOD_REAL, CHOLMOD.getcommon())
-    puint = convert(Ptr{UInt32}, p)
-    unsafe_store!(puint, CHOLMOD_INTLONG, 3*div(sizeof(Csize_t), 4) + 5*div(sizeof(Ptr{Cvoid}), 4) + 2)
-    @test_throws CHOLMOD.CHOLMODException CHOLMOD.Sparse(p)
-end
-
-@testset "illegal itype II" begin
-    p = cholmod_l_allocate_sparse(1, 1, 1, true, true, 0, CHOLMOD_REAL, CHOLMOD.getcommon())
-    puint = convert(Ptr{UInt32}, p)
-    unsafe_store!(puint,  5, 3*div(sizeof(Csize_t), 4) + 5*div(sizeof(Ptr{Cvoid}), 4) + 2)
-    @test_throws CHOLMOD.CHOLMODException CHOLMOD.Sparse(p)
-end
-
 # Test Dense wrappers (only Float64 supported a present)
 
 @testset "High level interface" for elty in (Float64, ComplexF64)
@@ -320,12 +361,6 @@ end
     @test isa(copy(CHOLMOD.eye(3)), CHOLMOD.Dense{Float64})
 end
 
-# Test Sparse and Factor
-@testset "test free!" begin
-    p = cholmod_l_allocate_sparse(1, 1, 1, true, true, 0, CHOLMOD_REAL, CHOLMOD.getcommon())
-    @test CHOLMOD.free!(p)
-end
-
 @testset "Core functionality" for elty in (Float64, ComplexF64)
     A1 = sparse([1:5; 1], [1:5; 2], elty == Float64 ? randn(6) : complex.(randn(6), randn(6)))
     A2 = sparse([1:5; 1], [1:5; 2], elty == Float64 ? randn(6) : complex.(randn(6), randn(6)))
@@ -655,10 +690,10 @@ end
 
 @testset "Issue 29367" begin
     if Int != Int32
-        @test_throws MethodError cholesky(sparse(Int32[1,2,3,4], Int32[1,2,3,4], Float64[1,4,16,64]))
-        @test_throws MethodError cholesky(sparse(Int32[1,2,3,4], Int32[1,2,3,4], Float32[1,4,16,64]))
-        @test_throws MethodError ldlt(sparse(Int32[1,2,3,4], Int32[1,2,3,4], Float64[1,4,16,64]))
-        @test_throws MethodError ldlt(sparse(Int32[1,2,3,4], Int32[1,2,3,4], Float32[1,4,16,64]))
+        @test_nowarn cholesky(sparse(Int32[1,2,3,4], Int32[1,2,3,4], Float64[1,4,16,64]))
+        @test_nowarn cholesky(sparse(Int32[1,2,3,4], Int32[1,2,3,4], Float32[1,4,16,64]))
+        @test_nowarn ldlt(sparse(Int32[1,2,3,4], Int32[1,2,3,4], Float64[1,4,16,64]))
+        @test_nowarn ldlt(sparse(Int32[1,2,3,4], Int32[1,2,3,4], Float32[1,4,16,64]))
     end
 end
 
@@ -788,15 +823,6 @@ end
     end
 end
 
-@testset "Check inputs to Sparse. Related to #20024" for t_ in (
-    (2, 2, [1, 2], SuiteSparse_long[], Float64[]),
-    (2, 2, [1, 2, 3], SuiteSparse_long[1], Float64[]),
-    (2, 2, [1, 2, 3], SuiteSparse_long[], Float64[1.0]),
-    (2, 2, [1, 2, 3], SuiteSparse_long[1], Float64[1.0]))
-    @test_throws ArgumentError SparseMatrixCSC(t_...)
-    @test_throws ArgumentError CHOLMOD.Sparse(t_[1], t_[2], t_[3] .- 1, t_[4] .- 1, t_[5])
-end
-
 @testset "sparse right multiplication of Symmetric and Hermitian matrices #21431" begin
     S = sparse(1.0I, 2, 2)
     @test issparse(S*S*S)
@@ -808,7 +834,7 @@ end
 end
 
 @testset "Test sparse low rank update for cholesky decomposition" begin
-    A = SparseMatrixCSC{Float64,SuiteSparse_long}(10, 5, [1,3,6,8,10,13], [6,7,1,2,9,3,5,1,7,6,7,9],
+    A = SparseMatrixCSC{Float64,Int}(10, 5, [1,3,6,8,10,13], [6,7,1,2,9,3,5,1,7,6,7,9],
         [-0.138843, 2.99571, -0.556814, 0.669704, -1.39252, 1.33814,
         1.02371, -0.502384, 1.10686, 0.262229, -1.6935, 0.525239])
     AtA = A'*A
@@ -922,23 +948,6 @@ end
     end
 end
 
-@testset "Check common is still in default state" begin
-    # This test intentionally depends on all the above tests!
-    current_common = CHOLMOD.getcommon()
-    default_common = Ref(cholmod_common())
-    result = cholmod_l_start(default_common)
-    @test result == CHOLMOD.TRUE
-    @test current_common[].print == 0
-    for name in (
-        :nmethods,
-        :postorder,
-        :final_ll,
-        :supernodal,
-    )
-        @test getproperty(current_common[], name) == getproperty(default_common[], name)
-    end
-end
-
 @testset "sym indefinite poly alg" begin
     K = open(joinpath(@__DIR__, "matrices", "stiffness_sym_indef")) do io
         ml = readline(io)
diff --git a/test/spqr.jl b/test/spqr.jl
index 43d692ee..16a72eef 100644
--- a/test/spqr.jl
+++ b/test/spqr.jl
@@ -9,8 +9,8 @@ using LinearAlgebra: I, istriu, norm, qr, rank, rmul!, lmul!, Adjoint, Transpose
 using SparseArrays: SparseArrays, sparse, sprandn, spzeros, SparseMatrixCSC
 using Random: seed!
 
+# TODO REMOVE SECOND PREDICATE WITH SS7.1
 if Base.USE_GPL_LIBS
-
 @testset "Sparse QR" begin
 m, n = 100, 10
 nn = 100
@@ -19,13 +19,15 @@ nn = 100
 
 @test repr("text/plain", qr(sprandn(4, 4, 0.5)).Q) == "4×4 $(SparseArrays.SPQR.QRSparseQ{Float64, Int})"
 
-@testset "element type of A: $eltyA" for eltyA in (Float64, ComplexF64)
+itypes = sizeof(Int) == 4 ? (Int32,) : (Int32, Int64)
+
+@testset "element type of A: $eltyA" for eltyA in (Float64, ComplexF64), iltyA in itypes
     if eltyA <: Real
-        A = sparse([1:n; rand(1:m, nn - n)], [1:n; rand(1:n, nn - n)], randn(nn), m, n)
+        A = sparse(iltyA[1:n; rand(1:m, nn - n)], iltyA[1:n; rand(1:n, nn - n)], randn(nn), m, n)
     else
-        A = sparse([1:n; rand(1:m, nn - n)], [1:n; rand(1:n, nn - n)], complex.(randn(nn), randn(nn)), m, n)
+        A = sparse(iltyA[1:n; rand(1:m, nn - n)], iltyA[1:n; rand(1:n, nn - n)], complex.(randn(nn), randn(nn)), m, n)
     end
-
+    
     F = qr(A)
     @test size(F) == (m,n)
     @test size(F, 1) == m