"keyword","repo_name","file_path","file_extension","file_size","line_count","content","language"
"Conjugate","guochu/VQC.jl","src/densitymatrix.jl",".jl","4224","96","struct DensityMatrix{T <: Number}
	data::Vector{T}
	nqubits::Int

function DensityMatrix{T}(data::AbstractVector{<:Number}, nqubits::Int) where {T <: Number}
	(length(data) == 2^(2*nqubits)) || throw(DimensionMismatch())
	new{T}(convert(Vector{T}, data), nqubits)
end

end

function DensityMatrix{T}(m::AbstractMatrix{<:Number}, nqubits::Int) where {T <: Number}
	(size(m, 1) == size(m, 2) == 2^nqubits) || throw(DimensionMismatch())
	return DensityMatrix{T}(reshape(m, length(m)), nqubits)
end
function DensityMatrix{T}(m::AbstractVector{<:Number}) where {T <: Number}
	n = _nqubits(m)
	return DensityMatrix{T}(m, div(n, 2))
end
DensityMatrix{T}(m::AbstractMatrix{<:Number}) where {T <: Number} = DensityMatrix{T}(reshape(m, length(m)))

DensityMatrix(data::Union{AbstractVector, AbstractMatrix}, nqubits::Int) = DensityMatrix{eltype(data)}(data, nqubits)
DensityMatrix(data::AbstractVector) = DensityMatrix(data, div(_nqubits(data), 2))
DensityMatrix(data::AbstractMatrix) = DensityMatrix(reshape(data, length(data)))
function DensityMatrix{T}(nqubits::Int) where {T<:Number}
	 v = zeros(T, 2^(2*nqubits))
	 v[1,1] = 1
	 return DensityMatrix{T}(v, nqubits)
end
DensityMatrix(::Type{T}, nqubits::Int) where {T<:Number} = DensityMatrix{T}(nqubits)
DensityMatrix(nqubits::Int) = DensityMatrix(ComplexF64, nqubits)
DensityMatrix(x::DensityMatrix) = DensityMatrix(x.data, nqubits(x))
DensityMatrix(x::StateVector) = (x_data = storage(x); DensityMatrix(kron(conj(x_data), x_data), nqubits(x)))


storage(x::DensityMatrix) = (L = 2^(nqubits(x)); reshape(x.data, L, L))
QuantumCircuits.nqubits(x::DensityMatrix) = x.nqubits

Base.eltype(::Type{DensityMatrix{T}}) where T = T
Base.eltype(x::DensityMatrix) = eltype(typeof(x))
Base.getindex(x::DensityMatrix, j::Int...) = getindex(storage(x), j...)
Base.setindex!(x::StateVector, v, j::Int...) = setindex!(storage(x), v, j...)

Base.convert(::Type{DensityMatrix{T}}, x::DensityMatrix) where {T<:Number} = DensityMatrix(convert(Vector{T}, x.data), nqubits(x))
Base.copy(x::DensityMatrix) = DensityMatrix(copy(x.data), nqubits(x))


Base.cat(v::DensityMatrix) = v
function Base.cat(v::DensityMatrix...)
    a, b = _qcat_util(storage.(v)...)
    return DensityMatrix(kron(a, b))
end

Base.isapprox(x::DensityMatrix, y::DensityMatrix; kwargs...) = isapprox(x.data, y.data; kwargs...)
Base.:(==)(x::DensityMatrix, y::DensityMatrix) = x.data == y.data

Base.:+(x::DensityMatrix, y::DensityMatrix) = DensityMatrix(x.data + y.data, nqubits(x))
Base.:-(x::DensityMatrix, y::DensityMatrix) = DensityMatrix(x.data - y.data, nqubits(x))
Base.:*(x::DensityMatrix, y::Number) = DensityMatrix(x.data * y, nqubits(x))
Base.:*(x::Number, y::DensityMatrix) = y * x
Base.:/(x::DensityMatrix, y::Number) = DensityMatrix(x.data / y, nqubits(x))


LinearAlgebra.tr(x::DensityMatrix) = tr(storage(x))
LinearAlgebra.dot(x::DensityMatrix, y::DensityMatrix) = dot(storage(x), storage(y))
LinearAlgebra.normalize!(x::DensityMatrix) = (x.data ./= tr(x); x)
LinearAlgebra.normalize(x::DensityMatrix) = normalize!(copy(x))
LinearAlgebra.ishermitian(x::DensityMatrix) = ishermitian(storage(x))
LinearAlgebra.isposdef(x::DensityMatrix) = isposdef(storage(x))

fidelity(x::DensityMatrix, y::DensityMatrix) = real(tr(sqrt(storage(x)) * sqrt(storage(y))))
fidelity(x::DensityMatrix, y::StateVector) = real(dot(storage(y), storage(x), storage(y)))
fidelity(x::StateVector, y::DensityMatrix) = fidelity(y, x)
distance2(x::DensityMatrix, y::DensityMatrix) = _distance2(x, y)
distance(x::DensityMatrix, y::DensityMatrix) = _distance(x, y)
schmidt_numbers(x::DensityMatrix) = eigvals(Hermitian(storage(x)))
renyi_entropy(x::DensityMatrix; kwargs...) = renyi_entropy(schmidt_numbers(x); kwargs...)

function rand_densitymatrix(::Type{T}, n::Int) where {T <: Number}
    (n >= 1) || error(""number of qubits must be positive."")
    L = 2^n
    v = randn(T, L, L)
    v = v' * v
    return normalize!(DensityMatrix(v' * v, n))
end
rand_densitymatrix(n::Int) = rand_densitymatrix(ComplexF64, n)

function QuantumCircuits.permute(x::DensityMatrix, newindex::Vector{Int})
	n = nqubits(x)
	L = length(x.data)
	return DensityMatrix(reshape(permute(reshape(x.data, ntuple(i->2, 2*n)), vcat(newindex, newindex .+ n)), L), n)
end 



","Julia"
"Conjugate","guochu/VQC.jl","src/measure.jl",".jl","2569","90","""""""
	apply!(x::QMeasure, qstate)
""""""
function apply!(x::QMeasure, qstate::Union{StateVector, DensityMatrix})
	x.keep || error(""only keep mode is implemented."")
	probability, istate = _local_measure(storage(qstate), x.position)
	op = I₂
	if x.auto_reset
		m = kron(op[:, istate], QuantumCircuits.Gates.ZERO)/sqrt(probability)
	else
		m = kron(op[:, istate], op[:, istate])/sqrt(probability)
	end
	m = reshape(m, (2, 2))
	apply!(gate(x.position, m), qstate)
	return istate-1, probability
end


""""""
	measure!(qstate::StateVector, pos::Int; auto_reset::Bool=true)
Measure the i-th qubit of the quantum state, and return a 2-tuple including the measurement outcome, \n 
and the probability with which we get the outcome. The quantum state is updated inplace. \n 
If auto_reset=true,the measured qubit is reset to 0, otherwise it will be the same as the measurement outcome.
""""""
measure!(qstate::Union{StateVector, DensityMatrix}, pos::Int; auto_reset::Bool=true) = apply!(QMeasure(pos, auto_reset=auto_reset), qstate)


function apply(s::QMeasure, qstater::StateVector)
	qstate = storage(qstater)
	swap!(qstate, 1, s.position)
	probability, istate = _local_measure(qstate, 1)
	# println(""with probability $probability to get $(istate-1)"")
	ss = div(length(qstate), 2)
	r = (transpose(I₂[:, istate])*reshape(qstate, (2, ss)))/sqrt(probability) 
	swap!(qstate, 1, s.position)
	return StateVector(reshape(r, length(r)), nqubits(qstater)-1), istate-1, probability	
end

""""""
	measure(qstate::StateVector, i::Int)
Measure the i-th qubit of the quantum state, and return a 3-tuple including the collapsed quantum state, \n 
the measurement outcome, and the probability with which we get the outcome.
""""""
measure(qstate::StateVector, pos::Int) = apply(QMeasure(pos), qstate)

function compute_probability_zero(v::AbstractVector, key::Int)
	L = length(v)
	pos = 2^(key-1)
	stri = pos * 2
	r = 0.
	for i in 0:stri:(L-1)
		@inbounds for j in 0:(pos-1)
			l = i + j + 1
			r += abs2(v[l])
		end
	end
	return r
end


function _local_measure(v::AbstractVector, key::Int)
	p0 = compute_probability_zero(v, key)
	l = [p0, 1-p0]
	i = discrete_sample(l)
	return l[i], i
end

# for density matrix
function compute_probability_zero(v::AbstractMatrix, key::Int)
	L = size(v, 1)
	pos = 2^(key-1)
	stri = pos * 2
	r = 0.
	for i in 0:stri:(L-1)
		@inbounds for j in 0:(pos-1)
			l = i + j + 1
			r += real(v[l, l])
		end
	end
	return r
end


function _local_measure(v::AbstractMatrix, key::Int)
	p0 = compute_probability_zero(v, key)
	l = [p0, 1-p0]
	i = discrete_sample(l)
	return l[i], i
end
","Julia"
"Conjugate","guochu/VQC.jl","src/postselect.jl",".jl","2515","72","

function apply!(x::QSelect, qstate::StateVector)
	x.state == 0 ? apply!(gate(x.position, QuantumCircuits.Gates.UP), qstate) : apply!(gate(x.position, QuantumCircuits.Gates.DOWN), qstate)
	s = norm(qstate)
	qstate.data ./= s
	return s
end

function apply(x::QSelect, qstate::StateVector; keep::Bool=false)
	r = _apply_impl(x, qstate, keep=keep)
	ns = cnorm(storage(r))
	return r / ns, real(ns)
end

""""""
	post_select!(qstate::StateVector, key::Int, state::Int=0)
Post-select the i-th qubit of the quantum state, and the quantum state is updated inplace, the probability is returned.
""""""
post_select!(qstate::StateVector, key::Int, state::Int=0) = apply!(QSelect(key, state), qstate)

""""""
	post_select(qstate::StateVector, key::Int, state::Int=0; keep::Bool=false)
Return the collapsed quantum state as well as the probability.
""""""
post_select(qstate::StateVector, key::Int, state::Int=0; keep::Bool=false) = apply(QSelect(key, state), qstate, keep=keep)





function _apply_throw_impl(x::QSelect, qstate::StateVector)
	swap!(storage(qstate), 1, x.position)
	ss = div(length(storage(qstate)), 2)
	tmp = reshape(storage(qstate), (2, ss))
	r = x.state==0 ? QuantumCircuits.Gates.ZERO'*tmp : QuantumCircuits.Gates.ONE'*tmp
	swap!(storage(qstate), 1, x.position)
	return StateVector(reshape(r, length(r)), nqubits(qstate)-1)
end

function _apply_keep_impl(x::QSelect, qstate::StateVector)
	tmp = copy(qstate)
	x.state == 0 ? apply!(gate(x.position, QuantumCircuits.Gates.UP), tmp) : apply!(gate(x.position, QuantumCircuits.Gates.DOWN), tmp)
	return StateVector(tmp, nqubits(qstate)-1)
end

function _apply_impl(x::QSelect, qstate::StateVector; keep::Bool=false)
	return keep ? _apply_keep_impl(x, qstate) : _apply_throw_impl(x, qstate)
end

cnorm(x::AbstractVector) = sqrt(dot(x, x))



@adjoint QSelect(key::Int, state::Int) = QSelect(key, state), z -> (nothing, nothing)

@adjoint _apply_throw_impl(x::QSelect, qstate::StateVector) = _apply_throw_impl(x, qstate), z -> begin
    if x.state == 0
        m = StateVector(kron(storage(z), ZERO))
    else
    	m = StateVector(kron(storage(z), ONE))
    end
    swap!(storage(m), 1, x.position)
    return (nothing, m)
end

@adjoint _apply_keep_impl(x::QSelect, qstate::StateVector) = _apply_keep_impl(x, qstate), z -> (nothing, _apply_keep_impl(x, StateVector(z, nqubits(qstate))) )

@adjoint _apply_impl(x::QSelect, qstate::StateVector; keep::Bool) = begin
	return keep ? Zygote.pullback(_apply_keep_impl, x, qstate) : Zygote.pullback(_apply_throw_impl, x, qstate)
end
","Julia"
"Conjugate","guochu/VQC.jl","src/statevector.jl",".jl","7557","229","struct StateVector{T <: Number} 
    data::Vector{T}
    nqubits::Int

function StateVector{T}(data::AbstractVector{<:Number}, nqubits::Int) where {T <: Number}
    @assert length(data) == 2^nqubits
    new{T}(convert(Vector{T}, data), nqubits)
end

end

StateVector(data::AbstractVector{T}, nqubits::Int) where {T <: Number} = StateVector{T}(data, nqubits)
StateVector{T}(data::AbstractVector{<:Number}) where T = StateVector{T}(data, _nqubits(data))
StateVector(data::AbstractVector{T}) where {T <: Number} = StateVector{T}(data)
function StateVector{T}(nqubits::Int) where {T<:Number} 
    v = zeros(T, 2^nqubits)
    v[1] = 1
    return StateVector{T}(v, nqubits)
end
StateVector(::Type{T}, nqubits::Int) where {T<:Number} = StateVector{T}(nqubits)
StateVector(nqubits::Int) = StateVector(ComplexF64, nqubits)
StateVector(x::StateVector) = StateVector(x.data, nqubits(x))

storage(x::StateVector) = x.data
QuantumCircuits.nqubits(x::StateVector) = x.nqubits

Base.eltype(::Type{StateVector{T}}) where T = T
Base.eltype(x::StateVector) = eltype(typeof(x))
Base.getindex(x::StateVector, j::Int) = getindex(storage(x), j)
Base.setindex!(x::StateVector, v, j::Int) = setindex!(storage(x), v, j)

Base.convert(::Type{StateVector{T}}, x::StateVector) where {T<:Number} = StateVector(convert(Vector{T}, storage(x)), nqubits(x))
Base.copy(x::StateVector) = StateVector(copy(storage(x)), nqubits(x))

Base.cat(v::StateVector) = v
function Base.cat(v::StateVector...)
    a, b = _qcat_util(storage.(v)...)
    return StateVector(kron(a, b))
end

Base.isapprox(x::StateVector, y::StateVector; kwargs...) = isapprox(storage(x), storage(y); kwargs...)
Base.:(==)(x::StateVector, y::StateVector) = storage(x) == storage(y)


Base.:+(x::StateVector, y::StateVector) = StateVector(storage(x) + storage(y), nqubits(x))
Base.:-(x::StateVector, y::StateVector) = StateVector(storage(x) - storage(y), nqubits(x))
Base.:*(x::StateVector, y::Number) = StateVector(storage(x) * y, nqubits(x))
Base.:*(x::Number, y::StateVector) = y * x
Base.:/(x::StateVector, y::Number) = StateVector(storage(x) / y, nqubits(x))
Base.:*(m::AbstractMatrix, x::StateVector) = StateVector( m * storage(x), nqubits(x) )


LinearAlgebra.norm(x::StateVector) = norm(storage(x))
LinearAlgebra.dot(x::StateVector, y::StateVector) = dot(storage(x), storage(y))
LinearAlgebra.dot(x::StateVector, m::AbstractVector, y::StateVector) = dot(storage(x), m, storage(y))
LinearAlgebra.normalize!(x::StateVector) = (normalize!(storage(x)); x)
LinearAlgebra.normalize(x::StateVector) = StateVector(normalize(storage(x)), nqubits(x))

""""""
    fidelity(x, y) 
    tr(√x * √y) if x and y are density matrices
    ⟨x|y⟩^2 if x and y are pure states
""""""
fidelity(x::StateVector, y::StateVector) = abs2(dot(x, y))
distance2(x::StateVector, y::StateVector) = _distance2(x, y)
distance(x::StateVector, y::StateVector) = _distance(x, y)


# encoding
onehot_encoding(::Type{T}, n::Int) where {T <: Number} = StateVector(onehot(T, 2^n, 1), n)
onehot_encoding(n::Int) = onehot_encoding(ComplexF64, n)
onehot_encoding(::Type{T}, i::AbstractVector{Int}) where {T <: Number} = StateVector(onehot(T, 2^(length(i)), _sub2ind(i)+1), length(i))
onehot_encoding(i::AbstractVector{Int})= onehot_encoding(ComplexF64, i)

function onehot(::Type{T}, L::Int, pos::Int) where T
    r = zeros(T, L)
    r[pos] = one(T)
    return r
end


""""""
    kernal_mapping(s::Real) = [cos(s*pi/2), sin(s*pi/2)]
    This maps 0 -> [1, 0] (|0>), and 1 -> [0, 1] (|1>)
""""""
kernal_mapping(s::Real) = [cos(s*pi/2), sin(s*pi/2)]


""""""
    qstate(::Type{T}, thetas::AbstractVector{<:Real}) where {T <: Number}
Return a product quantum state of [[cos(pi*theta/2), sin(pi*theta/2)]] for theta in thetas]\n
Example: qstate(Complex{Float64}, [0.5, 0.7])
""""""
function qubit_encoding(::Type{T}, i::AbstractVector{<:Real}) where {T <: Number}
    isempty(i) && throw(""empty input."")
    v = [convert(Vector{T}, item) for item in kernal_mapping.(i)]
    (length(v) == 1) && return StateVector{T}(v[1])
    a, b = _qcat_util(v...)
    return StateVector(kron(a, b))
end  
qubit_encoding(mpsstr::AbstractVector{<:Real}) = qubit_encoding(ComplexF64, mpsstr)

function amplitude_encoding(::Type{T}, v::AbstractVector{<:Number}; nqubits::Int=ceil(Int, log2(length(v)))) where {T<:Number}
    vn = norm(v)
    (vn ≈ 1.) || println(""input vector is not normalized, it will be renormalized as a quantum state."")
    vv = zeros(T, 2^nqubits)
    for i in 1:length(v)
        vv[i] = v[i] / vn
    end
    return StateVector(vv, nqubits)
end
amplitude_encoding(v::AbstractVector; kwargs...) = amplitude_encoding(ComplexF64, v; kwargs...)

function reset!(x::StateVector)
    fill!(storage(x), zero(eltype(x)))
    x[1] = one(eltype(x))
    return x
end
function reset_onehot!(x::StateVector, i::AbstractVector{Int})
    @assert nqubits(x) == length(i)
    pos = _sub2ind(i) + 1
    fill!(storage(x), zero(eltype(x)))
    x[pos] = one(eltype(x))
    return x
end

function reset_qubit!(x::StateVector, i::AbstractVector{<:Real})
    @assert nqubits(x) == length(i)
    if length(i) == 1
        copyto!(storage(x), kernal_mapping(i[1]))
        return x
    end
    a, b = _qcat_util(kernal_mapping.(i)...)
    m = length(a)
    n = length(b)
    xs = storage(x)
    for j in 1:m
        n_start = (j-1) * n + 1
        n_end = j * n
        tmp = a[j]
        @. xs[n_start:n_end] = tmp * b
    end
    return x
end

function amplitude(s::StateVector, i::AbstractVector{Int}; scaling::Real=sqrt(2))
    @assert length(i)==nqubits(s)
    idx = _sub2ind(i)
    return scaling==1 ? s[idx] : s[idx] * scaling^(nqubits(s))
end
amplitudes(s::StateVector) = storage(s)

function rand_state(::Type{T}, n::Int) where {T <: Number}
    (n >= 1) || error(""number of qubits must be positive."")
    v = randn(T, 2^n)
    v ./= norm(v)
    return StateVector(v, n)
end
rand_state(n::Int) = rand_state(ComplexF64, n)

function QuantumCircuits.permute(x::StateVector, newindex::Vector{Int})
    n = nqubits(x)
    L = length(storage(x))
    return StateVector(reshape(permute(reshape(storage(x), ntuple(i->2,n)), newindex), L), n)
end


function _sub2ind(v::AbstractVector{Int})
    @assert _is_valid_indices(v)
    isempty(v) && error(""input index is empty."")
    L = length(v)
    r = v[1]
    for i in 2:L
        r |= v[i] << (i-1)
    end
    return r
end

function _qcat_util(vr::Union{AbstractVector, AbstractMatrix}...)
    v = reverse(vr)
    L = length(v)
    # println(""$(typeof(v)), $L"")
    (L >= 2) || error(""something wrong."")
    Lh = div(L, 2)
    a = v[1]
    for i in 2:Lh
        a = kron(a, v[i])
    end
    b = v[Lh + 1]
    for i in Lh+2 : L
        b = kron(b, v[i])
    end
    return a, b
end

function _is_valid_indices(i::AbstractVector{Int})
    for s in i
        (s == 0 || s == 1) || return false 
    end   
    return true
end

_nqubits(s::AbstractVector) = begin
    n = round(Int, log2(length(s)))
    (2^n == length(s)) || error(""state can not be interpretted as a qubit state."")
    return n
end



# function reset!(x::AbstractVector, i::AbstractVector{<:AbstractFloat})
#     (nqubits(x) == length(i)) || error(""input basis mismatch with number of qubits."")
#     mpsstr = kernal_mapping.(i)
#     for (pos, item) in enumerate(Iterators.product(mpsstr...))
#         x[pos] = prod(item)
#     end
#     return x
# end


# function qrandn(::Type{T}, n::Int) where {T <: Number}
# 	(n >= 1) || error(""number of qubits must be positive."")
# 	v = randn(T, 2^n)
# 	v ./= norm(v)
# 	return v
# end

# qrandn(n::Int) = qrandn(Complex{Float64}, n)
","Julia"
"Conjugate","guochu/VQC.jl","src/VQC.jl",".jl","1750","86","module VQC


using Zygote
using Zygote: @adjoint


using LinearAlgebra, StaticArrays, QuantumCircuits, QuantumCircuits.Gates
using QuantumCircuits: permute
import LinearAlgebra, QuantumCircuits

# using KrylovKit: exponentiate
# using SparseArrays: spzeros, sparse, SparseMatrixCSC
# using Logging: @warn




# statevector
export StateVector, DensityMatrix, distance, distance2, onehot_encoding, qubit_encoding, amplitude_encoding, reset!, amplitude, amplitudes
export tr, dot, norm, normalize!, normalize, ishermitian
export reset_qubit!, reset_onehot!, storage, fidelity, rand_state, rand_densitymatrix, permute
export schmidt_numbers, renyi_entropy

# gate operations
export apply!

# measurement
export measure, measure!


# hamiltonian
export expectation

# AD for post selection may be removed in the future
export post_select, post_select!

# partial trace
export partial_tr

# utility functions



# auxiliary
include(""auxiliary/distance.jl"")
include(""auxiliary/parallel_for.jl"")
include(""auxiliary/sampling.jl"")
include(""auxiliary/tensorops.jl"")
include(""auxiliary/indexop.jl"")

# definitions of pure quantum gate
include(""statevector.jl"")

# density matrix representation 
include(""densitymatrix.jl"")

# quantum gate operations
include(""applygates/applygates.jl"")


# measurement and postselection
include(""measure.jl"")
include(""postselect.jl"")

# hamiltonian expectation
include(""hamiltonian/util.jl"")
include(""hamiltonian/apply_qterms/apply_qterms.jl"")
include(""hamiltonian/expecs/expecs.jl"")
include(""hamiltonian/expecs_dm/expecs_dm.jl"")


# differentiation
include(""circuitdiff.jl"")
include(""expecdiff.jl"")
include(""additional_adjoints.jl"")

# partial trace
include(""ptrace.jl"")

# utility functions
include(""utility/utility.jl"")


end
","Julia"
"Conjugate","guochu/VQC.jl","src/expecdiff.jl",".jl","2366","71","# gradient of expectation values


function _qterm_expec_util(m::QubitsTerm, state::StateVector)
	if length(positions(m)) <= LARGEST_SUPPORTED_NTERMS
	    return expectation(m, state), z -> (nothing, (conj(z) * m + z * m') * state ) 
	else
		v = m * state
		return dot(state, v), z -> begin
		   m1 = conj(z) * m
		   m2 = z * m'
		   _apply_qterm_util!(m1, storage(state), storage(v))
		   v2 = storage( m2 * state )
		   v2 .+= storage(v)
		   return (nothing, StateVector(v2, nqubits(state)))
		end
	end
end

# this could be slow
# _qterm_expec_util(m::QubitsTerm, state::DensityMatrix) = expectation(m, state), z -> (
# 	nothing,  storage((conj(z) * m + z * m') *  DensityMatrix(one(storage(state)), nqubits(state)))  )

_qterm_expec_util(m::QubitsTerm, state::DensityMatrix) = expectation(m, state), z -> (
			nothing,  (z * m') *  DensityMatrix(one(storage(state)), nqubits(state)))  


@adjoint expectation(m::QubitsTerm, state::Union{StateVector, DensityMatrix}) = _qterm_expec_util(m, state)

function _qop_expec_util(m::QubitsOperator, state_in::StateVector)
	if _largest_nterm(m) <= LARGEST_SUPPORTED_NTERMS
		return expectation(m, state_in), z -> (nothing, (conj(z) * m + z * m') * state_in ) 
	else
		state = storage(state_in)
		workspace = similar(state)
		state_2 = zeros(eltype(state), length(state))
		for (k, v) in m.data
		    for item in v
		    	_apply_qterm_util!(QubitsTerm(k, item[1], item[2]), state, workspace)
		    	state_2 .+= workspace
		    end
		end
		r = dot(state, state_2)
		return r, z -> begin
			if ishermitian(m)
			    state_2 .*= (conj(z) + z)
			else
				state_2 .*= conj(z)
				md = m'
				for (k, v) in md.data
					for item in v
						_apply_qterm_util!(QubitsTerm(k, item[1], item[2]), state, workspace)
						@. state_2 += z * workspace
		    		end
		    	end
			end
		    return (nothing, StateVector(state_2, nqubits(state_in)))
		end
	end	
end
# _qop_expec_util(m::QubitsOperator, state::DensityMatrix) = expectation(m, state), z -> (
# 	nothing, storage( (conj(z) * m + z * m') * DensityMatrix(one(storage(state)), nqubits(state)) ) )

_qop_expec_util(m::QubitsOperator, state::DensityMatrix) = expectation(m, state), z -> (
	nothing,  (z * m') * DensityMatrix(one(storage(state)), nqubits(state)) ) 


@adjoint expectation(m::QubitsOperator, state::Union{StateVector, DensityMatrix}) = _qop_expec_util(m, state)


","Julia"
"Conjugate","guochu/VQC.jl","src/additional_adjoints.jl",".jl","968","21","

@adjoint storage(x::Union{StateVector, DensityMatrix}) = storage(x), z -> (typeof(x)(z),)
@adjoint nqubits(x::Union{StateVector, DensityMatrix}) = nqubits(x), z -> (nothing,)
@adjoint StateVector(data::AbstractVector{<:Number}, n::Int) = StateVector(data, n), z -> (storage(z), nothing)
@adjoint StateVector(data::AbstractVector{<:Number}) = StateVector(data), z -> (storage(z),)
@adjoint DensityMatrix(data::AbstractMatrix{<:Number}, n::Int) = DensityMatrix(data, n), z -> (storage(z), nothing)
@adjoint DensityMatrix(data::AbstractMatrix{<:Number}) = DensityMatrix(data), z -> (storage(z),)

# @adjoint dot(x::StateVector, y::StateVector) = begin
# 	v, back = Zygote.pullback(dot, storage(x), storage(y))
# 	return v, z -> begin
# 		a, b = back(z)
# 		return StateVector(a, nqubits(x)), StateVector(b, nqubits(y))
# 	end
# end

# # this is stupid, why should I need it
# @adjoint dot(x::StateVector, y::StateVector) = Zygote.pullback(dot, storage(x), storage(y))

","Julia"
"Conjugate","guochu/VQC.jl","src/ptrace.jl",".jl","1669","55","# partial trace


function partial_tr(state::DensityMatrix, sites::Vector{Int})
	isempty(sites) && return state
	# some checks
	check_partial_tr_inputs(sites, nqubits(state))
	(length(sites) == nqubits(state)) && return tr(state)
	return DensityMatrix(_partial_tr_impl(storage(state), sites, nqubits(state)), nqubits(state) - length(sites) )
end


function partial_tr(state::StateVector, sites::Vector{Int})
	isempty(sites) && return DensityMatrix(state)
	n = nqubits(state)
	check_partial_tr_inputs(sites, n)
	(length(sites) == n) && return dot(state, state)

	axis = move_selected_index_backward(collect(1:n), sites)
	vt = permute(reshape(storage(state), ntuple(i->2, n)), axis)
	vt_shape = size(vt)
	s1 = prod(vt_shape[1:(n-length(sites))])
	s2 = prod(vt_shape[(n-length(sites)+1):end])
	vt = reshape(vt, s1, s2)
	# vt = vt * vt'
	return DensityMatrix(vt * vt', n - length(sites) )
end


function check_partial_tr_inputs(sites::Vector{Int}, n::Int)
	tmp = Set(sites)
	(length(sites) == length(tmp)) || throw(ArgumentError(""duplicate sites not allowed.""))
	for item in tmp
	    (item>=1 && item<=n) || throw(ArgumentError(""site out of range.""))
	end	
end

function _partial_tr_impl(v::AbstractMatrix, sites::Vector{Int}, n::Int)
	axis = move_selected_index_backward(collect(1:n), sites)
	# rdim = reverse(dim)
	vt = reshape(v, ntuple(i->2, 2*n))
	axis2 = axis .+ n
	vt = permute(vt, [axis..., axis2...])
	vt_shape = size(vt)[1:n]
	s1 = prod(vt_shape[1:(n-length(sites))])
	s2 = prod(vt_shape[(n-length(sites)+1):end])
	vt = permute(reshape(vt, s1,s2,s1,s2), (1,3,2,4))
	r = zeros(eltype(vt), s1, s1)
	for i in 1:s2
	    r .+= view(vt, :, :, i, i)
	end
	return r
end

","Julia"
"Conjugate","guochu/VQC.jl","src/circuitdiff.jl",".jl","2837","91","
@adjoint *(circuit::QCircuit, x::Union{StateVector, DensityMatrix}) = begin
    y = circuit * x
    return y, Δ -> begin
        Δ, grads, y = back_propagate(copy(Δ), circuit, copy(y))
        return grads, Δ
    end
end

@adjoint qubit_encoding(::Type{T}, mpsstr::Vector{<:Real}) where {T<:Number} = begin
    y = qubit_encoding(T, mpsstr)
    return y, Δ -> begin
        circuit = QCircuit([RyGate(i, theta*pi, isparas=true) for (i, theta) in enumerate(mpsstr)])
        Δ, grads, y = back_propagate(Δ, circuit, copy(y))
        return nothing, grads .* pi
    end
end

# @adjoint amplitude_encoding(::Type{T}, v::AbstractVector{<:Number}; kwargs...) where {T <: Number} = amplitude_encoding(
#     T, v; kwargs...), z -> (nothing, z[1:length(v)])


function back_propagate(Δ::StateVector, m::Gate, y::StateVector)
    Δ = apply!(m', Δ)
    y = apply!(m', y)
    ∇θs = nothing
    if nparameters(m) > 0
        ∇θs = [real(expectation(y, item, Δ)) for item in differentiate(m)]
    end
    return Δ, ∇θs, y
end

# a temporary solution, which requires an additional copy of the density matrix
# we can not assume x or y to be positive or hermitian here, since they may not be physical density matrix
function expectation(x::DensityMatrix, m::Gate, y::DensityMatrix)
    yc = copy(y)
    apply_threaded!(m, yc.data)
    return dot(storage(x)', storage(yc))
end 

function back_propagate(Δ::DensityMatrix, m::Gate, y::DensityMatrix)
    Δ = apply!(m', Δ)
    y = apply!(m', y)
    ∇θs = nothing
    if nparameters(m) > 0
        ∇θs = [real(expectation(y, item, Δ) + expectation(Δ, item', y)) for item in differentiate(m)]
    end
    return Δ, ∇θs, y
end

function back_propagate(Δ::DensityMatrix, m::QuantumMap, y::DensityMatrix)
    Δ = apply_dagger!(m, Δ)
    y = apply_inverse!(m, y)
    ∇θs = nothing
    return Δ, ∇θs, y
end

function back_propagate_util(Δ, circuit::QCircuit, y)
    RT = real(eltype(y))
    grads = Vector{RT}[]
    for item in reverse(circuit)
        Δ, ∇θs, y = back_propagate(Δ, item, y)
        !isnothing(∇θs) && push!(grads, ∇θs)
    end

    ∇θs_all = RT[]
    for item in Iterators.reverse(grads)
        append!(∇θs_all, item)
    end

    return Δ, ∇θs_all, y
end

back_propagate(Δ::StateVector, circuit::QCircuit, y::StateVector) = back_propagate_util(Δ, circuit, y)
back_propagate(Δ::DensityMatrix, circuit::QCircuit, y::DensityMatrix) = back_propagate_util(Δ, circuit, y)
 
 


# function back_propagate(Δ::AbstractMatrix, m::Gate, y::DensityMatrix)
#     Δ = StateVector(Δ, nqubits(y))
#     Δ = apply!(m', Δ)
#     y = apply!(m', y)
#     ∇θs = nothing
#     if nparameters(m) > 0
#         ∇θs = [real(expectation(y, item, Δ)) for item in differentiate(m)]
#     end
#     return storage(Δ), ∇θs, y
# end

","Julia"
"Conjugate","guochu/VQC.jl","src/utility/groundstate.jl",".jl","1071","25","using KrylovKit: eigsolve, exponentiate


function ground_state(h::QubitsOperator; kwargs...)
	ishermitian(h) || throw(ArgumentError(""input operator is not hermitian.""))
	n = QuantumCircuits.get_largest_pos(h)
	T = eltype(h)
	init_state = rand_state(T, n)

	eigvalues, eigvectors, info = eigsolve(x -> storage(h(StateVector(x, n))), storage(init_state), 1, :SR; ishermitian=true, kwargs...)
	(info.converged>=1) || error(""eigsolve fails to converge."")
	return eigvalues[1], StateVector(eigvectors[1], n)
end


function time_evolution(h::QubitsOperator, t::Number, v::StateVector; kwargs...)
	ishermitian(h) || throw(ArgumentError(""input operator is not hermitian.""))
	(QuantumCircuits.get_largest_pos(h) <= nqubits(v)) || throw(ArgumentError(""number of qubits mismatch.""))
	n = nqubits(v)
	T = promote_type(eltype(h), typeof(t), eltype(v) )
	v = convert(StateVector{T}, v)
	tmp, info = exponentiate(x -> storage(h(StateVector(x, n))), t, storage(v); ishermitian=true, kwargs...)
	(info.converged>=1) || error(""eigsolve fails to converge."")
	return StateVector(tmp, n)
end","Julia"
"Conjugate","guochu/VQC.jl","src/utility/variationalcircuit.jl",".jl","4239","149","""""""
	variational_circuit_1d(L::Int, depth::Int; θs::Vector{<:Real})
Return a variational quantum circuit given L qubis and d depth
""""""
function variational_circuit_1d(L::Int, depth::Int; θs::Vector{<:Real}=rand(_nparas(ComplexF64, L, depth)) .* 2π)
	paras = θs
	(length(paras) == _nparas(ComplexF64, L, depth)) || throw(""wrong number of parameters."")
	circuit = QCircuit()
	ncount = 1
	for i in 1:L
		push!(circuit, RzGate(i, paras[ncount], isparas=true))
		ncount += 1
		push!(circuit, RyGate(i, paras[ncount], isparas=true))
		ncount += 1
		push!(circuit, RzGate(i, paras[ncount], isparas=true))
		ncount += 1
	end		
	for i in 1:depth
		if isodd(i)
			for j in 1:(L-1)
		    	push!(circuit, CNOTGate(j, j+1))
			end
		else
			for j in (L-1):-1:1
		    	push!(circuit, CNOTGate(j, j+1))
			end			
		end
		for j in 1:L
			push!(circuit, RzGate(j, paras[ncount], isparas=true))
			ncount += 1
			push!(circuit, RyGate(j, paras[ncount], isparas=true))
			ncount += 1
			push!(circuit, RzGate(j, paras[ncount], isparas=true))
			ncount += 1
		end
	end
	@assert ncount == length(paras)+1
	return circuit	
end

function real_variational_circuit_1d(L::Int, depth::Int; θs::Vector{<:Real}=rand(_nparas(Float64, L, depth)) .* 2π)
	paras = θs
	(length(paras) == _nparas(Float64, L, depth)) || throw(""wrong number of parameters."")
	circuit = QCircuit()
	ncount = 1
	for i in 1:L
		push!(circuit, RyGate(i, paras[ncount], isparas=true))
		ncount += 1
	end		
	for i in 1:depth
		if isodd(i)
			for j in 1:(L-1)
		    	push!(circuit, CNOTGate(j, j+1))
			end
		else
			for j in (L-1):-1:1
		    	push!(circuit, CNOTGate(j, j+1))
			end			
		end
		for j in 1:L
			push!(circuit, RyGate(j, paras[ncount], isparas=true))
			ncount += 1
		end
	end
	@assert ncount == length(paras)+1
	return circuit	
end


# function variational_circuit_2d(m::Int, n::Int, depth::Int; θs::Vector{<:Real}=rand(_nparas(ComplexF64, m*n, depth)) .* 2π)
# 	paras = θs
# 	L = m*n
# 	(length(paras) == _nparas(ComplexF64, L, depth)) || throw(""wrong number of parameters."")
# 	circuit = QCircuit()
# 	ncount = 1
# 	for i in 1:L
# 		push!(circuit, RzGate(i, paras[ncount], isparas=true))
# 		ncount += 1
# 		push!(circuit, RyGate(i, paras[ncount], isparas=true))
# 		ncount += 1
# 		push!(circuit, RzGate(i, paras[ncount], isparas=true))
# 		ncount += 1
# 	end	

# 	index = LinearIndices((m, n))
# 	for l in 1:depth
# 		for i in 1:m
# 		    for j in 1:(n-1)
# 		        push!(circuit, CNOTGate(index[i, j], index[i, j+1]))
# 		    end
# 		end
# 		for i in 1:(m-1)
# 		    for j in 1:n
# 		        push!(circuit, CNOTGate(index[i, j], index[i+1, j]))
# 		    end
# 		end
# 		for i in 1:L
# 			push!(circuit, RzGate(i, paras[ncount], isparas=true))
# 			ncount += 1
# 			push!(circuit, RyGate(i, paras[ncount], isparas=true))
# 			ncount += 1
# 			push!(circuit, RzGate(i, paras[ncount], isparas=true))
# 			ncount += 1
# 		end	
# 	end
# 	@assert ncount == length(paras)+1
# 	return circuit
# end
# variational_circuit_2d(shapes::Tuple{Int, Int}, args...; kwargs...) = variational_circuit_2d(shapes[1], shapes[2], args...; kwargs...)

# function real_variational_circuit_2d(m::Int, n::Int, depth::Int; θs::Vector{<:Real}=rand(_nparas(Float64, m*n, depth)) .* 2π)
# 	paras = θs
# 	L = m*n
# 	(length(paras) == _nparas(Float64, L, depth)) || throw(""wrong number of parameters."")
# 	circuit = QCircuit()
# 	ncount = 1
# 	for i in 1:L
# 		push!(circuit, RyGate(i, paras[ncount], isparas=true))
# 		ncount += 1
# 	end			

# 	index = LinearIndices((m, n))
# 	for l in 1:depth
# 		for i in 1:m
# 		    for j in 1:(n-1)
# 		        push!(circuit, CNOTGate(index[i, j], index[i, j+1]))
# 		    end
# 		end
# 		for i in 1:(m-1)
# 		    for j in 1:n
# 		        push!(circuit, CNOTGate(index[i, j], index[i+1, j]))
# 		    end
# 		end
# 		for i in 1:L
# 			push!(circuit, RyGate(i, paras[ncount], isparas=true))
# 			ncount += 1
# 		end	
# 	end
# 	@assert ncount == length(paras)+1
# 	return circuit
# end
# real_variational_circuit_2d(shapes::Tuple{Int, Int}, args...; kwargs...) = real_variational_circuit_2d(shapes[1], shapes[2], args...; kwargs...)

function _nparas(::Type{T}, L::Int, depth::Int) where {T <: Number} 
	n = depth+1
	return (T <: Real) ? n * L : n * L * 3
end 

","Julia"
"Conjugate","guochu/VQC.jl","src/utility/qft.jl",".jl","427","25","export QFT

function _nnqft_one_block(L::Int)
	(L<=0) && error(""input size can not be 0"")
	r = QCircuit()
	if L==1
		push!(r, (1, H))
		return r
	else
		append!(r, _nnqft_one_block(L-1))
		push!(r, (((L,L-1), CONTROL(R(L)) * SWAP)))
		return r
	end
end

""""""
	efficient QFT which only contains nearest neighbour gates.
""""""
function QFT(L::Int)
	r = QCircuit()
	for i = L:-1:1
		append!(r, _nnqft_one_block(i))
	end
	return r
end","Julia"
"Conjugate","guochu/VQC.jl","src/utility/utility.jl",".jl","391","19","module Utilities

using VQC
using QuantumCircuits, QuantumCircuits.Gates

export heisenberg_1d, heisenberg_2d, ising_1d, ising_2d, ground_state, time_evolution
export QFT
export variational_circuit_1d, real_variational_circuit_1d
export order_finding

include(""spin_hamiltonians.jl"")
include(""groundstate.jl"")

include(""qft.jl"")
include(""variationalcircuit.jl"")
include(""shor/shor.jl"")


end","Julia"
"Conjugate","guochu/VQC.jl","src/utility/spin_hamiltonians.jl",".jl","2615","86","


""""""
    heisenberg xxz chain
""""""
function heisenberg_chain(L::Int; J::Real=1., Jzz::Real=J, hz::Real=0.)
    sp, sm, z = QuantumCircuits._get_op.([""+"", ""-"", ""Z""])
    terms = []
    # one site terms
    for i in 1:L
        push!(terms, QubitsTerm(i=>z, coeff=hz))
    end
    # nearest-neighbour interactions
    for i in 1:L-1
        t = QubitsTerm(i=>sp, i+1=>sm, coeff=2*J)
        push!(terms, t)
        push!(terms, t')
        push!(terms, QubitsTerm(i=>z, i+1=>z, coeff=Jzz))
    end
    return simplify(QubitsOperator(terms...))
end
heisenberg_1d(L::Int; kwargs...) = heisenberg_chain(L; kwargs...)

function heisenberg_2d(m::Int, n::Int=m; J::Real=1., Jzz::Real=J, hz::Real=0.)
    sp, sm, z = QuantumCircuits._get_op.([""+"", ""-"", ""Z""])
    terms = []
    for i in 1:m*n
        push!(terms, QubitsTerm(i=>z, coeff=hz))
    end
    index = LinearIndices((m, n))
    for i in 1:m
        for j in 1:(n-1)
            t = QubitsTerm(index[i, j]=>sp, index[i, j+1]=>sm, coeff=2*J)
            push!(terms, t)
            push!(terms, t')
            push!(terms, QubitsTerm(index[i, j]=>z, index[i, j+1]=>z, coeff=Jzz) )
        end
    end
    for i in 1:(m-1) 
        for j in 1:n
            t = QubitsTerm(index[i, j]=>sp, index[i+1, j]=>sm, coeff=2*J)
            push!(terms, t)
            push!(terms, t')
            push!(terms, QubitsTerm(index[i, j]=>z, index[i+1, j]=>z, coeff=Jzz) )
        end
    end
    return simplify(QubitsOperator(terms...))
end
heisenberg_2d(shapes::Tuple{Int, Int}; kwargs...) = heisenberg_2d(shapes[1], shapes[2]; kwargs...)


function ising_chain(L::Int; J::Real=1., hz::Real=1.)
    x, z = QuantumCircuits._get_op.([""X"", ""Z""])
    terms = []
    for i in 1:L
    	push!(terms, QubitsTerm(i=>z, coeff=hz))
    end
    for i in 1:L-1
    	push!(terms, QubitsTerm(i=>x, i+1=>x, coeff=J))
    end
    return simplify(QubitsOperator(terms...))
end
ising_1d(L::Int; kwargs...) = ising_chain(L; kwargs...)

function ising_2d(m::Int, n::Int=m; J::Real=1., hz::Real=1.)
    x, z = QuantumCircuits._get_op.([""X"", ""Z""])
    terms = []
    for i in 1:m*n
        push!(terms, QubitsTerm(i=>z, coeff=hz))
    end
    index = LinearIndices((m, n))
    for i in 1:m
        for j in 1:(n-1)
            push!(terms, QubitsTerm(index[i, j]=>x, index[i, j+1]=>x, coeff=J) )
        end
    end
    for i in 1:(m-1) 
        for j in 1:n
            push!(terms, QubitsTerm(index[i, j]=>x, index[i+1, j]=>x, coeff=J) )
        end
    end
    return simplify(QubitsOperator(terms...))
end
ising_2d(shapes::Tuple{Int, Int}; kwargs...) = ising_2d(shapes[1], shapes[2]; kwargs...)
","Julia"
"Conjugate","guochu/VQC.jl","src/utility/shor/shor.jl",".jl","125","8","
include(""util.jl"")
include(""Beauregard.jl"")
include(""Fowler.jl"")

include(""orderfinding_sqc.jl"")
include(""orderfinding.jl"")
","Julia"
"Conjugate","guochu/VQC.jl","src/utility/shor/Fowler.jl",".jl","6596","284","
# using 2n+4 qubits

const PLUS = [0.5+0.5*im 0.5-0.5*im; 0.5-0.5*im 0.5+0.5*im]
const MINUS = [0.5-0.5*im 0.5+0.5*im; 0.5+0.5*im 0.5-0.5*im]
const CONTROL_PLUS = CONTROL(PLUS)
const CONTROL_MINUS = CONTROL(MINUS)

""""""
    n = length(a)
    n qubits
    @ input output
    b[0]
    b[1]
    ...
    b[n-1]
""""""
LNNAdderCircuit(a::BinaryInteger) = QCircuit([PHASEGate(i, compute_phase(a, i)) for i in 0:(length(a)-1)])

""""""
    n = len(a)
    n+1 qubits
    @input
    c control qubit
    b[0]
    b[1]
    ...
    b[n-1]
    @output
    b[0]
    b[1]
    ...
    b[n-1]
    c control qubit
""""""
LNNCAdderCircuit(a::BinaryInteger; inverse::Bool=false) = inverse ? QCircuit(
[gate((i+1, i), SWAP * CONTROL(PHASE(compute_phase(a, i)))) for i in (length(a)-1):-1:0]) : QCircuit(
[gate((i, i+1), SWAP * CONTROL(PHASE(compute_phase(a, i)))) for i in 0:(length(a)-1)])

""""""
    this circuit contains n+6 qubits, where n+1 = len(a) = len(N)
    x1
    MS addition (most significant) qubit in |0> out |0>
    x2
    ki qubit in |0> out |0>
    kx qubit
    b[0]
    b[1]
    b[2]
    ...
    b[n]
""""""
function LNNModAdderCircuit(N::BinaryInteger, a::BinaryInteger)
    (length(N)==length(a)) || error(""binary integer a and N size mismatch."")
	L = length(a)
	n = L-1
	total_circuit = QCircuit()
    push!(total_circuit, gate((3,4), CONTROL_PLUS))
    push!(total_circuit, gate((2,3), CNOT))
    push!(total_circuit, gate((3,4), CONTROL_MINUS))
	push!(total_circuit, gate((2,3), SWAP*CNOT))
	push!(total_circuit, gate((3,4), CONTROL_PLUS))
	append!(total_circuit, shift(LNNCAdderCircuit(a, inverse=false), 4))
	append!(total_circuit, shift(LNNAdderCircuit(N), 4)')
	append!(total_circuit, shift(_QFT(L)', 4) )
	push!(total_circuit, gate((1,2), SWAP))
	push!(total_circuit, gate((2,3), SWAP))
	push!(total_circuit, gate((4,3), SWAP * CNOT))
	append!(total_circuit, move_site(4, n+4))
	append!(total_circuit, shift(_QFT(L), 3))
	append!(total_circuit, shift(LNNCAdderCircuit(N, inverse=true), 3) )
	append!(total_circuit, shift(LNNCAdderCircuit(a, inverse=false)', 4) )
    append!(total_circuit, shift(_QFT(L)', 5) )
	append!(total_circuit, move_site(4, n+5))
	push!(total_circuit, gate(4, X))
	push!(total_circuit, gate((4,3), CNOT))
	push!(total_circuit, gate(4, X))
    push!(total_circuit, gate((2,3), SWAP))
    push!(total_circuit, gate((1,2), SWAP))
	push!(total_circuit, gate((0,1), SWAP))
	append!(total_circuit, shift(_QFT(L), 4) )
	append!(total_circuit, shift(LNNCAdderCircuit(a, inverse=true), 4) )
	push!(total_circuit, gate((3,4), CONTROL_MINUS))
    push!(total_circuit, gate((2,3), CNOT * SWAP))
    push!(total_circuit, gate((3,4), CONTROL_PLUS))
    push!(total_circuit, gate((2,3), CNOT))
	push!(total_circuit, gate((1,2), SWAP))
	push!(total_circuit, gate((0,1), SWAP))
	push!(total_circuit, gate((3,4), CONTROL_MINUS))
	return total_circuit
end

""""""
    this circuit contains 2n+4 qubits, where n+1 = len(a) = len(N)
    x[0]
    x[1]
    ...
    x[n-2]
    MS
    x[n-1]
    ki
    kx
    b[0] n+3
    b[1]
    ...
    b[n]
""""""
function LNNCModMultiplierCircuit(N::BinaryInteger, a::BinaryInteger)
    (length(N)==length(a)) || error(""binary integer a and N size mismatch."")
	L = length(a)

	n = L-1

	total_circuit = QCircuit()

	# qft = shift(_QFT(L), n+3)
    # append!(total_circuit, qft)

	mv = move_site(n-2, 0)

	for i in 0:(n-1)

		apow = modular_multiply(a, 2^i, N)

		madder = LNNModAdderCircuit(N, apow)

        append!(total_circuit, shift(madder, n-2) )

        append!(total_circuit, mv)
    end

    # append!(total_circuit, qft')

	return total_circuit
end

function _cswap()
	circuit = QCircuit()
    push!(circuit, gate((2,1), CNOT))
	push!(circuit, gate((1,2), CONTROL_PLUS))
	push!(circuit, gate((0,1), CNOT))
	push!(circuit, gate((1,2), CONTROL_MINUS))
	push!(circuit, gate((0,1), SWAP * CNOT))
	push!(circuit, gate((1,2), SWAP * CONTROL_PLUS))
	push!(circuit, gate((1,0), CNOT))
	return circuit
end

function mesh(n::Int)
	circuit = QCircuit()
	for i in 0:(n-2)
        append!(circuit, move_site(n+i, 2*i+1))
    end
	return circuit
end

""""""
    2n+1 qubits
    c
    a[0]
    a[1]
    ...
    a[n-1]
    b[0]
    b[1]
    ...
    b[n-1]
""""""
function control_swap(n::Int)
	total_circuit = QCircuit()
    append!(total_circuit, shift(mesh(n), 1) )
	for i in 0:2:(2*n-1)
        append!(total_circuit, shift(_cswap(), i) )
    end
    append!(total_circuit, mesh(n)')
	return total_circuit
end

""""""
    this circuit contains 2n+4 qubits, where n+1 = len(a) = len(N)
    x[0]
    x[1]
    ...
    x[n-2]
    MS
    x[n-1]
    ki
    kx
    b[0]    n+3
    b[1]
    ...
    b[n]
""""""
function LNNModUCircuit(N::BinaryInteger, a::BinaryInteger, ra::BinaryInteger)
    ((length(N)==length(a)) && (length(N)==length(ra))) || error(""binary integer a, ar and N size mismatch."")
	L = length(a)
	n = L-1

	total_circuit = QCircuit()

    append!(total_circuit, LNNCModMultiplierCircuit(N, a))

    append!(total_circuit, shift(_QFT(L)', n+3) )
	append!(total_circuit, move_site(n-1, 0))
	append!(total_circuit, move_site(n+2, 1))
	append!(total_circuit, move_site(n+2, 2))
	append!(total_circuit, shift(move_site(0, n), n+3))

	# controled swap
    append!(total_circuit, shift(control_swap(n), 2) )

    append!(total_circuit, move_site(1, n+1))
	append!(total_circuit, move_site(0, n-1))
	append!(total_circuit, move_site(2*n+2, n+1))
	append!(total_circuit, move_site(2*n+3, n+3))
	append!(total_circuit, shift(_QFT(L), n+3))

    append!(total_circuit, LNNCModMultiplierCircuit(N, ra)')

	return total_circuit
end


""""""
    compute fa,N (x) = a^x mod N
    2n+3+m qubits alined as follows
    f[0]
    f[1]
    ...
    f[m-1]
    x[0]   m
    x[1]
    ...
    x[n-2]
    MS
    x[n-1]  m+n
    --ki--
    kx      m+n+1
    b[0]   m+n+2
    b[1]
    ...
    b[n]
    @input
    @x m bits qnumber
    @b result: n bits qnumber, initialized to be |0>
    @output
    @b->(a^x)%N
""""""
function LNNModExponentiatorCircuit(N::BinaryInteger, a::BinaryInteger, m::Int)
	(length(N)==length(a)) || error(""binary integer a and N size mismatch."")

	total_circuit = QCircuit()

	L = length(N)

	n = L-1

	ra = modular_inverse(a, N)

	qft_circuit = shift(_QFT(L), m+n+2)

    append!(total_circuit, qft_circuit)

	for i in (m-1):-1:0

		mv = move_site(i, m+n)

        append!(total_circuit, mv)

		# central block operations
        append!(total_circuit, shift(LNNModUCircuit(N, a, ra), m-1))

        append!(total_circuit, mv')

		a = modular_multiply(a, a, N)

        ra = modular_multiply(ra, ra, N)
    end

    append!(total_circuit, qft_circuit')

	return total_circuit
end
","Julia"
"Conjugate","guochu/VQC.jl","src/utility/shor/util.jl",".jl","1416","61","include(""binaryinteger.jl"")


""""""
	circuit to move i to j
""""""
function move_site(i::Int, j::Int)
	circuit = QCircuit()
	(i==j) && return circuit
	if i < j
		for k = i:(j-1)
			# push!(circuit, ((k, k+1), SWAP))
			push!(circuit, SWAPGate(k, k+1))
		end
	else
		for k = i:-1:(j+1)
			# push!(circuit, ((k, k-1), SWAP))
			push!(circuit, SWAPGate(k, k-1))
		end
	end
	return circuit
end

# function compute_phase(a::BinaryInteger, j::Int)
# 	s = 1
# 	n = length(a)
# 	for k in 1:(j+1)
# 		aj = a[n-(j+1-k)]
# 		s = s*exp(aj*pi*im/2^(k-1))
#     end
# 	return s
# end
# rotationA(a::BinaryInteger, j::Int) = [1 0; 0 compute_phase(a, j)]
function compute_phase(a::BinaryInteger, j::Int)
	s = 0.
	n = length(a)
	for k in 1:(j+1)
		aj = a[n-(j+1-k)]
		s += aj / 2^(k-1)
    end
	return s * pi
end

function control_swap_block(c::Int, n::Int, i::Int, inci::Int, j::Int, incj::Int)
	swap_i_j = QCircuit()
	# c_cnot = _row_kron(UP, eye(4)) + _row_kron(DOWN, CNOT)
	(i == j) && error(""position not allowed."")
	for k in 0:(n-1)
        # push!(swap_i_j, gate((j+k*incj, i+k*inci), CNOT))
		push!(swap_i_j, CNOTGate(j+k*incj, i+k*inci))
        # push!(swap_i_j, gate((c, i+k*inci, j+k*incj), c_cnot))
		push!(swap_i_j, TOFFOLIGate(c, i+k*inci, j+k*incj))
        # push!(swap_i_j, gate((j+k*incj, i+k*inci), CNOT))
		push!(swap_i_j, CNOTGate(j+k*incj, i+k*inci))
    end
	return swap_i_j
end


_QFT(L::Int) = shift(QFT(L), -1)
","Julia"
"Conjugate","guochu/VQC.jl","src/utility/shor/Beauregard.jl",".jl","5369","259","
# using 2n+3 qubits

# zero based circuit
# QFTAdderCircuit(a::BinaryInteger) = QCircuit([gate(i, rotationA(a, i)) for i in 0:(length(a)-1)])
QFTAdderCircuit(a::BinaryInteger) = QCircuit([PHASEGate(i, compute_phase(a, i)) for i in 0:(length(a)-1)])

""""""
    n = length(a)
    n+1 qubits
    b[0]
    b[1]
    ...
    b[n-1]
    c control qubit
""""""
# QFTCAdderCircuit(c::Int, a::BinaryInteger) = QCircuit([gate((c, i), CONTROL(rotationA(a, i))) for i in 0:(length(a)-1)])
# QFTCAdderCircuit(c::Int, a::BinaryInteger) = QCircuit(
# [CONTROLGate((c, i), rotationA(a, i)) for i in 0:(length(a)-1)])
QFTCAdderCircuit(c::Int, a::BinaryInteger) = QCircuit(
[CPHASEGate((c, i), compute_phase(a, i)) for i in 0:(length(a)-1)])

""""""
    n = length(a)
    n+2 qubits
    b[0]
    b[1]
    ...
    b[n-1]
    c2 control qubit 2
    c1 control qubit 1
""""""
# QFTCCAdderCircuit(c1::Int, c2::Int, a::BinaryInteger) = QCircuit(
# [gate((c1, c2, i), CONTROLCONTROL(rotationA(a, i))) for i in 0:(length(a)-1)])
QFTCCAdderCircuit(c1::Int, c2::Int, a::BinaryInteger) = QCircuit(
[CCPHASEGate((c1, c2, i), compute_phase(a, i)) for i in 0:(length(a)-1)])

""""""
    this circuit contains n+4 qubits, where n+1 = length(a) = length(N)
    t qubit in |0> out |0>
    b[0] addition (most significant) qubit in |0> out |0>
    b[1]
    b[2]
    ...
    b[n]
    c2
    c1
""""""
function QFTCCModAdderCircuit(N::BinaryInteger, a::BinaryInteger)
    (length(N)==length(a)) || error(""binary integer a and N size mismatch."")
	L = length(a)
	n = L-1

	total_circuit = QCircuit()

	cc_adder = shift(QFTCCAdderCircuit(L+1, L, a), 1)

	c_adder = shift(QFTCAdderCircuit(-1, N), 1)

	adder = shift(QFTAdderCircuit(N), 1)

	qft = shift(_QFT(L), 1)

    append!(total_circuit, cc_adder)

    append!(total_circuit, adder')

    append!(total_circuit, qft')

    # push!(total_circuit, gate((1, 0), CNOT))
    push!(total_circuit, CNOTGate(1, 0))

    append!(total_circuit, qft)

    append!(total_circuit, c_adder)

    append!(total_circuit, cc_adder')

    append!(total_circuit, qft')

    # push!(total_circuit, gate(1, X))
    push!(total_circuit, XGate(1))

    # push!(total_circuit, gate((1, 0), CNOT))
    push!(total_circuit, CNOTGate(1, 0))

    # push!(total_circuit, gate(1, X))
    push!(total_circuit, XGate(1))

    append!(total_circuit, qft)

    append!(total_circuit, cc_adder)

	return total_circuit
end

""""""
    this circuit contains 2n+3 qubits, where n+1 = length(a) = length(N)
    t qubit in |0> out |0>
    b[0] addition (most significant) qubit in |0> out |0>
    b[1]
    b[2]
    ...
    b[n]
    x[0]
    x[1]
    ...
    x[n-1]
    c control qubit
""""""
function QFTCModMultiplierCircuit(N::BinaryInteger, a::BinaryInteger)

	(length(N)==length(a)) || error(""binary integer a and N size mismatch."")
	L = length(a)

	n = L-1

	total_circuit = QCircuit()

	mv1 = move_site(2*n+2, n+3)

	for i in 0:(n-1)
		mv2 = shift(move_site(n-1-i, 0), n+2)

		append!(total_circuit, mv2)

		append!(total_circuit, mv1)

		apow = modular_multiply(a, 2^i, N)

		madder = QFTCCModAdderCircuit(N, apow)

		append!(total_circuit, madder)

		append!(total_circuit, mv1')

		append!(total_circuit, mv2')
    end

	return total_circuit
end

""""""
    this circuit contains 2n+3 qubits, where n+1 = length(a) = length(N)
    t qubit in |0> out |0>
    b[0] addition (most significant) qubit in |0> out |0>
    b[1]
    b[2]
    ...
    b[n]
    x[0]
    x[1]
    ...
    x[n-1]
    c control qubit
""""""
function QFTModUCircuit(N::BinaryInteger, a::BinaryInteger, ra::BinaryInteger)

	L = length(a)
	n = L-1

	qft = shift(_QFT(L), 1)

	c_swap = control_swap_block(2*n+2, n, 2, 1, n+2, 1)

	total_circuit = QCircuit()

	mult_circuit = QFTCModMultiplierCircuit(N, a)

	append!(total_circuit, mult_circuit)

	append!(total_circuit, qft')

	append!(total_circuit, c_swap)

	append!(total_circuit, qft)

	rmult_circuit = QFTCModMultiplierCircuit(N, ra)

	append!(total_circuit, rmult_circuit')

	return total_circuit
end

""""""
    compute fa,N (x) = a^x mod N
    2n+2+m qubits alined as follows
    t qubit in |0> out |0>
    b[0] addition qubit int |0> out |0>
    b[1]
    ...
    b[n]
    t[0]
    t[1]
    ...
    t[n-1]
    x[0]
    x[1]
    ...
    x[m-1]
    @input
    @t n bits temporary qnumber, initialized to be |1>
    @x m bits qnumber
    @b result: n bits qnumber, initialized to be |0>
    @output
    @b->(a^x)%N
""""""
function QFTCModExponentiatorCircuit(N::BinaryInteger, a::BinaryInteger, m::Int)
	(length(N)==length(a)) || error(""binary integer a and N size mismatch."")

	L = length(N)

	n = L-1

    ra = modular_inverse(a, N)

	total_circuit = QCircuit()

	c_swap = control_swap_block(2*n+2, n, 2, 1, n+2, 1)

	qft = shift(_QFT(L), 1)

    append!(total_circuit, qft)


	for i in (m-1):-1:0

		mv = shift(move_site(i, 0), 2*n+2)

        append!(total_circuit, mv)

		# central block operations

		mult_circuit = QFTCModMultiplierCircuit(N, a)

        append!(total_circuit, mult_circuit)

        append!(total_circuit, qft')

        append!(total_circuit, c_swap)

        append!(total_circuit, qft)

		rmult_circuit = QFTCModMultiplierCircuit(N, ra)

        append!(total_circuit, rmult_circuit')

        append!(total_circuit, mv')

        a = modular_multiply(a, a, N)

        ra = modular_multiply(ra, ra, N)
    end

    append!(total_circuit, qft')

	return total_circuit
end
","Julia"
"Conjugate","guochu/VQC.jl","src/utility/shor/binaryinteger.jl",".jl","1965","64","

struct BinaryInteger
    value::Int
    svalue::Vector{Int}
end

get_value(x::BinaryInteger) = x.value
get_svalue(x::BinaryInteger) = x.svalue
num_bits(x::BinaryInteger) = length(get_svalue(x))

Base.length(x::BinaryInteger) = length(get_svalue(x))
Base.getindex(x::BinaryInteger, i::Int) = getindex(get_svalue(x), i)
Base.iterate(x::BinaryInteger) = iterate(get_svalue(x))
Base.iterate(x::BinaryInteger, state) = iterate(get_svalue(x), state)
Base.IndexStyle(::Type{<:BinaryInteger}) = IndexLinear()
Base.firstindex(x::BinaryInteger) = firstindex(get_svalue(x))
Base.lastindex(x::BinaryInteger) = lastindex(get_svalue(x))

function BinaryInteger(v::Int, Nbits::Int)
    svalue = digits(v, base=2, pad=Nbits)
    (length(svalue) == Nbits) || error(""$Nbits is not enough for integer $v."")
    return BinaryInteger(v, reverse(svalue) )
end

function modular_inverse(a::BinaryInteger, N::BinaryInteger)
	(num_bits(a) == num_bits(N)) || error(""nbits mismatch."")
	r = invmod(get_value(a), get_value(N))
	return BinaryInteger(r, num_bits(a))
end

function modular_multiply(a::Integer, b::Integer, N::BinaryInteger)
	r = (a * b) % get_value(N)
	return BinaryInteger(r, num_bits(N))
end

function modular_multiply(a::BinaryInteger, b::Integer, N::BinaryInteger)
	(num_bits(a) == num_bits(N)) || error(""nbits mismatch."")
	return modular_multiply(get_value(a), b, N)
end

function modular_multiply(a::BinaryInteger, b::BinaryInteger, N::BinaryInteger)
	((num_bits(a) == num_bits(b)) && (num_bits(a) == num_bits(N))) || error(""nbits mismatch."")
	return modular_multiply(get_value(a), get_value(b), N)
end

function modular_pow(bs::Integer, exponent::Integer, modulus::Integer)
	(modulus==1) && return 0
	if exponent < 0
		bs = modular_inverse(bs, modulus)
		exponent = -exponent
	end
	result=1
	bs = bs % modulus
	while exponent > 0
		if (exponent % 2 == 1)
			result = (result*bs) % modulus
		end
		exponent = exponent >> 1
		bs = (bs*bs) % modulus
	end
	return result
end
","Julia"
"Conjugate","guochu/VQC.jl","src/utility/shor/orderfinding.jl",".jl","4379","151","

""""""
    n = len(a)-1 = len(N)-1
    4*n+2 qubits is needed
""""""
function order_finding_qft_circuit(a::BinaryInteger, N::BinaryInteger; verbosity::Int=1)

    ai = get_value(a)
	Ni = get_value(N)
	(ai==1) && error(""the input a can not be 1."")
	(Ni==1) && error(""the input N can not be 1."")

	(gcd(ai, Ni)==1) || error(""a and N are not co-prime to each other."")
    # nmax = length(a)
	# precision = 2**(-2*nmax-1)
	n = length(a)
	L = n+1
	a = BinaryInteger(get_value(a), L)
	N = BinaryInteger(get_value(N), L)
    (verbosity >= 3) && println(""n=$n, total number of qubits $(4*n+2)."")


	circuit = QCircuit()
    push!(circuit, gate(2*n+1, X))
    for i in (2*n+2):(4*n+1)
        push!(circuit, gate(i, H))
    end
	# circuit = shift(circuit, 2*n+2)
    append!(circuit, QFTCModExponentiatorCircuit(N, a, 2*n))
    append!(circuit, shift(_QFT(2*n), 2*n+2)')

    return circuit
	# check N
end

function order_finding_by_qft(::Type{T}, a::Int, N::Int; verbosity::Int=1) where {T<:Number}
    L = max(length(digits(a, base=2)), length(digits(N, base=2)))
    state = StateVector(T, 4*L+2)
    a = BinaryInteger(a, L)
    N = BinaryInteger(N, L)

    circuit = shift(order_finding_qft_circuit(a, N, verbosity=verbosity), 1)
    # println(""max min position $(max_site(circuit.data)), $(min_site(circuit.data))."")

    # circuit = fuse_gate(circuit)
    apply_circuit!(circuit, state)
    r = Int[]
    for i in 0:(2*L-1)
        observer = QMeasure(2*L+i+3)
        istate, probability = apply_circuit!(observer, state)
        push!(r, istate)
    end
    # return sum([(r[2 * L - i]*1. / (1 << (i + 1))) for i in 0:(2 * L-1)])
    return to_digits(r)
end

""""""
    see reference
    ""Implementation of Shor’s Algorithm on a Linear Nearest Neighbour Qubit Array""
    n = len(a)-1 = len(N)-1
    4*n+3 qubits is needed
    f[0]
    f[1]
    ...
    f[2n-1]
    x[0] 2n
    x[1]
    ...
    x[n-2]
    MS
    x[n-1]  3n
    kx
    b[0]
    b[1]
    ...
    b[n]
""""""
function order_finding_lnn_circuit(a::BinaryInteger, N::BinaryInteger; verbosity::Int=1)
    ai = get_value(a)
	Ni = get_value(N)
	(ai==1) && error(""the input a can not be 1."")
	(Ni==1) && error(""the input N can not be 1."")

	(gcd(ai, Ni)==1) || error(""a and N are not co-prime to each other."")
    # nmax = length(a)
	# precision = 2**(-2*nmax-1)
	n = length(a)
	L = n+1
	a = BinaryInteger(get_value(a), L)
	N = BinaryInteger(get_value(N), L)
    (verbosity >= 3) && println(""n=$n, total number of qubits $(4*n+3)."")

	circuit = QCircuit()
    push!(circuit, gate(3*n, X))
	for i in 0:(2*n-1)
        push!(circuit, gate(i, H))
    end
    append!(circuit, LNNModExponentiatorCircuit(N, a, 2*n))
	append!(circuit, _QFT(2*n)')
    append!(circuit, move_site(3*n, 3*n-1))

    return circuit
end

function order_finding_by_lnn(::Type{T}, a::Int, N::Int; verbosity::Int=1) where {T<:Number}
    L = max(length(digits(a, base=2)), length(digits(N, base=2)))
    state = StateVector(T, 4*L+3)
    a = BinaryInteger(a, L)
    N = BinaryInteger(N, L)
    circuit = shift(order_finding_lnn_circuit(a, N, verbosity=verbosity), 1)

    # println(""max min position $(max_site(circuit.data)), $(min_site(circuit.data))."")

    # circuit = fuse_gate(circuit)
    apply_circuit!(circuit, state)

    # # testing
    # println(""testing...."")
    # for i in (3*L+1):(4*L+3)
    #     observer = QMeasure(i)
    #     istate, probability = apply!(observer, state)
    #     println(""get $istate with probability $probability at $i-th qubit."")
    # end

    r = Int[]
    for i in 0:(2*L-1)
        observer = QMeasure(i+1)
        istate, probability = apply_circuit!(observer, state)
        push!(r, istate)
    end
    # return sum([(r[2 * L - i]*1. / (1 << (i + 1))) for i in 0:(2 * L-1)])
    return to_digits(r)
end

function order_finding(::Type{T}, a::Int, N::Int; less_qubits::Bool=true, algorithm::Symbol=:lnn, verbosity::Int=1) where {T<:Number}
    if less_qubits
        return order_finding_scq(T, a, N; algorithm=algorithm, verbosity=verbosity)
    else
        if algorithm == :lnn
            return order_finding_by_lnn(T, a, N; verbosity=verbosity)
        elseif algorithm == :qft
            return order_finding_by_qft(T, a, N; verbosity=verbosity)
        else
            error(""algorithm $algorithm not implemented."")
        end
    end
end

order_finding(a::Int, N::Int) = order_finding(ComplexF64, a, N)
","Julia"
"Conjugate","guochu/VQC.jl","src/utility/shor/orderfinding_sqc.jl",".jl","5795","224","# sqc : single qubit control to use less qubits

function to_digits(s::Vector)
	r = 0.
	for i in 0:(length(s)-1)
		r = r + s[i+1]*2.0^(-i-1)
    end
	return r
end


apply_circuit!(gt, state) = apply!(gt, state)

""""""
    see reference
    using the one control qubit trick
    this circuit contains 2n+3 qubits, where n+1 = len(a) = len(N)
    t qubit in |0> out |0>
    b[0] addition (most significant) qubit in |0> out |0>
    b[1]
    b[2]
    ...
    b[n]
    x[0]
    x[1]
    ...
    x[n-1]
    c control qubit
""""""
function order_finding_by_qft_impl(a::BinaryInteger, N::BinaryInteger, state; verbosity::Int=1)
    (length(N)==length(a)) || error(""binary integer a and N size mismatch."")

	ai = get_value(a)
	Ni = get_value(N)
	(ai==1) && error(""the input a can not be 1."")
	(Ni==1) && error(""the input N can not be 1."")

	(gcd(ai, Ni)==1) || error(""a and N are not co-prime to each other."")
    # nmax = length(a)
	# precision = 2**(-2*nmax-1)
	n = length(a)
	L = n+1
	a = BinaryInteger(get_value(a), L)
	N = BinaryInteger(get_value(N), L)
    (verbosity >= 3) && println(""n=$n, total number of qubits $(2*n+3)."")
	control_site = 2*n+3
	observer = QMeasure(control_site, auto_reset=true)

	ra = modular_inverse(a, N)

	qft_circuit = shift(_QFT(L), 2)

	apply_circuit!(qft_circuit, state)

	Hgate = gate(control_site, H)

	apply_circuit!(Hgate, state)

	astore = []
	rastore = []
	for i in 1:(2*n)
        push!(astore, a)
        push!(rastore, ra)
		a = modular_multiply(a, a, N)
		ra = modular_multiply(ra, ra, N)
    end

	r = []
	# print('total number of measurements %s'%(2*n))
	for i in 0:(2*n-1)
		apply_circuit!(Hgate, state)

		circuit = shift(QFTModUCircuit(N, astore[2*n-i], rastore[2*n-i]), 1)

        # println(""max min site $(max_site(circuit.data)), $(min_site(circuit.data))."")

		# println(""number of gates $(length(circuit))."")
		# circuit = fuse_gate(circuit)
		# println(""number of gates after gate fusion $(length(circuit))."")

		apply_circuit!(circuit, state)

		# apply rorate
		rot = gate(control_site, [1. 0.; 0. exp(-pi*im*to_digits(reverse(r)))])
		apply_circuit!(rot, state)

		apply_circuit!(Hgate, state)

		istate, probability = apply_circuit!(observer, state)

        push!(r, istate)

		(verbosity >= 2) && println(""measurement outcome at $i-th step is $istate."")
    end

	y = sum([(r[2 * n - i]*1. / (1 << (i + 1))) for i in 0:(2 * n-1)])
	return y

	# numerator, d = continuous_fraction(y, Ni-1)
	# (verbosity >= 1) && println(""numerator is $numerator, denominator is $d."")
    #
	# (modular_pow(ai, d, Ni)==1) && return d
    # (verbosity >= 2) && println(""order finding failed."")
	#
	# println(""fraction is $y."")
	# return -1
end

function scq_order_finding_by_qft(::Type{T}, a::Int, N::Int; verbosity::Int=1) where {T<:Number}
    L = max(length(digits(a, base=2)), length(digits(N, base=2)))
    state = StateVector(T, 2*L+3)
    apply_circuit!(gate(2*L+2, X), state)
    return order_finding_by_qft_impl(BinaryInteger(a, L), BinaryInteger(N, L), state; verbosity=verbosity)
end

""""""
	see reference
	using the one control qubit trick
	""Implementation of Shor’s Algorithm on a Linear Nearest Neighbour Qubit Array""
	n = len(a)-1 = len(N)-1
	2*n+4 qubits is needed
	x[0]
	x[1]
	...
	x[n-2]
	MS
	x[n-1]  n
	ki
	kx
	b[0]
	b[1]
	...
	b[n]
""""""
function order_finding_by_lnn_impl(a::BinaryInteger, N::BinaryInteger, state; verbosity::Int=1)
	# assert(driver in ['lnn'])
	ai = get_value(a)
	Ni = get_value(N)
	(ai==1) && error(""the input a can not be 1."")
	(Ni==1) && error(""the input N can not be 1."")

	(gcd(ai, Ni)==1) || error(""a and N are not co-prime to each other."")
	# precision = 2**(-2*nmax-1)
	n = length(a)
	L = n+1

	a = BinaryInteger(get_value(a), L)
	N = BinaryInteger(get_value(N), L)
	(verbosity >= 3) && println(""n=$n, total number of qubits $(2*n+4)."")

	observer = QMeasure(n+2, auto_reset=true)

	ra = modular_inverse(a, N)

	qft_circuit = shift(_QFT(L), n+4)

	apply_circuit!(qft_circuit, state)

	Hgate = gate(n+2, H)

	apply_circuit!(Hgate, state)

	astore = []
	rastore = []
	for i in 1:2*n
		push!(astore, a)
        push!(rastore, ra)
		a = modular_multiply(a, a, N)
		ra = modular_multiply(ra, ra, N)
	end

	r = []
	for i in 0:(2*n-1)
		apply_circuit!(Hgate, state)

		circuit = shift(LNNModUCircuit(N, astore[2*n-i], rastore[2*n-i]), 1)

		# println(""max min site $(max_site(circuit.data)), $(min_site(circuit.data))."")

		# println(""number of gates $(length(circuit))."")
		# circuit = fuse_gate(circuit)
		# println(""number of gates after gate fusion $(length(circuit))."")

		apply_circuit!(circuit, state)

		# apply rorate
		rot = gate(n+2, [1. 0.; 0. exp(-pi*im*to_digits(reverse(r)))])
		apply_circuit!(rot, state)

		apply_circuit!(Hgate, state)

		istate, probability = apply_circuit!(observer, state)

		push!(r, istate)

		(verbosity >= 2) && println(""measurement outcome at $i-th step is $istate."")
	end

	y = sum([(r[2 * n - i]*1. / (1 << (i + 1))) for i in 0:(2 * n-1)])
	return y
	# println(""fraction is $y."")
	# return -1
end

function scq_order_finding_by_lnn(::Type{T}, a::Int, N::Int; verbosity::Int=1) where {T<:Number}
    L = max(length(digits(a, base=2)), length(digits(N, base=2)))
    state = StateVector(T, 2*L+4)
    apply_circuit!(gate(L+1, X), state)
    return order_finding_by_lnn_impl(BinaryInteger(a, L), BinaryInteger(N, L), state; verbosity=verbosity)
end

""""""
	quantum order finding algorithm using single control qubits technique.
""""""
function order_finding_scq(::Type{T}, a::Int, N::Int; algorithm::Symbol=:lnn, verbosity::Int=1) where {T<:Number}
	if algorithm == :lnn
		return scq_order_finding_by_lnn(T, a, N; verbosity=verbosity)
	elseif algorithm == :qft
		return scq_order_finding_by_qft(T, a, N; verbosity=verbosity)
	else
		error(""algorithm $algorithm not implemented."")
	end
end
","Julia"
"Conjugate","guochu/VQC.jl","src/auxiliary/tensorops.jl",".jl","1375","53","
function swap!(qstate::AbstractVector, i::Int, j::Int)
	(i == j) && return 
	if i < j
		fsize = 2^(i-1)
		msize = 2^(j-i-1)
		bsize = div(length(qstate), (fsize*4*msize))
		s = reshape(qstate, (fsize, 2, msize, 2, bsize))

		# tmp = Tensor{T}(undef, fsize, msize, bsize)
		tmp = s[:, 1, :, 2, :]
		s[:, 1, :, 2, :] = s[:, 2, :, 1, :]
		s[:, 2, :, 1, :] = tmp
	else
		swap!(qstate, j, i)
	end
end

function _entropy(v::AbstractVector{<:Real}) 
    a = [(abs(item) <= 1.0e-12) ? 0. : item for item in v]
    a = [item for item in a if (item != 0.)]
    s = sum(a)
    a ./= s
    return -dot(a, log2.(a))
end

function entropy(v::AbstractArray{T, 1}) where {T <: Real}
	a = _check_and_filter(v)
	return -dot(a, log2.(a))
end

function renyi_entropy(v::AbstractArray{T, 1}; α::Real=1) where T
	α = convert(T, α)
	if α==one(α)
	    return entropy(v)
	else
		a = _check_and_filter(v)
		a = v.^(α)
		return (1/(1-α)) * log2(sum(a))
	end
end


function _check_and_filter(v::AbstractArray{<:Real}; tol::Real=1.0e-12)
	(abs(sum(v) - 1) <= tol) || throw(ArgumentError(""sum of singular values not equal to 1""))
	oo = zero(eltype(v))
	tol = convert(eltype(v), tol)
	for item in v
		((item < oo) && (-item > tol)) && throw(ArgumentError(""negative singular values""))
	end
	# return [(abs(item) <= tol) ? oo : item for item in v]
	return [item for item in v if abs(item) > tol] 
end","Julia"
"Conjugate","guochu/VQC.jl","src/auxiliary/parallel_for.jl",".jl","2144","62","using Base.Threads

const MIN_SIZE = 1024


get_size_1(total_itr::Int, n_threads::Int, thread_id::Int) = div(total_itr * thread_id, n_threads)
get_size_2(total_itr::Int, n_threads::Int, thread_id::Int) = div(total_itr * (thread_id + 1), n_threads)

""""""
    The inner function f is assumed to be Zero Based
""""""
function parallel_run(total_itr::Int, n_threads::Int, f::Function, args...)
    if (total_itr >= MIN_SIZE) && (n_threads > 1)
        # nave, resi, jobs = partition_jobs(total_itr, n_threads)
        Threads.@threads for thread_id in 0:(n_threads-1)
            ist = get_size_1(total_itr, n_threads, thread_id)
            ifn = get_size_2(total_itr, n_threads, thread_id) - 1
            f(ist, ifn, args...)
        end
    else
        f(0, total_itr-1, args...)
    end
end

""""""
    The inner function f is assumed to be Zero Based
""""""
function parallel_sum(::Type{T}, total_itr::Int, n_threads::Int, f::Function, args...) where {T<:Real}
    if (total_itr >= MIN_SIZE) && (n_threads > 1)
        # nave, resi, jobs = partition_jobs(total_itr, n_threads)
        r = Atomic{T}(0)
        Threads.@threads for thread_id in 0:(n_threads-1)
            ist = get_size_1(total_itr, n_threads, thread_id)
            ifn = get_size_2(total_itr, n_threads, thread_id) - 1
            atomic_add!(r, f(ist, ifn, args...))
        end
        return r[]
    else
        return f(0, total_itr-1, args...)
    end    
end


function parallel_sum(::Type{T}, total_itr::Int, n_threads::Int, f::Function, args...) where {T<:Complex}
    if (total_itr >= MIN_SIZE) && (n_threads > 1)
        # nave, resi, jobs = partition_jobs(total_itr, n_threads)
        RT = real(T)
        rr = Atomic{RT}(0)
        ri = Atomic{RT}(0)
        Threads.@threads for thread_id in 0:(n_threads-1)
            ist = get_size_1(total_itr, n_threads, thread_id)
            ifn = get_size_2(total_itr, n_threads, thread_id) - 1
            tmp = f(ist, ifn, args...)
            atomic_add!(rr, real(tmp))
            atomic_add!(ri, imag(tmp))
        end
        return Complex(rr[], ri[])
    else
        return f(0, total_itr-1, args...)
    end    
end
","Julia"
"Conjugate","guochu/VQC.jl","src/auxiliary/distance.jl",".jl","168","11","
function _distance2(x, y)
	sA = real(dot(x, x))
	sB = real(dot(y, y))
	c = dot(x, y)
	r = sA+sB-2*real(c)
	return abs(r)
end

_distance(x, y) = sqrt(_distance2(x, y))
","Julia"
"Conjugate","guochu/VQC.jl","src/auxiliary/sampling.jl",".jl","313","18","
function discrete_sample(l::Vector{Float64})
	isempty(l) && error(""no results."")
	s = sum(l)
	L = length(l)
	l1 = Vector{Float64}(undef, L+1)
	l1[1] = 0
	for i=1:L
	    l1[i+1] = l1[i] + l[i]/s
	end
	s = rand(Float64)
	for i = 1:L
	    if (s >= l1[i] && s < l1[i+1])
	        return i
	    end
	end
	return L
end","Julia"
"Conjugate","guochu/VQC.jl","src/auxiliary/indexop.jl",".jl","1509","75","

""""""	
	move_selected_index_forward(a, I)
	move the indexes specified by I to the front of a
	# Arguments
	@ a::NTuple{N, Int}: the input tensor.
	@ I: tuple or vector of integer.
""""""
function move_selected_index_forward(a::Vector{T}, I) where {T}
    na = length(a)
    nI = length(I)
    b = Vector{T}(undef, na)
    k1 = 0
    k2 = nI
    for i=1:na
        s = 0
        while s != nI
        	if i == I[s+1]
        		b[s+1] = a[k1+1]
        	    k1 += 1
        	    break
        	end
        	s += 1
        end
        if s == nI
        	b[k2+1]=a[k1+1]
        	k1 += 1
            k2 += 1
        end
    end
    return b
end

function move_selected_index_forward(a::NTuple{N, T}, I) where {N, T}
    return NTuple{N, T}(move_selected_index_forward([a...], I))
end

""""""	
	move_selected_index_backward(a, I)
	move the indexes specified by I to the back of a
	# Arguments
	@ a::NTuple{N, Int}: the input tensor.
	@ I: tuple or vector of integer.
""""""
function move_selected_index_backward(a::Vector{T}, I) where {T}
	na = length(a)
	nI = length(I)
	nr = na - nI
	b = Vector{T}(undef, na)
	k1 = 0
	k2 = 0
	for i = 1:na
	    s = 0
	    while s != nI
	    	if i == I[s+1]
	    		b[nr+s+1] = a[k1+1]
	    		k1 += 1
	    		break
	    	end
	    	s += 1
	    end
	    if s == nI
	        b[k2+1] = a[k1+1]
	        k2 += 1
	        k1 += 1
	    end
	end
	return b
end

function move_selected_index_backward(a::NTuple{N, T}, I) where {N, T}
	return NTuple{N, T}(move_selected_index_backward([a...], I))
end
","Julia"
"Conjugate","guochu/VQC.jl","src/hamiltonian/util.jl",".jl","1030","44","

_get_mat(x::Tuple{Vector{AbstractMatrix}, Number}) = QuantumCircuits._kron_ops(reverse(x[1])) * x[2]
_get_mat(x::QubitsTerm) = QuantumCircuits._kron_ops(reverse(oplist(x))) * coeff(x)

function _get_mat(n::Int, x::QuantumCircuits.QOP_DATA_VALUE_TYPE)
    isempty(x) && error(""bond is empty."")
    m = zeros(_scalar_type(x), 2^n, 2^n)
    for item in x
        tmp = QuantumCircuits._kron_ops(reverse(item[1]))
        alpha = item[2]
        @. m += alpha * tmp
    end
    return m
end


function _scalar_type(x::QuantumCircuits.QOP_DATA_VALUE_TYPE)
	T = Int
	for (k, coef) in x
		T = promote_type(T, typeof(coef))
		for item in k
			T = promote_type(T, eltype(item))
		end
	end
	return T
end


function LinearAlgebra.ishermitian(x::QubitsTerm)
	(imag(coeff(x)) ≈ 0.) || return false
	for item in oplist(x)
		ishermitian(item) || return false
	end
	return true
end
function LinearAlgebra.ishermitian(x::QubitsOperator)
	for (k, v) in x.data
		m = _get_mat(length(k), v)
		ishermitian(m) || return false
	end
	return true
end
","Julia"
"Conjugate","guochu/VQC.jl","src/hamiltonian/expecs_dm/expecs_dm.jl",".jl","585","28","
include(""expec_dm_serial.jl"")
include(""apply_qterms_dm.jl"")



function expectation(m::QubitsTerm, state::DensityMatrix) 
	isempty(m) && return tr(state)
	if length(positions(m)) <= 3
	    return expectation_value_serial(Tuple(positions(m)), _get_mat(m), storage(state))
	else
		return tr(m * state)
	end
end


function expectation(m::QubitsOperator, state::DensityMatrix)
	if _largest_nterm(m) <= 3
		r = zero(eltype(state))
		for (k, v) in m.data
			r += expectation_value_serial(k, _get_mat(length(k), v), storage(state))
		end 
		return r   
	else
		return tr(m * state)
	end
end
","Julia"
"Conjugate","guochu/VQC.jl","src/hamiltonian/expecs_dm/apply_qterms_dm.jl",".jl","713","34","


# apply hamiltonian term on density matrix


function (m::QubitsTerm)(vr::DensityMatrix)
	v = vr.data
	vout = similar(v)
	_apply_qterm_util!(m, v, vout)
	return DensityMatrix(vout, nqubits(vr))
end

function (m::QubitsOperator)(vr::DensityMatrix) 
	v = vr.data
	vout = zeros(eltype(v), length(v))
	if _largest_nterm(m) <= LARGEST_SUPPORTED_NTERMS
		_apply_util!(m, v, vout)
	else
		workspace = similar(v)
		for (k, dd) in m.data
			for item in dd
			   _apply_qterm_util!(QubitsTerm(k, item[1], item[2]), v, workspace) 
			   vout .+= workspace
			end
		end
	end
	return DensityMatrix(vout, nqubits(vr))
end


Base.:*(m::QubitsOperator, v::DensityMatrix) = m(v)
Base.:*(m::QubitsTerm, v::DensityMatrix) = m(v)
","Julia"
"Conjugate","guochu/VQC.jl","src/hamiltonian/expecs_dm/expec_dm_serial.jl",".jl","7876","182","
@inline get_2_by_2(state::AbstractMatrix, posa::Int, posb::Int) = SMatrix{2,2}(state[posa, posa], state[posb, posa], state[posa, posb], state[posb, posb])

@inline function get_4_by_4(state::AbstractMatrix, pos1::Int, pos2::Int, pos3::Int, pos4::Int)
	return SMatrix{4,4}(state[pos1, pos1], state[pos2, pos1], state[pos3, pos1], state[pos4, pos1], 
						state[pos1, pos2], state[pos2, pos2], state[pos3, pos2], state[pos4, pos2],
						state[pos1, pos3], state[pos2, pos3], state[pos3, pos3], state[pos4, pos3],
						state[pos1, pos4], state[pos2, pos4], state[pos3, pos4], state[pos4, pos4])
end 

@inline function get_8_by_8(state::AbstractMatrix, pos1::Int, pos2::Int, pos3::Int, pos4::Int, pos5::Int, pos6::Int, pos7::Int, pos8::Int)
	return SMatrix{8,8}(state[pos1, pos1], state[pos2, pos1], state[pos3, pos1], state[pos4, pos1], state[pos5, pos1], state[pos6, pos1], state[pos7, pos1], state[pos8, pos1],
						state[pos1, pos2], state[pos2, pos2], state[pos3, pos2], state[pos4, pos2], state[pos5, pos2], state[pos6, pos2], state[pos7, pos2], state[pos8, pos2],
						state[pos1, pos3], state[pos2, pos3], state[pos3, pos3], state[pos4, pos3], state[pos5, pos3], state[pos6, pos3], state[pos7, pos3], state[pos8, pos3],
						state[pos1, pos4], state[pos2, pos4], state[pos3, pos4], state[pos4, pos4], state[pos5, pos4], state[pos6, pos4], state[pos7, pos4], state[pos8, pos4],
						state[pos1, pos5], state[pos2, pos5], state[pos3, pos5], state[pos4, pos5], state[pos5, pos5], state[pos6, pos5], state[pos7, pos5], state[pos8, pos5],
						state[pos1, pos6], state[pos2, pos6], state[pos3, pos6], state[pos4, pos6], state[pos5, pos6], state[pos6, pos6], state[pos7, pos6], state[pos8, pos6],
						state[pos1, pos7], state[pos2, pos7], state[pos3, pos7], state[pos4, pos7], state[pos5, pos7], state[pos6, pos7], state[pos7, pos7], state[pos8, pos7],
						state[pos1, pos8], state[pos2, pos8], state[pos3, pos8], state[pos4, pos8], state[pos5, pos8], state[pos6, pos8], state[pos7, pos8], state[pos8, pos8])
end 


function _expectation_value_util(pos::Int, m::AbstractMatrix, state::AbstractMatrix)
	(size(m, 1) == size(m, 2)) || error(""observable must be a square matrix."")
	(size(m, 1) == 2) || error(""input must be a 2 by 2 matrix."")
	sj = 2
	s1 = 2^(pos-1)
	s2 = s1 * sj
	L = size(state, 1)
	r = zero(eltype(state))
	for i in 0:s2:(L-1)
		for j in 0:(s1-1)
			pos_start = i + j + 1
		    v = get_2_by_2(state, pos_start, pos_start + s1)
		    @fastmath r += tr(m * v)
		end
	end
	return r
end

# function _expectation_value_util(pos::Int, m::AbstractMatrix, state::AbstractMatrix, state_c::AbstractMatrix)
# 	(size(m, 1) == size(m, 2)) || error(""observable must be a square matrix."")
# 	(size(m, 1) == 2) || error(""input must be a 2 by 2 matrix."")
# 	sj = 2
# 	s1 = 2^(pos-1)
# 	s2 = s1 * sj
# 	L = size(state, 1)
# 	r = zero(eltype(state))
# 	for i in 0:s2:(L-1)
# 		for j in 0:(s1-1)
# 		    pos_start = i + j + 1
# 		    pos_b = pos_start + s1
# 		    v = get_2_by_2(state, pos_start, pos_b)
# 		    v_c = get_2_by_2(state_c, pos_start, pos_b)
# 		    @fastmath r += dot(v_c, m, v)
# 		end
# 	end
# 	return r
# end

function _expectation_value_util(key::Tuple{Int, Int}, m::AbstractMatrix, v::AbstractMatrix)
	(size(m, 1) == size(m, 2)) || error(""observable must be a square matrix."")
	(size(m, 1) == 4) || error(""input must be a 4 by 4 matrix."")
    L = size(v, 1)
    q1, q2 = key
    pos1, pos2 = 2^(q1-1), 2^(q2-1)
    stride1, stride2 = 2 * pos1, 2 * pos2
    r = zero(eltype(v))
    for i in 0:stride2:(L-1)
        for j in 0:stride1:(pos2-1)
            @inbounds for k in 0:(pos1-1)
                l = i + j + k + 1
                vi = get_4_by_4(v, l, l + pos1, l + pos2, l + pos1 + pos2)
                @fastmath r += tr(m * vi)
            end
        end
    end
    return r
end


# function _expectation_value_util(key::Tuple{Int, Int}, m::AbstractMatrix, v::AbstractMatrix, v_c::AbstractMatrix)
# 	(size(m, 1) == size(m, 2)) || error(""observable must be a square matrix."")
# 	(size(m, 1) == 4) || error(""input must be a 4 by 4 matrix."")
#     L = size(v, 1)
#     q1, q2 = key
#     pos1, pos2 = 2^(q1-1), 2^(q2-1)
#     stride1, stride2 = 2 * pos1, 2 * pos2
#     r = zero(eltype(v))
#     for i in 0:stride2:(L-1)
#         for j in 0:stride1:(pos2-1)
#             @inbounds for k in 0:(pos1-1)
#                 l = i + j + k + 1
#                 vi = get_4_by_4(v, l, l + pos1, l + pos2, l + pos1 + pos2)
#                 vi_c = get_4_by_4(v_c, l, l + pos1, l + pos2, l + pos1 + pos2)
#                 @fastmath r += dot(vi_c, m, vi)
#             end
#         end
#     end
#     return r
# end

function _expectation_value_util(key::Tuple{Int, Int, Int}, m::AbstractMatrix, v::AbstractMatrix)
    L = size(v, 1)
    q1, q2, q3 = key
    pos1, pos2, pos3 = 2^(q1-1), 2^(q2-1), 2^(q3-1)
    stride1, stride2, stride3 = 2 * pos1, 2 * pos2, 2 * pos3
    r = zero(eltype(v))
   	for h in 0:stride3:(L-1)
   		for i in 0:stride2:(pos3-1)
   			for j in 0:stride1:(pos2-1)
   				@inbounds for k in 0:(pos1-1)
   					l000 = h + i + j + k + 1
   					l100 = l000 + pos1
            		l010 = l000 + pos2
            		l110 = l010 + pos1

            		l001 = l000 + pos3
            		l101 = l001 + pos1
            		l011 = l001 + pos2
            		l111 = l011 + pos1
                	vi = get_8_by_8(v, l000, l100, l010, l110, l001, l101, l011, l111)
                	@fastmath r += tr(m * vi)
            	end
        	end
    	end
    end
    return r
end


# function _expectation_value_util(key::Tuple{Int, Int, Int}, m::AbstractMatrix, v::AbstractMatrix, v_c::AbstractMatrix)
#     L = size(v, 1)
#     q1, q2, q3 = key
#     pos1, pos2, pos3 = 2^(q1-1), 2^(q2-1), 2^(q3-1)
#     stride1, stride2, stride3 = 2 * pos1, 2 * pos2, 2 * pos3
#     r = zero(eltype(v))
#    	for h in 0:stride3:(L-1)
#    		for i in 0:stride2:(pos3-1)
#    			for j in 0:stride1:(pos2-1)
#    				@inbounds for k in 0:(pos1-1)
#    					l000 = h + i + j + k + 1
#    					l100 = l000 + pos1
#             		l010 = l000 + pos2
#             		l110 = l010 + pos1

#             		l001 = l000 + pos3
#             		l101 = l001 + pos1
#             		l011 = l001 + pos2
#             		l111 = l011 + pos1
#                 	vi = get_8_by_8(v, l000, l100, l010, l110, l001, l101, l011, l111)
#                 	vi_c = get_8_by_8(v_c, l000, l100, l010, l110, l001, l101, l011, l111)
#                 	@fastmath r += dot(vi_c, m, vi)
#             	end
#         	end
#     	end
#     end
#     return r
# end

# expectation_value_serial(pos::Int, m::AbstractMatrix, state::AbstractMatrix, state_c::AbstractMatrix) = _expectation_value_util(
# 	pos, SMatrix{2,2, eltype(state)}(m), state, state_c)
expectation_value_serial(pos::Int, m::AbstractMatrix, state::AbstractMatrix) = _expectation_value_util(
	pos, SMatrix{2,2, eltype(state)}(m), state)


# expectation_value_serial(pos::Tuple{Int}, m::AbstractMatrix, state::AbstractMatrix, state_c::AbstractMatrix) = expectation_value_serial(
# 	pos[1], m, state, state_c)
expectation_value_serial(pos::Tuple{Int}, m::AbstractMatrix, state::AbstractMatrix) = expectation_value_serial(
	pos[1], m, state)

# expectation_value_serial(pos::Tuple{Int, Int}, m::AbstractMatrix, state::AbstractMatrix, state_c::AbstractMatrix) = _expectation_value_util(
# 	pos, SMatrix{4,4, eltype(state)}(m), state, state_c)
expectation_value_serial(pos::Tuple{Int, Int}, m::AbstractMatrix, state::AbstractMatrix) = _expectation_value_util(
	pos, SMatrix{4,4, eltype(state)}(m), state)

# expectation_value_serial(pos::Tuple{Int, Int, Int}, m::AbstractMatrix, state::AbstractMatrix, state_c::AbstractMatrix) = _expectation_value_util(
# 	pos, m, state, state_c) 
expectation_value_serial(pos::Tuple{Int, Int, Int}, m::AbstractMatrix, state::AbstractMatrix) = _expectation_value_util(
	pos, SMatrix{8,8, eltype(state)}(m), state)

","Julia"
"Conjugate","guochu/VQC.jl","src/hamiltonian/expecs/expec_high_qubit_terms.jl",".jl","4926","127","

function _expectation_value_fourbody_util(key::Tuple{Int, Int, Int, Int}, U::AbstractMatrix, v::AbstractVector)
    L = length(v)
    q1, q2, q3, q4 = key
    pos1, pos2, pos3, pos4 = 1 << (q1-1), 1 << (q2-1), 1 << (q3-1), 1 << (q4-1)
    # stride2, stride3 = pos1 << 1, pos2 << 1
    mask0 = pos1 - 1
    mask1 = xor(pos2 - 1, 2 * pos1 - 1)
    mask2 = xor(pos3 - 1, 2 * pos2 - 1)
    mask3 = xor(pos4 - 1, 2 * pos3 - 1)
    mask4 = xor(L - 1, 2 * pos4 - 1)
    # println(""pos1=$pos1, pos2=$pos2, m0=$mask0, m1=$mask1, m2=$mask2"")

    
    function f(ist::Int, ifn::Int, posa::Int, posb::Int, posc::Int, posd::Int, m1::Int, m2::Int, m3::Int, 
    	m4::Int, m5::Int, mat::AbstractMatrix, p::AbstractVector) 
    	r = zero(eltype(p))
        @inbounds for i in ist:ifn
            l0000 = (16 * i & m5) | (8 * i & m4) | (4 * i & m3) | (2 * i & m2) | (i & m1) + 1
            l1000 = l0000 + posa
            l0100 = l0000 + posb
            l0010 = l0000 + posc
            l0001 = l0000 + posd

            l1100 = l0100 + posa
            l1010 = l0010 + posa
            l1001 = l1000 + posd
            l0110 = l0010 + posb
            l0101 = l0100 + posd
            l0011 = l0010 + posd
            
            l1110 = l1100 + posc
            l1101 = l1100 + posd
            l1011 = l1010 + posd
            l0111 = l0110 + posd

            l1111 = l1110 + posd

            vi = SVector(p[l0000], p[l1000], p[l0100], p[l1100], p[l0010], p[l1010], p[l0110], p[l1110],
                p[l0001], p[l1001], p[l0101], p[l1101], p[l0011], p[l1011], p[l0111], p[l1111])

            @fastmath r += dot(vi, mat, vi)
        end
        return r
    end
    total_itr = div(L, 16)
    return parallel_sum(eltype(v), total_itr, Threads.nthreads(), f, pos1, pos2, pos3, pos4, mask0, mask1, mask2, mask3, mask4, U, v)
end

expectation_value_threaded(key::Tuple{Int, Int, Int, Int}, U::AbstractMatrix, v::AbstractVector) = _expectation_value_fourbody_util(
	key, SMatrix{16,16, eltype(v)}(U), v)


function _expectation_value_fivebody_util(key::Tuple{Int, Int, Int, Int, Int}, U::AbstractMatrix, v::AbstractVector)
    L = length(v)
    q1, q2, q3, q4, q5 = key
    pos1, pos2, pos3, pos4, pos5 = 1 << (q1-1), 1 << (q2-1), 1 << (q3-1), 1 << (q4-1), 1 << (q5-1)
    # stride2, stride3 = pos1 << 1, pos2 << 1
    mask0 = pos1 - 1
    mask1 = xor(pos2 - 1, 2 * pos1 - 1)
    mask2 = xor(pos3 - 1, 2 * pos2 - 1)
    mask3 = xor(pos4 - 1, 2 * pos3 - 1)
    mask4 = xor(pos5 - 1, 2 * pos4 - 1)
    mask5 = xor(L - 1, 2 * pos5 - 1)
    # println(""pos1=$pos1, pos2=$pos2, m0=$mask0, m1=$mask1, m2=$mask2"")

    function f(ist::Int, ifn::Int, posa::Int, posb::Int, posc::Int, posd::Int, pose::Int, 
        m1::Int, m2::Int, m3::Int, m4::Int, m5::Int, m6::Int, mat::AbstractMatrix, p::AbstractVector) 
    	r = zero(eltype(p))
        @inbounds for i in ist:ifn
            l00000 = (32 * i & m6) | (16 * i & m5) | (8 * i & m4) | (4 * i & m3) | (2 * i & m2) | (i & m1) + 1
            l10000 = l00000 + posa
            l01000 = l00000 + posb
            l00100 = l00000 + posc
            l00010 = l00000 + posd
            l00001 = l00000 + pose

            l11000 = l01000 + posa
            l10100 = l00100 + posa
            l10010 = l10000 + posd
            l10001 = l10000 + pose
            l01100 = l00100 + posb
            l01010 = l01000 + posd
            l01001 = l01000 + pose
            l00110 = l00100 + posd
            l00101 = l00100 + pose
            l00011 = l00010 + pose

            
            l11100 = l11000 + posc
            l11010 = l11000 + posd
            l11001 = l11000 + pose
            l10110 = l10100 + posd
            l10101 = l10100 + pose
            l10011 = l10010 + pose
            l01110 = l01100 + posd
            l01101 = l01100 + pose
            l01011 = l01010 + pose
            l00111 = l00110 + pose

            l11110 = l11100 + posd
            l11101 = l11100 + pose
            l11011 = l11010 + pose
            l10111 = l10110 + pose
            l01111 = l01110 + pose

            l11111 = l11110 + pose

            vi = SVector(p[l00000], p[l10000], p[l01000], p[l11000], p[l00100], p[l10100], p[l01100], p[l11100],
                p[l00010], p[l10010], p[l01010], p[l11010], p[l00110], p[l10110], p[l01110], p[l11110],
                p[l00001], p[l10001], p[l01001], p[l11001], p[l00101], p[l10101], p[l01101], p[l11101],
                p[l00011], p[l10011], p[l01011], p[l11011], p[l00111], p[l10111], p[l01111], p[l11111])


            @fastmath r += dot(vi, mat, vi)
        end
        return r
    end
    total_itr = div(L, 32)
    parallel_sum(eltype(v), total_itr, Threads.nthreads(), f, pos1, pos2, pos3, pos4, pos5, mask0, mask1, mask2, mask3, mask4, mask5, U, v)
end


expectation_value_threaded(key::Tuple{Int, Int, Int, Int, Int}, U::AbstractMatrix, v::AbstractVector) = _expectation_value_fivebody_util(
	key, SMatrix{32,32, eltype(v)}(U), v)
","Julia"
"Conjugate","guochu/VQC.jl","src/hamiltonian/expecs/expec_serial.jl",".jl","4890","130","
function _expectation_value_util(pos::Int, m::AbstractMatrix, state::AbstractVector)
	(size(m, 1) == size(m, 2)) || error(""observable must be a square matrix."")
	(size(m, 1) == 2) || error(""input must be a 2 by 2 matrix."")
	sj = 2
	s1 = 2^(pos-1)
	s2 = s1 * sj
	r = zero(eltype(state))
	for i in 0:s2:(length(state)-1)
		for j in 0:(s1-1)
		    pos_start = i + j + 1
		    v = SVector(state[pos_start], state[pos_start + s1])
		    @fastmath r += dot(v, m, v)
		end
	end
	return r
end

function _expectation_value_util(pos::Int, m::AbstractMatrix, state::AbstractVector, state_c::AbstractVector)
	(size(m, 1) == size(m, 2)) || error(""observable must be a square matrix."")
	(size(m, 1) == 2) || error(""input must be a 2 by 2 matrix."")
	sj = 2
	s1 = 2^(pos-1)
	s2 = s1 * sj
	r = zero(eltype(state))
	for i in 0:s2:(length(state)-1)
		for j in 0:(s1-1)
		    pos_start = i + j + 1
		    v = SVector(state[pos_start], state[pos_start + s1])
		    v_c = SVector(state_c[pos_start], state_c[pos_start + s1])
		    @fastmath r += dot(v_c, m, v)
		end
	end
	return r
end

function _expectation_value_util(key::Tuple{Int, Int}, m::AbstractMatrix, v::AbstractVector)
	(size(m, 1) == size(m, 2)) || error(""observable must be a square matrix."")
	(size(m, 1) == 4) || error(""input must be a 4 by 4 matrix."")
    L = length(v)
    q1, q2 = key
    pos1, pos2 = 2^(q1-1), 2^(q2-1)
    stride1, stride2 = 2 * pos1, 2 * pos2
    r = zero(eltype(v))
    for i in 0:stride2:(L-1)
        for j in 0:stride1:(pos2-1)
            @inbounds for k in 0:(pos1-1)
                l = i + j + k + 1
                vi = SVector(v[l], v[l + pos1], v[l + pos2], v[l + pos1 + pos2])
                @fastmath r += dot(vi, m, vi)
            end
        end
    end
    return r
end


function _expectation_value_util(key::Tuple{Int, Int}, m::AbstractMatrix, v::AbstractVector, v_c::AbstractVector)
	(size(m, 1) == size(m, 2)) || error(""observable must be a square matrix."")
	(size(m, 1) == 4) || error(""input must be a 4 by 4 matrix."")
    L = length(v)
    q1, q2 = key
    pos1, pos2 = 2^(q1-1), 2^(q2-1)
    stride1, stride2 = 2 * pos1, 2 * pos2
    r = zero(eltype(v))
    for i in 0:stride2:(L-1)
        for j in 0:stride1:(pos2-1)
            @inbounds for k in 0:(pos1-1)
                l = i + j + k + 1
                vi = SVector(v[l], v[l + pos1], v[l + pos2], v[l + pos1 + pos2])
                vi_c = SVector(v_c[l], v_c[l + pos1], v_c[l + pos2], v_c[l + pos1 + pos2])
                @fastmath r += dot(vi_c, m, vi)
            end
        end
    end
    return r
end


function _expectation_value_util(key::Tuple{Int, Int, Int}, m::AbstractMatrix, v::AbstractVector, v_c::AbstractVector)
    L = length(v)
    q1, q2, q3 = key
    pos1, pos2, pos3 = 2^(q1-1), 2^(q2-1), 2^(q3-1)
    stride1, stride2, stride3 = 2 * pos1, 2 * pos2, 2 * pos3
    r = zero(eltype(v))
   	for h in 0:stride3:(L-1)
   		for i in 0:stride2:(pos3-1)
   			for j in 0:stride1:(pos2-1)
   				@inbounds for k in 0:(pos1-1)
   					l000 = h + i + j + k + 1
   					l100 = l000 + pos1
            		l010 = l000 + pos2
            		l110 = l010 + pos1

            		l001 = l000 + pos3
            		l101 = l001 + pos1
            		l011 = l001 + pos2
            		l111 = l011 + pos1
                	vi = SVector(v[l000], v[l100], v[l010], v[l110], v[l001], v[l101], v[l011], v[l111])
                	vi_c = SVector(v_c[l000], v_c[l100], v_c[l010], v_c[l110], v_c[l001], v_c[l101], v_c[l011], v_c[l111])
                	@fastmath r += dot(vi_c, m, vi)
            	end
        	end
    	end
    end
    return r
end

expectation_value_serial(pos::Int, m::AbstractMatrix, state::AbstractVector, state_c::AbstractVector) = _expectation_value_util(
	pos, SMatrix{2,2, eltype(state)}(m), state, state_c)
expectation_value_serial(pos::Int, m::AbstractMatrix, state::AbstractVector) = _expectation_value_util(
	pos, SMatrix{2,2, eltype(state)}(m), state)


expectation_value_serial(pos::Tuple{Int}, m::AbstractMatrix, state::AbstractVector, state_c::AbstractVector) = expectation_value_serial(
	pos[1], m, state, state_c)
expectation_value_serial(pos::Tuple{Int}, m::AbstractMatrix, state::AbstractVector) = expectation_value_serial(
	pos[1], m, state)

expectation_value_serial(pos::Tuple{Int, Int}, m::AbstractMatrix, state::AbstractVector, state_c::AbstractVector) = _expectation_value_util(
	pos, SMatrix{4,4, eltype(state)}(m), state, state_c)
expectation_value_serial(pos::Tuple{Int, Int}, m::AbstractMatrix, state::AbstractVector) = _expectation_value_util(
	pos, SMatrix{4,4, eltype(state)}(m), state)

expectation_value_serial(pos::Tuple{Int, Int, Int}, m::AbstractMatrix, state::AbstractVector, state_c::AbstractVector) = _expectation_value_util(
	pos, m, state, state_c) 
expectation_value_serial(pos::Tuple{Int, Int, Int}, m::AbstractMatrix, state::AbstractVector) = expectation_value_serial(
	pos, m, state, state)

","Julia"
"Conjugate","guochu/VQC.jl","src/hamiltonian/expecs/expec_threaded.jl",".jl","25008","654","
""""""
    applys when key > 3, U is the transposed op
""""""
function _expectation_value_util_H(key::Int, U::AbstractMatrix, v::AbstractVector)
    L = length(v)
    sizek = 1 << (key - 1)
    mask0 = sizek - 1
    mask1 = xor(L - 1, 2 * sizek - 1)
    f(ist::Int, ifn::Int, pos::Int, m1::Int, m2::Int, mat::AbstractMatrix, p::AbstractVector) = begin
    	r = zero(eltype(p))
        @inbounds for i in ist:ifn
            l = (16 * i & m2) | (8 * i & m1) + 1
            l1 = l + pos
            vi = SMatrix{8, 2}(p[l], p[l+1], p[l+2], p[l+3], p[l+4], p[l+5], p[l+6], p[l+7],
            p[l1], p[l1+1], p[l1+2], p[l1+3], p[l1+4], p[l1+5], p[l1+6], p[l1+7])

            vi_t = transpose(vi)
            @fastmath r += dot(vi_t, mat, vi_t)
        end
        return r
    end

	return parallel_sum(eltype(v), div(L, 16), Threads.nthreads(), f, sizek, mask0, mask1, U, v)
end

""""""
    applys when key <= 3, U is the transposed op
""""""
function _expectation_value_util_L(key::Int, U::AbstractMatrix, v::AbstractVector)
    L = length(v)
    f1(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector) = begin
    	r = zero(eltype(p))
        @inbounds for i in ist:ifn
            l = 16 * i + 1
            vi = SMatrix{2, 8}(p[l], p[l+1], p[l+2], p[l+3], p[l+4], p[l+5], p[l+6], p[l+7],
            p[l+8], p[l+9], p[l+10], p[l+11], p[l+12], p[l+13], p[l+14], p[l+15])

            @fastmath r += dot(vi, mat, vi)
        end
        return r
    end
    f2(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector) = begin
    	r = zero(eltype(p))
        @inbounds for i in ist:ifn
            l = 16 * i + 1
            vi = SMatrix{2, 8}(p[l], p[l+2], p[l+1], p[l+3], p[l+4], p[l+6], p[l+5], p[l+7],
            p[l+8], p[l+10], p[l+9], p[l+11], p[l+12], p[l+14], p[l+13], p[l+15])

            @fastmath r += dot(vi, mat, vi)
        end
        return r
    end
    f3(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector) = begin
    	r = zero(eltype(p))
        @inbounds for i in ist:ifn
            l = 16 * i + 1
            vi = SMatrix{2, 8}(p[l], p[l+4], p[l+1], p[l+5], p[l+2], p[l+6], p[l+3], p[l+7],
            p[l+8], p[l+12], p[l+9], p[l+13], p[l+10], p[l+14], p[l+11], p[l+15])

            @fastmath r += dot(vi, mat, vi)
        end
        return r
    end
    if key == 1
        f = f1
    elseif key == 2
        f = f2
    elseif key == 3
        f = f3
    else
        error(""qubit position $key not allowed for L."")
    end

    parallel_sum(eltype(v), div(L, 16), Threads.nthreads(), f, U, v)
end

function _expectation_value_threaded_util(q0::Int, U::AbstractMatrix, v::AbstractVector)
    if q0 > 3
        return _expectation_value_util_H(q0, SMatrix{2,2, eltype(v)}(U), v)
    else
        return _expectation_value_util_L(q0, SMatrix{2,2, eltype(v)}(U), v)
    end
end
_expectation_value_threaded_util(q0::Tuple{Int}, U::AbstractMatrix, v::AbstractVector) = _expectation_value_threaded_util(
    q0[1], U, v)



""""""
    applys when both keys > 3, U is the transposed op
""""""
function _expectation_value_util_HH(key::Tuple{Int, Int}, U::AbstractMatrix, v::AbstractVector)
    L = length(v)
    q1, q2 = key
    pos1, pos2 = 1 << (q1-1), 1 << (q2-1)
    # stride2, stride3 = pos1 << 1, pos2 << 1
    mask0 = pos1 - 1
    mask1 = xor(pos2 - 1, 2 * pos1 - 1)
    mask2 = xor(L - 1, 2 * pos2 - 1)
    # println(""pos1=$pos1, pos2=$pos2, m0=$mask0, m1=$mask1, m2=$mask2"")

    total_itr = div(L, 32)
    f(ist::Int, ifn::Int, posa::Int, posb::Int, m1::Int, m2::Int, m3::Int, mat::AbstractMatrix, p::AbstractVector) = begin
    	r = zero(eltype(p))
        @inbounds for i in ist:ifn
            l = (32 * i & m3) | (16 * i & m2) | (8 * i & m1) + 1
            # l = div(l, 2) + 1
            l1 = l + posa
            l2 = l + posb
            l3 = l2 + posa
            # println(""l0=$l, l1=$l1, l2=$l2, l3=$l3"")
            vi = SMatrix{8, 4}(p[l], p[l+1], p[l+2], p[l+3], p[l+4], p[l+5], p[l+6], p[l+7],
            p[l1], p[l1+1], p[l1+2], p[l1+3], p[l1+4], p[l1+5], p[l1+6], p[l1+7],
            p[l2], p[l2+1], p[l2+2], p[l2+3], p[l2+4], p[l2+5], p[l2+6], p[l2+7],
            p[l3], p[l3+1], p[l3+2], p[l3+3], p[l3+4], p[l3+5], p[l3+6], p[l3+7])

            vi_t = transpose(vi)
            @fastmath r += dot(vi_t, mat, vi_t)
        end
        return r
    end

    parallel_sum(eltype(v), total_itr, Threads.nthreads(), f, pos1, pos2, mask0, mask1, mask2, U, v)
end


""""""
    applys when q1 <= 3 and q2 > 4, U is the transposed op
""""""
function _expectation_value_util_LH(key::Tuple{Int, Int}, U::AbstractMatrix, v::AbstractVector)
    L = length(v)
    q1, q2 = key
    sizej = 1 << (q2-1)
    mask0 = sizej - 1
    mask1 = xor(L - 1, 2 * sizej - 1)

    f1H(ist::Int, ifn::Int, posb::Int, m1::Int, m2::Int, mat::AbstractMatrix, p::AbstractVector) = begin
    	r = zero(eltype(p))
        @inbounds for i in ist:ifn
            l = (32 * i & m2) | (16 * i & m1)
            l1 = l + posb
            # println(""l=$l, l1=$l1"")
            vi = SMatrix{8, 4}(p[l+1], p[l+3], p[l+5], p[l+7], p[l+9], p[l+11], p[l+13], p[l+15],
            p[l+2], p[l+4], p[l+6], p[l+8], p[l+10], p[l+12], p[l+14], p[l+16],
            p[l1+1], p[l1+3], p[l1+5], p[l1+7], p[l1+9], p[l1+11], p[l1+13], p[l1+15],
            p[l1+2], p[l1+4], p[l1+6], p[l1+8], p[l1+10], p[l1+12], p[l1+14], p[l1+16])

            vi_t = transpose(vi)
            @fastmath r += dot(vi_t, mat, vi_t)
        end
        return r
    end

    f2H(ist::Int, ifn::Int, posb::Int, m1::Int, m2::Int, mat::AbstractMatrix, p::AbstractVector) = begin
    	r = zero(eltype(p))
        @inbounds for i in ist:ifn
            l = (32 * i & m2) | (16 * i & m1)
            l1 = l + posb
            # println(""l=$l, l1=$l1"")
            vi = SMatrix{8, 4}(p[l+1], p[l+2], p[l+5], p[l+6], p[l+9], p[l+10], p[l+13], p[l+14],
            p[l+3], p[l+4], p[l+7], p[l+8], p[l+11], p[l+12], p[l+15], p[l+16],
            p[l1+1], p[l1+2], p[l1+5], p[l1+6], p[l1+9], p[l1+10], p[l1+13], p[l1+14],
            p[l1+3], p[l1+4], p[l1+7], p[l1+8], p[l1+11], p[l1+12], p[l1+15], p[l1+16])

            vi_t = transpose(vi)
            @fastmath r += dot(vi_t, mat, vi_t)
        end
        return r
    end

    f3H(ist::Int, ifn::Int, posb::Int, m1::Int, m2::Int, mat::AbstractMatrix, p::AbstractVector) = begin
    	r = zero(eltype(p))
        @inbounds for i in ist:ifn
            l = (32 * i & m2) | (16 * i & m1)
            l1 = l + posb
            # println(""l=$l, l1=$l1"")
            vi = SMatrix{8, 4}(p[l+1], p[l+2], p[l+3], p[l+4], p[l+9], p[l+10], p[l+11], p[l+12],
            p[l+5], p[l+6], p[l+7], p[l+8], p[l+13], p[l+14], p[l+15], p[l+16],
            p[l1+1], p[l1+2], p[l1+3], p[l1+4], p[l1+9], p[l1+10], p[l1+11], p[l1+12],
            p[l1+5], p[l1+6], p[l1+7], p[l1+8], p[l1+13], p[l1+14], p[l1+15], p[l1+16])

            vi_t = transpose(vi)
            @fastmath r += dot(vi_t, mat, vi_t)
        end
        return r
    end

    if q1 == 1
        f = f1H
    elseif q1 == 2
        f = f2H
    elseif q1 == 3
        f = f3H
    else
        error(""qubit position $q1 not allowed for LH."")
    end
    total_itr = div(L, 32)

    parallel_sum(eltype(v), total_itr, Threads.nthreads(), f, sizej, mask0, mask1, U, v)
end

""""""
    applys when both keys <= 4
""""""
function _expectation_value_util_LL(key::Tuple{Int, Int}, U::AbstractMatrix, v::AbstractVector)
    L = length(v)
    q1, q2 = key
    f12(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector) = begin
    	r = zero(eltype(p))
        @inbounds for i in ist:ifn
            l = 32 * i + 1
            vi = SMatrix{4, 8}(p[l], p[l+1], p[l+2], p[l+3], p[l+4], p[l+5], p[l+6], p[l+7],
            p[l+8], p[l+9], p[l+10], p[l+11], p[l+12], p[l+13], p[l+14], p[l+15],
            p[l+16], p[l+17], p[l+18], p[l+19], p[l+20], p[l+21], p[l+22], p[l+23],
            p[l+24], p[l+25], p[l+26], p[l+27], p[l+28], p[l+29], p[l+30], p[l+31])

            @fastmath r += dot(vi, mat, vi)
        end
        return r
    end
    f13(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector) = begin
    	r = zero(eltype(p))
        @inbounds for i in ist:ifn
            l = 32 * i + 1
            vi = SMatrix{4, 8}(p[l], p[l+1], p[l+4], p[l+5], p[l+2], p[l+3], p[l+6], p[l+7],
            p[l+8], p[l+9], p[l+12], p[l+13], p[l+10], p[l+11], p[l+14], p[l+15],
            p[l+16], p[l+17], p[l+20], p[l+21], p[l+18], p[l+19], p[l+22], p[l+23],
            p[l+24], p[l+25], p[l+28], p[l+29], p[l+26], p[l+27], p[l+30], p[l+31])

            @fastmath r += dot(vi, mat, vi)
        end
        return r
    end
    f14(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector) = begin
    	r = zero(eltype(p))
        @inbounds for i in ist:ifn
            l = 32 * i
            vi = SMatrix{4, 8}(p[l+1], p[l+2], p[l+9], p[l+10], p[l+3], p[l+4], p[l+11], p[l+12],
            p[l+5], p[l+6], p[l+13], p[l+14], p[l+7], p[l+8], p[l+15], p[l+16],
            p[l+17], p[l+18], p[l+25], p[l+26], p[l+19], p[l+20], p[l+27], p[l+28],
            p[l+21], p[l+22], p[l+29], p[l+30], p[l+23], p[l+24], p[l+31], p[l+32])

            @fastmath r += dot(vi, mat, vi)
        end
        return r
    end
    f23(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector) = begin
   	 	r = zero(eltype(p))
        @inbounds for i in ist:ifn
            l = 32 * i + 1
            vi = SMatrix{4, 8}(p[l], p[l+2], p[l+4], p[l+6], p[l+1], p[l+3], p[l+5], p[l+7],
            p[l+8], p[l+10], p[l+12], p[l+14], p[l+9], p[l+11], p[l+13], p[l+15],
            p[l+16], p[l+18], p[l+20], p[l+22], p[l+17], p[l+19], p[l+21], p[l+23],
            p[l+24], p[l+26], p[l+28], p[l+30], p[l+25], p[l+27], p[l+29], p[l+31])

            @fastmath r += dot(vi, mat, vi)
        end
        return r
    end
    f24(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector) = begin
    	r = zero(eltype(p))
        @inbounds for i in ist:ifn
            l = 32 * i
            vi = SMatrix{4, 8}(p[l+1], p[l+3], p[l+9], p[l+11], p[l+2], p[l+4], p[l+10], p[l+12],
            p[l+5], p[l+7], p[l+13], p[l+15], p[l+6], p[l+8], p[l+14], p[l+16],
            p[l+17], p[l+19], p[l+25], p[l+27], p[l+18], p[l+20], p[l+26], p[l+28],
            p[l+21], p[l+23], p[l+29], p[l+31], p[l+22], p[l+24], p[l+30], p[l+32])

            @fastmath r += dot(vi, mat, vi)
        end
        return r
    end
    f34(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector) = begin
    	r = zero(eltype(p))
        @inbounds for i in ist:ifn
            l = 32 * i
            vi = SMatrix{4, 8}(p[l+1], p[l+5], p[l+9], p[l+13], p[l+2], p[l+6], p[l+10], p[l+14],
            p[l+3], p[l+7], p[l+11], p[l+15], p[l+4], p[l+8], p[l+12], p[l+16],
            p[l+17], p[l+21], p[l+25], p[l+29], p[l+18], p[l+22], p[l+26], p[l+30],
            p[l+19], p[l+23], p[l+27], p[l+31], p[l+20], p[l+24], p[l+28], p[l+32])

            @fastmath r += dot(vi, mat, vi)
        end
        return r
    end
    if q1==1 && q2 == 2
        f = f12
    elseif q1==1 && q2 == 3
        f = f13
    elseif q1==1 && q2 == 4
        f = f14
    elseif q1==2 && q2 == 3
        f = f23
    elseif q1==2 && q2 == 4
        f = f24
    elseif q1==3 && q2 == 4
        f = f34
    else
        error(""qubit position $q1 and $q2 not allowed for LL."")
    end
    total_itr = div(L, 32)

    parallel_sum(eltype(v), total_itr, Threads.nthreads(), f, U, v)
end


function _expectation_value_threaded_util(key::Tuple{Int, Int}, U::AbstractMatrix, v::AbstractVector)
    q0, q1 = key
    if q0 > 3
        return _expectation_value_util_HH(key, SMatrix{4,4, eltype(v)}(U), v)
    elseif q1 > 4
        return _expectation_value_util_LH(key, SMatrix{4,4, eltype(v)}(U), v)
    else
        return _expectation_value_util_LL(key, SMatrix{4,4, eltype(v)}(U), v)
    end
end


""""""
    applys when both keys > 2, U is assumed to be transposed
""""""
function _expectation_value_util_HHH(key::Tuple{Int, Int, Int}, U::AbstractMatrix, v::AbstractVector)
    L = length(v)
    q1, q2, q3 = key
    pos1, pos2, pos3 = 1 << (q1-1), 1 << (q2-1), 1 << (q3-1)
    # stride2, stride3 = pos1 << 1, pos2 << 1
    mask0 = pos1 - 1
    mask1 = xor(pos2 - 1, 2 * pos1 - 1)
    mask2 = xor(pos3 - 1, 2 * pos2 - 1)
    mask3 = xor(L - 1, 2 * pos3 - 1)
    # println(""pos1=$pos1, pos2=$pos2, m0=$mask0, m1=$mask1, m2=$mask2"")

    total_itr = div(L, 32)
    f(ist::Int, ifn::Int, posa::Int, posb::Int, posc::Int, m1::Int, m2::Int, m3::Int, m4::Int, mat::AbstractMatrix, p::AbstractVector) = begin
    	r = zero(eltype(p))
        @inbounds for i in ist:ifn
            l000 = (32 * i & m4) | (16 * i & m3) | (8 * i & m2) | (4 * i & m1) + 1
            l100 = l000 + posa
            l010 = l000 + posb
            l110 = l010 + posa

            l001 = l000 + posc
            l101 = l001 + posa
            l011 = l001 + posb
            l111 = l011 + posa

            # println(""$l000, $l100, $l010, $l110, $l001, $l101, $l011, $l111"")
            vi = SMatrix{4, 8}(p[l000], p[l000+1], p[l000+2], p[l000+3],
                               p[l100], p[l100+1], p[l100+2], p[l100+3],
                               p[l010], p[l010+1], p[l010+2], p[l010+3],
                               p[l110], p[l110+1], p[l110+2], p[l110+3],
                               p[l001], p[l001+1], p[l001+2], p[l001+3],
                               p[l101], p[l101+1], p[l101+2], p[l101+3],
                               p[l011], p[l011+1], p[l011+2], p[l011+3],
                               p[l111], p[l111+1], p[l111+2], p[l111+3])

            vi_t = transpose(vi)

            @fastmath r += dot(vi_t, mat, vi_t)
        end
        return r
    end

    parallel_sum(eltype(v), total_itr, Threads.nthreads(), f, pos1, pos2, pos3, mask0, mask1, mask2, mask3, U, v)
end


""""""
    applys when q1 <= 2 and q2 > 3, U is the transposed op
""""""
function _expectation_value_util_LHH(key::Tuple{Int, Int, Int}, U::AbstractMatrix, v::AbstractVector)
    L = length(v)
    q1, q2, q3 = key
    sizej, sizel = 1 << (q2-1), 1 << (q3-1)
    mask0 = sizej - 1
    mask1 = xor(sizel - 1, 2 * sizej - 1)
    mask2 = xor(L-1, 2 * sizel - 1)

    f1H(ist::Int, ifn::Int, posb::Int, posc::Int, m1::Int, m2::Int, m3::Int, mat::AbstractMatrix, p::AbstractVector) = begin
    	r = zero(eltype(p))
        @inbounds for i in ist:ifn
            l = (32 * i & m3) | (16 * i & m2) | (8 * i & m1)
            l1 = l + posb
            l2 = l + posc
            l3 = l2 + posb
            # println(""$l, $l1, $l2, $l3"")
            vi = SMatrix{4, 8}(p[l+1], p[l+3], p[l+5], p[l+7],
                               p[l+2], p[l+4], p[l+6], p[l+8],
                               p[l1+1], p[l1+3], p[l1+5], p[l1+7],
                               p[l1+2], p[l1+4], p[l1+6], p[l1+8],
                               p[l2+1], p[l2+3], p[l2+5], p[l2+7],
                               p[l2+2], p[l2+4], p[l2+6], p[l2+8],
                               p[l3+1], p[l3+3], p[l3+5], p[l3+7],
                               p[l3+2], p[l3+4], p[l3+6], p[l3+8])

            vi_t = transpose(vi)
            @fastmath r += dot(vi_t, mat, vi_t)
        end
        return r
    end

    f2H(ist::Int, ifn::Int, posb::Int, posc::Int, m1::Int, m2::Int, m3::Int, mat::AbstractMatrix, p::AbstractVector) = begin
    	r = zero(eltype(p))
        @inbounds for i in ist:ifn
            l = (32 * i & m3) | (16 * i & m2) | (8 * i & m1)
            l1 = l + posb
            l2 = l + posc
            l3 = l2 + posb
            vi = SMatrix{4, 8}(p[l+1], p[l+2], p[l+5], p[l+6],
                               p[l+3], p[l+4], p[l+7], p[l+8],
                               p[l1+1], p[l1+2], p[l1+5], p[l1+6],
                               p[l1+3], p[l1+4], p[l1+7], p[l1+8],
                               p[l2+1], p[l2+2], p[l2+5], p[l2+6],
                               p[l2+3], p[l2+4], p[l2+7], p[l2+8],
                               p[l3+1], p[l3+2], p[l3+5], p[l3+6],
                               p[l3+3], p[l3+4], p[l3+7], p[l3+8])

            vi_t = transpose(vi)
            @fastmath r += dot(vi_t, mat, vi_t)
        end
        return r
    end

    f3H(ist::Int, ifn::Int, posb::Int, posc::Int, m1::Int, m2::Int, m3::Int, mat::AbstractMatrix, p::AbstractVector) = begin
    	r = zero(eltype(p))
        @inbounds for i in ist:ifn
            l = (32 * i & m3) | (16 * i & m2) | (8 * i & m1)
            l1 = l + posb
            l2 = l + posc
            l3 = l2 + posb
            vi = SMatrix{4, 8}(p[l+1], p[l+2], p[l+3], p[l+4],
                               p[l+5], p[l+6], p[l+7], p[l+8],
                               p[l1+1], p[l1+2], p[l1+3], p[l1+4],
                               p[l1+5], p[l1+6], p[l1+7], p[l1+8],
                               p[l2+1], p[l2+2], p[l2+3], p[l2+4],
                               p[l2+5], p[l2+6], p[l2+7], p[l2+8],
                               p[l3+1], p[l3+2], p[l3+3], p[l3+4],
                               p[l3+5], p[l3+6], p[l3+7], p[l3+8])

            vi_t = transpose(vi)
            @fastmath r += dot(vi_t, mat, vi_t)
        end
        return r
    end

    if q1 == 1
        f = f1H
    elseif q1 == 2
        f = f2H
    elseif q1 == 3
        f = f3H
    else
        error(""qubit position $q1 not allowed for LHH."")
    end
    (q2 > 3) || error(""qubit 2 position $q2 not allowed for LHH."")
    total_itr = div(L, 32)

    parallel_sum(eltype(v), total_itr, Threads.nthreads(), f, sizej, sizel, mask0, mask1, mask2, U, v)
end

""""""
    applys when q1, q2 <= 3 and q3 > 4, U is the transposed op
""""""
function _expectation_value_util_LLH(key::Tuple{Int, Int, Int}, U::AbstractMatrix, v::AbstractVector)
    L = length(v)
    q1, q2, q3 = key
    sizej = 1 << (q3-1)
    mask0 = sizej - 1
    mask1 = xor(L - 1, 2 * sizej - 1)

    f12H(ist::Int, ifn::Int, posb::Int, m1::Int, m2::Int, mat::AbstractMatrix, p::AbstractVector) = begin
    	r = zero(eltype(p))
        @inbounds for i in ist:ifn
            l = (32 * i & m2) | (16 * i & m1)
            l1 = l + posb
            # println(""l=$l, l1=$l1"")
            vi = SMatrix{4, 8}(p[l+1], p[l+5], p[l+9], p[l+13],
                               p[l+2], p[l+6], p[l+10], p[l+14],
                               p[l+3], p[l+7], p[l+11], p[l+15],
                               p[l+4], p[l+8], p[l+12], p[l+16],
                               p[l1+1], p[l1+5], p[l1+9], p[l1+13],
                               p[l1+2], p[l1+6], p[l1+10], p[l1+14],
                               p[l1+3], p[l1+7], p[l1+11], p[l1+15],
                               p[l1+4], p[l1+8], p[l1+12], p[l1+16])

 			vi_t = transpose(vi)
 			@fastmath r += dot(vi_t, mat, vi_t)
        end
        return r
    end

    f13H(ist::Int, ifn::Int, posb::Int, m1::Int, m2::Int, mat::AbstractMatrix, p::AbstractVector) = begin
    	r = zero(eltype(p))
        @inbounds for i in ist:ifn
            l = (32 * i & m2) | (16 * i & m1)
            l1 = l + posb
            # println(""l=$l, l1=$l1"")
            vi = SMatrix{4, 8}(p[l+1], p[l+3], p[l+9], p[l+11],
                               p[l+2], p[l+4], p[l+10], p[l+12],
                               p[l+5], p[l+7], p[l+13], p[l+15],
                               p[l+6], p[l+8], p[l+14], p[l+16],
                               p[l1+1], p[l1+3], p[l1+9], p[l1+11],
                               p[l1+2], p[l1+4], p[l1+10], p[l1+12],
                               p[l1+5], p[l1+7], p[l1+13], p[l1+15],
                               p[l1+6], p[l1+8], p[l1+14], p[l1+16])

 			vi_t = transpose(vi)
 			@fastmath r += dot(vi_t, mat, vi_t)
        end
        return r
    end

    f23H(ist::Int, ifn::Int, posb::Int, m1::Int, m2::Int, mat::AbstractMatrix, p::AbstractVector) = begin
    	r = zero(eltype(p))
        @inbounds for i in ist:ifn
            l = (32 * i & m2) | (16 * i & m1)
            l1 = l + posb
            # println(""l=$l, l1=$l1"")
            vi = SMatrix{4, 8}(p[l+1], p[l+2], p[l+9], p[l+10],
                               p[l+3], p[l+4], p[l+11], p[l+12],
                               p[l+5], p[l+6], p[l+13], p[l+14],
                               p[l+7], p[l+8], p[l+15], p[l+16],
                               p[l1+1], p[l1+2], p[l1+9], p[l1+10],
                               p[l1+3], p[l1+4], p[l1+11], p[l1+12],
                               p[l1+5], p[l1+6], p[l1+13], p[l1+14],
                               p[l1+7], p[l1+8], p[l1+15], p[l1+16])

             vi_t = transpose(vi)
 			@fastmath r += dot(vi_t, mat, vi_t)
        end
        return r
    end

    if q1 == 1 && q2 == 2
        f = f12H
    elseif q1 == 1 && q2 == 3
        f = f13H
    elseif q1 == 2 && q2 == 3
        f = f23H
    else
        error(""qubit position $q1 not allowed for LH."")
    end
    total_itr = div(L, 32)

    parallel_sum(eltype(v), total_itr, Threads.nthreads(), f, sizej, mask0, mask1, U, v)
end


""""""
    applys when both keys <= 4
""""""
function _expectation_value_util_LLL(key::Tuple{Int, Int, Int}, U::AbstractMatrix, v::AbstractVector)
    L = length(v)
    q1, q2, q3 = key
    f123(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector) = begin
    	r = zero(eltype(p))
        @inbounds for i in ist:ifn
            l = 32 * i + 1
            vi = SMatrix{8, 4}(p[l], p[l+1], p[l+2], p[l+3], p[l+4], p[l+5], p[l+6], p[l+7],
            p[l+8], p[l+9], p[l+10], p[l+11], p[l+12], p[l+13], p[l+14], p[l+15],
            p[l+16], p[l+17], p[l+18], p[l+19], p[l+20], p[l+21], p[l+22], p[l+23],
            p[l+24], p[l+25], p[l+26], p[l+27], p[l+28], p[l+29], p[l+30], p[l+31])

 			@fastmath r += dot(vi, mat, vi)
        end
        return r
    end
    f124(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector) = begin
    	r = zero(eltype(p))
        @inbounds for i in ist:ifn
            l = 32 * i
            vi = SMatrix{8, 4}(p[l+1], p[l+2], p[l+3], p[l+4], p[l+9], p[l+10], p[l+11], p[l+12],
                               p[l+5], p[l+6], p[l+7], p[l+8], p[l+13], p[l+14], p[l+15], p[l+16],
                               p[l+17], p[l+18], p[l+19], p[l+20], p[l+25], p[l+26], p[l+27], p[l+28],
                               p[l+21], p[l+22], p[l+23], p[l+24], p[l+29], p[l+30], p[l+31], p[l+32])

            @fastmath r += dot(vi, mat, vi)
        end
        return r
    end
    f134(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector) = begin
    	r = zero(eltype(p))
        @inbounds for i in ist:ifn
            l = 32 * i
            vi = SMatrix{8, 4}(p[l+1], p[l+2], p[l+5], p[l+6], p[l+9], p[l+10], p[l+13], p[l+14],
                               p[l+3], p[l+4], p[l+7], p[l+8], p[l+11], p[l+12], p[l+15], p[l+16],
                               p[l+17], p[l+18], p[l+21], p[l+22], p[l+25], p[l+26], p[l+29], p[l+30],
                               p[l+19], p[l+20], p[l+23], p[l+24], p[l+27], p[l+28], p[l+31], p[l+32])

            @fastmath r += dot(vi, mat, vi)
        end
        return r
    end
    f234(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector) = begin
    	r = zero(eltype(p))
        @inbounds for i in ist:ifn
            l = 32 * i
            vi = SMatrix{8, 4}(p[l+1], p[l+3], p[l+5], p[l+7], p[l+9], p[l+11], p[l+13], p[l+15],
                               p[l+2], p[l+4], p[l+6], p[l+8], p[l+10], p[l+12], p[l+14], p[l+16],
                               p[l+17], p[l+19], p[l+21], p[l+23], p[l+25], p[l+27], p[l+29], p[l+31],
                               p[l+18], p[l+20], p[l+22], p[l+24], p[l+26], p[l+28], p[l+30], p[l+32])

            @fastmath r += dot(vi, mat, vi)
        end
        return r
    end
    if q1==1 && q2 == 2 && q3 == 3
        f = f123
    elseif q1==1 && q2 == 2 && q3 == 4
        f = f124
    elseif q1==1 && q2 == 3 && q3 == 4
        f = f134
    elseif q1==2 && q2 == 3 && q3 == 4
        f = f234
    else
        error(""qubit position $q1 and $q2 not allowed for LL."")
    end
    total_itr = div(L, 32)

    parallel_sum(eltype(v), total_itr, Threads.nthreads(), f, U, v)
end

function _expectation_value_threaded_util(key::Tuple{Int, Int, Int}, U::AbstractMatrix, v::AbstractVector)
    q0, q1, q2 = key
    if q0 > 2
        return _expectation_value_util_HHH(key, SMatrix{8,8, eltype(v)}(U), v)
    elseif q1 > 3
        return _expectation_value_util_LHH(key, SMatrix{8,8, eltype(v)}(U), v)
    elseif q2 > 4
        return _expectation_value_util_LLH(key, SMatrix{8,8, eltype(v)}(U), v)
    else
        return _expectation_value_util_LLL(key, SMatrix{8,8, eltype(v)}(U), v)
    end
end


expectation_value_threaded(pos::Int, m::AbstractMatrix, state::AbstractVector) = _expectation_value_threaded_util(
	pos, m, state)

expectation_value_threaded(pos::Tuple{Int}, m::AbstractMatrix, state::AbstractVector) = expectation_value_threaded(
	pos[1], m, state)

expectation_value_threaded(pos::Tuple{Int, Int}, m::AbstractMatrix, state::AbstractVector) = _expectation_value_threaded_util(
	pos, m, state)

expectation_value_threaded(pos::Tuple{Int, Int, Int}, m::AbstractMatrix, state::AbstractVector) = _expectation_value_threaded_util(
	pos, m, state)





","Julia"
"Conjugate","guochu/VQC.jl","src/hamiltonian/expecs/expec_threaded_2.jl",".jl","35736","792","


""""""
    applys when key > 3, U is the transposed op
""""""
function _expectation_value_util_H(key::Int, U::AbstractMatrix, v::AbstractVector, vout::AbstractVector)
    L = length(v)
    sizek = 1 << (key - 1)
    mask0 = sizek - 1
    mask1 = xor(L - 1, 2 * sizek - 1)
    f(ist::Int, ifn::Int, pos::Int, m1::Int, m2::Int, mat::AbstractMatrix, p::AbstractVector, po::AbstractVector) = begin
    	r = zero(eltype(p))
        @inbounds for i in ist:ifn
            l = (16 * i & m2) | (8 * i & m1) + 1
            l1 = l + pos
            vi = SMatrix{8, 2}(p[l], p[l+1], p[l+2], p[l+3], p[l+4], p[l+5], p[l+6], p[l+7],
            p[l1], p[l1+1], p[l1+2], p[l1+3], p[l1+4], p[l1+5], p[l1+6], p[l1+7])

            vo = SMatrix{8, 2}(po[l], po[l+1], po[l+2], po[l+3], po[l+4], po[l+5], po[l+6], po[l+7],
            po[l1], po[l1+1], po[l1+2], po[l1+3], po[l1+4], po[l1+5], po[l1+6], po[l1+7])


            @fastmath r += dot(transpose(vo), mat, transpose(vi))
        end
        return r
    end

	return parallel_sum(eltype(v), div(L, 16), Threads.nthreads(), f, sizek, mask0, mask1, U, v, vout)
end

""""""
    applys when key <= 3, U is the transposed op
""""""
function _expectation_value_util_L(key::Int, U::AbstractMatrix, v::AbstractVector, vout::AbstractVector)
    L = length(v)
    f1(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector, po::AbstractVector) = begin
    	r = zero(eltype(p))
        @inbounds for i in ist:ifn
            l = 16 * i + 1
            vi = SMatrix{2, 8}(p[l], p[l+1], p[l+2], p[l+3], p[l+4], p[l+5], p[l+6], p[l+7],
            p[l+8], p[l+9], p[l+10], p[l+11], p[l+12], p[l+13], p[l+14], p[l+15])

            vo = SMatrix{2, 8}(po[l], po[l+1], po[l+2], po[l+3], po[l+4], po[l+5], po[l+6], po[l+7],
            po[l+8], po[l+9], po[l+10], po[l+11], po[l+12], po[l+13], po[l+14], po[l+15])

            @fastmath r += dot(vo, mat, vi)
        end
        return r
    end
    f2(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector, po::AbstractVector) = begin
    	r = zero(eltype(p))
        @inbounds for i in ist:ifn
            l = 16 * i + 1
            vi = SMatrix{2, 8}(p[l], p[l+2], p[l+1], p[l+3], p[l+4], p[l+6], p[l+5], p[l+7],
            p[l+8], p[l+10], p[l+9], p[l+11], p[l+12], p[l+14], p[l+13], p[l+15])

            vo = SMatrix{2, 8}(po[l], po[l+2], po[l+1], po[l+3], po[l+4], po[l+6], po[l+5], po[l+7],
            po[l+8], po[l+10], po[l+9], po[l+11], po[l+12], po[l+14], po[l+13], po[l+15])

            @fastmath r += dot(vo, mat, vi)
        end
        return r
    end
    f3(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector, po::AbstractVector) = begin
    	r = zero(eltype(p))
        @inbounds for i in ist:ifn
            l = 16 * i + 1
            vi = SMatrix{2, 8}(p[l], p[l+4], p[l+1], p[l+5], p[l+2], p[l+6], p[l+3], p[l+7],
            p[l+8], p[l+12], p[l+9], p[l+13], p[l+10], p[l+14], p[l+11], p[l+15])

            vo = SMatrix{2, 8}(po[l], po[l+4], po[l+1], po[l+5], po[l+2], po[l+6], po[l+3], po[l+7],
            po[l+8], po[l+12], po[l+9], po[l+13], po[l+10], po[l+14], po[l+11], po[l+15])

            @fastmath r += dot(vo, mat, vi)
        end
        return r
    end
    if key == 1
        f = f1
    elseif key == 2
        f = f2
    elseif key == 3
        f = f3
    else
        error(""qubit position $key not allowed for L."")
    end

    parallel_sum(eltype(v), div(L, 16), Threads.nthreads(), f, U, v, vout)
end

function _expectation_value_threaded_util(q0::Int, U::AbstractMatrix, v::AbstractVector, vout::AbstractVector)
    if q0 > 3
        return _expectation_value_util_H(q0, SMatrix{2,2, eltype(v)}(U), v, vout)
    else
        return _expectation_value_util_L(q0, SMatrix{2,2, eltype(v)}(U), v, vout)
    end
end
_expectation_value_threaded_util(q0::Tuple{Int}, U::AbstractMatrix, v::AbstractVector, vout::AbstractVector) = _expectation_value_threaded_util(
    q0[1], U, v, vout)




""""""
    applys when both keys > 3, U is the transposed op
""""""
function _expectation_value_util_HH(key::Tuple{Int, Int}, U::AbstractMatrix, v::AbstractVector, vout::AbstractVector)
    L = length(v)
    q1, q2 = key
    pos1, pos2 = 1 << (q1-1), 1 << (q2-1)
    # stride2, stride3 = pos1 << 1, pos2 << 1
    mask0 = pos1 - 1
    mask1 = xor(pos2 - 1, 2 * pos1 - 1)
    mask2 = xor(L - 1, 2 * pos2 - 1)
    # println(""pos1=$pos1, pos2=$pos2, m0=$mask0, m1=$mask1, m2=$mask2"")

    total_itr = div(L, 32)
    f(ist::Int, ifn::Int, posa::Int, posb::Int, m1::Int, m2::Int, m3::Int, mat::AbstractMatrix, p::AbstractVector, po::AbstractVector) = begin
    	r = zero(eltype(p))
        @inbounds for i in ist:ifn
            l = (32 * i & m3) | (16 * i & m2) | (8 * i & m1) + 1
            # l = div(l, 2) + 1
            l1 = l + posa
            l2 = l + posb
            l3 = l2 + posa
            # println(""l0=$l, l1=$l1, l2=$l2, l3=$l3"")
            vi = SMatrix{8, 4}(p[l], p[l+1], p[l+2], p[l+3], p[l+4], p[l+5], p[l+6], p[l+7],
            p[l1], p[l1+1], p[l1+2], p[l1+3], p[l1+4], p[l1+5], p[l1+6], p[l1+7],
            p[l2], p[l2+1], p[l2+2], p[l2+3], p[l2+4], p[l2+5], p[l2+6], p[l2+7],
            p[l3], p[l3+1], p[l3+2], p[l3+3], p[l3+4], p[l3+5], p[l3+6], p[l3+7])

            vo = SMatrix{8, 4}(po[l], po[l+1], po[l+2], po[l+3], po[l+4], po[l+5], po[l+6], po[l+7],
            po[l1], po[l1+1], po[l1+2], po[l1+3], po[l1+4], po[l1+5], po[l1+6], po[l1+7],
            po[l2], po[l2+1], po[l2+2], po[l2+3], po[l2+4], po[l2+5], po[l2+6], po[l2+7],
            po[l3], po[l3+1], po[l3+2], po[l3+3], po[l3+4], po[l3+5], po[l3+6], po[l3+7])


            @fastmath r += dot(transpose(vo), mat, transpose(vi))
        end
        return r
    end

    parallel_sum(eltype(v), total_itr, Threads.nthreads(), f, pos1, pos2, mask0, mask1, mask2, U, v, vout)
end


""""""
    applys when q1 <= 3 and q2 > 4, U is the transposed op
""""""
function _expectation_value_util_LH(key::Tuple{Int, Int}, U::AbstractMatrix, v::AbstractVector, vout::AbstractVector)
    L = length(v)
    q1, q2 = key
    sizej = 1 << (q2-1)
    mask0 = sizej - 1
    mask1 = xor(L - 1, 2 * sizej - 1)

    f1H(ist::Int, ifn::Int, posb::Int, m1::Int, m2::Int, mat::AbstractMatrix, p::AbstractVector, po::AbstractVector) = begin
    	r = zero(eltype(p))
        @inbounds for i in ist:ifn
            l = (32 * i & m2) | (16 * i & m1)
            l1 = l + posb
            # println(""l=$l, l1=$l1"")
            vi = SMatrix{8, 4}(p[l+1], p[l+3], p[l+5], p[l+7], p[l+9], p[l+11], p[l+13], p[l+15],
            p[l+2], p[l+4], p[l+6], p[l+8], p[l+10], p[l+12], p[l+14], p[l+16],
            p[l1+1], p[l1+3], p[l1+5], p[l1+7], p[l1+9], p[l1+11], p[l1+13], p[l1+15],
            p[l1+2], p[l1+4], p[l1+6], p[l1+8], p[l1+10], p[l1+12], p[l1+14], p[l1+16])

            vo = SMatrix{8, 4}(po[l+1], po[l+3], po[l+5], po[l+7], po[l+9], po[l+11], po[l+13], po[l+15],
            po[l+2], po[l+4], po[l+6], po[l+8], po[l+10], po[l+12], po[l+14], po[l+16],
            po[l1+1], po[l1+3], po[l1+5], po[l1+7], po[l1+9], po[l1+11], po[l1+13], po[l1+15],
            po[l1+2], po[l1+4], po[l1+6], po[l1+8], po[l1+10], po[l1+12], po[l1+14], po[l1+16])

            @fastmath r += dot(transpose(vo), mat, transpose(vi))
        end
        return r
    end

    f2H(ist::Int, ifn::Int, posb::Int, m1::Int, m2::Int, mat::AbstractMatrix, p::AbstractVector, po::AbstractVector) = begin
    	r = zero(eltype(p))
        @inbounds for i in ist:ifn
            l = (32 * i & m2) | (16 * i & m1)
            l1 = l + posb
            # println(""l=$l, l1=$l1"")
            vi = SMatrix{8, 4}(p[l+1], p[l+2], p[l+5], p[l+6], p[l+9], p[l+10], p[l+13], p[l+14],
            p[l+3], p[l+4], p[l+7], p[l+8], p[l+11], p[l+12], p[l+15], p[l+16],
            p[l1+1], p[l1+2], p[l1+5], p[l1+6], p[l1+9], p[l1+10], p[l1+13], p[l1+14],
            p[l1+3], p[l1+4], p[l1+7], p[l1+8], p[l1+11], p[l1+12], p[l1+15], p[l1+16])

            vo = SMatrix{8, 4}(po[l+1], po[l+2], po[l+5], po[l+6], po[l+9], po[l+10], po[l+13], po[l+14],
            po[l+3], po[l+4], po[l+7], po[l+8], po[l+11], po[l+12], po[l+15], po[l+16],
            po[l1+1], po[l1+2], po[l1+5], po[l1+6], po[l1+9], po[l1+10], po[l1+13], po[l1+14],
            po[l1+3], po[l1+4], po[l1+7], po[l1+8], po[l1+11], po[l1+12], po[l1+15], po[l1+16])

            @fastmath r += dot(transpose(vo), mat, transpose(vi))
        end
        return r
    end

    f3H(ist::Int, ifn::Int, posb::Int, m1::Int, m2::Int, mat::AbstractMatrix, p::AbstractVector, po::AbstractVector) = begin
    	r = zero(eltype(p))
        @inbounds for i in ist:ifn
            l = (32 * i & m2) | (16 * i & m1)
            l1 = l + posb
            # println(""l=$l, l1=$l1"")
            vi = SMatrix{8, 4}(p[l+1], p[l+2], p[l+3], p[l+4], p[l+9], p[l+10], p[l+11], p[l+12],
            p[l+5], p[l+6], p[l+7], p[l+8], p[l+13], p[l+14], p[l+15], p[l+16],
            p[l1+1], p[l1+2], p[l1+3], p[l1+4], p[l1+9], p[l1+10], p[l1+11], p[l1+12],
            p[l1+5], p[l1+6], p[l1+7], p[l1+8], p[l1+13], p[l1+14], p[l1+15], p[l1+16])

            vo = SMatrix{8, 4}(po[l+1], po[l+2], po[l+3], po[l+4], po[l+9], po[l+10], po[l+11], po[l+12],
            po[l+5], po[l+6], po[l+7], po[l+8], po[l+13], po[l+14], po[l+15], po[l+16],
            po[l1+1], po[l1+2], po[l1+3], po[l1+4], po[l1+9], po[l1+10], po[l1+11], po[l1+12],
            po[l1+5], po[l1+6], po[l1+7], po[l1+8], po[l1+13], po[l1+14], po[l1+15], po[l1+16])

            @fastmath r += dot(transpose(vo), mat, transpose(vi))
        end
        return r
    end

    if q1 == 1
        f = f1H
    elseif q1 == 2
        f = f2H
    elseif q1 == 3
        f = f3H
    else
        error(""qubit position $q1 not allowed for LH."")
    end
    total_itr = div(L, 32)

    parallel_sum(eltype(v), total_itr, Threads.nthreads(), f, sizej, mask0, mask1, U, v, vout)
end

""""""
    applys when both keys <= 4
""""""
function _expectation_value_util_LL(key::Tuple{Int, Int}, U::AbstractMatrix, v::AbstractVector, vout::AbstractVector)
    L = length(v)
    q1, q2 = key
    f12(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector, po::AbstractVector) = begin
    	r = zero(eltype(p))
        @inbounds for i in ist:ifn
            l = 32 * i + 1
            vi = SMatrix{4, 8}(p[l], p[l+1], p[l+2], p[l+3], p[l+4], p[l+5], p[l+6], p[l+7],
            p[l+8], p[l+9], p[l+10], p[l+11], p[l+12], p[l+13], p[l+14], p[l+15],
            p[l+16], p[l+17], p[l+18], p[l+19], p[l+20], p[l+21], p[l+22], p[l+23],
            p[l+24], p[l+25], p[l+26], p[l+27], p[l+28], p[l+29], p[l+30], p[l+31])

            vo = SMatrix{4, 8}(po[l], po[l+1], po[l+2], po[l+3], po[l+4], po[l+5], po[l+6], po[l+7],
            po[l+8], po[l+9], po[l+10], po[l+11], po[l+12], po[l+13], po[l+14], po[l+15],
            po[l+16], po[l+17], po[l+18], po[l+19], po[l+20], po[l+21], po[l+22], po[l+23],
            po[l+24], po[l+25], po[l+26], po[l+27], po[l+28], po[l+29], po[l+30], po[l+31])

            @fastmath r += dot(vo, mat, vi)
        end
        return r
    end
    f13(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector, po::AbstractVector) = begin
    	r = zero(eltype(p))
        @inbounds for i in ist:ifn
            l = 32 * i + 1
            vi = SMatrix{4, 8}(p[l], p[l+1], p[l+4], p[l+5], p[l+2], p[l+3], p[l+6], p[l+7],
            p[l+8], p[l+9], p[l+12], p[l+13], p[l+10], p[l+11], p[l+14], p[l+15],
            p[l+16], p[l+17], p[l+20], p[l+21], p[l+18], p[l+19], p[l+22], p[l+23],
            p[l+24], p[l+25], p[l+28], p[l+29], p[l+26], p[l+27], p[l+30], p[l+31])

            vo = SMatrix{4, 8}(po[l], po[l+1], po[l+4], po[l+5], po[l+2], po[l+3], po[l+6], po[l+7],
            po[l+8], po[l+9], po[l+12], po[l+13], po[l+10], po[l+11], po[l+14], po[l+15],
            po[l+16], po[l+17], po[l+20], po[l+21], po[l+18], po[l+19], po[l+22], po[l+23],
            po[l+24], po[l+25], po[l+28], po[l+29], po[l+26], po[l+27], po[l+30], po[l+31])

            @fastmath r += dot(vo, mat, vi)
        end
        return r
    end
    f14(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector, po::AbstractVector) = begin
    	r = zero(eltype(p))
        @inbounds for i in ist:ifn
            l = 32 * i
            vi = SMatrix{4, 8}(p[l+1], p[l+2], p[l+9], p[l+10], p[l+3], p[l+4], p[l+11], p[l+12],
            p[l+5], p[l+6], p[l+13], p[l+14], p[l+7], p[l+8], p[l+15], p[l+16],
            p[l+17], p[l+18], p[l+25], p[l+26], p[l+19], p[l+20], p[l+27], p[l+28],
            p[l+21], p[l+22], p[l+29], p[l+30], p[l+23], p[l+24], p[l+31], p[l+32])

            vo = SMatrix{4, 8}(po[l+1], po[l+2], po[l+9], po[l+10], po[l+3], po[l+4], po[l+11], po[l+12],
            po[l+5], po[l+6], po[l+13], po[l+14], po[l+7], po[l+8], po[l+15], po[l+16],
            po[l+17], po[l+18], po[l+25], po[l+26], po[l+19], po[l+20], po[l+27], po[l+28],
            po[l+21], po[l+22], po[l+29], po[l+30], po[l+23], po[l+24], po[l+31], po[l+32])

            @fastmath r += dot(vo, mat, vi)
        end
        return r
    end
    f23(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector, po::AbstractVector) = begin
   	 	r = zero(eltype(p))
        @inbounds for i in ist:ifn
            l = 32 * i + 1
            vi = SMatrix{4, 8}(p[l], p[l+2], p[l+4], p[l+6], p[l+1], p[l+3], p[l+5], p[l+7],
            p[l+8], p[l+10], p[l+12], p[l+14], p[l+9], p[l+11], p[l+13], p[l+15],
            p[l+16], p[l+18], p[l+20], p[l+22], p[l+17], p[l+19], p[l+21], p[l+23],
            p[l+24], p[l+26], p[l+28], p[l+30], p[l+25], p[l+27], p[l+29], p[l+31])

            vo = SMatrix{4, 8}(po[l], po[l+2], po[l+4], po[l+6], po[l+1], po[l+3], po[l+5], po[l+7],
            po[l+8], po[l+10], po[l+12], po[l+14], po[l+9], po[l+11], po[l+13], po[l+15],
            po[l+16], po[l+18], po[l+20], po[l+22], po[l+17], po[l+19], po[l+21], po[l+23],
            po[l+24], po[l+26], po[l+28], po[l+30], po[l+25], po[l+27], po[l+29], po[l+31])

            @fastmath r += dot(vo, mat, vi)
        end
        return r
    end
    f24(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector, po::AbstractVector) = begin
    	r = zero(eltype(p))
        @inbounds for i in ist:ifn
            l = 32 * i
            vi = SMatrix{4, 8}(p[l+1], p[l+3], p[l+9], p[l+11], p[l+2], p[l+4], p[l+10], p[l+12],
            p[l+5], p[l+7], p[l+13], p[l+15], p[l+6], p[l+8], p[l+14], p[l+16],
            p[l+17], p[l+19], p[l+25], p[l+27], p[l+18], p[l+20], p[l+26], p[l+28],
            p[l+21], p[l+23], p[l+29], p[l+31], p[l+22], p[l+24], p[l+30], p[l+32])

            vo = SMatrix{4, 8}(po[l+1], po[l+3], po[l+9], po[l+11], po[l+2], po[l+4], po[l+10], po[l+12],
            po[l+5], po[l+7], po[l+13], po[l+15], po[l+6], po[l+8], po[l+14], po[l+16],
            po[l+17], po[l+19], po[l+25], po[l+27], po[l+18], po[l+20], po[l+26], po[l+28],
            po[l+21], po[l+23], po[l+29], po[l+31], po[l+22], po[l+24], po[l+30], po[l+32])

            @fastmath r += dot(vo, mat, vi)
        end
        return r
    end
    f34(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector, po::AbstractVector) = begin
    	r = zero(eltype(p))
        @inbounds for i in ist:ifn
            l = 32 * i
            vi = SMatrix{4, 8}(p[l+1], p[l+5], p[l+9], p[l+13], p[l+2], p[l+6], p[l+10], p[l+14],
            p[l+3], p[l+7], p[l+11], p[l+15], p[l+4], p[l+8], p[l+12], p[l+16],
            p[l+17], p[l+21], p[l+25], p[l+29], p[l+18], p[l+22], p[l+26], p[l+30],
            p[l+19], p[l+23], p[l+27], p[l+31], p[l+20], p[l+24], p[l+28], p[l+32])

            vo = SMatrix{4, 8}(po[l+1], po[l+5], po[l+9], po[l+13], po[l+2], po[l+6], po[l+10], po[l+14],
            po[l+3], po[l+7], po[l+11], po[l+15], po[l+4], po[l+8], po[l+12], po[l+16],
            po[l+17], po[l+21], po[l+25], po[l+29], po[l+18], po[l+22], po[l+26], po[l+30],
            po[l+19], po[l+23], po[l+27], po[l+31], po[l+20], po[l+24], po[l+28], po[l+32])

            @fastmath r += dot(vo, mat, vi)
        end
        return r
    end
    if q1==1 && q2 == 2
        f = f12
    elseif q1==1 && q2 == 3
        f = f13
    elseif q1==1 && q2 == 4
        f = f14
    elseif q1==2 && q2 == 3
        f = f23
    elseif q1==2 && q2 == 4
        f = f24
    elseif q1==3 && q2 == 4
        f = f34
    else
        error(""qubit position $q1 and $q2 not allowed for LL."")
    end
    total_itr = div(L, 32)

    parallel_sum(eltype(v), total_itr, Threads.nthreads(), f, U, v, vout)
end


function _expectation_value_threaded_util(key::Tuple{Int, Int}, U::AbstractMatrix, v::AbstractVector, vout::AbstractVector)
    q0, q1 = key
    if q0 > 3
        return _expectation_value_util_HH(key, SMatrix{4,4, eltype(v)}(U), v, vout)
    elseif q1 > 4
        return _expectation_value_util_LH(key, SMatrix{4,4, eltype(v)}(U), v, vout)
    else
        return _expectation_value_util_LL(key, SMatrix{4,4, eltype(v)}(U), v, vout)
    end
end


""""""
    applys when both keys > 2, U is assumed to be transposed
""""""
function _expectation_value_util_HHH(key::Tuple{Int, Int, Int}, U::AbstractMatrix, v::AbstractVector, vout::AbstractVector)
    L = length(v)
    q1, q2, q3 = key
    pos1, pos2, pos3 = 1 << (q1-1), 1 << (q2-1), 1 << (q3-1)
    # stride2, stride3 = pos1 << 1, pos2 << 1
    mask0 = pos1 - 1
    mask1 = xor(pos2 - 1, 2 * pos1 - 1)
    mask2 = xor(pos3 - 1, 2 * pos2 - 1)
    mask3 = xor(L - 1, 2 * pos3 - 1)
    # println(""pos1=$pos1, pos2=$pos2, m0=$mask0, m1=$mask1, m2=$mask2"")

    total_itr = div(L, 32)
    f(ist::Int, ifn::Int, posa::Int, posb::Int, posc::Int, m1::Int, m2::Int, m3::Int, m4::Int, mat, p, po) = begin
        r = zero(eltype(p))
        @inbounds for i in ist:ifn
            l000 = (32 * i & m4) | (16 * i & m3) | (8 * i & m2) | (4 * i & m1) + 1
            l100 = l000 + posa
            l010 = l000 + posb
            l110 = l010 + posa

            l001 = l000 + posc
            l101 = l001 + posa
            l011 = l001 + posb
            l111 = l011 + posa

            # println(""$l000, $l100, $l010, $l110, $l001, $l101, $l011, $l111"")
            vi = SMatrix{4, 8}(p[l000], p[l000+1], p[l000+2], p[l000+3],
                               p[l100], p[l100+1], p[l100+2], p[l100+3],
                               p[l010], p[l010+1], p[l010+2], p[l010+3],
                               p[l110], p[l110+1], p[l110+2], p[l110+3],
                               p[l001], p[l001+1], p[l001+2], p[l001+3],
                               p[l101], p[l101+1], p[l101+2], p[l101+3],
                               p[l011], p[l011+1], p[l011+2], p[l011+3],
                               p[l111], p[l111+1], p[l111+2], p[l111+3])

            vo = SMatrix{4, 8}(po[l000], po[l000+1], po[l000+2], po[l000+3],
                               po[l100], po[l100+1], po[l100+2], po[l100+3],
                               po[l010], po[l010+1], po[l010+2], po[l010+3],
                               po[l110], po[l110+1], po[l110+2], po[l110+3],
                               po[l001], po[l001+1], po[l001+2], po[l001+3],
                               po[l101], po[l101+1], po[l101+2], po[l101+3],
                               po[l011], po[l011+1], po[l011+2], po[l011+3],
                               po[l111], po[l111+1], po[l111+2], po[l111+3])


            @fastmath r += dot(transpose(vo), mat, transpose(vi))
        end
        return r
    end

    parallel_sum(eltype(v), total_itr, Threads.nthreads(), f, pos1, pos2, pos3, mask0, mask1, mask2, mask3, U, v, vout)
end


""""""
    applys when q1 <= 2 and q2 > 3, U is the transposed op
""""""
function _expectation_value_util_LHH(key::Tuple{Int, Int, Int}, U::AbstractMatrix, v::AbstractVector, vout::AbstractVector)
    L = length(v)
    q1, q2, q3 = key
    sizej, sizel = 1 << (q2-1), 1 << (q3-1)
    mask0 = sizej - 1
    mask1 = xor(sizel - 1, 2 * sizej - 1)
    mask2 = xor(L-1, 2 * sizel - 1)

    f1H(ist::Int, ifn::Int, posb::Int, posc::Int, m1::Int, m2::Int, m3::Int, mat, p, po) = begin
        r = zero(eltype(p))
        @inbounds for i in ist:ifn
            l = (32 * i & m3) | (16 * i & m2) | (8 * i & m1)
            l1 = l + posb
            l2 = l + posc
            l3 = l2 + posb
            # println(""$l, $l1, $l2, $l3"")
            vi = SMatrix{4, 8}(p[l+1], p[l+3], p[l+5], p[l+7],
                               p[l+2], p[l+4], p[l+6], p[l+8],
                               p[l1+1], p[l1+3], p[l1+5], p[l1+7],
                               p[l1+2], p[l1+4], p[l1+6], p[l1+8],
                               p[l2+1], p[l2+3], p[l2+5], p[l2+7],
                               p[l2+2], p[l2+4], p[l2+6], p[l2+8],
                               p[l3+1], p[l3+3], p[l3+5], p[l3+7],
                               p[l3+2], p[l3+4], p[l3+6], p[l3+8])

            vo = SMatrix{4, 8}(po[l+1], po[l+3], po[l+5], po[l+7],
                               po[l+2], po[l+4], po[l+6], po[l+8],
                               po[l1+1], po[l1+3], po[l1+5], po[l1+7],
                               po[l1+2], po[l1+4], po[l1+6], po[l1+8],
                               po[l2+1], po[l2+3], po[l2+5], po[l2+7],
                               po[l2+2], po[l2+4], po[l2+6], po[l2+8],
                               po[l3+1], po[l3+3], po[l3+5], po[l3+7],
                               po[l3+2], po[l3+4], po[l3+6], po[l3+8])


            @fastmath r += dot(transpose(vo), mat, transpose(vi))
        end
        return r
    end

    f2H(ist::Int, ifn::Int, posb::Int, posc::Int, m1::Int, m2::Int, m3::Int, mat, p, po) = begin
        r = zero(eltype(p))
        @inbounds for i in ist:ifn
            l = (32 * i & m3) | (16 * i & m2) | (8 * i & m1)
            l1 = l + posb
            l2 = l + posc
            l3 = l2 + posb
            vi = SMatrix{4, 8}(p[l+1], p[l+2], p[l+5], p[l+6],
                               p[l+3], p[l+4], p[l+7], p[l+8],
                               p[l1+1], p[l1+2], p[l1+5], p[l1+6],
                               p[l1+3], p[l1+4], p[l1+7], p[l1+8],
                               p[l2+1], p[l2+2], p[l2+5], p[l2+6],
                               p[l2+3], p[l2+4], p[l2+7], p[l2+8],
                               p[l3+1], p[l3+2], p[l3+5], p[l3+6],
                               p[l3+3], p[l3+4], p[l3+7], p[l3+8])

            vo = SMatrix{4, 8}(po[l+1], po[l+2], po[l+5], po[l+6],
                               po[l+3], po[l+4], po[l+7], po[l+8],
                               po[l1+1], po[l1+2], po[l1+5], po[l1+6],
                               po[l1+3], po[l1+4], po[l1+7], po[l1+8],
                               po[l2+1], po[l2+2], po[l2+5], po[l2+6],
                               po[l2+3], po[l2+4], po[l2+7], po[l2+8],
                               po[l3+1], po[l3+2], po[l3+5], po[l3+6],
                               po[l3+3], po[l3+4], po[l3+7], po[l3+8])

            @fastmath r += dot(transpose(vo), mat, transpose(vi))
        end
        return r
    end

    f3H(ist::Int, ifn::Int, posb::Int, posc::Int, m1::Int, m2::Int, m3::Int, mat, p, po) = begin
        r = zero(eltype(p))
        @inbounds for i in ist:ifn
            l = (32 * i & m3) | (16 * i & m2) | (8 * i & m1)
            l1 = l + posb
            l2 = l + posc
            l3 = l2 + posb
            vi = SMatrix{4, 8}(p[l+1], p[l+2], p[l+3], p[l+4],
                               p[l+5], p[l+6], p[l+7], p[l+8],
                               p[l1+1], p[l1+2], p[l1+3], p[l1+4],
                               p[l1+5], p[l1+6], p[l1+7], p[l1+8],
                               p[l2+1], p[l2+2], p[l2+3], p[l2+4],
                               p[l2+5], p[l2+6], p[l2+7], p[l2+8],
                               p[l3+1], p[l3+2], p[l3+3], p[l3+4],
                               p[l3+5], p[l3+6], p[l3+7], p[l3+8])

            vo = SMatrix{4, 8}(po[l+1], po[l+2], po[l+3], po[l+4],
                               po[l+5], po[l+6], po[l+7], po[l+8],
                               po[l1+1], po[l1+2], po[l1+3], po[l1+4],
                               po[l1+5], po[l1+6], po[l1+7], po[l1+8],
                               po[l2+1], po[l2+2], po[l2+3], po[l2+4],
                               po[l2+5], po[l2+6], po[l2+7], po[l2+8],
                               po[l3+1], po[l3+2], po[l3+3], po[l3+4],
                               po[l3+5], po[l3+6], po[l3+7], po[l3+8])

            @fastmath r += dot(transpose(vo), mat, transpose(vi))
        end
        return r
    end

    if q1 == 1
        f = f1H
    elseif q1 == 2
        f = f2H
    elseif q1 == 3
        f = f3H
    else
        error(""qubit position $q1 not allowed for LHH."")
    end
    (q2 > 3) || error(""qubit 2 position $q2 not allowed for LHH."")
    total_itr = div(L, 32)

    parallel_sum(eltype(v), total_itr, Threads.nthreads(), f, sizej, sizel, mask0, mask1, mask2, U, v, vout)
end

""""""
    applys when q1, q2 <= 3 and q3 > 4, U is the transposed op
""""""
function _expectation_value_util_LLH(key::Tuple{Int, Int, Int}, U::AbstractMatrix, v::AbstractVector, vout::AbstractVector)
    L = length(v)
    q1, q2, q3 = key
    sizej = 1 << (q3-1)
    mask0 = sizej - 1
    mask1 = xor(L - 1, 2 * sizej - 1)

    f12H(ist::Int, ifn::Int, posb::Int, m1::Int, m2::Int, mat, p, po) = begin
        r = zero(eltype(p))
        @inbounds for i in ist:ifn
            l = (32 * i & m2) | (16 * i & m1)
            l1 = l + posb
            # println(""l=$l, l1=$l1"")
            vi = SMatrix{4, 8}(p[l+1], p[l+5], p[l+9], p[l+13],
                               p[l+2], p[l+6], p[l+10], p[l+14],
                               p[l+3], p[l+7], p[l+11], p[l+15],
                               p[l+4], p[l+8], p[l+12], p[l+16],
                               p[l1+1], p[l1+5], p[l1+9], p[l1+13],
                               p[l1+2], p[l1+6], p[l1+10], p[l1+14],
                               p[l1+3], p[l1+7], p[l1+11], p[l1+15],
                               p[l1+4], p[l1+8], p[l1+12], p[l1+16])

            vo = SMatrix{4, 8}(po[l+1], po[l+5], po[l+9], po[l+13],
                               po[l+2], po[l+6], po[l+10], po[l+14],
                               po[l+3], po[l+7], po[l+11], po[l+15],
                               po[l+4], po[l+8], po[l+12], po[l+16],
                               po[l1+1], po[l1+5], po[l1+9], po[l1+13],
                               po[l1+2], po[l1+6], po[l1+10], po[l1+14],
                               po[l1+3], po[l1+7], po[l1+11], po[l1+15],
                               po[l1+4], po[l1+8], po[l1+12], po[l1+16])

            @fastmath r += dot(transpose(vo), mat, transpose(vi))
        end
        return r
    end

    f13H(ist::Int, ifn::Int, posb::Int, m1::Int, m2::Int, mat, p, po) = begin
        r = zero(eltype(p))
        @inbounds for i in ist:ifn
            l = (32 * i & m2) | (16 * i & m1)
            l1 = l + posb
            # println(""l=$l, l1=$l1"")
            vi = SMatrix{4, 8}(p[l+1], p[l+3], p[l+9], p[l+11],
                               p[l+2], p[l+4], p[l+10], p[l+12],
                               p[l+5], p[l+7], p[l+13], p[l+15],
                               p[l+6], p[l+8], p[l+14], p[l+16],
                               p[l1+1], p[l1+3], p[l1+9], p[l1+11],
                               p[l1+2], p[l1+4], p[l1+10], p[l1+12],
                               p[l1+5], p[l1+7], p[l1+13], p[l1+15],
                               p[l1+6], p[l1+8], p[l1+14], p[l1+16])

            vo = SMatrix{4, 8}(po[l+1], po[l+3], po[l+9], po[l+11],
                               po[l+2], po[l+4], po[l+10], po[l+12],
                               po[l+5], po[l+7], po[l+13], po[l+15],
                               po[l+6], po[l+8], po[l+14], po[l+16],
                               po[l1+1], po[l1+3], po[l1+9], po[l1+11],
                               po[l1+2], po[l1+4], po[l1+10], po[l1+12],
                               po[l1+5], po[l1+7], po[l1+13], po[l1+15],
                               po[l1+6], po[l1+8], po[l1+14], po[l1+16])

            @fastmath r += dot(transpose(vo), mat, transpose(vi))
        end
        return r
    end

    f23H(ist::Int, ifn::Int, posb::Int, m1::Int, m2::Int, mat, p, po) = begin
        r = zero(eltype(p))
        @inbounds for i in ist:ifn
            l = (32 * i & m2) | (16 * i & m1)
            l1 = l + posb
            # println(""l=$l, l1=$l1"")
            vi = SMatrix{4, 8}(p[l+1], p[l+2], p[l+9], p[l+10],
                               p[l+3], p[l+4], p[l+11], p[l+12],
                               p[l+5], p[l+6], p[l+13], p[l+14],
                               p[l+7], p[l+8], p[l+15], p[l+16],
                               p[l1+1], p[l1+2], p[l1+9], p[l1+10],
                               p[l1+3], p[l1+4], p[l1+11], p[l1+12],
                               p[l1+5], p[l1+6], p[l1+13], p[l1+14],
                               p[l1+7], p[l1+8], p[l1+15], p[l1+16])

            vo = SMatrix{4, 8}(po[l+1], po[l+2], po[l+9], po[l+10],
                               po[l+3], po[l+4], po[l+11], po[l+12],
                               po[l+5], po[l+6], po[l+13], po[l+14],
                               po[l+7], po[l+8], po[l+15], po[l+16],
                               po[l1+1], po[l1+2], po[l1+9], po[l1+10],
                               po[l1+3], po[l1+4], po[l1+11], po[l1+12],
                               po[l1+5], po[l1+6], po[l1+13], po[l1+14],
                               po[l1+7], po[l1+8], po[l1+15], po[l1+16])

            @fastmath r += dot(transpose(vo), mat, transpose(vi))
        end
        return r
    end

    if q1 == 1 && q2 == 2
        f = f12H
    elseif q1 == 1 && q2 == 3
        f = f13H
    elseif q1 == 2 && q2 == 3
        f = f23H
    else
        error(""qubit position $q1 not allowed for LH."")
    end
    total_itr = div(L, 32)

    parallel_sum(eltype(v), total_itr, Threads.nthreads(), f, sizej, mask0, mask1, U, v, vout)
end


""""""
    applys when both keys <= 4
""""""
function _expectation_value_util_LLL(key::Tuple{Int, Int, Int}, U::AbstractMatrix, v::AbstractVector, vout::AbstractVector)
    L = length(v)
    q1, q2, q3 = key
    f123(ist::Int, ifn::Int, mat::AbstractMatrix, p, po) = begin
        r = zero(eltype(p))
        @inbounds for i in ist:ifn
            l = 32 * i + 1
            vi = SMatrix{8, 4}(p[l], p[l+1], p[l+2], p[l+3], p[l+4], p[l+5], p[l+6], p[l+7],
            p[l+8], p[l+9], p[l+10], p[l+11], p[l+12], p[l+13], p[l+14], p[l+15],
            p[l+16], p[l+17], p[l+18], p[l+19], p[l+20], p[l+21], p[l+22], p[l+23],
            p[l+24], p[l+25], p[l+26], p[l+27], p[l+28], p[l+29], p[l+30], p[l+31])

            vo = SMatrix{8, 4}(po[l], po[l+1], po[l+2], po[l+3], po[l+4], po[l+5], po[l+6], po[l+7],
            po[l+8], po[l+9], po[l+10], po[l+11], po[l+12], po[l+13], po[l+14], po[l+15],
            po[l+16], po[l+17], po[l+18], po[l+19], po[l+20], po[l+21], po[l+22], po[l+23],
            po[l+24], po[l+25], po[l+26], po[l+27], po[l+28], po[l+29], po[l+30], po[l+31])

            @fastmath r += dot(vo, mat, vi)
        end
        return r
    end
    f124(ist::Int, ifn::Int, mat::AbstractMatrix, p, po) = begin
        r = zero(eltype(p))
        @inbounds for i in ist:ifn
            l = 32 * i
            vi = SMatrix{8, 4}(p[l+1], p[l+2], p[l+3], p[l+4], p[l+9], p[l+10], p[l+11], p[l+12],
                               p[l+5], p[l+6], p[l+7], p[l+8], p[l+13], p[l+14], p[l+15], p[l+16],
                               p[l+17], p[l+18], p[l+19], p[l+20], p[l+25], p[l+26], p[l+27], p[l+28],
                               p[l+21], p[l+22], p[l+23], p[l+24], p[l+29], p[l+30], p[l+31], p[l+32])

            vo = SMatrix{8, 4}(po[l+1], po[l+2], po[l+3], po[l+4], po[l+9], po[l+10], po[l+11], po[l+12],
                               po[l+5], po[l+6], po[l+7], po[l+8], po[l+13], po[l+14], po[l+15], po[l+16],
                               po[l+17], po[l+18], po[l+19], po[l+20], po[l+25], po[l+26], po[l+27], po[l+28],
                               po[l+21], po[l+22], po[l+23], po[l+24], po[l+29], po[l+30], po[l+31], po[l+32])

            @fastmath r += dot(vo, mat, vi)
        end
        return r
    end
    f134(ist::Int, ifn::Int, mat::AbstractMatrix, p, po) = begin
        r = zero(eltype(p))
        @inbounds for i in ist:ifn
            l = 32 * i
            vi = SMatrix{8, 4}(p[l+1], p[l+2], p[l+5], p[l+6], p[l+9], p[l+10], p[l+13], p[l+14],
                               p[l+3], p[l+4], p[l+7], p[l+8], p[l+11], p[l+12], p[l+15], p[l+16],
                               p[l+17], p[l+18], p[l+21], p[l+22], p[l+25], p[l+26], p[l+29], p[l+30],
                               p[l+19], p[l+20], p[l+23], p[l+24], p[l+27], p[l+28], p[l+31], p[l+32])

            vo = SMatrix{8, 4}(po[l+1], po[l+2], po[l+5], po[l+6], po[l+9], po[l+10], po[l+13], po[l+14],
                               po[l+3], po[l+4], po[l+7], po[l+8], po[l+11], po[l+12], po[l+15], po[l+16],
                               po[l+17], po[l+18], po[l+21], po[l+22], po[l+25], po[l+26], po[l+29], po[l+30],
                               po[l+19], po[l+20], po[l+23], po[l+24], po[l+27], po[l+28], po[l+31], po[l+32])

            @fastmath r += dot(vo, mat, vi)
        end
        return r
    end
    f234(ist::Int, ifn::Int, mat::AbstractMatrix, p, po) = begin
        r = zero(eltype(p))
        @inbounds for i in ist:ifn
            l = 32 * i
            vi = SMatrix{8, 4}(p[l+1], p[l+3], p[l+5], p[l+7], p[l+9], p[l+11], p[l+13], p[l+15],
                               p[l+2], p[l+4], p[l+6], p[l+8], p[l+10], p[l+12], p[l+14], p[l+16],
                               p[l+17], p[l+19], p[l+21], p[l+23], p[l+25], p[l+27], p[l+29], p[l+31],
                               p[l+18], p[l+20], p[l+22], p[l+24], p[l+26], p[l+28], p[l+30], p[l+32])

            vo = SMatrix{8, 4}(po[l+1], po[l+3], po[l+5], po[l+7], po[l+9], po[l+11], po[l+13], po[l+15],
                               po[l+2], po[l+4], po[l+6], po[l+8], po[l+10], po[l+12], po[l+14], po[l+16],
                               po[l+17], po[l+19], po[l+21], po[l+23], po[l+25], po[l+27], po[l+29], po[l+31],
                               po[l+18], po[l+20], po[l+22], po[l+24], po[l+26], po[l+28], po[l+30], po[l+32])

            @fastmath r += dot(vo, mat, vi)
        end
        return r
    end
    if q1==1 && q2 == 2 && q3 == 3
        f = f123
    elseif q1==1 && q2 == 2 && q3 == 4
        f = f124
    elseif q1==1 && q2 == 3 && q3 == 4
        f = f134
    elseif q1==2 && q2 == 3 && q3 == 4
        f = f234
    else
        error(""qubit position $q1 and $q2 not allowed for LL."")
    end
    total_itr = div(L, 32)

    parallel_sum(eltype(v), total_itr, Threads.nthreads(), f, U, v, vout)
end

function _expectation_value_threaded_util(key::Tuple{Int, Int, Int}, U::AbstractMatrix, v::AbstractVector, vout::AbstractVector)
    q0, q1, q2 = key
    if q0 > 2
        return _expectation_value_util_HHH(key, SMatrix{8,8, eltype(v)}(U), v, vout)
    elseif q1 > 3
        return _expectation_value_util_LHH(key, SMatrix{8,8, eltype(v)}(U), v, vout)
    elseif q2 > 4
        return _expectation_value_util_LLH(key, SMatrix{8,8, eltype(v)}(U), v, vout)
    else
        return _expectation_value_util_LLL(key, SMatrix{8,8, eltype(v)}(U), v, vout)
    end
end

expectation_value_threaded(pos::Int, m::AbstractMatrix, state::AbstractVector, state_c::AbstractVector) = _expectation_value_threaded_util(
	pos, m, state, state_c)


expectation_value_threaded(pos::Tuple{Int}, m::AbstractMatrix, state::AbstractVector, state_c::AbstractVector) = expectation_value_threaded(
	pos[1], m, state, state_c)


expectation_value_threaded(pos::Tuple{Int, Int}, m::AbstractMatrix, state::AbstractVector, state_c::AbstractVector) = _expectation_value_threaded_util(
	pos, m, state, state_c)

expectation_value_threaded(pos::Tuple{Int, Int, Int}, m::AbstractMatrix, state::AbstractVector, state_c::AbstractVector) = _expectation_value_threaded_util(
    pos, m, state, state_c)



","Julia"
"Conjugate","guochu/VQC.jl","src/hamiltonian/expecs/expec_high_qubit_terms_2.jl",".jl","5747","135","

function _expectation_value_fourbody_util(key::Tuple{Int, Int, Int, Int}, U::AbstractMatrix, v::AbstractVector, vout::AbstractVector)
    L = length(v)
    q1, q2, q3, q4 = key
    pos1, pos2, pos3, pos4 = 1 << (q1-1), 1 << (q2-1), 1 << (q3-1), 1 << (q4-1)
    # stride2, stride3 = pos1 << 1, pos2 << 1
    mask0 = pos1 - 1
    mask1 = xor(pos2 - 1, 2 * pos1 - 1)
    mask2 = xor(pos3 - 1, 2 * pos2 - 1)
    mask3 = xor(pos4 - 1, 2 * pos3 - 1)
    mask4 = xor(L - 1, 2 * pos4 - 1)
    # println(""pos1=$pos1, pos2=$pos2, m0=$mask0, m1=$mask1, m2=$mask2"")

    
    function f(ist::Int, ifn::Int, posa::Int, posb::Int, posc::Int, posd::Int, m1::Int, m2::Int, m3::Int, 
    	m4::Int, m5::Int, mat::AbstractMatrix, p::AbstractVector, po::AbstractVector) 
    	r = zero(eltype(p))
        @inbounds for i in ist:ifn
            l0000 = (16 * i & m5) | (8 * i & m4) | (4 * i & m3) | (2 * i & m2) | (i & m1) + 1
            l1000 = l0000 + posa
            l0100 = l0000 + posb
            l0010 = l0000 + posc
            l0001 = l0000 + posd

            l1100 = l0100 + posa
            l1010 = l0010 + posa
            l1001 = l1000 + posd
            l0110 = l0010 + posb
            l0101 = l0100 + posd
            l0011 = l0010 + posd
            
            l1110 = l1100 + posc
            l1101 = l1100 + posd
            l1011 = l1010 + posd
            l0111 = l0110 + posd

            l1111 = l1110 + posd

            vi = SVector(p[l0000], p[l1000], p[l0100], p[l1100], p[l0010], p[l1010], p[l0110], p[l1110],
                p[l0001], p[l1001], p[l0101], p[l1101], p[l0011], p[l1011], p[l0111], p[l1111])

            vo = SVector(po[l0000], po[l1000], po[l0100], po[l1100], po[l0010], po[l1010], po[l0110], po[l1110],
                po[l0001], po[l1001], po[l0101], po[l1101], po[l0011], po[l1011], po[l0111], po[l1111])

            @fastmath r += dot(vo, mat, vi)
        end
        return r
    end
    total_itr = div(L, 16)
    parallel_sum(eltype(v), total_itr, Threads.nthreads(), f, pos1, pos2, pos3, pos4, mask0, mask1, mask2, mask3, mask4, U, v, vout)
end

expectation_value_threaded(key::Tuple{Int, Int, Int, Int}, U::AbstractMatrix, v::AbstractVector, vout::AbstractVector) = _expectation_value_fourbody_util(
	key, SMatrix{16,16, eltype(v)}(U), v, vout)

function _expectation_value_fivebody_util(key::Tuple{Int, Int, Int, Int, Int}, U::AbstractMatrix, v::AbstractVector, vout::AbstractVector)
    L = length(v)
    q1, q2, q3, q4, q5 = key
    pos1, pos2, pos3, pos4, pos5 = 1 << (q1-1), 1 << (q2-1), 1 << (q3-1), 1 << (q4-1), 1 << (q5-1)
    # stride2, stride3 = pos1 << 1, pos2 << 1
    mask0 = pos1 - 1
    mask1 = xor(pos2 - 1, 2 * pos1 - 1)
    mask2 = xor(pos3 - 1, 2 * pos2 - 1)
    mask3 = xor(pos4 - 1, 2 * pos3 - 1)
    mask4 = xor(pos5 - 1, 2 * pos4 - 1)
    mask5 = xor(L - 1, 2 * pos5 - 1)
    # println(""pos1=$pos1, pos2=$pos2, m0=$mask0, m1=$mask1, m2=$mask2"")

    function f(ist::Int, ifn::Int, posa::Int, posb::Int, posc::Int, posd::Int, pose::Int, 
        m1::Int, m2::Int, m3::Int, m4::Int, m5::Int, m6::Int, mat::AbstractMatrix, p::AbstractVector, po::AbstractVector) 
    	r = zero(eltype(p))
        @inbounds for i in ist:ifn
            l00000 = (32 * i & m6) | (16 * i & m5) | (8 * i & m4) | (4 * i & m3) | (2 * i & m2) | (i & m1) + 1
            l10000 = l00000 + posa
            l01000 = l00000 + posb
            l00100 = l00000 + posc
            l00010 = l00000 + posd
            l00001 = l00000 + pose

            l11000 = l01000 + posa
            l10100 = l00100 + posa
            l10010 = l10000 + posd
            l10001 = l10000 + pose
            l01100 = l00100 + posb
            l01010 = l01000 + posd
            l01001 = l01000 + pose
            l00110 = l00100 + posd
            l00101 = l00100 + pose
            l00011 = l00010 + pose

            
            l11100 = l11000 + posc
            l11010 = l11000 + posd
            l11001 = l11000 + pose
            l10110 = l10100 + posd
            l10101 = l10100 + pose
            l10011 = l10010 + pose
            l01110 = l01100 + posd
            l01101 = l01100 + pose
            l01011 = l01010 + pose
            l00111 = l00110 + pose

            l11110 = l11100 + posd
            l11101 = l11100 + pose
            l11011 = l11010 + pose
            l10111 = l10110 + pose
            l01111 = l01110 + pose

            l11111 = l11110 + pose

            vi = SVector(p[l00000], p[l10000], p[l01000], p[l11000], p[l00100], p[l10100], p[l01100], p[l11100],
                p[l00010], p[l10010], p[l01010], p[l11010], p[l00110], p[l10110], p[l01110], p[l11110],
                p[l00001], p[l10001], p[l01001], p[l11001], p[l00101], p[l10101], p[l01101], p[l11101],
                p[l00011], p[l10011], p[l01011], p[l11011], p[l00111], p[l10111], p[l01111], p[l11111])

            vo = SVector(po[l00000], po[l10000], po[l01000], po[l11000], po[l00100], po[l10100], po[l01100], po[l11100],
                po[l00010], po[l10010], po[l01010], po[l11010], po[l00110], po[l10110], po[l01110], po[l11110],
                po[l00001], po[l10001], po[l01001], po[l11001], po[l00101], po[l10101], po[l01101], po[l11101],
                po[l00011], po[l10011], po[l01011], po[l11011], po[l00111], po[l10111], po[l01111], po[l11111])


            @fastmath r += dot(vo, mat, vi)
        end
        return r
    end
    total_itr = div(L, 32)
    parallel_sum(eltype(v), total_itr, Threads.nthreads(), f, pos1, pos2, pos3, pos4, pos5, mask0, mask1, mask2, mask3, mask4, mask5, U, v, vout)
end


expectation_value_threaded(key::Tuple{Int, Int, Int, Int, Int}, U::AbstractMatrix, v::AbstractVector, vout::AbstractVector) = _expectation_value_fivebody_util(
	key, SMatrix{32,32, eltype(v)}(U), v, vout)

","Julia"
"Conjugate","guochu/VQC.jl","src/hamiltonian/expecs/expecs.jl",".jl","6158","132","

include(""expec_serial.jl"")
include(""expec_threaded.jl"")
include(""expec_threaded_2.jl"")

include(""expec_high_qubit_terms.jl"")
include(""expec_high_qubit_terms_2.jl"")



function expectation(m::QubitsTerm, state::StateVector) 
	isempty(m) && return dot(state, state)
	if length(positions(m)) <= LARGEST_SUPPORTED_NTERMS
	    return expectation_value(Tuple(positions(m)), _get_mat(m), storage(state))
	else
		return dot(state, m * state)
	end
end


function expectation(m::QubitsOperator, state::StateVector)
	if _largest_nterm(m) <= LARGEST_SUPPORTED_NTERMS
		r = zero(eltype(state))
		for (k, v) in m.data
			r += expectation_value(k, _get_mat(length(k), v), storage(state))
		end 
		return r   
	else
		# state = storage(state)
		# workspace = similar(state)
		# state_2 = zeros(eltype(state), length(state))
		# for (k, v) in m.data
		#     for item in v
		#     	_apply_qterm_util!(QubitsTerm(k, item[1], item[2]), state, workspace)
		#     	state_2 .+= workspace
		#     end
		# end
		# return dot(state, state_2)
		return dot(state, m * state)
	end
end


function expectation(state_c::StateVector, m::QubitsTerm, state::StateVector) 
	isempty(m) && return dot(state_c, state)
	if length(positions(m)) <= LARGEST_SUPPORTED_NTERMS
		return expectation_value(Tuple(positions(m)), _get_mat(m), storage(state), storage(state_c))
	else
		return dot(state_c, m * state)
	end	
end

function expectation(state_c::StateVector, m::QubitsOperator, state::StateVector)
	if _largest_nterm(m) <= LARGEST_SUPPORTED_NTERMS
		r = zero(eltype(state))
		for (k, v) in m.data
			r += expectation_value(k, _get_mat(length(k), v), storage(state), storage(state_c))
		end
		return r
	else
		# state = storage(state)
		# workspace = similar(state)
		# state_2 = zeros(eltype(state), length(state))
		# for (k, v) in m.data
		#     for item in v
		#     	_apply_qterm_util!(QubitsTerm(k, item[1], item[2]), state, workspace)
		#     	state_2 .+= workspace
		#     end
		# end
		# return dot(state_c, state_2)
		return dot(state_c, m * state)
	end
end

expectation(m::Gate, state::StateVector) = expectation_value(ordered_positions(m), ordered_mat(m), storage(state))
expectation(state_c::StateVector, m::Gate, state::StateVector) = expectation_value(
	ordered_positions(m), ordered_mat(m), storage(state), storage(state_c))

expectation(state_c::StateVector, m::AbstractMatrix, state::StateVector) = dot(storage(state_c), m, storage(state))
expectation(m::AbstractMatrix, state::StateVector) = dot(state, m, state)



expectation_value(pos::Int, m::AbstractMatrix, state::AbstractVector) = (length(state) >= 32) ? expectation_value_threaded(
	pos, m, state) : expectation_value_serial(pos, m, state)
expectation_value(pos::Int, m::AbstractMatrix, state::AbstractVector, state_c::AbstractVector) = (length(state) >= 32) ? expectation_value_threaded(
	pos, m, state, state_c) : expectation_value_serial(pos, m, state, state_c)
expectation_value(pos::Tuple{Int}, m::AbstractMatrix, state::AbstractVector) = expectation_value(pos[1], m, state)
expectation_value(pos::Tuple{Int}, m::AbstractMatrix, state::AbstractVector, state_c::AbstractVector) = expectation_value(
	pos[1], m, state, state_c)

expectation_value(pos::Tuple{Int, Int}, m::AbstractMatrix, state::AbstractVector) = (length(state) >= 32) ? expectation_value_threaded(
	pos, m, state) : expectation_value_serial(pos, m, state)
expectation_value(pos::Tuple{Int, Int}, m::AbstractMatrix, state::AbstractVector, state_c::AbstractVector) = (length(state) >= 32) ? expectation_value_threaded(
	pos, m, state, state_c) : expectation_value_serial(pos, m, state, state_c)
expectation_value(pos::Tuple{Int, Int}, m::AbstractArray{T, 4}, state::AbstractVector) where T = expectation_value(
	pos, reshape(m, 4, 4), state)
expectation_value(pos::Tuple{Int, Int}, m::AbstractArray{T, 4}, state::AbstractVector, state_c::AbstractVector) where T = expectation_value(
	pos, reshape(m, 4, 4), state, state_c)


expectation_value(pos::Tuple{Int, Int, Int}, m::AbstractMatrix, state::AbstractVector) = (length(state) >= 32) ? expectation_value_threaded(
	pos, m, state) : expectation_value_serial(pos, m, state)
expectation_value(pos::Tuple{Int, Int, Int}, m::AbstractMatrix, state::AbstractVector, state_c::AbstractVector) = (length(state) >= 32) ? expectation_value_threaded(
	pos, m, state, state_c) : expectation_value_serial(pos, m, state, state_c)
expectation_value(pos::Tuple{Int, Int, Int}, m::AbstractArray{T, 6}, state::AbstractVector) where T = expectation_value(
	pos, reshape(m, 8, 8), state)
expectation_value(pos::Tuple{Int, Int, Int}, m::AbstractArray{T, 6}, state::AbstractVector, state_c::AbstractVector) where T = expectation_value(
	pos, reshape(m, 8, 8), state, state_c)


expectation_value(pos::Tuple{Int, Int, Int, Int}, m::AbstractMatrix, state::AbstractVector) = expectation_value_threaded(
	pos, m, state) 
expectation_value(pos::Tuple{Int, Int, Int, Int}, m::AbstractMatrix, state::AbstractVector, state_c::AbstractVector) = expectation_value_threaded(
	pos, m, state, state_c) 
expectation_value(pos::Tuple{Int, Int, Int, Int}, m::AbstractArray{T, 8}, state::AbstractVector) where T = expectation_value(
	pos, Matrix{eltype(state)}(reshape(m, 16, 16)), state)
expectation_value(pos::Tuple{Int, Int, Int, Int}, m::AbstractArray{T, 8}, state::AbstractVector, state_c::AbstractVector) where T = expectation_value(
	pos, Matrix{eltype(state)}(reshape(m, 16, 16)), state, state_c)


expectation_value(pos::Tuple{Int, Int, Int, Int, Int}, m::AbstractMatrix, state::AbstractVector) = expectation_value_threaded(
	pos, m, state) 
expectation_value(pos::Tuple{Int, Int, Int, Int, Int}, m::AbstractMatrix, state::AbstractVector, state_c::AbstractVector) = expectation_value_threaded(
	pos, m, state, state_c) 
expectation_value(pos::Tuple{Int, Int, Int, Int, Int}, m::AbstractArray{T, 10}, state::AbstractVector) where T = expectation_value(
	pos, Matrix{eltype(state)}(reshape(m, 32, 32)), state)
expectation_value(pos::Tuple{Int, Int, Int, Int, Int}, m::AbstractArray{T, 10}, state::AbstractVector, state_c::AbstractVector) where T = expectation_value(
	pos, Matrix{eltype(state)}(reshape(m, 32, 32)), state, state_c)

","Julia"
"Conjugate","guochu/VQC.jl","src/hamiltonian/apply_qterms/long_range_threaded.jl",".jl","6932","181","

function _apply_fourbody_term_impl!(key::Tuple{Int, Int, Int, Int}, U::AbstractMatrix, v::AbstractVector, vout::AbstractVector)
    L = length(v)
    q1, q2, q3, q4 = key
    pos1, pos2, pos3, pos4 = 1 << (q1-1), 1 << (q2-1), 1 << (q3-1), 1 << (q4-1)
    # stride2, stride3 = pos1 << 1, pos2 << 1
    mask0 = pos1 - 1
    mask1 = xor(pos2 - 1, 2 * pos1 - 1)
    mask2 = xor(pos3 - 1, 2 * pos2 - 1)
    mask3 = xor(pos4 - 1, 2 * pos3 - 1)
    mask4 = xor(L - 1, 2 * pos4 - 1)
    # println(""pos1=$pos1, pos2=$pos2, m0=$mask0, m1=$mask1, m2=$mask2"")

    
    function f(ist::Int, ifn::Int, posa::Int, posb::Int, posc::Int, posd::Int, m1::Int, m2::Int, m3::Int, 
    	m4::Int, m5::Int, mat::AbstractMatrix, p::AbstractVector, po::AbstractVector) 
        @inbounds for i in ist:ifn
            l0000 = (16 * i & m5) | (8 * i & m4) | (4 * i & m3) | (2 * i & m2) | (i & m1) + 1
            l1000 = l0000 + posa
            l0100 = l0000 + posb
            l0010 = l0000 + posc
            l0001 = l0000 + posd

            l1100 = l0100 + posa
            l1010 = l0010 + posa
            l1001 = l1000 + posd
            l0110 = l0010 + posb
            l0101 = l0100 + posd
            l0011 = l0010 + posd
            
            l1110 = l1100 + posc
            l1101 = l1100 + posd
            l1011 = l1010 + posd
            l0111 = l0110 + posd

            l1111 = l1110 + posd

            vi = SVector(p[l0000], p[l1000], p[l0100], p[l1100], p[l0010], p[l1010], p[l0110], p[l1110],
                p[l0001], p[l1001], p[l0101], p[l1101], p[l0011], p[l1011], p[l0111], p[l1111])

            @fastmath begin
                vo = mat * vi
                po[l0000] += vo[1] 
                po[l1000] += vo[2] 
                po[l0100] += vo[3] 
                po[l1100] += vo[4] 
                po[l0010] += vo[5] 
                po[l1010] += vo[6] 
                po[l0110] += vo[7] 
                po[l1110] += vo[8]
                po[l0001] += vo[9] 
                po[l1001] += vo[10] 
                po[l0101] += vo[11] 
                po[l1101] += vo[12] 
                po[l0011] += vo[13] 
                po[l1011] += vo[14] 
                po[l0111] += vo[15] 
                po[l1111] += vo[16]
            end
        end
    end
    total_itr = div(L, 16)
    parallel_run(total_itr, Threads.nthreads(), f, pos1, pos2, pos3, pos4, mask0, mask1, mask2, mask3, mask4, U, v, vout)
end


_apply_gate_threaded2!(key::Tuple{Int, Int, Int, Int}, U::AbstractMatrix, v::AbstractVector, vout::AbstractVector) = _apply_fourbody_term_impl!(
	key, SMatrix{16,16, eltype(v)}(U), v, vout)


_apply_gate_2!(key::Tuple{Int, Int, Int, Int}, U::AbstractMatrix, v::AbstractVector, vout::AbstractVector) = _apply_gate_threaded2!(
	key, U, v, vout)

function _apply_fivebody_term_impl!(key::Tuple{Int, Int, Int, Int, Int}, U::AbstractMatrix, v::AbstractVector, vout::AbstractVector)
    L = length(v)
    q1, q2, q3, q4, q5 = key
    pos1, pos2, pos3, pos4, pos5 = 1 << (q1-1), 1 << (q2-1), 1 << (q3-1), 1 << (q4-1), 1 << (q5-1)
    # stride2, stride3 = pos1 << 1, pos2 << 1
    mask0 = pos1 - 1
    mask1 = xor(pos2 - 1, 2 * pos1 - 1)
    mask2 = xor(pos3 - 1, 2 * pos2 - 1)
    mask3 = xor(pos4 - 1, 2 * pos3 - 1)
    mask4 = xor(pos5 - 1, 2 * pos4 - 1)
    mask5 = xor(L - 1, 2 * pos5 - 1)
    # println(""pos1=$pos1, pos2=$pos2, m0=$mask0, m1=$mask1, m2=$mask2"")

    function f(ist::Int, ifn::Int, posa::Int, posb::Int, posc::Int, posd::Int, pose::Int, 
        m1::Int, m2::Int, m3::Int, m4::Int, m5::Int, m6::Int, mat::AbstractMatrix, p::AbstractVector, po::AbstractVector) 
        @inbounds for i in ist:ifn
            l00000 = (32 * i & m6) | (16 * i & m5) | (8 * i & m4) | (4 * i & m3) | (2 * i & m2) | (i & m1) + 1
            l10000 = l00000 + posa
            l01000 = l00000 + posb
            l00100 = l00000 + posc
            l00010 = l00000 + posd
            l00001 = l00000 + pose

            l11000 = l01000 + posa
            l10100 = l00100 + posa
            l10010 = l10000 + posd
            l10001 = l10000 + pose
            l01100 = l00100 + posb
            l01010 = l01000 + posd
            l01001 = l01000 + pose
            l00110 = l00100 + posd
            l00101 = l00100 + pose
            l00011 = l00010 + pose

            
            l11100 = l11000 + posc
            l11010 = l11000 + posd
            l11001 = l11000 + pose
            l10110 = l10100 + posd
            l10101 = l10100 + pose
            l10011 = l10010 + pose
            l01110 = l01100 + posd
            l01101 = l01100 + pose
            l01011 = l01010 + pose
            l00111 = l00110 + pose

            l11110 = l11100 + posd
            l11101 = l11100 + pose
            l11011 = l11010 + pose
            l10111 = l10110 + pose
            l01111 = l01110 + pose

            l11111 = l11110 + pose

            vi = SVector(p[l00000], p[l10000], p[l01000], p[l11000], p[l00100], p[l10100], p[l01100], p[l11100],
                p[l00010], p[l10010], p[l01010], p[l11010], p[l00110], p[l10110], p[l01110], p[l11110],
                p[l00001], p[l10001], p[l01001], p[l11001], p[l00101], p[l10101], p[l01101], p[l11101],
                p[l00011], p[l10011], p[l01011], p[l11011], p[l00111], p[l10111], p[l01111], p[l11111])

            @fastmath begin
                vo = mat * vi

                po[l00000] += vo[1] 
                po[l10000] += vo[2] 
                po[l01000] += vo[3] 
                po[l11000] += vo[4] 
                po[l00100] += vo[5] 
                po[l10100] += vo[6] 
                po[l01100] += vo[7] 
                po[l11100] += vo[8]
                po[l00010] += vo[9] 
                po[l10010] += vo[10] 
                po[l01010] += vo[11] 
                po[l11010] += vo[12] 
                po[l00110] += vo[13] 
                po[l10110] += vo[14] 
                po[l01110] += vo[15] 
                po[l11110] += vo[16]
                po[l00001] += vo[17] 
                po[l10001] += vo[18] 
                po[l01001] += vo[19] 
                po[l11001] += vo[20] 
                po[l00101] += vo[21] 
                po[l10101] += vo[22] 
                po[l01101] += vo[23] 
                po[l11101] += vo[24]
                po[l00011] += vo[25] 
                po[l10011] += vo[26] 
                po[l01011] += vo[27] 
                po[l11011] += vo[28] 
                po[l00111] += vo[29] 
                po[l10111] += vo[30] 
                po[l01111] += vo[31] 
                po[l11111] += vo[32]
            end
        end
    end
    total_itr = div(L, 32)
    parallel_run(total_itr, Threads.nthreads(), f, pos1, pos2, pos3, pos4, pos5, mask0, mask1, mask2, mask3, mask4, mask5, U, v, vout)
end

_apply_gate_threaded2!(key::Tuple{Int, Int, Int, Int, Int}, U::AbstractMatrix, v::AbstractVector, vout::AbstractVector) = _apply_fivebody_term_impl!(
	key, SMatrix{32,32, eltype(v)}(U), v, vout)



","Julia"
"Conjugate","guochu/VQC.jl","src/hamiltonian/apply_qterms/apply_qterms.jl",".jl","1440","65","include(""short_range_serial.jl"")
include(""short_range_threaded.jl"")
include(""long_range_threaded.jl"")


function (m::QubitsTerm)(vr::StateVector)
	v = storage(vr)
	vout = similar(v)
	_apply_qterm_util!(m, v, vout)
	return StateVector(vout, nqubits(vr))
end

function (m::QubitsOperator)(vr::StateVector) 
	v = storage(vr)
	vout = zeros(eltype(v), length(v))
	if _largest_nterm(m) <= LARGEST_SUPPORTED_NTERMS
		_apply_util!(m, v, vout)
	else
		workspace = similar(v)
		for (k, dd) in m.data
			for item in dd
			   _apply_qterm_util!(QubitsTerm(k, item[1], item[2]), v, workspace) 
			   vout .+= workspace
			end
		end
	end
	return StateVector(vout, nqubits(vr))
end


Base.:*(m::QubitsOperator, v::StateVector) = m(v)
Base.:*(m::QubitsTerm, v::StateVector) = m(v)



const LARGEST_SUPPORTED_NTERMS = 5


function _largest_nterm(x::QubitsOperator)
	n = 0
	for (k, v) in x.data
		n = max(n, length(k))
	end
	return n
end

function _apply_qterm_util!(m::QubitsTerm, v::AbstractVector, vout::AbstractVector)
	tmp = coeff(m)
	@. vout = tmp * v
	if length(v) >= 32
		for (pos, mat) in zip(positions(m), oplist(m))
			_apply_gate_threaded2!(pos, mat, vout)
		end	
	else    
		for (pos, mat) in zip(positions(m), oplist(m))
			_apply_gate_2!(pos, mat, vout)
		end			
	end
end


_apply_util!(m::QubitsOperator, v::AbstractVector, vout::AbstractVector) = (length(v) >= 32) ? _apply_threaded_util!(
    m, v, vout) : _apply_serial_util!(m, v, vout)

","Julia"
"Conjugate","guochu/VQC.jl","src/hamiltonian/apply_qterms/short_range_threaded.jl",".jl","58807","1528","


""""""
    applys when key > 3, U is the transposed op
""""""
function _apply_onebody_gate_H!(key::Int, U::AbstractMatrix, v::AbstractVector, vout::AbstractVector)
    L = length(v)
    sizek = 1 << (key - 1)
    mask0 = sizek - 1
    mask1 = xor(L - 1, 2 * sizek - 1)
    f(ist::Int, ifn::Int, pos::Int, m1::Int, m2::Int, mat::AbstractMatrix, p::AbstractVector, po::AbstractVector) = begin
        @inbounds for i in ist:ifn
            l = (16 * i & m2) | (8 * i & m1) + 1
            l1 = l + pos
            vi = SMatrix{8, 2}(p[l], p[l+1], p[l+2], p[l+3], p[l+4], p[l+5], p[l+6], p[l+7],
            p[l1], p[l1+1], p[l1+2], p[l1+3], p[l1+4], p[l1+5], p[l1+6], p[l1+7])

            @fastmath begin
                vo = vi * mat

                po[l] += vo[1]
                po[l+1] += vo[2]
                po[l+2] += vo[3]
                po[l+3] += vo[4]
                po[l+4] += vo[5]
                po[l+5] += vo[6]
                po[l+6] += vo[7]
                po[l+7] += vo[8]
                po[l1] += vo[9]
                po[l1+1] += vo[10]
                po[l1+2] += vo[11]
                po[l1+3] += vo[12]
                po[l1+4] += vo[13]
                po[l1+5] += vo[14]
                po[l1+6] += vo[15]
                po[l1+7] += vo[16]
            end
        end
    end

    parallel_run(div(L, 16), Threads.nthreads(), f, sizek, mask0, mask1, U, v, vout)
end

""""""
    applys when key <= 3, U is the transposed op
""""""
function _apply_onebody_gate_L!(key::Int, U::AbstractMatrix, v::AbstractVector, vout::AbstractVector)
    L = length(v)
    f1(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector, po::AbstractVector) = begin
        @inbounds for i in ist:ifn
            l = 16 * i + 1
            vi = SMatrix{2, 8}(p[l], p[l+1], p[l+2], p[l+3], p[l+4], p[l+5], p[l+6], p[l+7],
            p[l+8], p[l+9], p[l+10], p[l+11], p[l+12], p[l+13], p[l+14], p[l+15])

            @fastmath begin
                vo = mat * vi

                po[l] += vo[1]
                po[l+1] += vo[2]
                po[l+2] += vo[3]
                po[l+3] += vo[4]
                po[l+4] += vo[5]
                po[l+5] += vo[6]
                po[l+6] += vo[7]
                po[l+7] += vo[8]
                po[l+8] += vo[9]
                po[l+9] += vo[10]
                po[l+10] += vo[11]
                po[l+11] += vo[12]
                po[l+12] += vo[13]
                po[l+13] += vo[14]
                po[l+14] += vo[15]
                po[l+15] += vo[16]
            end          

            # @fastmath po[l:(l+15)] .+= mat * vi
        end
    end
    f2(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector, po::AbstractVector) = begin
        @inbounds for i in ist:ifn
            l = 16 * i + 1
            vi = SMatrix{2, 8}(p[l], p[l+2], p[l+1], p[l+3], p[l+4], p[l+6], p[l+5], p[l+7],
            p[l+8], p[l+10], p[l+9], p[l+11], p[l+12], p[l+14], p[l+13], p[l+15])

            @fastmath begin
                vo = mat * vi

                po[l] += vo[1]
                po[l+2] += vo[2]
                po[l+1] += vo[3]
                po[l+3] += vo[4]
                po[l+4] += vo[5]
                po[l+6] += vo[6]
                po[l+5] += vo[7]
                po[l+7] += vo[8]
                po[l+8] += vo[9]
                po[l+10] += vo[10]
                po[l+9] += vo[11]
                po[l+11] += vo[12]
                po[l+12] += vo[13]
                po[l+14] += vo[14]
                po[l+13] += vo[15]
                po[l+15] += vo[16]
            end

            # @fastmath p[l], p[l+2], p[l+1], p[l+3], p[l+4], p[l+6], p[l+5], p[l+7],
            # p[l+8], p[l+10], p[l+9], p[l+11], p[l+12], p[l+14], p[l+13], p[l+15] = mat * vi
        end
    end
    f3(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector, po::AbstractVector) = begin
        @inbounds for i in ist:ifn
            l = 16 * i + 1
            vi = SMatrix{2, 8}(p[l], p[l+4], p[l+1], p[l+5], p[l+2], p[l+6], p[l+3], p[l+7],
            p[l+8], p[l+12], p[l+9], p[l+13], p[l+10], p[l+14], p[l+11], p[l+15])

            @fastmath begin

                vo = mat * vi

                po[l] += vo[1]
                po[l+4] += vo[2]
                po[l+1] += vo[3]
                po[l+5] += vo[4]
                po[l+2] += vo[5]
                po[l+6] += vo[6]
                po[l+3] += vo[7]
                po[l+7] += vo[8]
                po[l+8] += vo[9]
                po[l+12] += vo[10]
                po[l+9] += vo[11]
                po[l+13] += vo[12]
                po[l+10] += vo[13]
                po[l+14] += vo[14]
                po[l+11] += vo[15]
                po[l+15] += vo[16]
            end
            # @fastmath p[l], p[l+4], p[l+1], p[l+5], p[l+2], p[l+6], p[l+3], p[l+7],
            # p[l+8], p[l+12], p[l+9], p[l+13], p[l+10], p[l+14], p[l+11], p[l+15] = mat * vi
        end
    end
    if key == 1
        f = f1
    elseif key == 2
        f = f2
    elseif key == 3
        f = f3
    else
        error(""qubit position $key not allowed for L."")
    end

    parallel_run(div(L, 16), Threads.nthreads(), f, U, v, vout)
end

function _apply_gate_threaded2!(q0::Int, U::AbstractMatrix, v::AbstractVector, vout::AbstractVector)
    if q0 > 3
        return _apply_onebody_gate_H!(q0, SMatrix{2,2, eltype(v)}(transpose(U)), v, vout)
    else
        return _apply_onebody_gate_L!(q0, SMatrix{2,2, eltype(v)}(U), v, vout)
    end
end

_apply_gate_threaded2!(q0::Tuple{Int}, U::AbstractMatrix, v::AbstractVector, vout::AbstractVector) = _apply_gate_threaded2!(
    q0[1], U, v, vout)

""""""
    applys when both keys > 3, U is the transposed op
""""""
function _apply_twobody_gate_HH!(key::Tuple{Int, Int}, U::AbstractMatrix, v::AbstractVector, vout::AbstractVector)
    L = length(v)
    q1, q2 = key
    pos1, pos2 = 1 << (q1-1), 1 << (q2-1)
    # stride2, stride3 = pos1 << 1, pos2 << 1
    mask0 = pos1 - 1
    mask1 = xor(pos2 - 1, 2 * pos1 - 1)
    mask2 = xor(L - 1, 2 * pos2 - 1)
    # println(""pos1=$pos1, pos2=$pos2, m0=$mask0, m1=$mask1, m2=$mask2"")

    total_itr = div(L, 32)
    f(ist::Int, ifn::Int, posa::Int, posb::Int, m1::Int, m2::Int, m3::Int, mat::AbstractMatrix, p::AbstractVector, po::AbstractVector) = begin
        @inbounds for i in ist:ifn
            l = (32 * i & m3) | (16 * i & m2) | (8 * i & m1) + 1
            # l = div(l, 2) + 1
            l1 = l + posa
            l2 = l + posb
            l3 = l2 + posa
            # println(""l0=$l, l1=$l1, l2=$l2, l3=$l3"")
            vi = SMatrix{8, 4}(p[l], p[l+1], p[l+2], p[l+3], p[l+4], p[l+5], p[l+6], p[l+7],
            p[l1], p[l1+1], p[l1+2], p[l1+3], p[l1+4], p[l1+5], p[l1+6], p[l1+7],
            p[l2], p[l2+1], p[l2+2], p[l2+3], p[l2+4], p[l2+5], p[l2+6], p[l2+7],
            p[l3], p[l3+1], p[l3+2], p[l3+3], p[l3+4], p[l3+5], p[l3+6], p[l3+7])

            @fastmath begin
                vo = vi * mat

                po[l] += vo[1]
                po[l+1] += vo[2]
                po[l+2] += vo[3]
                po[l+3] += vo[4]
                po[l+4] += vo[5]
                po[l+5] += vo[6]
                po[l+6] += vo[7]
                po[l+7] += vo[8]
                po[l1] += vo[9]
                po[l1+1] += vo[10]
                po[l1+2] += vo[11]
                po[l1+3] += vo[12]
                po[l1+4] += vo[13]
                po[l1+5] += vo[14]
                po[l1+6] += vo[15]
                po[l1+7] += vo[16]
                po[l2] += vo[17]
                po[l2+1] += vo[18]
                po[l2+2] += vo[19]
                po[l2+3] += vo[20]
                po[l2+4] += vo[21]
                po[l2+5] += vo[22]
                po[l2+6] += vo[23]
                po[l2+7] += vo[24]
                po[l3] += vo[25]
                po[l3+1] += vo[26]
                po[l3+2] += vo[27]
                po[l3+3] += vo[28]
                po[l3+4] += vo[29]
                po[l3+5] += vo[30]
                po[l3+6] += vo[31]
                po[l3+7] += vo[32]
            end

            # @fastmath p[l], p[l+1], p[l+2], p[l+3], p[l+4], p[l+5], p[l+6], p[l+7],
            # p[l1], p[l1+1], p[l1+2], p[l1+3], p[l1+4], p[l1+5], p[l1+6], p[l1+7],
            # p[l2], p[l2+1], p[l2+2], p[l2+3], p[l2+4], p[l2+5], p[l2+6], p[l2+7],
            # p[l3], p[l3+1], p[l3+2], p[l3+3], p[l3+4], p[l3+5], p[l3+6], p[l3+7] = vi * mat
        end
    end

    parallel_run(total_itr, Threads.nthreads(), f, pos1, pos2, mask0, mask1, mask2, U, v, vout)
end

""""""
    applys when q1 <= 3 and q2 > 4, U is the transposed op
""""""
function _apply_twobody_gate_LH!(key::Tuple{Int, Int}, U::AbstractMatrix, v::AbstractVector, vout::AbstractVector)
    L = length(v)
    q1, q2 = key
    sizej = 1 << (q2-1)
    mask0 = sizej - 1
    mask1 = xor(L - 1, 2 * sizej - 1)

    f1H(ist::Int, ifn::Int, posb::Int, m1::Int, m2::Int, mat::AbstractMatrix, p::AbstractVector, po::AbstractVector) = begin
        @inbounds for i in ist:ifn
            l = (32 * i & m2) | (16 * i & m1)
            l1 = l + posb
            # println(""l=$l, l1=$l1"")
            vi = SMatrix{8, 4}(p[l+1], p[l+3], p[l+5], p[l+7], p[l+9], p[l+11], p[l+13], p[l+15],
            p[l+2], p[l+4], p[l+6], p[l+8], p[l+10], p[l+12], p[l+14], p[l+16],
            p[l1+1], p[l1+3], p[l1+5], p[l1+7], p[l1+9], p[l1+11], p[l1+13], p[l1+15],
            p[l1+2], p[l1+4], p[l1+6], p[l1+8], p[l1+10], p[l1+12], p[l1+14], p[l1+16])

            @fastmath begin
                vo = vi * mat

                po[l+1] += vo[1]
                po[l+3] += vo[2]
                po[l+5] += vo[3]
                po[l+7] += vo[4]
                po[l+9] += vo[5]
                po[l+11] += vo[6]
                po[l+13] += vo[7]
                po[l+15] += vo[8]
                po[l+2] += vo[9]
                po[l+4] += vo[10]
                po[l+6] += vo[11]
                po[l+8] += vo[12]
                po[l+10] += vo[13]
                po[l+12] += vo[14]
                po[l+14] += vo[15]
                po[l+16] += vo[16]
                po[l1+1] += vo[17]
                po[l1+3] += vo[18]
                po[l1+5] += vo[19]
                po[l1+7] += vo[20]
                po[l1+9] += vo[21]
                po[l1+11] += vo[22]
                po[l1+13] += vo[23]
                po[l1+15] += vo[24]
                po[l1+2] += vo[25]
                po[l1+4] += vo[26]
                po[l1+6] += vo[27]
                po[l1+8] += vo[28]
                po[l1+10] += vo[29]
                po[l1+12] += vo[30]
                po[l1+14] += vo[31]
                po[l1+16] += vo[32]
            end

            # @fastmath p[l+1], p[l+3], p[l+5], p[l+7], p[l+9], p[l+11], p[l+13], p[l+15],
            # p[l+2], p[l+4], p[l+6], p[l+8], p[l+10], p[l+12], p[l+14], p[l+16],
            # p[l1+1], p[l1+3], p[l1+5], p[l1+7], p[l1+9], p[l1+11], p[l1+13], p[l1+15],
            # p[l1+2], p[l1+4], p[l1+6], p[l1+8], p[l1+10], p[l1+12], p[l1+14], p[l1+16] = vi * mat
        end
    end

    f2H(ist::Int, ifn::Int, posb::Int, m1::Int, m2::Int, mat::AbstractMatrix, p::AbstractVector, po::AbstractVector) = begin
        @inbounds for i in ist:ifn
            l = (32 * i & m2) | (16 * i & m1)
            l1 = l + posb
            # println(""l=$l, l1=$l1"")
            vi = SMatrix{8, 4}(p[l+1], p[l+2], p[l+5], p[l+6], p[l+9], p[l+10], p[l+13], p[l+14],
            p[l+3], p[l+4], p[l+7], p[l+8], p[l+11], p[l+12], p[l+15], p[l+16],
            p[l1+1], p[l1+2], p[l1+5], p[l1+6], p[l1+9], p[l1+10], p[l1+13], p[l1+14],
            p[l1+3], p[l1+4], p[l1+7], p[l1+8], p[l1+11], p[l1+12], p[l1+15], p[l1+16])

            @fastmath begin
                vo = vi * mat

                po[l+1] += vo[1]
                po[l+2] += vo[2]
                po[l+5] += vo[3]
                po[l+6] += vo[4]
                po[l+9] += vo[5]
                po[l+10] += vo[6]
                po[l+13] += vo[7]
                po[l+14] += vo[8]
                po[l+3] += vo[9]
                po[l+4] += vo[10]
                po[l+7] += vo[11]
                po[l+8] += vo[12]
                po[l+11] += vo[13]
                po[l+12] += vo[14]
                po[l+15] += vo[15]
                po[l+16] += vo[16]
                po[l1+1] += vo[17]
                po[l1+2] += vo[18]
                po[l1+5] += vo[19]
                po[l1+6] += vo[20]
                po[l1+9] += vo[21]
                po[l1+10] += vo[22]
                po[l1+13] += vo[23]
                po[l1+14] += vo[24]
                po[l1+3] += vo[25]
                po[l1+4] += vo[26]
                po[l1+7] += vo[27]
                po[l1+8] += vo[28]
                po[l1+11] += vo[29]
                po[l1+12] += vo[30]
                po[l1+15] += vo[31]
                po[l1+16] += vo[32]
            end

            # @fastmath p[l+1], p[l+2], p[l+5], p[l+6], p[l+9], p[l+10], p[l+13], p[l+14],
            # p[l+3], p[l+4], p[l+7], p[l+8], p[l+11], p[l+12], p[l+15], p[l+16],
            # p[l1+1], p[l1+2], p[l1+5], p[l1+6], p[l1+9], p[l1+10], p[l1+13], p[l1+14],
            # p[l1+3], p[l1+4], p[l1+7], p[l1+8], p[l1+11], p[l1+12], p[l1+15], p[l1+16] = vi * mat
        end
    end

    f3H(ist::Int, ifn::Int, posb::Int, m1::Int, m2::Int, mat::AbstractMatrix, p::AbstractVector, po::AbstractVector) = begin
        @inbounds for i in ist:ifn
            l = (32 * i & m2) | (16 * i & m1)
            l1 = l + posb
            # println(""l=$l, l1=$l1"")
            vi = SMatrix{8, 4}(p[l+1], p[l+2], p[l+3], p[l+4], p[l+9], p[l+10], p[l+11], p[l+12],
            p[l+5], p[l+6], p[l+7], p[l+8], p[l+13], p[l+14], p[l+15], p[l+16],
            p[l1+1], p[l1+2], p[l1+3], p[l1+4], p[l1+9], p[l1+10], p[l1+11], p[l1+12],
            p[l1+5], p[l1+6], p[l1+7], p[l1+8], p[l1+13], p[l1+14], p[l1+15], p[l1+16])

            @fastmath begin
                vo = vi * mat

                po[l+1] += vo[1]
                po[l+2] += vo[2]
                po[l+3] += vo[3]
                po[l+4] += vo[4]
                po[l+9] += vo[5]
                po[l+10] += vo[6]
                po[l+11] += vo[7]
                po[l+12] += vo[8]
                po[l+5] += vo[9]
                po[l+6] += vo[10]
                po[l+7] += vo[11]
                po[l+8] += vo[12]
                po[l+13] += vo[13]
                po[l+14] += vo[14]
                po[l+15] += vo[15]
                po[l+16] += vo[16]
                po[l1+1] += vo[17]
                po[l1+2] += vo[18]
                po[l1+3] += vo[19]
                po[l1+4] += vo[20]
                po[l1+9] += vo[21]
                po[l1+10] += vo[22]
                po[l1+11] += vo[23]
                po[l1+12] += vo[24]
                po[l1+5] += vo[25]
                po[l1+6] += vo[26]
                po[l1+7] += vo[27]
                po[l1+8] += vo[28]
                po[l1+13] += vo[29]
                po[l1+14] += vo[30]
                po[l1+15] += vo[31]
                po[l1+16] += vo[32]
            end

            # @fastmath p[l+1], p[l+2], p[l+3], p[l+4], p[l+9], p[l+10], p[l+11], p[l+12],
            # p[l+5], p[l+6], p[l+7], p[l+8], p[l+13], p[l+14], p[l+15], p[l+16],
            # p[l1+1], p[l1+2], p[l1+3], p[l1+4], p[l1+9], p[l1+10], p[l1+11], p[l1+12],
            # p[l1+5], p[l1+6], p[l1+7], p[l1+8], p[l1+13], p[l1+14], p[l1+15], p[l1+16] = vi * mat
        end
    end

    if q1 == 1
        f = f1H
    elseif q1 == 2
        f = f2H
    elseif q1 == 3
        f = f3H
    else
        error(""qubit position $q1 not allowed for LH."")
    end
    total_itr = div(L, 32)

    parallel_run(total_itr, Threads.nthreads(), f, sizej, mask0, mask1, U, v, vout)
end


""""""
    applys when both keys <= 4
""""""
function _apply_twobody_gate_LL!(key::Tuple{Int, Int}, U::AbstractMatrix, v::AbstractVector, vout::AbstractVector)
    L = length(v)
    q1, q2 = key
    f12(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector, po::AbstractVector) = begin
        @inbounds for i in ist:ifn
            l = 32 * i + 1
            vi = SMatrix{4, 8}(p[l], p[l+1], p[l+2], p[l+3], p[l+4], p[l+5], p[l+6], p[l+7],
            p[l+8], p[l+9], p[l+10], p[l+11], p[l+12], p[l+13], p[l+14], p[l+15],
            p[l+16], p[l+17], p[l+18], p[l+19], p[l+20], p[l+21], p[l+22], p[l+23],
            p[l+24], p[l+25], p[l+26], p[l+27], p[l+28], p[l+29], p[l+30], p[l+31])

            @fastmath begin
                vo = mat * vi

                po[l] += vo[1]
                po[l+1] += vo[2]
                po[l+2] += vo[3]
                po[l+3] += vo[4]
                po[l+4] += vo[5]
                po[l+5] += vo[6]
                po[l+6] += vo[7]
                po[l+7] += vo[8]
                po[l+8] += vo[9]
                po[l+9] += vo[10]
                po[l+10] += vo[11]
                po[l+11] += vo[12]
                po[l+12] += vo[13]
                po[l+13] += vo[14]
                po[l+14] += vo[15]
                po[l+15] += vo[16]
                po[l+16] += vo[17]
                po[l+17] += vo[18]
                po[l+18] += vo[19]
                po[l+19] += vo[20]
                po[l+20] += vo[21]
                po[l+21] += vo[22]
                po[l+22] += vo[23]
                po[l+23] += vo[24]
                po[l+24] += vo[25]
                po[l+25] += vo[26]
                po[l+26] += vo[27]
                po[l+27] += vo[28]
                po[l+28] += vo[29]
                po[l+29] += vo[30]
                po[l+30] += vo[31]
                po[l+31] += vo[32]
            end

            # @fastmath po[l:(l+31)] = mat * vi
        end
    end
    f13(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector, po::AbstractVector) = begin
        @inbounds for i in ist:ifn
            l = 32 * i + 1
            vi = SMatrix{4, 8}(p[l], p[l+1], p[l+4], p[l+5], p[l+2], p[l+3], p[l+6], p[l+7],
            p[l+8], p[l+9], p[l+12], p[l+13], p[l+10], p[l+11], p[l+14], p[l+15],
            p[l+16], p[l+17], p[l+20], p[l+21], p[l+18], p[l+19], p[l+22], p[l+23],
            p[l+24], p[l+25], p[l+28], p[l+29], p[l+26], p[l+27], p[l+30], p[l+31])

            @fastmath begin
                vo = mat * vi

                po[l] += vo[1]
                po[l+1] += vo[2]
                po[l+4] += vo[3]
                po[l+5] += vo[4]
                po[l+2] += vo[5]
                po[l+3] += vo[6]
                po[l+6] += vo[7]
                po[l+7] += vo[8]
                po[l+8] += vo[9]
                po[l+9] += vo[10]
                po[l+12] += vo[11]
                po[l+13] += vo[12]
                po[l+10] += vo[13]
                po[l+11] += vo[14]
                po[l+14] += vo[15]
                po[l+15] += vo[16]
                po[l+16] += vo[17]
                po[l+17] += vo[18]
                po[l+20] += vo[19]
                po[l+21] += vo[20]
                po[l+18] += vo[21]
                po[l+19] += vo[22]
                po[l+22] += vo[23]
                po[l+23] += vo[24]
                po[l+24] += vo[25]
                po[l+25] += vo[26]
                po[l+28] += vo[27]
                po[l+29] += vo[28]
                po[l+26] += vo[29]
                po[l+27] += vo[30]
                po[l+30] += vo[31]
                po[l+31] += vo[32]
            end

            # @fastmath p[l], p[l+1], p[l+4], p[l+5], p[l+2], p[l+3], p[l+6], p[l+7],
            # p[l+8], p[l+9], p[l+12], p[l+13], p[l+10], p[l+11], p[l+14], p[l+15],
            # p[l+16], p[l+17], p[l+20], p[l+21], p[l+18], p[l+19], p[l+22], p[l+23],
            # p[l+24], p[l+25], p[l+28], p[l+29], p[l+26], p[l+27], p[l+30], p[l+31] = mat * vi
        end
    end
    f14(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector, po::AbstractVector) = begin
        @inbounds for i in ist:ifn
            l = 32 * i
            vi = SMatrix{4, 8}(p[l+1], p[l+2], p[l+9], p[l+10], p[l+3], p[l+4], p[l+11], p[l+12],
            p[l+5], p[l+6], p[l+13], p[l+14], p[l+7], p[l+8], p[l+15], p[l+16],
            p[l+17], p[l+18], p[l+25], p[l+26], p[l+19], p[l+20], p[l+27], p[l+28],
            p[l+21], p[l+22], p[l+29], p[l+30], p[l+23], p[l+24], p[l+31], p[l+32])

            @fastmath begin
                vo = mat * vi

                po[l+1] += vo[1]
                po[l+2] += vo[2]
                po[l+9] += vo[3]
                po[l+10] += vo[4]
                po[l+3] += vo[5]
                po[l+4] += vo[6]
                po[l+11] += vo[7]
                po[l+12] += vo[8]
                po[l+5] += vo[9]
                po[l+6] += vo[10]
                po[l+13] += vo[11]
                po[l+14] += vo[12]
                po[l+7] += vo[13]
                po[l+8] += vo[14]
                po[l+15] += vo[15]
                po[l+16] += vo[16]
                po[l+17] += vo[17]
                po[l+18] += vo[18]
                po[l+25] += vo[19]
                po[l+26] += vo[20]
                po[l+19] += vo[21]
                po[l+20] += vo[22]
                po[l+27] += vo[23]
                po[l+28] += vo[24]
                po[l+21] += vo[25]
                po[l+22] += vo[26]
                po[l+29] += vo[27]
                po[l+30] += vo[28]
                po[l+23] += vo[29]
                po[l+24] += vo[30]
                po[l+31] += vo[31]
                po[l+32] += vo[32]
            end

            # @fastmath p[l+1], p[l+2], p[l+9], p[l+10], p[l+3], p[l+4], p[l+11], p[l+12],
            # p[l+5], p[l+6], p[l+13], p[l+14], p[l+7], p[l+8], p[l+15], p[l+16],
            # p[l+17], p[l+18], p[l+25], p[l+26], p[l+19], p[l+20], p[l+27], p[l+28],
            # p[l+21], p[l+22], p[l+29], p[l+30], p[l+23], p[l+24], p[l+31], p[l+32] = mat * vi
        end
    end
    f23(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector, po::AbstractVector) = begin
        @inbounds for i in ist:ifn
            l = 32 * i + 1
            vi = SMatrix{4, 8}(p[l], p[l+2], p[l+4], p[l+6], p[l+1], p[l+3], p[l+5], p[l+7],
            p[l+8], p[l+10], p[l+12], p[l+14], p[l+9], p[l+11], p[l+13], p[l+15],
            p[l+16], p[l+18], p[l+20], p[l+22], p[l+17], p[l+19], p[l+21], p[l+23],
            p[l+24], p[l+26], p[l+28], p[l+30], p[l+25], p[l+27], p[l+29], p[l+31])

            @fastmath begin
                vo = mat * vi

                po[l] += vo[1]
                po[l+2] += vo[2]
                po[l+4] += vo[3]
                po[l+6] += vo[4]
                po[l+1] += vo[5]
                po[l+3] += vo[6]
                po[l+5] += vo[7]
                po[l+7] += vo[8]
                po[l+8] += vo[9]
                po[l+10] += vo[10]
                po[l+12] += vo[11]
                po[l+14] += vo[12]
                po[l+9] += vo[13]
                po[l+11] += vo[14]
                po[l+13] += vo[15]
                po[l+15] += vo[16]
                po[l+16] += vo[17]
                po[l+18] += vo[18]
                po[l+20] += vo[19]
                po[l+22] += vo[20]
                po[l+17] += vo[21]
                po[l+19] += vo[22]
                po[l+21] += vo[23]
                po[l+23] += vo[24]
                po[l+24] += vo[25]
                po[l+26] += vo[26]
                po[l+28] += vo[27]
                po[l+30] += vo[28]
                po[l+25] += vo[29]
                po[l+27] += vo[30]
                po[l+29] += vo[31]
                po[l+31] += vo[32]
            end

            # @fastmath p[l], p[l+2], p[l+4], p[l+6], p[l+1], p[l+3], p[l+5], p[l+7],
            # p[l+8], p[l+10], p[l+12], p[l+14], p[l+9], p[l+11], p[l+13], p[l+15],
            # p[l+16], p[l+18], p[l+20], p[l+22], p[l+17], p[l+19], p[l+21], p[l+23],
            # p[l+24], p[l+26], p[l+28], p[l+30], p[l+25], p[l+27], p[l+29], p[l+31] = mat * vi
        end
    end
    f24(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector, po::AbstractVector) = begin
        @inbounds for i in ist:ifn
            l = 32 * i
            vi = SMatrix{4, 8}(p[l+1], p[l+3], p[l+9], p[l+11], p[l+2], p[l+4], p[l+10], p[l+12],
            p[l+5], p[l+7], p[l+13], p[l+15], p[l+6], p[l+8], p[l+14], p[l+16],
            p[l+17], p[l+19], p[l+25], p[l+27], p[l+18], p[l+20], p[l+26], p[l+28],
            p[l+21], p[l+23], p[l+29], p[l+31], p[l+22], p[l+24], p[l+30], p[l+32])

            @fastmath begin
                vo = mat * vi

                po[l+1] += vo[1]
                po[l+3] += vo[2]
                po[l+9] += vo[3]
                po[l+11] += vo[4]
                po[l+2] += vo[5]
                po[l+4] += vo[6]
                po[l+10] += vo[7]
                po[l+12] += vo[8]
                po[l+5] += vo[9]
                po[l+7] += vo[10]
                po[l+13] += vo[11]
                po[l+15] += vo[12]
                po[l+6] += vo[13]
                po[l+8] += vo[14]
                po[l+14] += vo[15]
                po[l+16] += vo[16]
                po[l+17] += vo[17]
                po[l+19] += vo[18]
                po[l+25] += vo[19]
                po[l+27] += vo[20]
                po[l+18] += vo[21]
                po[l+20] += vo[22]
                po[l+26] += vo[23]
                po[l+28] += vo[24]
                po[l+21] += vo[25]
                po[l+23] += vo[26]
                po[l+29] += vo[27]
                po[l+31] += vo[28]
                po[l+22] += vo[29]
                po[l+24] += vo[30]
                po[l+30] += vo[31]
                po[l+32] += vo[32]
            end

            # @fastmath p[l+1], p[l+3], p[l+9], p[l+11], p[l+2], p[l+4], p[l+10], p[l+12],
            # p[l+5], p[l+7], p[l+13], p[l+15], p[l+6], p[l+8], p[l+14], p[l+16],
            # p[l+17], p[l+19], p[l+25], p[l+27], p[l+18], p[l+20], p[l+26], p[l+28],
            # p[l+21], p[l+23], p[l+29], p[l+31], p[l+22], p[l+24], p[l+30], p[l+32] = mat * vi
        end
    end
    f34(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector, po::AbstractVector) = begin
        @inbounds for i in ist:ifn
            l = 32 * i
            vi = SMatrix{4, 8}(p[l+1], p[l+5], p[l+9], p[l+13], p[l+2], p[l+6], p[l+10], p[l+14],
            p[l+3], p[l+7], p[l+11], p[l+15], p[l+4], p[l+8], p[l+12], p[l+16],
            p[l+17], p[l+21], p[l+25], p[l+29], p[l+18], p[l+22], p[l+26], p[l+30],
            p[l+19], p[l+23], p[l+27], p[l+31], p[l+20], p[l+24], p[l+28], p[l+32])

            @fastmath begin
                vo = mat * vi

                po[l+1] += vo[1]
                po[l+5] += vo[2]
                po[l+9] += vo[3]
                po[l+13] += vo[4]
                po[l+2] += vo[5]
                po[l+6] += vo[6]
                po[l+10] += vo[7]
                po[l+14] += vo[8]
                po[l+3] += vo[9]
                po[l+7] += vo[10]
                po[l+11] += vo[11]
                po[l+15] += vo[12]
                po[l+4] += vo[13]
                po[l+8] += vo[14]
                po[l+12] += vo[15]
                po[l+16] += vo[16]
                po[l+17] += vo[17]
                po[l+21] += vo[18]
                po[l+25] += vo[19]
                po[l+29] += vo[20]
                po[l+18] += vo[21]
                po[l+22] += vo[22]
                po[l+26] += vo[23]
                po[l+30] += vo[24]
                po[l+19] += vo[25]
                po[l+23] += vo[26]
                po[l+27] += vo[27]
                po[l+31] += vo[28]
                po[l+20] += vo[29]
                po[l+24] += vo[30]
                po[l+28] += vo[31]
                po[l+32] += vo[32]
            end

            # @fastmath p[l+1], p[l+5], p[l+9], p[l+13], p[l+2], p[l+6], p[l+10], p[l+14],
            # p[l+3], p[l+7], p[l+11], p[l+15], p[l+4], p[l+8], p[l+12], p[l+16],
            # p[l+17], p[l+21], p[l+25], p[l+29], p[l+18], p[l+22], p[l+26], p[l+30],
            # p[l+19], p[l+23], p[l+27], p[l+31], p[l+20], p[l+24], p[l+28], p[l+32] = mat * vi
        end
    end
    if q1==1 && q2 == 2
        f = f12
    elseif q1==1 && q2 == 3
        f = f13
    elseif q1==1 && q2 == 4
        f = f14
    elseif q1==2 && q2 == 3
        f = f23
    elseif q1==2 && q2 == 4
        f = f24
    elseif q1==3 && q2 == 4
        f = f34
    else
        error(""qubit position $q1 and $q2 not allowed for LL."")
    end
    total_itr = div(L, 32)

    parallel_run(total_itr, Threads.nthreads(), f, U, v, vout)
end

function _apply_gate_threaded2!(key::Tuple{Int, Int}, U::AbstractMatrix, v::AbstractVector, vout::AbstractVector)
    q0, q1 = key
    if q0 > 3
        return _apply_twobody_gate_HH!(key, SMatrix{4,4, eltype(v)}(transpose(U)), v, vout)
    elseif q1 > 4
        return _apply_twobody_gate_LH!(key, SMatrix{4,4, eltype(v)}(transpose(U)), v, vout)
    else
        return _apply_twobody_gate_LL!(key, SMatrix{4,4, eltype(v)}(U), v, vout)
    end
end


""""""
    applys when both keys > 2, U is assumed to be transposed
""""""
function _apply_threebody_gate_HHH!(key::Tuple{Int, Int, Int}, U::AbstractMatrix, v::AbstractVector, vout::AbstractVector)
    L = length(v)
    q1, q2, q3 = key
    pos1, pos2, pos3 = 1 << (q1-1), 1 << (q2-1), 1 << (q3-1)
    # stride2, stride3 = pos1 << 1, pos2 << 1
    mask0 = pos1 - 1
    mask1 = xor(pos2 - 1, 2 * pos1 - 1)
    mask2 = xor(pos3 - 1, 2 * pos2 - 1)
    mask3 = xor(L - 1, 2 * pos3 - 1)
    # println(""pos1=$pos1, pos2=$pos2, m0=$mask0, m1=$mask1, m2=$mask2"")

    total_itr = div(L, 32)
    f(ist::Int, ifn::Int, posa::Int, posb::Int, posc::Int, m1::Int, m2::Int, m3::Int, m4::Int, mat::AbstractMatrix, p::AbstractVector, po::AbstractVector) = begin
        @inbounds for i in ist:ifn
            l000 = (32 * i & m4) | (16 * i & m3) | (8 * i & m2) | (4 * i & m1) + 1
            l100 = l000 + posa
            l010 = l000 + posb
            l110 = l010 + posa

            l001 = l000 + posc
            l101 = l001 + posa
            l011 = l001 + posb
            l111 = l011 + posa

            # println(""$l000, $l100, $l010, $l110, $l001, $l101, $l011, $l111"")
            vi = SMatrix{4, 8}(p[l000], p[l000+1], p[l000+2], p[l000+3],
                               p[l100], p[l100+1], p[l100+2], p[l100+3],
                               p[l010], p[l010+1], p[l010+2], p[l010+3],
                               p[l110], p[l110+1], p[l110+2], p[l110+3],
                               p[l001], p[l001+1], p[l001+2], p[l001+3],
                               p[l101], p[l101+1], p[l101+2], p[l101+3],
                               p[l011], p[l011+1], p[l011+2], p[l011+3],
                               p[l111], p[l111+1], p[l111+2], p[l111+3])

            @fastmath begin
                vo = vi * mat

                po[l000] += vo[1]
                po[l000+1] += vo[2]
                po[l000+2] += vo[3]
                po[l000+3] += vo[4]
                po[l100] += vo[5]
                po[l100+1] += vo[6]
                po[l100+2] += vo[7]
                po[l100+3] += vo[8]
                po[l010] += vo[9]
                po[l010+1] += vo[10]
                po[l010+2] += vo[11]
                po[l010+3] += vo[12]
                po[l110] += vo[13] 
                po[l110+1] += vo[14] 
                po[l110+2] += vo[15] 
                po[l110+3] += vo[16]
                po[l001] += vo[17] 
                po[l001+1] += vo[18] 
                po[l001+2] += vo[19] 
                po[l001+3] += vo[20]
                po[l101] += vo[21] 
                po[l101+1] += vo[22] 
                po[l101+2] += vo[23] 
                po[l101+3] += vo[24]
                po[l011] += vo[25] 
                po[l011+1] += vo[26] 
                po[l011+2] += vo[27] 
                po[l011+3] += vo[28]
                po[l111] += vo[29] 
                po[l111+1] += vo[30] 
                po[l111+2] += vo[31]  
                po[l111+3] += vo[32]
            end

            # @fastmath p[l000], p[l000+1], p[l000+2], p[l000+3],
            #           p[l100], p[l100+1], p[l100+2], p[l100+3],
            #           p[l010], p[l010+1], p[l010+2], p[l010+3],
            #           p[l110], p[l110+1], p[l110+2], p[l110+3],
            #           p[l001], p[l001+1], p[l001+2], p[l001+3],
            #           p[l101], p[l101+1], p[l101+2], p[l101+3],
            #           p[l011], p[l011+1], p[l011+2], p[l011+3],
            #           p[l111], p[l111+1], p[l111+2], p[l111+3] = vi * mat
        end
    end

    parallel_run(total_itr, Threads.nthreads(), f, pos1, pos2, pos3, mask0, mask1, mask2, mask3, U, v, vout)
end

""""""
    applys when q1 <= 2 and q2 > 3, U is the transposed op
""""""
function _apply_threebody_gate_LHH!(key::Tuple{Int, Int, Int}, U::AbstractMatrix, v::AbstractVector, vout::AbstractVector)
    L = length(v)
    q1, q2, q3 = key
    sizej, sizel = 1 << (q2-1), 1 << (q3-1)
    mask0 = sizej - 1
    mask1 = xor(sizel - 1, 2 * sizej - 1)
    mask2 = xor(L-1, 2 * sizel - 1)

    f1H(ist::Int, ifn::Int, posb::Int, posc::Int, m1::Int, m2::Int, m3::Int, mat::AbstractMatrix, p::AbstractVector, po::AbstractVector) = begin
        @inbounds for i in ist:ifn
            l = (32 * i & m3) | (16 * i & m2) | (8 * i & m1)
            l1 = l + posb
            l2 = l + posc
            l3 = l2 + posb
            # println(""$l, $l1, $l2, $l3"")
            vi = SMatrix{4, 8}(p[l+1], p[l+3], p[l+5], p[l+7],
                               p[l+2], p[l+4], p[l+6], p[l+8],
                               p[l1+1], p[l1+3], p[l1+5], p[l1+7],
                               p[l1+2], p[l1+4], p[l1+6], p[l1+8],
                               p[l2+1], p[l2+3], p[l2+5], p[l2+7],
                               p[l2+2], p[l2+4], p[l2+6], p[l2+8],
                               p[l3+1], p[l3+3], p[l3+5], p[l3+7],
                               p[l3+2], p[l3+4], p[l3+6], p[l3+8])

            @fastmath begin
                vo = vi * mat

                po[l+1] += vo[1]
                po[l+3] += vo[2] 
                po[l+5] += vo[3] 
                po[l+7] += vo[4]
                po[l+2] += vo[5] 
                po[l+4] += vo[6] 
                po[l+6] += vo[7] 
                po[l+8] += vo[8]
                po[l1+1] += vo[9] 
                po[l1+3] += vo[10] 
                po[l1+5] += vo[11] 
                po[l1+7] += vo[12]
                po[l1+2] += vo[13] 
                po[l1+4] += vo[14] 
                po[l1+6] += vo[15] 
                po[l1+8] += vo[16]
                po[l2+1] += vo[17] 
                po[l2+3] += vo[18] 
                po[l2+5] += vo[19] 
                po[l2+7] += vo[20]
                po[l2+2] += vo[21] 
                po[l2+4] += vo[22] 
                po[l2+6] += vo[23] 
                po[l2+8] += vo[24]
                po[l3+1] += vo[25] 
                po[l3+3] += vo[26] 
                po[l3+5] += vo[27] 
                po[l3+7] += vo[28]
                po[l3+2] += vo[29] 
                po[l3+4] += vo[30] 
                po[l3+6] += vo[31] 
                po[l3+8] += vo[32]
            end

            # @fastmath p[l+1], p[l+3], p[l+5], p[l+7],
            #           p[l+2], p[l+4], p[l+6], p[l+8],
            #           p[l1+1], p[l1+3], p[l1+5], p[l1+7],
            #           p[l1+2], p[l1+4], p[l1+6], p[l1+8],
            #           p[l2+1], p[l2+3], p[l2+5], p[l2+7],
            #           p[l2+2], p[l2+4], p[l2+6], p[l2+8],
            #           p[l3+1], p[l3+3], p[l3+5], p[l3+7],
            #           p[l3+2], p[l3+4], p[l3+6], p[l3+8] = vi * mat
        end
    end

    f2H(ist::Int, ifn::Int, posb::Int, posc::Int, m1::Int, m2::Int, m3::Int, mat::AbstractMatrix, p::AbstractVector, po::AbstractVector) = begin
        @inbounds for i in ist:ifn
            l = (32 * i & m3) | (16 * i & m2) | (8 * i & m1)
            l1 = l + posb
            l2 = l + posc
            l3 = l2 + posb
            vi = SMatrix{4, 8}(p[l+1], p[l+2], p[l+5], p[l+6],
                               p[l+3], p[l+4], p[l+7], p[l+8],
                               p[l1+1], p[l1+2], p[l1+5], p[l1+6],
                               p[l1+3], p[l1+4], p[l1+7], p[l1+8],
                               p[l2+1], p[l2+2], p[l2+5], p[l2+6],
                               p[l2+3], p[l2+4], p[l2+7], p[l2+8],
                               p[l3+1], p[l3+2], p[l3+5], p[l3+6],
                               p[l3+3], p[l3+4], p[l3+7], p[l3+8])

            @fastmath begin
                vo = vi * mat

                po[l+1] += vo[1] 
                po[l+2] += vo[2] 
                po[l+5] += vo[3] 
                po[l+6] += vo[4]
                po[l+3] += vo[5] 
                po[l+4] += vo[6] 
                po[l+7] += vo[7] 
                po[l+8] += vo[8]
                po[l1+1] += vo[9] 
                po[l1+2] += vo[10] 
                po[l1+5] += vo[11] 
                po[l1+6] += vo[12]
                po[l1+3] += vo[13] 
                po[l1+4] += vo[14] 
                po[l1+7] += vo[15] 
                po[l1+8] += vo[16]
                po[l2+1] += vo[17] 
                po[l2+2] += vo[18] 
                po[l2+5] += vo[19] 
                po[l2+6] += vo[20]
                po[l2+3] += vo[21] 
                po[l2+4] += vo[22] 
                po[l2+7] += vo[23] 
                po[l2+8] += vo[24]
                po[l3+1] += vo[25] 
                po[l3+2] += vo[26] 
                po[l3+5] += vo[27] 
                po[l3+6] += vo[28]
                po[l3+3] += vo[29] 
                po[l3+4] += vo[30] 
                po[l3+7] += vo[31] 
                po[l3+8] += vo[32]
            end

            # @fastmath p[l+1], p[l+2], p[l+5], p[l+6],
            #           p[l+3], p[l+4], p[l+7], p[l+8],
            #           p[l1+1], p[l1+2], p[l1+5], p[l1+6],
            #           p[l1+3], p[l1+4], p[l1+7], p[l1+8],
            #           p[l2+1], p[l2+2], p[l2+5], p[l2+6],
            #           p[l2+3], p[l2+4], p[l2+7], p[l2+8],
            #           p[l3+1], p[l3+2], p[l3+5], p[l3+6],
            #           p[l3+3], p[l3+4], p[l3+7], p[l3+8] = vi * mat
        end
    end

    f3H(ist::Int, ifn::Int, posb::Int, posc::Int, m1::Int, m2::Int, m3::Int, mat::AbstractMatrix, p::AbstractVector, po::AbstractVector) = begin
        @inbounds for i in ist:ifn
            l = (32 * i & m3) | (16 * i & m2) | (8 * i & m1)
            l1 = l + posb
            l2 = l + posc
            l3 = l2 + posb
            vi = SMatrix{4, 8}(p[l+1], p[l+2], p[l+3], p[l+4],
                               p[l+5], p[l+6], p[l+7], p[l+8],
                               p[l1+1], p[l1+2], p[l1+3], p[l1+4],
                               p[l1+5], p[l1+6], p[l1+7], p[l1+8],
                               p[l2+1], p[l2+2], p[l2+3], p[l2+4],
                               p[l2+5], p[l2+6], p[l2+7], p[l2+8],
                               p[l3+1], p[l3+2], p[l3+3], p[l3+4],
                               p[l3+5], p[l3+6], p[l3+7], p[l3+8])

            @fastmath begin
                vo = vi * mat

                po[l+1] += vo[1] 
                po[l+2] += vo[2] 
                po[l+3] += vo[3] 
                po[l+4] += vo[4]
                po[l+5] += vo[5] 
                po[l+6] += vo[6] 
                po[l+7] += vo[7] 
                po[l+8] += vo[8]
                po[l1+1] += vo[9] 
                po[l1+2] += vo[10] 
                po[l1+3] += vo[11] 
                po[l1+4] += vo[12]
                po[l1+5] += vo[13] 
                po[l1+6] += vo[14] 
                po[l1+7] += vo[15] 
                po[l1+8] += vo[16]
                po[l2+1] += vo[17] 
                po[l2+2] += vo[18] 
                po[l2+3] += vo[19] 
                po[l2+4] += vo[20]
                po[l2+5] += vo[21] 
                po[l2+6] += vo[22] 
                po[l2+7] += vo[23] 
                po[l2+8] += vo[24]
                po[l3+1] += vo[25] 
                po[l3+2] += vo[26] 
                po[l3+3] += vo[27] 
                po[l3+4] += vo[28]
                po[l3+5] += vo[29] 
                po[l3+6] += vo[30] 
                po[l3+7] += vo[31] 
                po[l3+8] += vo[32]
            end

            # @fastmath p[l+1], p[l+2], p[l+3], p[l+4],
            #           p[l+5], p[l+6], p[l+7], p[l+8],
            #           p[l1+1], p[l1+2], p[l1+3], p[l1+4],
            #           p[l1+5], p[l1+6], p[l1+7], p[l1+8],
            #           p[l2+1], p[l2+2], p[l2+3], p[l2+4],
            #           p[l2+5], p[l2+6], p[l2+7], p[l2+8],
            #           p[l3+1], p[l3+2], p[l3+3], p[l3+4],
            #           p[l3+5], p[l3+6], p[l3+7], p[l3+8] = vi * mat
        end
    end

    if q1 == 1
        f = f1H
    elseif q1 == 2
        f = f2H
    elseif q1 == 3
        f = f3H
    else
        error(""qubit position $q1 not allowed for LHH."")
    end
    (q2 > 3) || error(""qubit 2 position $q2 not allowed for LHH."")
    total_itr = div(L, 32)

    parallel_run(total_itr, Threads.nthreads(), f, sizej, sizel, mask0, mask1, mask2, U, v, vout)
end

""""""
    applys when q1, q2 <= 3 and q3 > 4, U is the transposed op
""""""
function _apply_threebody_gate_LLH!(key::Tuple{Int, Int, Int}, U::AbstractMatrix, v::AbstractVector, vout::AbstractVector)
    L = length(v)
    q1, q2, q3 = key
    sizej = 1 << (q3-1)
    mask0 = sizej - 1
    mask1 = xor(L - 1, 2 * sizej - 1)

    f12H(ist::Int, ifn::Int, posb::Int, m1::Int, m2::Int, mat::AbstractMatrix, p::AbstractVector, po::AbstractVector) = begin
        @inbounds for i in ist:ifn
            l = (32 * i & m2) | (16 * i & m1)
            l1 = l + posb
            # println(""l=$l, l1=$l1"")
            vi = SMatrix{4, 8}(p[l+1], p[l+5], p[l+9], p[l+13],
                               p[l+2], p[l+6], p[l+10], p[l+14],
                               p[l+3], p[l+7], p[l+11], p[l+15],
                               p[l+4], p[l+8], p[l+12], p[l+16],
                               p[l1+1], p[l1+5], p[l1+9], p[l1+13],
                               p[l1+2], p[l1+6], p[l1+10], p[l1+14],
                               p[l1+3], p[l1+7], p[l1+11], p[l1+15],
                               p[l1+4], p[l1+8], p[l1+12], p[l1+16])

            @fastmath begin
                vo = vi * mat

                po[l+1] += vo[1] 
                po[l+5] += vo[2] 
                po[l+9] += vo[3] 
                po[l+13] += vo[4]
                po[l+2] += vo[5] 
                po[l+6] += vo[6] 
                po[l+10] += vo[7] 
                po[l+14] += vo[8]
                po[l+3] += vo[9] 
                po[l+7] += vo[10] 
                po[l+11] += vo[11] 
                po[l+15] += vo[12]
                po[l+4] += vo[13] 
                po[l+8] += vo[14] 
                po[l+12] += vo[15] 
                po[l+16] += vo[16]
                po[l1+1] += vo[17]
                po[l1+5] += vo[18] 
                po[l1+9] += vo[19] 
                po[l1+13] += vo[20]
                po[l1+2] += vo[21] 
                po[l1+6] += vo[22] 
                po[l1+10] += vo[23] 
                po[l1+14] += vo[24]
                po[l1+3] += vo[25] 
                po[l1+7] += vo[26] 
                po[l1+11] += vo[27] 
                po[l1+15] += vo[28]
                po[l1+4] += vo[29] 
                po[l1+8] += vo[30] 
                po[l1+12] += vo[31] 
                po[l1+16] += vo[32]
            end

            # @fastmath p[l+1], p[l+5], p[l+9], p[l+13],
            #           p[l+2], p[l+6], p[l+10], p[l+14],
            #           p[l+3], p[l+7], p[l+11], p[l+15],
            #           p[l+4], p[l+8], p[l+12], p[l+16],
            #           p[l1+1], p[l1+5], p[l1+9], p[l1+13],
            #           p[l1+2], p[l1+6], p[l1+10], p[l1+14],
            #           p[l1+3], p[l1+7], p[l1+11], p[l1+15],
            #           p[l1+4], p[l1+8], p[l1+12], p[l1+16] = vi * mat
        end
    end

    f13H(ist::Int, ifn::Int, posb::Int, m1::Int, m2::Int, mat::AbstractMatrix, p::AbstractVector, po::AbstractVector) = begin
        @inbounds for i in ist:ifn
            l = (32 * i & m2) | (16 * i & m1)
            l1 = l + posb
            # println(""l=$l, l1=$l1"")
            vi = SMatrix{4, 8}(p[l+1], p[l+3], p[l+9], p[l+11],
                               p[l+2], p[l+4], p[l+10], p[l+12],
                               p[l+5], p[l+7], p[l+13], p[l+15],
                               p[l+6], p[l+8], p[l+14], p[l+16],
                               p[l1+1], p[l1+3], p[l1+9], p[l1+11],
                               p[l1+2], p[l1+4], p[l1+10], p[l1+12],
                               p[l1+5], p[l1+7], p[l1+13], p[l1+15],
                               p[l1+6], p[l1+8], p[l1+14], p[l1+16])

            @fastmath begin
                vo = vi * mat

                po[l+1] += vo[1] 
                po[l+3] += vo[2] 
                po[l+9] += vo[3] 
                po[l+11] += vo[4]
                po[l+2] += vo[5] 
                po[l+4] += vo[6] 
                po[l+10] += vo[7] 
                po[l+12] += vo[8]
                po[l+5] += vo[9] 
                po[l+7] += vo[10] 
                po[l+13] += vo[11] 
                po[l+15] += vo[12]
                po[l+6] += vo[13] 
                po[l+8] += vo[14] 
                po[l+14] += vo[15] 
                po[l+16] += vo[16]
                po[l1+1] += vo[17] 
                po[l1+3] += vo[18] 
                po[l1+9] += vo[19] 
                po[l1+11] += vo[20]
                po[l1+2] += vo[21] 
                po[l1+4] += vo[22] 
                po[l1+10] += vo[23] 
                po[l1+12] += vo[24]
                po[l1+5] += vo[25] 
                po[l1+7] += vo[26] 
                po[l1+13] += vo[27] 
                po[l1+15] += vo[28]
                po[l1+6] += vo[29] 
                po[l1+8] += vo[30] 
                po[l1+14] += vo[31] 
                po[l1+16] += vo[32]
            end

            # @fastmath p[l+1], p[l+3], p[l+9], p[l+11],
            #           p[l+2], p[l+4], p[l+10], p[l+12],
            #           p[l+5], p[l+7], p[l+13], p[l+15],
            #           p[l+6], p[l+8], p[l+14], p[l+16],
            #           p[l1+1], p[l1+3], p[l1+9], p[l1+11],
            #           p[l1+2], p[l1+4], p[l1+10], p[l1+12],
            #           p[l1+5], p[l1+7], p[l1+13], p[l1+15],
            #           p[l1+6], p[l1+8], p[l1+14], p[l1+16] = vi * mat
        end
    end

    f23H(ist::Int, ifn::Int, posb::Int, m1::Int, m2::Int, mat::AbstractMatrix, p::AbstractVector, po::AbstractVector) = begin
        @inbounds for i in ist:ifn
            l = (32 * i & m2) | (16 * i & m1)
            l1 = l + posb
            # println(""l=$l, l1=$l1"")
            vi = SMatrix{4, 8}(p[l+1], p[l+2], p[l+9], p[l+10],
                               p[l+3], p[l+4], p[l+11], p[l+12],
                               p[l+5], p[l+6], p[l+13], p[l+14],
                               p[l+7], p[l+8], p[l+15], p[l+16],
                               p[l1+1], p[l1+2], p[l1+9], p[l1+10],
                               p[l1+3], p[l1+4], p[l1+11], p[l1+12],
                               p[l1+5], p[l1+6], p[l1+13], p[l1+14],
                               p[l1+7], p[l1+8], p[l1+15], p[l1+16])

            @fastmath begin
                vo = vi * mat

                po[l+1] += vo[1] 
                po[l+2] += vo[2] 
                po[l+9] += vo[3] 
                po[l+10] += vo[4]
                po[l+3] += vo[5] 
                po[l+4] += vo[6] 
                po[l+11] += vo[7] 
                po[l+12] += vo[8]
                po[l+5] += vo[9] 
                po[l+6] += vo[10] 
                po[l+13] += vo[11] 
                po[l+14] += vo[12]
                po[l+7] += vo[13] 
                po[l+8] += vo[14] 
                po[l+15] += vo[15] 
                po[l+16] += vo[16]
                po[l1+1] += vo[17] 
                po[l1+2] += vo[18] 
                po[l1+9] += vo[19] 
                po[l1+10] += vo[20]
                po[l1+3] += vo[21] 
                po[l1+4] += vo[22] 
                po[l1+11] += vo[23] 
                po[l1+12] += vo[24]
                po[l1+5] += vo[25] 
                po[l1+6] += vo[26] 
                po[l1+13] += vo[27] 
                po[l1+14] += vo[28]
                po[l1+7] += vo[29] 
                po[l1+8] += vo[30] 
                po[l1+15] += vo[31]
                po[l1+16] += vo[32]     
            end

            # @fastmath p[l+1], p[l+2], p[l+9], p[l+10],
            #           p[l+3], p[l+4], p[l+11], p[l+12],
            #           p[l+5], p[l+6], p[l+13], p[l+14],
            #           p[l+7], p[l+8], p[l+15], p[l+16],
            #           p[l1+1], p[l1+2], p[l1+9], p[l1+10],
            #           p[l1+3], p[l1+4], p[l1+11], p[l1+12],
            #           p[l1+5], p[l1+6], p[l1+13], p[l1+14],
            #           p[l1+7], p[l1+8], p[l1+15], p[l1+16] = vi * mat
        end
    end

    if q1 == 1 && q2 == 2
        f = f12H
    elseif q1 == 1 && q2 == 3
        f = f13H
    elseif q1 == 2 && q2 == 3
        f = f23H
    else
        error(""qubit position $q1 not allowed for LH."")
    end
    total_itr = div(L, 32)

    parallel_run(total_itr, Threads.nthreads(), f, sizej, mask0, mask1, U, v, vout)
end

""""""
    applys when both keys <= 4
""""""
function _apply_threebody_gate_LLL!(key::Tuple{Int, Int, Int}, U::AbstractMatrix, v::AbstractVector, vout::AbstractVector)
    L = length(v)
    q1, q2, q3 = key
    f123(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector, po::AbstractVector) = begin
        @inbounds for i in ist:ifn
            l = 32 * i + 1
            vi = SMatrix{8, 4}(p[l], p[l+1], p[l+2], p[l+3], p[l+4], p[l+5], p[l+6], p[l+7],
            p[l+8], p[l+9], p[l+10], p[l+11], p[l+12], p[l+13], p[l+14], p[l+15],
            p[l+16], p[l+17], p[l+18], p[l+19], p[l+20], p[l+21], p[l+22], p[l+23],
            p[l+24], p[l+25], p[l+26], p[l+27], p[l+28], p[l+29], p[l+30], p[l+31])

            @fastmath begin
                vo = mat * vi

                po[l] += vo[1]
                po[l+1] += vo[2]
                po[l+2] += vo[3]
                po[l+3] += vo[4]
                po[l+4] += vo[5]
                po[l+5] += vo[6]
                po[l+6] += vo[7]
                po[l+7] += vo[8]
                po[l+8] += vo[9]
                po[l+9] += vo[10]
                po[l+10] += vo[11]
                po[l+11] += vo[12]
                po[l+12] += vo[13]
                po[l+13] += vo[14]
                po[l+14] += vo[15]
                po[l+15] += vo[16]
                po[l+16] += vo[17]
                po[l+17] += vo[18]
                po[l+18] += vo[19]
                po[l+19] += vo[20]
                po[l+20] += vo[21]
                po[l+21] += vo[22]
                po[l+22] += vo[23]
                po[l+23] += vo[24]
                po[l+24] += vo[25]
                po[l+25] += vo[26]
                po[l+26] += vo[27]
                po[l+27] += vo[28]
                po[l+28] += vo[29]
                po[l+29] += vo[30]
                po[l+30] += vo[31]
                po[l+31] += vo[32]               
            end
            # @fastmath p[l:(l+31)]= mat * vi
        end
    end
    f124(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector, po::AbstractVector) = begin
        @inbounds for i in ist:ifn
            l = 32 * i
            vi = SMatrix{8, 4}(p[l+1], p[l+2], p[l+3], p[l+4], p[l+9], p[l+10], p[l+11], p[l+12],
                               p[l+5], p[l+6], p[l+7], p[l+8], p[l+13], p[l+14], p[l+15], p[l+16],
                               p[l+17], p[l+18], p[l+19], p[l+20], p[l+25], p[l+26], p[l+27], p[l+28],
                               p[l+21], p[l+22], p[l+23], p[l+24], p[l+29], p[l+30], p[l+31], p[l+32])

            @fastmath begin
                vo = mat * vi

                po[l+1] += vo[1] 
                po[l+2] += vo[2] 
                po[l+3] += vo[3] 
                po[l+4] += vo[4] 
                po[l+9] += vo[5] 
                po[l+10] += vo[6] 
                po[l+11] += vo[7] 
                po[l+12] += vo[8]
                po[l+5] += vo[9] 
                po[l+6] += vo[10] 
                po[l+7] += vo[11] 
                po[l+8] += vo[12] 
                po[l+13] += vo[13] 
                po[l+14] += vo[14] 
                po[l+15] += vo[15] 
                po[l+16] += vo[16]
                po[l+17] += vo[17] 
                po[l+18] += vo[18] 
                po[l+19] += vo[19] 
                po[l+20] += vo[20] 
                po[l+25] += vo[21] 
                po[l+26] += vo[22] 
                po[l+27] += vo[23] 
                po[l+28] += vo[24]
                po[l+21] += vo[25] 
                po[l+22] += vo[26] 
                po[l+23] += vo[27] 
                po[l+24] += vo[28] 
                po[l+29] += vo[29] 
                po[l+30] += vo[30] 
                po[l+31] += vo[31] 
                po[l+32] += vo[32]    
            end

            # @fastmath p[l+1], p[l+2], p[l+3], p[l+4], p[l+9], p[l+10], p[l+11], p[l+12],
            #           p[l+5], p[l+6], p[l+7], p[l+8], p[l+13], p[l+14], p[l+15], p[l+16],
            #           p[l+17], p[l+18], p[l+19], p[l+20], p[l+25], p[l+26], p[l+27], p[l+28],
            #           p[l+21], p[l+22], p[l+23], p[l+24], p[l+29], p[l+30], p[l+31], p[l+32] = mat * vi
        end
    end
    f134(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector, po::AbstractVector) = begin
        @inbounds for i in ist:ifn
            l = 32 * i
            vi = SMatrix{8, 4}(p[l+1], p[l+2], p[l+5], p[l+6], p[l+9], p[l+10], p[l+13], p[l+14],
                               p[l+3], p[l+4], p[l+7], p[l+8], p[l+11], p[l+12], p[l+15], p[l+16],
                               p[l+17], p[l+18], p[l+21], p[l+22], p[l+25], p[l+26], p[l+29], p[l+30],
                               p[l+19], p[l+20], p[l+23], p[l+24], p[l+27], p[l+28], p[l+31], p[l+32])

            @fastmath begin
                vo = mat * vi

                po[l+1] += vo[1] 
                po[l+2] += vo[2] 
                po[l+5] += vo[3] 
                po[l+6] += vo[4] 
                po[l+9] += vo[5] 
                po[l+10] += vo[6] 
                po[l+13] += vo[7] 
                po[l+14] += vo[8]
                po[l+3] += vo[9] 
                po[l+4] += vo[10] 
                po[l+7] += vo[11] 
                po[l+8] += vo[12] 
                po[l+11] += vo[13] 
                po[l+12] += vo[14] 
                po[l+15] += vo[15] 
                po[l+16] += vo[16]
                po[l+17] += vo[17] 
                po[l+18] += vo[18] 
                po[l+21] += vo[19] 
                po[l+22] += vo[20] 
                po[l+25] += vo[21] 
                po[l+26] += vo[22] 
                po[l+29] += vo[23] 
                po[l+30] += vo[24]
                po[l+19] += vo[25] 
                po[l+20] += vo[26] 
                po[l+23] += vo[27] 
                po[l+24] += vo[28] 
                po[l+27] += vo[29] 
                po[l+28] += vo[30] 
                po[l+31] += vo[31] 
                po[l+32] += vo[32]
            end

            # @fastmath p[l+1], p[l+2], p[l+5], p[l+6], p[l+9], p[l+10], p[l+13], p[l+14],
            #           p[l+3], p[l+4], p[l+7], p[l+8], p[l+11], p[l+12], p[l+15], p[l+16],
            #           p[l+17], p[l+18], p[l+21], p[l+22], p[l+25], p[l+26], p[l+29], p[l+30],
            #           p[l+19], p[l+20], p[l+23], p[l+24], p[l+27], p[l+28], p[l+31], p[l+32] = mat * vi
        end
    end
    f234(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector, po::AbstractVector) = begin
        @inbounds for i in ist:ifn
            l = 32 * i
            vi = SMatrix{8, 4}(p[l+1], p[l+3], p[l+5], p[l+7], p[l+9], p[l+11], p[l+13], p[l+15],
                               p[l+2], p[l+4], p[l+6], p[l+8], p[l+10], p[l+12], p[l+14], p[l+16],
                               p[l+17], p[l+19], p[l+21], p[l+23], p[l+25], p[l+27], p[l+29], p[l+31],
                               p[l+18], p[l+20], p[l+22], p[l+24], p[l+26], p[l+28], p[l+30], p[l+32])

            @fastmath begin
                vo = mat * vi
                
                po[l+1] += vo[1] 
                po[l+3] += vo[2] 
                po[l+5] += vo[3] 
                po[l+7] += vo[4] 
                po[l+9] += vo[5] 
                po[l+11] += vo[6] 
                po[l+13] += vo[7]
                po[l+15] += vo[8]
                po[l+2] += vo[9] 
                po[l+4] += vo[10] 
                po[l+6] += vo[11] 
                po[l+8] += vo[12] 
                po[l+10] += vo[13] 
                po[l+12] += vo[14] 
                po[l+14] += vo[15] 
                po[l+16] += vo[16]
                po[l+17] += vo[17] 
                po[l+19] += vo[18] 
                po[l+21] += vo[19] 
                po[l+23] += vo[20] 
                po[l+25] += vo[21] 
                po[l+27] += vo[22] 
                po[l+29] += vo[23] 
                po[l+31] += vo[24]
                po[l+18] += vo[25] 
                po[l+20] += vo[26] 
                po[l+22] += vo[27] 
                po[l+24] += vo[28] 
                po[l+26] += vo[29] 
                po[l+28] += vo[30] 
                po[l+30] += vo[31] 
                po[l+32] += vo[32]    
            end

            # @fastmath p[l+1], p[l+3], p[l+5], p[l+7], p[l+9], p[l+11], p[l+13], p[l+15],
            #           p[l+2], p[l+4], p[l+6], p[l+8], p[l+10], p[l+12], p[l+14], p[l+16],
            #           p[l+17], p[l+19], p[l+21], p[l+23], p[l+25], p[l+27], p[l+29], p[l+31],
            #           p[l+18], p[l+20], p[l+22], p[l+24], p[l+26], p[l+28], p[l+30], p[l+32] = mat * vi
        end
    end
    if q1==1 && q2 == 2 && q3 == 3
        f = f123
    elseif q1==1 && q2 == 2 && q3 == 4
        f = f124
    elseif q1==1 && q2 == 3 && q3 == 4
        f = f134
    elseif q1==2 && q2 == 3 && q3 == 4
        f = f234
    else
        error(""qubit position $q1 and $q2 not allowed for LL."")
    end
    total_itr = div(L, 32)

    parallel_run(total_itr, Threads.nthreads(), f, U, v, vout)
end

function _apply_gate_threaded2!(key::Tuple{Int, Int, Int}, U::AbstractMatrix, v::AbstractVector, vout::AbstractVector)
    q0, q1, q2 = key
    if q0 > 2
        return _apply_threebody_gate_HHH!(key, SMatrix{8,8, eltype(v)}(transpose(U)), v, vout)
    elseif q1 > 3
        return _apply_threebody_gate_LHH!(key, SMatrix{8,8, eltype(v)}(transpose(U)), v, vout)
    elseif q2 > 4
        return _apply_threebody_gate_LLH!(key, SMatrix{8,8, eltype(v)}(transpose(U)), v, vout)
    else
        return _apply_threebody_gate_LLL!(key, SMatrix{8,8, eltype(v)}(U), v, vout)
    end
end


# assume vout is initialized with 0s
function _apply_threaded_util!(m::QubitsOperator, v::AbstractVector, vout::AbstractVector)
    for (k, bond) in m.data
        _apply_gate_threaded2!(k, _get_mat(length(k), bond), v, vout)
    end
    return vout
end



","Julia"
"Conjugate","guochu/VQC.jl","src/hamiltonian/apply_qterms/short_range_serial.jl",".jl","3442","99","

function _apply_gate_2_impl!(key::Int, U::AbstractMatrix, v::AbstractVector, vout::AbstractVector)
    L = length(v)
    pos = 2^(key-1)
    strid = pos * 2
    for i in 0:strid:(L-1)
        @inbounds for j in 0:(pos-1)
            l = i + j + 1
            vi1 = v[l]
            vi2 = v[l + pos]
            @fastmath vo1 = U[1,1] * vi1 + U[1,2] * vi2
            @fastmath vo2 = U[2,1] * vi1 + U[2,2] * vi2
            vout[l] += vo1
            vout[l + pos] += vo2
        end
    end
end

_apply_gate_2!(key::Int, U::AbstractMatrix, v::AbstractVector, vout::AbstractVector) = _apply_gate_2_impl!(
	key, SMatrix{2,2, eltype(v)}(U), v, vout)
_apply_gate_2!(key::Tuple{Int}, U::AbstractMatrix, v::AbstractVector, vout::AbstractVector) = _apply_gate_2!(
    key[1], U, v, vout)


function _apply_gate_2_impl!(key::Tuple{Int, Int}, U::AbstractMatrix, v::AbstractVector, vout::AbstractVector)
    # U = Matrix(transpose(reshape(U, 4, 4)))
    L = length(v)
    q1, q2 = key
    pos1, pos2 = 2^(q1-1), 2^(q2-1)
    stride1, stride2 = 2 * pos1, 2 * pos2
    for i in 0:stride2:(L-1)
        for j in 0:stride1:(pos2-1)
            @inbounds for k in 0:(pos1-1)
                l = i + j + k + 1
                vi = SVector(v[l], v[l + pos1], v[l + pos2], v[l + pos1 + pos2])
                @fastmath vo = U * vi

                vout[l] += vo[1] 
                vout[l + pos1] += vo[2] 
                vout[l + pos2] += vo[3] 
                vout[l + pos1 + pos2] += vo[4]
            end
        end
    end
end

_apply_gate_2!(key::Tuple{Int, Int}, U::AbstractMatrix, v::AbstractVector, vout::AbstractVector) =  _apply_gate_2_impl!(
key, SMatrix{4,4, eltype(v)}(U), v, vout)

function _apply_gate_2_impl!(key::Tuple{Int, Int, Int}, m::AbstractMatrix, v::AbstractVector, vout::AbstractVector)
    L = length(v)
    q1, q2, q3 = key
    pos1, pos2, pos3 = 2^(q1-1), 2^(q2-1), 2^(q3-1)
    stride1, stride2, stride3 = 2 * pos1, 2 * pos2, 2 * pos3
    for h in 0:stride3:(L-1)
        for i in 0:stride2:(pos3-1)
            for j in 0:stride1:(pos2-1)
                @inbounds for k in 0:(pos1-1)
                    l000 = h + i + j + k + 1
                    l100 = l000 + pos1
                    l010 = l000 + pos2
                    l110 = l010 + pos1

                    l001 = l000 + pos3
                    l101 = l001 + pos1
                    l011 = l001 + pos2
                    l111 = l011 + pos1
                    vi = SVector(v[l000], v[l100], v[l010], v[l110], v[l001], v[l101], v[l011], v[l111])
                    
                    @fastmath begin
                        vo = m * vi
                        vout[l000] += vo[1] 
                        vout[l100] += vo[2] 
                        vout[l010] += vo[3] 
                        vout[l110] += vo[4] 
                        vout[l001] += vo[5] 
                        vout[l101] += vo[6] 
                        vout[l011] += vo[7] 
                        vout[l111] += vo[8]
                    end 
                end
            end
        end
    end
end

_apply_gate_2!(key::Tuple{Int, Int, Int}, U::AbstractMatrix, v::AbstractVector, vout::AbstractVector) = _apply_gate_2_impl!(
key, SMatrix{8,8, eltype(v)}(U), v, vout)

function _apply_serial_util!(m::QubitsOperator, v::AbstractVector, vout::AbstractVector)
    for (k, bond) in m.data
        _apply_gate_2!(k, _get_mat(length(k), bond), v, vout)
    end
    return vout
end


","Julia"
"Conjugate","guochu/VQC.jl","src/applygates/applygates.jl",".jl","89","5","
include(""generic/generic.jl"")
include(""specific/specific.jl"")

include(""apply_qmaps.jl"")","Julia"
"Conjugate","guochu/VQC.jl","src/applygates/apply_qmaps.jl",".jl","2439","87","


""""""
	apply!(x::QuantumMap, state::DensityMatrix) 
	apply a generc quantum channel on the quantum state
""""""
function apply!(x::QuantumMap, state::DensityMatrix) 
	@assert _check_pos_range(x, nqubits(state))
	T = eltype(state)
	if (eltype(x) <: Complex) && (T <: Real)
		state = convert(DensityMatrix{Complex{T}}, state)
	end
	_qmap_apply_threaded!(x, state.data, nqubits(state))
	return state
end

apply!(x::QuantumMap, state::StateVector) = apply!(x, DensityMatrix(state)) 

""""""
	apply_dagger!(x::QuantumMap, state::DensityMatrix) 
	apply the hermitian conjugate of quantum map on rho
	this function is needed for auto-differentiation
""""""
function apply_dagger!(x::QuantumMap, state::DensityMatrix) 
	@assert _check_pos_range(x, nqubits(state))
	T = eltype(state)
	if (eltype(x) <: Complex) && (T <: Real)
		state = convert(DensityMatrix{Complex{T}}, state)
	end
	_qmap_apply_dagger_threaded!(x, state.data, nqubits(state))
	return state
end

""""""
	apply_inverse!(x::QuantumMap, state::DensityMatrix) 
	apply the inverse of quantum map on rho, this requires the supermatrix to be invertable.
	this function is needed for auto-differentiation
""""""
function apply_inverse!(x::QuantumMap, state::DensityMatrix) 
	@assert _check_pos_range(x, nqubits(state))
	T = eltype(state)
	if (eltype(x) <: Complex) && (T <: Real)
		state = convert(DensityMatrix{Complex{T}}, state)
	end
	_qmap_apply_inverse_threaded!(x, state.data, nqubits(state))
	return state
end


# unitary gate operation on density matrix
function _qmap_apply_threaded!(x::QuantumMap{N}, s::AbstractVector, n::Int) where N
	pos = ordered_positions(x)
	pos2 = ntuple(i->pos[i]+n, N)
	all_pos = (pos..., pos2...)
	m = ordered_supermat(x)
	if length(s) >= 32
		_apply_gate_threaded2!(all_pos, m, s)
	else
		_apply_gate_2!(all_pos, m, s)
	end
end

function _qmap_apply_dagger_threaded!(x::QuantumMap{N}, s::AbstractVector, n::Int) where N
	pos = ordered_positions(x)
	pos2 = ntuple(i->pos[i]+n, N)
	all_pos = (pos..., pos2...)
	m = ordered_supermat(x)
	if length(s) >= 32
		_apply_gate_threaded2!(all_pos, m', s)
	else
		_apply_gate_2!(all_pos, m', s)
	end
end

function _qmap_apply_inverse_threaded!(x::QuantumMap{N}, s::AbstractVector, n::Int) where N
	pos = ordered_positions(x)
	pos2 = ntuple(i->pos[i]+n, N)
	all_pos = (pos..., pos2...)
	m = ordered_supermat(x)
	if length(s) >= 32
		_apply_gate_threaded2!(all_pos, inv(m), s)
	else
		_apply_gate_2!(all_pos, inv(m), s)
	end
end
","Julia"
"Conjugate","guochu/VQC.jl","src/applygates/specific/phasegate.jl",".jl","1323","44","

""""""
    specialization for PHASEGate
""""""
function apply_threaded!(gt::PHASEGate, v::AbstractVector)
    (length(v) < 32) && return apply_serial!(gt, v)
    L = length(v)
    sizek = 1 << (ordered_positions(gt)[1] - 1)
    mask0 = sizek - 1
    mask1 = xor(L - 1, 2 * sizek - 1)
    f(ist::Int, ifn::Int, pos::Int, m1::Int, m2::Int, alpha::Number, p::AbstractVector) = begin
        @inbounds for i in ist:ifn
            l = (2 * i & m2) | (i & m1) + pos
            @fastmath p[l] *= alpha
        end
    end

    exp_phi = convert(eltype(v), exp(im * parameters(gt)[1] ))
    total_itr = div(L, 2)
    parallel_run(total_itr, Threads.nthreads(), f, sizek+1, mask0, mask1, exp_phi, v)
end

""""""
    specialization for XGate
""""""
function apply_threaded!(gt::XGate, v::AbstractVector)
    (length(v) < 32) && return apply_serial!(gt, v)
    L = length(v)
    sizek = 1 << (ordered_positions(gt)[1] - 1)
    mask0 = sizek - 1
    mask1 = xor(L - 1, 2 * sizek - 1)
    f(ist::Int, ifn::Int, pos::Int, m1::Int, m2::Int, p::AbstractVector) = begin
        @inbounds for i in ist:ifn
            l = (2 * i & m2) | (i & m1) + 1
            l1 = l + pos
            @fastmath p[l], p[l1] = p[l1], p[l]
        end
    end

    total_itr = div(L, 2)
    parallel_run(total_itr, Threads.nthreads(), f, sizek, mask0, mask1, v)
end
","Julia"
"Conjugate","guochu/VQC.jl","src/applygates/specific/fredkingate.jl",".jl","3455","105","


function apply_threaded!(gt::FREDKINGate, v::AbstractVector)
    (length(v) < 32) && return apply_serial!(gt, v)

    L = length(v)
    q1, q2, q3 = ordered_positions(gt)
    pos1, pos2, pos3 = 1 << (q1-1), 1 << (q2-1), 1 << (q3-1)
    # stride2, stride3 = pos1 << 1, pos2 << 1
    mask0 = pos1 - 1
    mask1 = xor(pos2 - 1, 2 * pos1 - 1)
    mask2 = xor(pos3 - 1, 2 * pos2 - 1)
    mask3 = xor(L - 1, 2 * pos3 - 1)
    # println(""pos1=$pos1, pos2=$pos2, m0=$mask0, m1=$mask1, m2=$mask2"")

    f_f(ist::Int, ifn::Int, posa::Int, posb::Int, posc::Int, m1::Int, m2::Int, m3::Int, m4::Int, p::AbstractVector) = begin
        @inbounds for i in ist:ifn
            l000 = (8 * i & m4) | (4 * i & m3) | (2 * i & m2) | (i & m1) + 1
            # l100 = l000 + posa
            l010 = l000 + posb
            l110 = l010 + posa

            l001 = l000 + posc
            l101 = l001 + posa
            # l011 = l001 + posb
            # l111 = l011 + posa

            @fastmath p[l110], p[l101] = p[l101], p[l110]
        end
    end

    f_m(ist::Int, ifn::Int, posa::Int, posb::Int, posc::Int, m1::Int, m2::Int, m3::Int, m4::Int, p::AbstractVector) = begin
        @inbounds for i in ist:ifn
            l000 = (8 * i & m4) | (4 * i & m3) | (2 * i & m2) | (i & m1) + 1
            # l100 = l000 + posa
            l010 = l000 + posb
            l110 = l010 + posa

            l001 = l000 + posc
            # l101 = l001 + posa
            l011 = l001 + posb
            # l111 = l011 + posa

            @fastmath p[l110], p[l011] = p[l011], p[l110]
        end
    end

    f_e(ist::Int, ifn::Int, posa::Int, posb::Int, posc::Int, m1::Int, m2::Int, m3::Int, m4::Int, p::AbstractVector) = begin
        @inbounds for i in ist:ifn
            l000 = (8 * i & m4) | (4 * i & m3) | (2 * i & m2) | (i & m1) + 1
            # l100 = l000 + posa
            # l010 = l000 + posb
            # l110 = l010 + posa

            l001 = l000 + posc
            l101 = l001 + posa
            l011 = l001 + posb
            # l111 = l011 + posa

            @fastmath p[l101], p[l011] = p[l011], p[l101]
        end
    end

    target = positions(gt)[1]
    if target == q1
        f = f_f
    elseif target == q2
        f = f_m
    elseif target == q3
        f = f_e
    else
        error(""target $target does not exist in $key."")
    end
    total_itr = div(L, 8)
    parallel_run(total_itr, Threads.nthreads(), f, pos1, pos2, pos3, mask0, mask1, mask2, mask3, v)
end


function apply_threaded!(gt::CCPHASEGate, v::AbstractVector)
    (length(v) < 32) && return apply_serial!(gt, v)

    L = length(v)
    q1, q2, q3 = ordered_positions(gt)
    pos1, pos2, pos3 = 1 << (q1-1), 1 << (q2-1), 1 << (q3-1)
    # stride2, stride3 = pos1 << 1, pos2 << 1
    mask0 = pos1 - 1
    mask1 = xor(pos2 - 1, 2 * pos1 - 1)
    mask2 = xor(pos3 - 1, 2 * pos2 - 1)
    mask3 = xor(L - 1, 2 * pos3 - 1)
    # println(""pos1=$pos1, pos2=$pos2, m0=$mask0, m1=$mask1, m2=$mask2"")

    f(ist::Int, ifn::Int, posabc1::Int, m1::Int, m2::Int, m3::Int, m4::Int, alpha::Number, p::AbstractVector) = begin
        @inbounds for i in ist:ifn
            l111 = (8 * i & m4) | (4 * i & m3) | (2 * i & m2) | (i & m1) + posabc1

            @fastmath p[l111] *= alpha
        end
    end
    exp_phi = convert(eltype(v), exp(im * parameters(gt)[1] ))

    total_itr = div(L, 8)
    parallel_run(total_itr, Threads.nthreads(), f, pos1+pos2+pos3+1, mask0, mask1, mask2, mask3, exp_phi, v)
end
","Julia"
"Conjugate","guochu/VQC.jl","src/applygates/specific/specific.jl",".jl","116","7","
include(""swapgates.jl"")

# specialized gates
include(""phasegate.jl"")
include(""czgate.jl"")
include(""fredkingate.jl"")","Julia"
"Conjugate","guochu/VQC.jl","src/applygates/specific/swapgates.jl",".jl","1763","50","

function apply_threaded!(gt::SWAPGate, v::AbstractVector)
    (length(v) < 32) && return apply_serial!(gt, v)
    L = length(v)
    q1, q2 = ordered_positions(gt)
    pos1, pos2 = 1 << (q1-1), 1 << (q2-1)

    mask0 = pos1 - 1
    mask1 = xor(pos2 - 1, 2 * pos1 - 1)
    mask2 = xor(L - 1, 2 * pos2 - 1)

    f(ist::Int, ifn::Int, posa::Int, posb::Int, m1::Int, m2::Int, m3::Int, p::AbstractVector) = begin
        @inbounds for i in ist:ifn
            l = (4 * i & m3) | (2 * i & m2) | (i & m1) + 1
            l1 = l + posa
            l2 = l + posb
            p[l1], p[l2] = p[l2], p[l1]
        end
    end
    total_itr = div(L, 4)
    parallel_run(total_itr, Threads.nthreads(), f, pos1, pos2, mask0, mask1, mask2, v)
end

function _apply_iswap_util!(gt, v::AbstractVector, coef::Number)
    L = length(v)
    q1, q2 = ordered_positions(gt)
    pos1, pos2 = 1 << (q1-1), 1 << (q2-1)

    mask0 = pos1 - 1
    mask1 = xor(pos2 - 1, 2 * pos1 - 1)
    mask2 = xor(L - 1, 2 * pos2 - 1)

    f(ist::Int, ifn::Int, posa::Int, posb::Int, m1::Int, m2::Int, m3::Int, coeff::Number, p::AbstractVector) = begin
        @inbounds for i in ist:ifn
            l = (4 * i & m3) | (2 * i & m2) | (i & m1) + 1
            l1 = l + posa
            l2 = l + posb
            @fastmath p[l1], p[l2] = coeff*p[l2], coeff*p[l1]
        end
    end
    total_itr = div(L, 4)
    parallel_run(total_itr, Threads.nthreads(), f, pos1, pos2, mask0, mask1, mask2, convert(eltype(v), coef), v)
end

apply_threaded!(gt::iSWAPGate, v::AbstractVector) = (length(v) >= 32) ? _apply_iswap_util!(
    gt, v, im) : apply_serial!(gt, v)
apply_threaded!(gt::AdjointQuantumGate{iSWAPGate}, v::AbstractVector) = (length(v) >= 32) ? _apply_iswap_util!(
    gt, v, -im) : apply_serial!(gt, v)
","Julia"
"Conjugate","guochu/VQC.jl","src/applygates/specific/czgate.jl",".jl","2746","96","

""""""
    specialized for CZ gate
""""""
function apply_threaded!(gt::CZGate, v::AbstractVector)
    (length(v) < 32) && return apply_serial!(gt, v)
    L = length(v)
    q1, q2 = ordered_positions(gt)
    pos1, pos2 = 1 << (q1-1), 1 << (q2-1)

    mask0 = pos1 - 1
    mask1 = xor(pos2 - 1, 2 * pos1 - 1)
    mask2 = xor(L - 1, 2 * pos2 - 1)

    f(ist::Int, ifn::Int, posab1::Int, m1::Int, m2::Int, m3::Int, p::AbstractVector) = begin
        @inbounds for i in ist:ifn
            l = (4 * i & m3) | (2 * i & m2) | (i & m1) + posab1
            p[l] = -p[l]
        end
    end

    total_itr = div(L, 4)
    parallel_run(total_itr, Threads.nthreads(), f, pos1+pos2+1, mask0, mask1, mask2, v)
end

""""""
    specialized for CNOT gate
""""""
function apply_threaded!(gt::CNOTGate, v::AbstractVector)
    (length(v) < 32) && return apply_serial!(gt, v)
    L = length(v)
    q1, q2 = ordered_positions(gt)
    pos1, pos2 = 1 << (q1-1), 1 << (q2-1)

    mask0 = pos1 - 1
    mask1 = xor(pos2 - 1, 2 * pos1 - 1)
    mask2 = xor(L - 1, 2 * pos2 - 1)

    f_f(ist::Int, ifn::Int, posa::Int, posb::Int, m1::Int, m2::Int, m3::Int, p::AbstractVector) = begin
        @inbounds for i in ist:ifn
            l00 = (4 * i & m3) | (2 * i & m2) | (i & m1) + 1
            l10 = l00 + posa
            l01 = l00 + posb
            l11 = l01 + posa
            p[l10], p[l11] = p[l11], p[l10]
        end
    end

    f_e(ist::Int, ifn::Int, posa::Int, posb::Int, m1::Int, m2::Int, m3::Int, p::AbstractVector) = begin
        @inbounds for i in ist:ifn
            l00 = (4 * i & m3) | (2 * i & m2) | (i & m1) + 1
            l10 = l00 + posa
            l01 = l00 + posb
            l11 = l01 + posa
            p[l01], p[l11] = p[l11], p[l01]
        end
    end

    if positions(gt)[1] == q1
        f = f_f
    else
        f = f_e
    end

    total_itr = div(L, 4)
    parallel_run(total_itr, Threads.nthreads(), f, pos1, pos2, mask0, mask1, mask2, v)
end

""""""
    specialized for CPHASE gate
""""""
function apply_threaded!(gt::CPHASEGate, v::AbstractVector)
    (length(v) < 32) && return apply_serial!(gt, v)

    L = length(v)
    q1, q2 = ordered_positions(gt)
    pos1, pos2 = 1 << (q1-1), 1 << (q2-1)

    mask0 = pos1 - 1
    mask1 = xor(pos2 - 1, 2 * pos1 - 1)
    mask2 = xor(L - 1, 2 * pos2 - 1)

    f(ist::Int, ifn::Int, posab1::Int, m1::Int, m2::Int, m3::Int, alpha::Number, p::AbstractVector) = begin
        @inbounds for i in ist:ifn
            l = (4 * i & m3) | (2 * i & m2) | (i & m1) + posab1
            @fastmath p[l] *= alpha
        end
    end

    exp_phi = convert(eltype(v), exp(im * parameters(gt)[1] ))

    total_itr = div(L, 4)
    parallel_run(total_itr, Threads.nthreads(), f, pos1+pos2+1, mask0, mask1, mask2, exp_phi, v)
end
","Julia"
"Conjugate","guochu/VQC.jl","src/applygates/generic/threaded_long_range.jl",".jl","5741","135","# experimental support for 4-qubit and 5-qubit gate operation

function _apply_fourbody_gate_impl!(key::Tuple{Int, Int, Int, Int}, U::AbstractMatrix, v::AbstractVector)
    L = length(v)
    q1, q2, q3, q4 = key
    pos1, pos2, pos3, pos4 = 1 << (q1-1), 1 << (q2-1), 1 << (q3-1), 1 << (q4-1)
    # stride2, stride3 = pos1 << 1, pos2 << 1
    mask0 = pos1 - 1
    mask1 = xor(pos2 - 1, 2 * pos1 - 1)
    mask2 = xor(pos3 - 1, 2 * pos2 - 1)
    mask3 = xor(pos4 - 1, 2 * pos3 - 1)
    mask4 = xor(L - 1, 2 * pos4 - 1)
    # println(""pos1=$pos1, pos2=$pos2, m0=$mask0, m1=$mask1, m2=$mask2"")

    f(ist::Int, ifn::Int, posa::Int, posb::Int, posc::Int, posd::Int, m1::Int, m2::Int, m3::Int, m4::Int, m5::Int, mat::AbstractMatrix, p::AbstractVector) = begin
        @inbounds for i in ist:ifn
            l0000 = (16 * i & m5) | (8 * i & m4) | (4 * i & m3) | (2 * i & m2) | (i & m1) + 1
            l1000 = l0000 + posa
            l0100 = l0000 + posb
            l0010 = l0000 + posc
            l0001 = l0000 + posd

            l1100 = l0100 + posa
            l1010 = l0010 + posa
            l1001 = l1000 + posd
            l0110 = l0010 + posb
            l0101 = l0100 + posd
            l0011 = l0010 + posd
            
            l1110 = l1100 + posc
            l1101 = l1100 + posd
            l1011 = l1010 + posd
            l0111 = l0110 + posd

            l1111 = l1110 + posd



            # println(""$l000, $l100, $l010, $l110, $l001, $l101, $l011, $l111"")
            vi = SVector(p[l0000], p[l1000], p[l0100], p[l1100], p[l0010], p[l1010], p[l0110], p[l1110],
                p[l0001], p[l1001], p[l0101], p[l1101], p[l0011], p[l1011], p[l0111], p[l1111])

            @fastmath p[l0000], p[l1000], p[l0100], p[l1100], p[l0010], p[l1010], p[l0110], p[l1110],
                p[l0001], p[l1001], p[l0101], p[l1101], p[l0011], p[l1011], p[l0111], p[l1111] = mat * vi 
        end
    end
    total_itr = div(L, 16)
    parallel_run(total_itr, Threads.nthreads(), f, pos1, pos2, pos3, pos4, mask0, mask1, mask2, mask3, mask4, U, v)
end

_apply_gate_threaded2!(key::Tuple{Int, Int, Int, Int}, U::AbstractMatrix, v::AbstractVector) = _apply_fourbody_gate_impl!(
    key, SMatrix{16,16, eltype(v)}(U), v)

# used in apply_serial when n = 4
_apply_gate_2!(key::Tuple{Int, Int, Int, Int}, U::AbstractMatrix, v::AbstractVector) = _apply_gate_threaded2!(key, U, v)


# This takes forever to compile
function _apply_fivebody_gate_impl!(key::Tuple{Int, Int, Int, Int, Int}, U::AbstractMatrix, v::AbstractVector)
    L = length(v)
    q1, q2, q3, q4, q5 = key
    pos1, pos2, pos3, pos4, pos5 = 1 << (q1-1), 1 << (q2-1), 1 << (q3-1), 1 << (q4-1), 1 << (q5-1)
    # stride2, stride3 = pos1 << 1, pos2 << 1
    mask0 = pos1 - 1
    mask1 = xor(pos2 - 1, 2 * pos1 - 1)
    mask2 = xor(pos3 - 1, 2 * pos2 - 1)
    mask3 = xor(pos4 - 1, 2 * pos3 - 1)
    mask4 = xor(pos5 - 1, 2 * pos4 - 1)
    mask5 = xor(L - 1, 2 * pos5 - 1)
    # println(""pos1=$pos1, pos2=$pos2, m0=$mask0, m1=$mask1, m2=$mask2"")

    function f(ist::Int, ifn::Int, posa::Int, posb::Int, posc::Int, posd::Int, pose::Int, 
        m1::Int, m2::Int, m3::Int, m4::Int, m5::Int, m6::Int, mat::AbstractMatrix, p::AbstractVector) 
        @inbounds for i in ist:ifn
            l00000 = (32 * i & m6) | (16 * i & m5) | (8 * i & m4) | (4 * i & m3) | (2 * i & m2) | (i & m1) + 1
            l10000 = l00000 + posa
            l01000 = l00000 + posb
            l00100 = l00000 + posc
            l00010 = l00000 + posd
            l00001 = l00000 + pose

            l11000 = l01000 + posa
            l10100 = l00100 + posa
            l10010 = l10000 + posd
            l10001 = l10000 + pose
            l01100 = l00100 + posb
            l01010 = l01000 + posd
            l01001 = l01000 + pose
            l00110 = l00100 + posd
            l00101 = l00100 + pose
            l00011 = l00010 + pose

            
            l11100 = l11000 + posc
            l11010 = l11000 + posd
            l11001 = l11000 + pose
            l10110 = l10100 + posd
            l10101 = l10100 + pose
            l10011 = l10010 + pose
            l01110 = l01100 + posd
            l01101 = l01100 + pose
            l01011 = l01010 + pose
            l00111 = l00110 + pose

            l11110 = l11100 + posd
            l11101 = l11100 + pose
            l11011 = l11010 + pose
            l10111 = l10110 + pose
            l01111 = l01110 + pose

            l11111 = l11110 + pose



            # println(""$l000, $l100, $l010, $l110, $l001, $l101, $l011, $l111"")
            vi = SVector(p[l00000], p[l10000], p[l01000], p[l11000], p[l00100], p[l10100], p[l01100], p[l11100],
                p[l00010], p[l10010], p[l01010], p[l11010], p[l00110], p[l10110], p[l01110], p[l11110],
                p[l00001], p[l10001], p[l01001], p[l11001], p[l00101], p[l10101], p[l01101], p[l11101],
                p[l00011], p[l10011], p[l01011], p[l11011], p[l00111], p[l10111], p[l01111], p[l11111])

            @fastmath p[l00000], p[l10000], p[l01000], p[l11000], p[l00100], p[l10100], p[l01100], p[l11100],
                p[l00010], p[l10010], p[l01010], p[l11010], p[l00110], p[l10110], p[l01110], p[l11110],
                p[l00001], p[l10001], p[l01001], p[l11001], p[l00101], p[l10101], p[l01101], p[l11101],
                p[l00011], p[l10011], p[l01011], p[l11011], p[l00111], p[l10111], p[l01111], p[l11111] = mat * vi 
        end
    end
    total_itr = div(L, 32)
    parallel_run(total_itr, Threads.nthreads(), f, pos1, pos2, pos3, pos4, pos5, mask0, mask1, mask2, mask3, mask4, mask5, U, v)
end

_apply_gate_threaded2!(key::Tuple{Int, Int, Int, Int, Int}, U::AbstractMatrix, v::AbstractVector) = _apply_fivebody_gate_impl!(
    key, SMatrix{32,32, eltype(v)}(U), v)


","Julia"
"Conjugate","guochu/VQC.jl","src/applygates/generic/threaded_short_range.jl",".jl","34508","768","# one, two, three-qubit gate operations


""""""
    applys when key > 3, U is the transposed op
""""""
function _apply_onebody_gate_H!(key::Int, U::AbstractMatrix, v::AbstractVector)
    L = length(v)
    sizek = 1 << (key - 1)
    mask0 = sizek - 1
    mask1 = xor(L - 1, 2 * sizek - 1)
    f(ist::Int, ifn::Int, pos::Int, m1::Int, m2::Int, mat::AbstractMatrix, p::AbstractVector) = begin
        @inbounds for i in ist:ifn
            l = (16 * i & m2) | (8 * i & m1) + 1
            l1 = l + pos
            vi = SMatrix{8, 2}(p[l], p[l+1], p[l+2], p[l+3], p[l+4], p[l+5], p[l+6], p[l+7],
            p[l1], p[l1+1], p[l1+2], p[l1+3], p[l1+4], p[l1+5], p[l1+6], p[l1+7])

            @fastmath p[l], p[l+1], p[l+2], p[l+3], p[l+4], p[l+5], p[l+6], p[l+7],
            p[l1], p[l1+1], p[l1+2], p[l1+3], p[l1+4], p[l1+5], p[l1+6], p[l1+7] = vi * mat
        end
    end

    total_itr = div(L, 16)
    # n_threads = Threads.nthreads()
    # if (total_itr >= MIN_SIZE) && (n_threads > 1)
    #     # println(""2*****************************"")
    #     nave, resi, jobs = partition_jobs(total_itr, n_threads)
    #     Threads.@threads for s in 1:n_threads
    #         ist = jobs[s]
    #         ifn = jobs[s+1] - 1
    #         f(ist, ifn, sizek, mask0, mask1, U, v)
    #     end
    # else
    #     # println(""1*****************************"")
    #     f(0, total_itr-1, sizek, mask0, mask1, U, v)
    # end
    parallel_run(total_itr, Threads.nthreads(), f, sizek, mask0, mask1, U, v)
end

""""""
    applys when key <= 3, U is the transposed op
""""""
function _apply_onebody_gate_L!(key::Int, U::AbstractMatrix, v::AbstractVector)
    L = length(v)
    f1(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector) = begin
        @inbounds for i in ist:ifn
            l = 16 * i + 1
            vi = SMatrix{2, 8}(p[l], p[l+1], p[l+2], p[l+3], p[l+4], p[l+5], p[l+6], p[l+7],
            p[l+8], p[l+9], p[l+10], p[l+11], p[l+12], p[l+13], p[l+14], p[l+15])
            @fastmath p[l:(l+15)]= mat * vi
        end
    end
    f2(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector) = begin
        @inbounds for i in ist:ifn
            l = 16 * i + 1
            vi = SMatrix{2, 8}(p[l], p[l+2], p[l+1], p[l+3], p[l+4], p[l+6], p[l+5], p[l+7],
            p[l+8], p[l+10], p[l+9], p[l+11], p[l+12], p[l+14], p[l+13], p[l+15])

            @fastmath p[l], p[l+2], p[l+1], p[l+3], p[l+4], p[l+6], p[l+5], p[l+7],
            p[l+8], p[l+10], p[l+9], p[l+11], p[l+12], p[l+14], p[l+13], p[l+15] = mat * vi
        end
    end
    f3(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector) = begin
        @inbounds for i in ist:ifn
            l = 16 * i + 1
            vi = SMatrix{2, 8}(p[l], p[l+4], p[l+1], p[l+5], p[l+2], p[l+6], p[l+3], p[l+7],
            p[l+8], p[l+12], p[l+9], p[l+13], p[l+10], p[l+14], p[l+11], p[l+15])

            @fastmath p[l], p[l+4], p[l+1], p[l+5], p[l+2], p[l+6], p[l+3], p[l+7],
            p[l+8], p[l+12], p[l+9], p[l+13], p[l+10], p[l+14], p[l+11], p[l+15] = mat * vi
        end
    end
    if key == 1
        f = f1
    elseif key == 2
        f = f2
    elseif key == 3
        f = f3
    else
        error(""qubit position $key not allowed for L."")
    end
    total_itr = div(L, 16)
    # n_threads = Threads.nthreads()
    # if (total_itr >= MIN_SIZE) && (n_threads > 1)
    #     # println(""2*****************************"")
    #     nave, resi, jobs = partition_jobs(total_itr, n_threads)
    #     Threads.@threads for s in 1:n_threads
    #         ist = jobs[s]
    #         ifn = jobs[s+1] - 1
    #         f(ist, ifn, U, v)
    #     end
    # else
    #     # println(""1*****************************"")
    #     f(0, total_itr-1, U, v)
    # end
    parallel_run(total_itr, Threads.nthreads(), f, U, v)
end

function _apply_gate_threaded2!(q0::Int, U::AbstractMatrix, v::AbstractVector)
    if q0 > 3
        return _apply_onebody_gate_H!(q0, SMatrix{2,2, eltype(v)}(transpose(U)), v)
    else
        return _apply_onebody_gate_L!(q0, SMatrix{2,2, eltype(v)}(U), v)
    end
end

_apply_gate_threaded2!(q0::Tuple{Int}, U::AbstractMatrix, v::AbstractVector) = _apply_gate_threaded2!(q0[1], U, v)

""""""
    applys when both keys > 3, U is the transposed op
""""""
function _apply_twobody_gate_HH!(key::Tuple{Int, Int}, U::AbstractMatrix, v::AbstractVector)
    L = length(v)
    q1, q2 = key
    pos1, pos2 = 1 << (q1-1), 1 << (q2-1)
    # stride2, stride3 = pos1 << 1, pos2 << 1
    mask0 = pos1 - 1
    mask1 = xor(pos2 - 1, 2 * pos1 - 1)
    mask2 = xor(L - 1, 2 * pos2 - 1)
    # println(""pos1=$pos1, pos2=$pos2, m0=$mask0, m1=$mask1, m2=$mask2"")

    total_itr = div(L, 32)
    f(ist::Int, ifn::Int, posa::Int, posb::Int, m1::Int, m2::Int, m3::Int, mat::AbstractMatrix, p::AbstractVector) = begin
        @inbounds for i in ist:ifn
            l = (32 * i & m3) | (16 * i & m2) | (8 * i & m1) + 1
            # l = div(l, 2) + 1
            l1 = l + posa
            l2 = l + posb
            l3 = l2 + posa
            # println(""l0=$l, l1=$l1, l2=$l2, l3=$l3"")
            vi = SMatrix{8, 4}(p[l], p[l+1], p[l+2], p[l+3], p[l+4], p[l+5], p[l+6], p[l+7],
            p[l1], p[l1+1], p[l1+2], p[l1+3], p[l1+4], p[l1+5], p[l1+6], p[l1+7],
            p[l2], p[l2+1], p[l2+2], p[l2+3], p[l2+4], p[l2+5], p[l2+6], p[l2+7],
            p[l3], p[l3+1], p[l3+2], p[l3+3], p[l3+4], p[l3+5], p[l3+6], p[l3+7])

            @fastmath p[l], p[l+1], p[l+2], p[l+3], p[l+4], p[l+5], p[l+6], p[l+7],
            p[l1], p[l1+1], p[l1+2], p[l1+3], p[l1+4], p[l1+5], p[l1+6], p[l1+7],
            p[l2], p[l2+1], p[l2+2], p[l2+3], p[l2+4], p[l2+5], p[l2+6], p[l2+7],
            p[l3], p[l3+1], p[l3+2], p[l3+3], p[l3+4], p[l3+5], p[l3+6], p[l3+7] = vi * mat
        end
    end
    # n_threads = Threads.nthreads()
    # if (total_itr >= MIN_SIZE) && (n_threads > 1)
    #     # println(""2*****************************"")
    #     nave, resi, jobs = partition_jobs(total_itr, n_threads)
    #     Threads.@threads for s in 1:n_threads
    #         ist = jobs[s]
    #         ifn = jobs[s+1] - 1
    #         f(ist, ifn, pos1, pos2, mask0, mask1, mask2, U, v)
    #     end
    # else
    #     # println(""1*****************************"")
    #     f(0, total_itr-1, pos1, pos2, mask0, mask1, mask2, U, v)
    # end
    parallel_run(total_itr, Threads.nthreads(), f, pos1, pos2, mask0, mask1, mask2, U, v)
end

""""""
    applys when q1 <= 3 and q2 > 4, U is the transposed op
""""""
function _apply_twobody_gate_LH!(key::Tuple{Int, Int}, U::AbstractMatrix, v::AbstractVector)
    L = length(v)
    q1, q2 = key
    sizej = 1 << (q2-1)
    mask0 = sizej - 1
    mask1 = xor(L - 1, 2 * sizej - 1)

    f1H(ist::Int, ifn::Int, posb::Int, m1::Int, m2::Int, mat::AbstractMatrix, p::AbstractVector) = begin
        @inbounds for i in ist:ifn
            l = (32 * i & m2) | (16 * i & m1)
            l1 = l + posb
            # println(""l=$l, l1=$l1"")
            vi = SMatrix{8, 4}(p[l+1], p[l+3], p[l+5], p[l+7], p[l+9], p[l+11], p[l+13], p[l+15],
            p[l+2], p[l+4], p[l+6], p[l+8], p[l+10], p[l+12], p[l+14], p[l+16],
            p[l1+1], p[l1+3], p[l1+5], p[l1+7], p[l1+9], p[l1+11], p[l1+13], p[l1+15],
            p[l1+2], p[l1+4], p[l1+6], p[l1+8], p[l1+10], p[l1+12], p[l1+14], p[l1+16])

            @fastmath p[l+1], p[l+3], p[l+5], p[l+7], p[l+9], p[l+11], p[l+13], p[l+15],
            p[l+2], p[l+4], p[l+6], p[l+8], p[l+10], p[l+12], p[l+14], p[l+16],
            p[l1+1], p[l1+3], p[l1+5], p[l1+7], p[l1+9], p[l1+11], p[l1+13], p[l1+15],
            p[l1+2], p[l1+4], p[l1+6], p[l1+8], p[l1+10], p[l1+12], p[l1+14], p[l1+16] = vi * mat
        end
    end

    f2H(ist::Int, ifn::Int, posb::Int, m1::Int, m2::Int, mat::AbstractMatrix, p::AbstractVector) = begin
        @inbounds for i in ist:ifn
            l = (32 * i & m2) | (16 * i & m1)
            l1 = l + posb
            # println(""l=$l, l1=$l1"")
            vi = SMatrix{8, 4}(p[l+1], p[l+2], p[l+5], p[l+6], p[l+9], p[l+10], p[l+13], p[l+14],
            p[l+3], p[l+4], p[l+7], p[l+8], p[l+11], p[l+12], p[l+15], p[l+16],
            p[l1+1], p[l1+2], p[l1+5], p[l1+6], p[l1+9], p[l1+10], p[l1+13], p[l1+14],
            p[l1+3], p[l1+4], p[l1+7], p[l1+8], p[l1+11], p[l1+12], p[l1+15], p[l1+16])

            @fastmath p[l+1], p[l+2], p[l+5], p[l+6], p[l+9], p[l+10], p[l+13], p[l+14],
            p[l+3], p[l+4], p[l+7], p[l+8], p[l+11], p[l+12], p[l+15], p[l+16],
            p[l1+1], p[l1+2], p[l1+5], p[l1+6], p[l1+9], p[l1+10], p[l1+13], p[l1+14],
            p[l1+3], p[l1+4], p[l1+7], p[l1+8], p[l1+11], p[l1+12], p[l1+15], p[l1+16] = vi * mat
        end
    end

    f3H(ist::Int, ifn::Int, posb::Int, m1::Int, m2::Int, mat::AbstractMatrix, p::AbstractVector) = begin
        @inbounds for i in ist:ifn
            l = (32 * i & m2) | (16 * i & m1)
            l1 = l + posb
            # println(""l=$l, l1=$l1"")
            vi = SMatrix{8, 4}(p[l+1], p[l+2], p[l+3], p[l+4], p[l+9], p[l+10], p[l+11], p[l+12],
            p[l+5], p[l+6], p[l+7], p[l+8], p[l+13], p[l+14], p[l+15], p[l+16],
            p[l1+1], p[l1+2], p[l1+3], p[l1+4], p[l1+9], p[l1+10], p[l1+11], p[l1+12],
            p[l1+5], p[l1+6], p[l1+7], p[l1+8], p[l1+13], p[l1+14], p[l1+15], p[l1+16])

            @fastmath p[l+1], p[l+2], p[l+3], p[l+4], p[l+9], p[l+10], p[l+11], p[l+12],
            p[l+5], p[l+6], p[l+7], p[l+8], p[l+13], p[l+14], p[l+15], p[l+16],
            p[l1+1], p[l1+2], p[l1+3], p[l1+4], p[l1+9], p[l1+10], p[l1+11], p[l1+12],
            p[l1+5], p[l1+6], p[l1+7], p[l1+8], p[l1+13], p[l1+14], p[l1+15], p[l1+16] = vi * mat
        end
    end

    if q1 == 1
        f = f1H
    elseif q1 == 2
        f = f2H
    elseif q1 == 3
        f = f3H
    else
        error(""qubit position $q1 not allowed for LH."")
    end
    total_itr = div(L, 32)

    # n_threads = Threads.nthreads()
    # if (total_itr >= MIN_SIZE) && (n_threads > 1)
    #     # println(""2*****************************"")
    #     nave, resi, jobs = partition_jobs(total_itr, n_threads)
    #     Threads.@threads for s in 1:n_threads
    #         ist = jobs[s]
    #         ifn = jobs[s+1] - 1
    #         f(ist, ifn, sizej, mask0, mask1, U, v)
    #     end
    # else
    #     # println(""1*****************************"")
    #     f(0, total_itr-1, sizej, mask0, mask1, U, v)
    # end
    parallel_run(total_itr, Threads.nthreads(), f, sizej, mask0, mask1, U, v)
end


""""""
    applys when both keys <= 4
""""""
function _apply_twobody_gate_LL!(key::Tuple{Int, Int}, U::AbstractMatrix, v::AbstractVector)
    L = length(v)
    q1, q2 = key
    f12(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector) = begin
        @inbounds for i in ist:ifn
            l = 32 * i + 1
            vi = SMatrix{4, 8}(p[l], p[l+1], p[l+2], p[l+3], p[l+4], p[l+5], p[l+6], p[l+7],
            p[l+8], p[l+9], p[l+10], p[l+11], p[l+12], p[l+13], p[l+14], p[l+15],
            p[l+16], p[l+17], p[l+18], p[l+19], p[l+20], p[l+21], p[l+22], p[l+23],
            p[l+24], p[l+25], p[l+26], p[l+27], p[l+28], p[l+29], p[l+30], p[l+31])
            @fastmath p[l:(l+31)]= mat * vi
        end
    end
    f13(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector) = begin
        @inbounds for i in ist:ifn
            l = 32 * i + 1
            vi = SMatrix{4, 8}(p[l], p[l+1], p[l+4], p[l+5], p[l+2], p[l+3], p[l+6], p[l+7],
            p[l+8], p[l+9], p[l+12], p[l+13], p[l+10], p[l+11], p[l+14], p[l+15],
            p[l+16], p[l+17], p[l+20], p[l+21], p[l+18], p[l+19], p[l+22], p[l+23],
            p[l+24], p[l+25], p[l+28], p[l+29], p[l+26], p[l+27], p[l+30], p[l+31])

            @fastmath p[l], p[l+1], p[l+4], p[l+5], p[l+2], p[l+3], p[l+6], p[l+7],
            p[l+8], p[l+9], p[l+12], p[l+13], p[l+10], p[l+11], p[l+14], p[l+15],
            p[l+16], p[l+17], p[l+20], p[l+21], p[l+18], p[l+19], p[l+22], p[l+23],
            p[l+24], p[l+25], p[l+28], p[l+29], p[l+26], p[l+27], p[l+30], p[l+31] = mat * vi
        end
    end
    f14(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector) = begin
        @inbounds for i in ist:ifn
            l = 32 * i
            vi = SMatrix{4, 8}(p[l+1], p[l+2], p[l+9], p[l+10], p[l+3], p[l+4], p[l+11], p[l+12],
            p[l+5], p[l+6], p[l+13], p[l+14], p[l+7], p[l+8], p[l+15], p[l+16],
            p[l+17], p[l+18], p[l+25], p[l+26], p[l+19], p[l+20], p[l+27], p[l+28],
            p[l+21], p[l+22], p[l+29], p[l+30], p[l+23], p[l+24], p[l+31], p[l+32])

            @fastmath p[l+1], p[l+2], p[l+9], p[l+10], p[l+3], p[l+4], p[l+11], p[l+12],
            p[l+5], p[l+6], p[l+13], p[l+14], p[l+7], p[l+8], p[l+15], p[l+16],
            p[l+17], p[l+18], p[l+25], p[l+26], p[l+19], p[l+20], p[l+27], p[l+28],
            p[l+21], p[l+22], p[l+29], p[l+30], p[l+23], p[l+24], p[l+31], p[l+32] = mat * vi
        end
    end
    f23(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector) = begin
        @inbounds for i in ist:ifn
            l = 32 * i + 1
            vi = SMatrix{4, 8}(p[l], p[l+2], p[l+4], p[l+6], p[l+1], p[l+3], p[l+5], p[l+7],
            p[l+8], p[l+10], p[l+12], p[l+14], p[l+9], p[l+11], p[l+13], p[l+15],
            p[l+16], p[l+18], p[l+20], p[l+22], p[l+17], p[l+19], p[l+21], p[l+23],
            p[l+24], p[l+26], p[l+28], p[l+30], p[l+25], p[l+27], p[l+29], p[l+31])

            @fastmath p[l], p[l+2], p[l+4], p[l+6], p[l+1], p[l+3], p[l+5], p[l+7],
            p[l+8], p[l+10], p[l+12], p[l+14], p[l+9], p[l+11], p[l+13], p[l+15],
            p[l+16], p[l+18], p[l+20], p[l+22], p[l+17], p[l+19], p[l+21], p[l+23],
            p[l+24], p[l+26], p[l+28], p[l+30], p[l+25], p[l+27], p[l+29], p[l+31] = mat * vi
        end
    end
    f24(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector) = begin
        @inbounds for i in ist:ifn
            l = 32 * i
            vi = SMatrix{4, 8}(p[l+1], p[l+3], p[l+9], p[l+11], p[l+2], p[l+4], p[l+10], p[l+12],
            p[l+5], p[l+7], p[l+13], p[l+15], p[l+6], p[l+8], p[l+14], p[l+16],
            p[l+17], p[l+19], p[l+25], p[l+27], p[l+18], p[l+20], p[l+26], p[l+28],
            p[l+21], p[l+23], p[l+29], p[l+31], p[l+22], p[l+24], p[l+30], p[l+32])

            @fastmath p[l+1], p[l+3], p[l+9], p[l+11], p[l+2], p[l+4], p[l+10], p[l+12],
            p[l+5], p[l+7], p[l+13], p[l+15], p[l+6], p[l+8], p[l+14], p[l+16],
            p[l+17], p[l+19], p[l+25], p[l+27], p[l+18], p[l+20], p[l+26], p[l+28],
            p[l+21], p[l+23], p[l+29], p[l+31], p[l+22], p[l+24], p[l+30], p[l+32] = mat * vi
        end
    end
    f34(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector) = begin
        @inbounds for i in ist:ifn
            l = 32 * i
            vi = SMatrix{4, 8}(p[l+1], p[l+5], p[l+9], p[l+13], p[l+2], p[l+6], p[l+10], p[l+14],
            p[l+3], p[l+7], p[l+11], p[l+15], p[l+4], p[l+8], p[l+12], p[l+16],
            p[l+17], p[l+21], p[l+25], p[l+29], p[l+18], p[l+22], p[l+26], p[l+30],
            p[l+19], p[l+23], p[l+27], p[l+31], p[l+20], p[l+24], p[l+28], p[l+32])

            @fastmath p[l+1], p[l+5], p[l+9], p[l+13], p[l+2], p[l+6], p[l+10], p[l+14],
            p[l+3], p[l+7], p[l+11], p[l+15], p[l+4], p[l+8], p[l+12], p[l+16],
            p[l+17], p[l+21], p[l+25], p[l+29], p[l+18], p[l+22], p[l+26], p[l+30],
            p[l+19], p[l+23], p[l+27], p[l+31], p[l+20], p[l+24], p[l+28], p[l+32] = mat * vi
        end
    end
    if q1==1 && q2 == 2
        f = f12
    elseif q1==1 && q2 == 3
        f = f13
    elseif q1==1 && q2 == 4
        f = f14
    elseif q1==2 && q2 == 3
        f = f23
    elseif q1==2 && q2 == 4
        f = f24
    elseif q1==3 && q2 == 4
        f = f34
    else
        error(""qubit position $q1 and $q2 not allowed for LL."")
    end
    total_itr = div(L, 32)
    # n_threads = Threads.nthreads()
    # if (total_itr >= MIN_SIZE) && (n_threads > 1)
    #     nave, resi, jobs = partition_jobs(total_itr, n_threads)
    #     Threads.@threads for s in 1:n_threads
    #         ist = jobs[s]
    #         ifn = jobs[s+1] - 1
    #         f(ist, ifn, U, v)
    #     end
    # else
    #     f(0, total_itr-1, U, v)
    # end
    parallel_run(total_itr, Threads.nthreads(), f, U, v)
end

function _apply_gate_threaded2!(key::Tuple{Int, Int}, U::AbstractMatrix, v::AbstractVector)
    q0, q1 = key
    if q0 > 3
        return _apply_twobody_gate_HH!(key, SMatrix{4,4, eltype(v)}(transpose(U)), v)
    elseif q1 > 4
        return _apply_twobody_gate_LH!(key, SMatrix{4,4, eltype(v)}(transpose(U)), v)
    else
        return _apply_twobody_gate_LL!(key, SMatrix{4,4, eltype(v)}(U), v)
    end
end

""""""
    applys when both keys > 2, U is assumed to be transposed
""""""
function _apply_threebody_gate_HHH!(key::Tuple{Int, Int, Int}, U::AbstractMatrix, v::AbstractVector)
    L = length(v)
    q1, q2, q3 = key
    pos1, pos2, pos3 = 1 << (q1-1), 1 << (q2-1), 1 << (q3-1)
    # stride2, stride3 = pos1 << 1, pos2 << 1
    mask0 = pos1 - 1
    mask1 = xor(pos2 - 1, 2 * pos1 - 1)
    mask2 = xor(pos3 - 1, 2 * pos2 - 1)
    mask3 = xor(L - 1, 2 * pos3 - 1)
    # println(""pos1=$pos1, pos2=$pos2, m0=$mask0, m1=$mask1, m2=$mask2"")

    total_itr = div(L, 32)
    f(ist::Int, ifn::Int, posa::Int, posb::Int, posc::Int, m1::Int, m2::Int, m3::Int, m4::Int, mat::AbstractMatrix, p::AbstractVector) = begin
        @inbounds for i in ist:ifn
            l000 = (32 * i & m4) | (16 * i & m3) | (8 * i & m2) | (4 * i & m1) + 1
            l100 = l000 + posa
            l010 = l000 + posb
            l110 = l010 + posa

            l001 = l000 + posc
            l101 = l001 + posa
            l011 = l001 + posb
            l111 = l011 + posa

            # println(""$l000, $l100, $l010, $l110, $l001, $l101, $l011, $l111"")
            vi = SMatrix{4, 8}(p[l000], p[l000+1], p[l000+2], p[l000+3],
                               p[l100], p[l100+1], p[l100+2], p[l100+3],
                               p[l010], p[l010+1], p[l010+2], p[l010+3],
                               p[l110], p[l110+1], p[l110+2], p[l110+3],
                               p[l001], p[l001+1], p[l001+2], p[l001+3],
                               p[l101], p[l101+1], p[l101+2], p[l101+3],
                               p[l011], p[l011+1], p[l011+2], p[l011+3],
                               p[l111], p[l111+1], p[l111+2], p[l111+3])

            @fastmath p[l000], p[l000+1], p[l000+2], p[l000+3],
                      p[l100], p[l100+1], p[l100+2], p[l100+3],
                      p[l010], p[l010+1], p[l010+2], p[l010+3],
                      p[l110], p[l110+1], p[l110+2], p[l110+3],
                      p[l001], p[l001+1], p[l001+2], p[l001+3],
                      p[l101], p[l101+1], p[l101+2], p[l101+3],
                      p[l011], p[l011+1], p[l011+2], p[l011+3],
                      p[l111], p[l111+1], p[l111+2], p[l111+3] = vi * mat
        end
    end
    # n_threads = Threads.nthreads()
    # if (total_itr >= MIN_SIZE) && (n_threads > 1)
    #     # println(""2*****************************"")
    #     nave, resi, jobs = partition_jobs(total_itr, n_threads)
    #     Threads.@threads for s in 1:n_threads
    #         ist = jobs[s]
    #         ifn = jobs[s+1] - 1
    #         f(ist, ifn, pos1, pos2, pos3, mask0, mask1, mask2, mask3, U, v)
    #     end
    # else
    #     # println(""1*****************************"")
    #     f(0, total_itr-1, pos1, pos2, pos3, mask0, mask1, mask2, mask3, U, v)
    # end
    parallel_run(total_itr, Threads.nthreads(), f, pos1, pos2, pos3, mask0, mask1, mask2, mask3, U, v)
end

""""""
    applys when q1 <= 2 and q2 > 3, U is the transposed op
""""""
function _apply_threebody_gate_LHH!(key::Tuple{Int, Int, Int}, U::AbstractMatrix, v::AbstractVector)
    L = length(v)
    q1, q2, q3 = key
    sizej, sizel = 1 << (q2-1), 1 << (q3-1)
    mask0 = sizej - 1
    mask1 = xor(sizel - 1, 2 * sizej - 1)
    mask2 = xor(L-1, 2 * sizel - 1)

    f1H(ist::Int, ifn::Int, posb::Int, posc::Int, m1::Int, m2::Int, m3::Int, mat::AbstractMatrix, p::AbstractVector) = begin
        @inbounds for i in ist:ifn
            l = (32 * i & m3) | (16 * i & m2) | (8 * i & m1)
            l1 = l + posb
            l2 = l + posc
            l3 = l2 + posb
            # println(""$l, $l1, $l2, $l3"")
            vi = SMatrix{4, 8}(p[l+1], p[l+3], p[l+5], p[l+7],
                               p[l+2], p[l+4], p[l+6], p[l+8],
                               p[l1+1], p[l1+3], p[l1+5], p[l1+7],
                               p[l1+2], p[l1+4], p[l1+6], p[l1+8],
                               p[l2+1], p[l2+3], p[l2+5], p[l2+7],
                               p[l2+2], p[l2+4], p[l2+6], p[l2+8],
                               p[l3+1], p[l3+3], p[l3+5], p[l3+7],
                               p[l3+2], p[l3+4], p[l3+6], p[l3+8])

            @fastmath p[l+1], p[l+3], p[l+5], p[l+7],
                      p[l+2], p[l+4], p[l+6], p[l+8],
                      p[l1+1], p[l1+3], p[l1+5], p[l1+7],
                      p[l1+2], p[l1+4], p[l1+6], p[l1+8],
                      p[l2+1], p[l2+3], p[l2+5], p[l2+7],
                      p[l2+2], p[l2+4], p[l2+6], p[l2+8],
                      p[l3+1], p[l3+3], p[l3+5], p[l3+7],
                      p[l3+2], p[l3+4], p[l3+6], p[l3+8] = vi * mat
        end
    end

    f2H(ist::Int, ifn::Int, posb::Int, posc::Int, m1::Int, m2::Int, m3::Int, mat::AbstractMatrix, p::AbstractVector) = begin
        @inbounds for i in ist:ifn
            l = (32 * i & m3) | (16 * i & m2) | (8 * i & m1)
            l1 = l + posb
            l2 = l + posc
            l3 = l2 + posb
            vi = SMatrix{4, 8}(p[l+1], p[l+2], p[l+5], p[l+6],
                               p[l+3], p[l+4], p[l+7], p[l+8],
                               p[l1+1], p[l1+2], p[l1+5], p[l1+6],
                               p[l1+3], p[l1+4], p[l1+7], p[l1+8],
                               p[l2+1], p[l2+2], p[l2+5], p[l2+6],
                               p[l2+3], p[l2+4], p[l2+7], p[l2+8],
                               p[l3+1], p[l3+2], p[l3+5], p[l3+6],
                               p[l3+3], p[l3+4], p[l3+7], p[l3+8])

            @fastmath p[l+1], p[l+2], p[l+5], p[l+6],
                      p[l+3], p[l+4], p[l+7], p[l+8],
                      p[l1+1], p[l1+2], p[l1+5], p[l1+6],
                      p[l1+3], p[l1+4], p[l1+7], p[l1+8],
                      p[l2+1], p[l2+2], p[l2+5], p[l2+6],
                      p[l2+3], p[l2+4], p[l2+7], p[l2+8],
                      p[l3+1], p[l3+2], p[l3+5], p[l3+6],
                      p[l3+3], p[l3+4], p[l3+7], p[l3+8] = vi * mat
        end
    end

    f3H(ist::Int, ifn::Int, posb::Int, posc::Int, m1::Int, m2::Int, m3::Int, mat::AbstractMatrix, p::AbstractVector) = begin
        @inbounds for i in ist:ifn
            l = (32 * i & m3) | (16 * i & m2) | (8 * i & m1)
            l1 = l + posb
            l2 = l + posc
            l3 = l2 + posb
            vi = SMatrix{4, 8}(p[l+1], p[l+2], p[l+3], p[l+4],
                               p[l+5], p[l+6], p[l+7], p[l+8],
                               p[l1+1], p[l1+2], p[l1+3], p[l1+4],
                               p[l1+5], p[l1+6], p[l1+7], p[l1+8],
                               p[l2+1], p[l2+2], p[l2+3], p[l2+4],
                               p[l2+5], p[l2+6], p[l2+7], p[l2+8],
                               p[l3+1], p[l3+2], p[l3+3], p[l3+4],
                               p[l3+5], p[l3+6], p[l3+7], p[l3+8])

            @fastmath p[l+1], p[l+2], p[l+3], p[l+4],
                      p[l+5], p[l+6], p[l+7], p[l+8],
                      p[l1+1], p[l1+2], p[l1+3], p[l1+4],
                      p[l1+5], p[l1+6], p[l1+7], p[l1+8],
                      p[l2+1], p[l2+2], p[l2+3], p[l2+4],
                      p[l2+5], p[l2+6], p[l2+7], p[l2+8],
                      p[l3+1], p[l3+2], p[l3+3], p[l3+4],
                      p[l3+5], p[l3+6], p[l3+7], p[l3+8] = vi * mat
        end
    end

    if q1 == 1
        f = f1H
    elseif q1 == 2
        f = f2H
    elseif q1 == 3
        f = f3H
    else
        error(""qubit position $q1 not allowed for LHH."")
    end
    (q2 > 3) || error(""qubit 2 position $q2 not allowed for LHH."")
    total_itr = div(L, 32)

    # n_threads = Threads.nthreads()
    # if (total_itr >= MIN_SIZE) && (n_threads > 1)
    #     # println(""2*****************************"")
    #     nave, resi, jobs = partition_jobs(total_itr, n_threads)
    #     Threads.@threads for s in 1:n_threads
    #         ist = jobs[s]
    #         ifn = jobs[s+1] - 1
    #         f(ist, ifn, sizej, sizel, mask0, mask1, mask2, U, v)
    #     end
    # else
    #     # println(""1*****************************"")
    #     f(0, total_itr-1, sizej, sizel, mask0, mask1, mask2, U, v)
    # end
    parallel_run(total_itr, Threads.nthreads(), f, sizej, sizel, mask0, mask1, mask2, U, v)
end

""""""
    applys when q1, q2 <= 3 and q3 > 4, U is the transposed op
""""""
function _apply_threebody_gate_LLH!(key::Tuple{Int, Int, Int}, U::AbstractMatrix, v::AbstractVector)
    L = length(v)
    q1, q2, q3 = key
    sizej = 1 << (q3-1)
    mask0 = sizej - 1
    mask1 = xor(L - 1, 2 * sizej - 1)

    f12H(ist::Int, ifn::Int, posb::Int, m1::Int, m2::Int, mat::AbstractMatrix, p::AbstractVector) = begin
        @inbounds for i in ist:ifn
            l = (32 * i & m2) | (16 * i & m1)
            l1 = l + posb
            # println(""l=$l, l1=$l1"")
            vi = SMatrix{4, 8}(p[l+1], p[l+5], p[l+9], p[l+13],
                               p[l+2], p[l+6], p[l+10], p[l+14],
                               p[l+3], p[l+7], p[l+11], p[l+15],
                               p[l+4], p[l+8], p[l+12], p[l+16],
                               p[l1+1], p[l1+5], p[l1+9], p[l1+13],
                               p[l1+2], p[l1+6], p[l1+10], p[l1+14],
                               p[l1+3], p[l1+7], p[l1+11], p[l1+15],
                               p[l1+4], p[l1+8], p[l1+12], p[l1+16])

            @fastmath p[l+1], p[l+5], p[l+9], p[l+13],
                      p[l+2], p[l+6], p[l+10], p[l+14],
                      p[l+3], p[l+7], p[l+11], p[l+15],
                      p[l+4], p[l+8], p[l+12], p[l+16],
                      p[l1+1], p[l1+5], p[l1+9], p[l1+13],
                      p[l1+2], p[l1+6], p[l1+10], p[l1+14],
                      p[l1+3], p[l1+7], p[l1+11], p[l1+15],
                      p[l1+4], p[l1+8], p[l1+12], p[l1+16] = vi * mat
        end
    end

    f13H(ist::Int, ifn::Int, posb::Int, m1::Int, m2::Int, mat::AbstractMatrix, p::AbstractVector) = begin
        @inbounds for i in ist:ifn
            l = (32 * i & m2) | (16 * i & m1)
            l1 = l + posb
            # println(""l=$l, l1=$l1"")
            vi = SMatrix{4, 8}(p[l+1], p[l+3], p[l+9], p[l+11],
                               p[l+2], p[l+4], p[l+10], p[l+12],
                               p[l+5], p[l+7], p[l+13], p[l+15],
                               p[l+6], p[l+8], p[l+14], p[l+16],
                               p[l1+1], p[l1+3], p[l1+9], p[l1+11],
                               p[l1+2], p[l1+4], p[l1+10], p[l1+12],
                               p[l1+5], p[l1+7], p[l1+13], p[l1+15],
                               p[l1+6], p[l1+8], p[l1+14], p[l1+16])

            @fastmath p[l+1], p[l+3], p[l+9], p[l+11],
                      p[l+2], p[l+4], p[l+10], p[l+12],
                      p[l+5], p[l+7], p[l+13], p[l+15],
                      p[l+6], p[l+8], p[l+14], p[l+16],
                      p[l1+1], p[l1+3], p[l1+9], p[l1+11],
                      p[l1+2], p[l1+4], p[l1+10], p[l1+12],
                      p[l1+5], p[l1+7], p[l1+13], p[l1+15],
                      p[l1+6], p[l1+8], p[l1+14], p[l1+16] = vi * mat
        end
    end

    f23H(ist::Int, ifn::Int, posb::Int, m1::Int, m2::Int, mat::AbstractMatrix, p::AbstractVector) = begin
        @inbounds for i in ist:ifn
            l = (32 * i & m2) | (16 * i & m1)
            l1 = l + posb
            # println(""l=$l, l1=$l1"")
            vi = SMatrix{4, 8}(p[l+1], p[l+2], p[l+9], p[l+10],
                               p[l+3], p[l+4], p[l+11], p[l+12],
                               p[l+5], p[l+6], p[l+13], p[l+14],
                               p[l+7], p[l+8], p[l+15], p[l+16],
                               p[l1+1], p[l1+2], p[l1+9], p[l1+10],
                               p[l1+3], p[l1+4], p[l1+11], p[l1+12],
                               p[l1+5], p[l1+6], p[l1+13], p[l1+14],
                               p[l1+7], p[l1+8], p[l1+15], p[l1+16])

            @fastmath p[l+1], p[l+2], p[l+9], p[l+10],
                      p[l+3], p[l+4], p[l+11], p[l+12],
                      p[l+5], p[l+6], p[l+13], p[l+14],
                      p[l+7], p[l+8], p[l+15], p[l+16],
                      p[l1+1], p[l1+2], p[l1+9], p[l1+10],
                      p[l1+3], p[l1+4], p[l1+11], p[l1+12],
                      p[l1+5], p[l1+6], p[l1+13], p[l1+14],
                      p[l1+7], p[l1+8], p[l1+15], p[l1+16] = vi * mat
        end
    end

    if q1 == 1 && q2 == 2
        f = f12H
    elseif q1 == 1 && q2 == 3
        f = f13H
    elseif q1 == 2 && q2 == 3
        f = f23H
    else
        error(""qubit position $q1 not allowed for LH."")
    end
    total_itr = div(L, 32)

    # n_threads = Threads.nthreads()
    # if (total_itr >= MIN_SIZE) && (n_threads > 1)
    #     # println(""2*****************************"")
    #     nave, resi, jobs = partition_jobs(total_itr, n_threads)
    #     Threads.@threads for s in 1:n_threads
    #         ist = jobs[s]
    #         ifn = jobs[s+1] - 1
    #         f(ist, ifn, sizej, mask0, mask1, U, v)
    #     end
    # else
    #     # println(""1*****************************"")
    #     f(0, total_itr-1, sizej, mask0, mask1, U, v)
    # end
    parallel_run(total_itr, Threads.nthreads(), f, sizej, mask0, mask1, U, v)
end

""""""
    applys when both keys <= 4
""""""
function _apply_threebody_gate_LLL!(key::Tuple{Int, Int, Int}, U::AbstractMatrix, v::AbstractVector)
    L = length(v)
    q1, q2, q3 = key
    f123(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector) = begin
        @inbounds for i in ist:ifn
            l = 32 * i + 1
            vi = SMatrix{8, 4}(p[l], p[l+1], p[l+2], p[l+3], p[l+4], p[l+5], p[l+6], p[l+7],
            p[l+8], p[l+9], p[l+10], p[l+11], p[l+12], p[l+13], p[l+14], p[l+15],
            p[l+16], p[l+17], p[l+18], p[l+19], p[l+20], p[l+21], p[l+22], p[l+23],
            p[l+24], p[l+25], p[l+26], p[l+27], p[l+28], p[l+29], p[l+30], p[l+31])
            @fastmath p[l:(l+31)]= mat * vi
        end
    end
    f124(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector) = begin
        @inbounds for i in ist:ifn
            l = 32 * i
            vi = SMatrix{8, 4}(p[l+1], p[l+2], p[l+3], p[l+4], p[l+9], p[l+10], p[l+11], p[l+12],
                               p[l+5], p[l+6], p[l+7], p[l+8], p[l+13], p[l+14], p[l+15], p[l+16],
                               p[l+17], p[l+18], p[l+19], p[l+20], p[l+25], p[l+26], p[l+27], p[l+28],
                               p[l+21], p[l+22], p[l+23], p[l+24], p[l+29], p[l+30], p[l+31], p[l+32])

            @fastmath p[l+1], p[l+2], p[l+3], p[l+4], p[l+9], p[l+10], p[l+11], p[l+12],
                      p[l+5], p[l+6], p[l+7], p[l+8], p[l+13], p[l+14], p[l+15], p[l+16],
                      p[l+17], p[l+18], p[l+19], p[l+20], p[l+25], p[l+26], p[l+27], p[l+28],
                      p[l+21], p[l+22], p[l+23], p[l+24], p[l+29], p[l+30], p[l+31], p[l+32] = mat * vi
        end
    end
    f134(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector) = begin
        @inbounds for i in ist:ifn
            l = 32 * i
            vi = SMatrix{8, 4}(p[l+1], p[l+2], p[l+5], p[l+6], p[l+9], p[l+10], p[l+13], p[l+14],
                               p[l+3], p[l+4], p[l+7], p[l+8], p[l+11], p[l+12], p[l+15], p[l+16],
                               p[l+17], p[l+18], p[l+21], p[l+22], p[l+25], p[l+26], p[l+29], p[l+30],
                               p[l+19], p[l+20], p[l+23], p[l+24], p[l+27], p[l+28], p[l+31], p[l+32])

            @fastmath p[l+1], p[l+2], p[l+5], p[l+6], p[l+9], p[l+10], p[l+13], p[l+14],
                      p[l+3], p[l+4], p[l+7], p[l+8], p[l+11], p[l+12], p[l+15], p[l+16],
                      p[l+17], p[l+18], p[l+21], p[l+22], p[l+25], p[l+26], p[l+29], p[l+30],
                      p[l+19], p[l+20], p[l+23], p[l+24], p[l+27], p[l+28], p[l+31], p[l+32] = mat * vi
        end
    end
    f234(ist::Int, ifn::Int, mat::AbstractMatrix, p::AbstractVector) = begin
        @inbounds for i in ist:ifn
            l = 32 * i
            vi = SMatrix{8, 4}(p[l+1], p[l+3], p[l+5], p[l+7], p[l+9], p[l+11], p[l+13], p[l+15],
                               p[l+2], p[l+4], p[l+6], p[l+8], p[l+10], p[l+12], p[l+14], p[l+16],
                               p[l+17], p[l+19], p[l+21], p[l+23], p[l+25], p[l+27], p[l+29], p[l+31],
                               p[l+18], p[l+20], p[l+22], p[l+24], p[l+26], p[l+28], p[l+30], p[l+32])

            @fastmath p[l+1], p[l+3], p[l+5], p[l+7], p[l+9], p[l+11], p[l+13], p[l+15],
                      p[l+2], p[l+4], p[l+6], p[l+8], p[l+10], p[l+12], p[l+14], p[l+16],
                      p[l+17], p[l+19], p[l+21], p[l+23], p[l+25], p[l+27], p[l+29], p[l+31],
                      p[l+18], p[l+20], p[l+22], p[l+24], p[l+26], p[l+28], p[l+30], p[l+32] = mat * vi
        end
    end
    if q1==1 && q2 == 2 && q3 == 3
        f = f123
    elseif q1==1 && q2 == 2 && q3 == 4
        f = f124
    elseif q1==1 && q2 == 3 && q3 == 4
        f = f134
    elseif q1==2 && q2 == 3 && q3 == 4
        f = f234
    else
        error(""qubit position $q1 and $q2 not allowed for LL."")
    end
    total_itr = div(L, 32)

    # n_threads = Threads.nthreads()
    # if (total_itr >= MIN_SIZE) && (n_threads > 1)
    #     nave, resi, jobs = partition_jobs(total_itr, n_threads)
    #     Threads.@threads for s in 1:n_threads
    #         ist = jobs[s]
    #         ifn = jobs[s+1] - 1
    #         f(ist, ifn, U, v)
    #     end
    # else
    #     f(0, total_itr-1, U, v)
    # end
    parallel_run(total_itr, Threads.nthreads(), f, U, v)
end

function _apply_gate_threaded2!(key::Tuple{Int, Int, Int}, U::AbstractMatrix, v::AbstractVector)
    q0, q1, q2 = key
    if q0 > 2
        return _apply_threebody_gate_HHH!(key, SMatrix{8,8, eltype(v)}(transpose(U)), v)
    elseif q1 > 3
        return _apply_threebody_gate_LHH!(key, SMatrix{8,8, eltype(v)}(transpose(U)), v)
    elseif q2 > 4
        return _apply_threebody_gate_LLH!(key, SMatrix{8,8, eltype(v)}(transpose(U)), v)
    else
        return _apply_threebody_gate_LLL!(key, SMatrix{8,8, eltype(v)}(U), v)
    end
end



","Julia"
"Conjugate","guochu/VQC.jl","src/applygates/generic/serial_short_range.jl",".jl","2549","75","
function _apply_gate_2_impl!(key::Int, U::AbstractMatrix, v::AbstractVector)
    L = length(v)
    pos = 2^(key-1)
    strid = pos * 2
    for i in 0:strid:(L-1)
        @inbounds for j in 0:(pos-1)
            l = i + j + 1
            vi1 = v[l]
            vi2 = v[l + pos]
            vo1 = U[1,1] * vi1 + U[1,2] * vi2
            vo2 = U[2,1] * vi1 + U[2,2] * vi2
            v[l] = vo1
            v[l + pos] = vo2
        end
    end
end

_apply_gate_2!(key::Int, U::AbstractMatrix, v::AbstractVector) = _apply_gate_2_impl!(
key, SMatrix{2,2, eltype(v)}(U), v)
_apply_gate_2!(key::Tuple{Int}, U::AbstractMatrix, v::AbstractVector) = _apply_gate_2!(key[1], U, v)

function _apply_gate_2_impl!(key::Tuple{Int, Int}, U::AbstractMatrix, v::AbstractVector)
    # U = Matrix(transpose(reshape(U, 4, 4)))
    L = length(v)
    q1, q2 = key
    pos1, pos2 = 2^(q1-1), 2^(q2-1)
    stride1, stride2 = 2 * pos1, 2 * pos2
    for i in 0:stride2:(L-1)
        for j in 0:stride1:(pos2-1)
            @inbounds for k in 0:(pos1-1)
                l = i + j + k + 1
                vi = SVector(v[l], v[l + pos1], v[l + pos2], v[l + pos1 + pos2])
                v[l], v[l + pos1], v[l + pos2], v[l + pos1 + pos2] = U * vi
            end
        end
    end
end

function _apply_gate_2_impl!(key::Tuple{Int, Int, Int}, m::AbstractMatrix, v::AbstractVector)
    L = length(v)
    q1, q2, q3 = key
    pos1, pos2, pos3 = 2^(q1-1), 2^(q2-1), 2^(q3-1)
    stride1, stride2, stride3 = 2 * pos1, 2 * pos2, 2 * pos3
    for h in 0:stride3:(L-1)
        for i in 0:stride2:(pos3-1)
            for j in 0:stride1:(pos2-1)
                @inbounds for k in 0:(pos1-1)
                    l000 = h + i + j + k + 1
                    l100 = l000 + pos1
                    l010 = l000 + pos2
                    l110 = l010 + pos1

                    l001 = l000 + pos3
                    l101 = l001 + pos1
                    l011 = l001 + pos2
                    l111 = l011 + pos1
                    vi = SVector(v[l000], v[l100], v[l010], v[l110], v[l001], v[l101], v[l011], v[l111])

                    @fastmath v[l000], v[l100], v[l010], v[l110], v[l001], v[l101], v[l011], v[l111] = m * vi
                    
                end
            end
        end
    end
end

_apply_gate_2!(key::Tuple{Int, Int}, U::AbstractMatrix, v::AbstractVector) =  _apply_gate_2_impl!(
key, SMatrix{4,4, eltype(v)}(U), v)
_apply_gate_2!(key::Tuple{Int, Int, Int}, U::AbstractMatrix, v::AbstractVector) = _apply_gate_2_impl!(
key, SMatrix{8,8, eltype(v)}(U), v)



","Julia"
"Conjugate","guochu/VQC.jl","src/applygates/generic/generic.jl",".jl","1867","65","
include(""serial_short_range.jl"")
include(""threaded_short_range.jl"")
include(""threaded_long_range.jl"")

function apply!(x::Gate, state::StateVector) 
	@assert _check_pos_range(x, nqubits(state))
	T = eltype(state)
	if (eltype(x) <: Complex) && (T <: Real)
		state = convert(StateVector{Complex{T}}, state)
	end
	apply_threaded!(x, storage(state))
	return state
end

function apply!(x::Gate, state::DensityMatrix) 
	@assert _check_pos_range(x, nqubits(state))
	T = eltype(state)
	if (eltype(x) <: Complex) && (T <: Real)
		state = convert(DensityMatrix{Complex{T}}, state)
	end
	_dm_apply_threaded!(x, state.data, nqubits(state))
	return state
end

function apply!(circuit::QCircuit, state::Union{StateVector, DensityMatrix})
	for gate in circuit
		state = apply!(gate, state)
	end
	return state
end

Base.:*(circuit::QCircuit, state::Union{StateVector, DensityMatrix}) = apply!(circuit, copy(state))

function _check_pos_range(x, n::Int)
	pos = ordered_positions(x)
	(length(pos) > 5) && throw(""only implement 5-qubit gates and less currently."")
	return (pos[1] >= 1) && (pos[end] <= n)
end



apply_serial!(x::Gate, s::AbstractVector) = _apply_gate_2!(ordered_positions(x), ordered_mat(x), s)
apply_serial!(x::Gate, state::StateVector) = (apply_serial!(x, storage(state)); state)


""""""
    currently support mostly 5-qubit gate
""""""
apply_threaded!(x::Gate, s::AbstractVector) = (length(s) >= 32) ? _apply_gate_threaded2!(ordered_positions(x), ordered_mat(x), s) : apply_serial!(x, s)


# unitary gate operation on density matrix
function _dm_apply_threaded!(x::Gate{N}, s::AbstractVector, n::Int) where N
	pos = ordered_positions(x)
	m = ordered_mat(x)
	if length(s) >= 32
		_apply_gate_threaded2!(pos, m, s)
		_apply_gate_threaded2!(ntuple(i->pos[i]+n, N), conj(m), s)
	else
		_apply_gate_2!(pos, m, s)
		_apply_gate_2!(ntuple(i->pos[i]+n, N), conj(m), s)
	end
end
","Julia"
"Conjugate","guochu/VQC.jl","test/check_high_qubit_gate.jl",".jl","8640","208","



function check_fourbody_single(::Type{T}, L::Int, j::Int, k::Int, l::Int, m::Int) where T
    state1 = rand_state(T, L)
    m1 = random_unitary(1)
    m2 = random_unitary(1)
    m3 = random_unitary(1)
    m4 = random_unitary(1)
    gate1 = from_external((j, k, l, m), kron(m1, m2, m3, m4))
    h = QubitsTerm(j=>m1, k=>m2, l=>m3, m=>m4)
    state2 = matrix(L, h) * state1
    apply!(gate1, state1)
    return maximum(abs.(storage(state1 - state2)) )
end

function check_fourbody(::Type{T}, L::Int, i::Int, j::Int, k::Int, l::Int) where T
	errs = []
	push!(errs, check_fourbody_single(ComplexF64, L, i,j,k,l))
	push!(errs, check_fourbody_single(ComplexF64, L, i,j,l,k))
	push!(errs, check_fourbody_single(ComplexF64, L, j,i,k,l))
	push!(errs, check_fourbody_single(ComplexF64, L, j,i,l,k))
	push!(errs, check_fourbody_single(ComplexF64, L, l,k,j,i))
	push!(errs, check_fourbody_single(ComplexF64, L, k,i,l,j))
	return all(errs .< 1.0e-6)
end

function check_fivebody_single(::Type{T}, L::Int, j::Int, k::Int, l::Int, m::Int, n::Int) where T
    state1 = rand_state(T, L)
    m1 = random_unitary(1)
    m2 = random_unitary(1)
    m3 = random_unitary(1)
    m4 = random_unitary(1)
    m5 = random_unitary(1)
    gate1 = from_external((j, k, l, m, n), kron(m1, m2, m3, m4, m5))
    h = QubitsTerm(j=>m1, k=>m2, l=>m3, m=>m4, n=>m5)
    state2 = matrix(L, h) * state1
    apply!(gate1, state1)
    return maximum(abs.(storage(state1 - state2)) )
end

function check_fivebody(::Type{T}, L::Int, i::Int, j::Int, k::Int, l::Int, n::Int) where T
	errs = []
	push!(errs, check_fivebody_single(ComplexF64, L, i,j,k,l,n))
	push!(errs, check_fivebody_single(ComplexF64, L, i,j,l,n,k))
	push!(errs, check_fivebody_single(ComplexF64, L, j,i,n,k,l))
	push!(errs, check_fivebody_single(ComplexF64, L, j,n,i,l,k))
	push!(errs, check_fivebody_single(ComplexF64, L, l,k,j,n,i))
	push!(errs, check_fivebody_single(ComplexF64, L, n,k,i,l,j))
	return all(errs .< 1.0e-6)
end


function check_qham_fourbody_single(::Type{T}, L::Int, j::Int, k::Int, l::Int, m::Int) where T
    state1 = rand_state(T, L)
    m1 = random_unitary(1)
    m2 = random_unitary(1)
    m3 = random_unitary(1)
    m4 = random_unitary(1)
    gate1 = from_external((j, k, l, m), kron(m1, m2, m3, m4))
    h = QubitsTerm(j=>m1, k=>m2, l=>m3, m=>m4)
    state2 = h * state1
    apply!(gate1, state1)
    return maximum(abs.(storage(state1 - state2)) )
end

function check_qham_fourbody(::Type{T}, L::Int, i::Int, j::Int, k::Int, l::Int) where T
    errs = []
    push!(errs, check_qham_fourbody_single(ComplexF64, L, i,j,k,l))
    push!(errs, check_qham_fourbody_single(ComplexF64, L, i,j,l,k))
    push!(errs, check_qham_fourbody_single(ComplexF64, L, j,i,k,l))
    push!(errs, check_qham_fourbody_single(ComplexF64, L, j,i,l,k))
    push!(errs, check_qham_fourbody_single(ComplexF64, L, l,k,j,i))
    push!(errs, check_qham_fourbody_single(ComplexF64, L, k,i,l,j))
    return all(errs .< 1.0e-6)
end

function check_qham_fivebody_single(::Type{T}, L::Int, j::Int, k::Int, l::Int, m::Int, n::Int) where T
    state1 = rand_state(T, L)
    m1 = random_unitary(1)
    m2 = random_unitary(1)
    m3 = random_unitary(1)
    m4 = random_unitary(1)
    m5 = random_unitary(1)
    gate1 = from_external((j, k, l, m, n), kron(m1, m2, m3, m4, m5))
    h = QubitsTerm(j=>m1, k=>m2, l=>m3, m=>m4, n=>m5)
    state2 = h * state1
    apply!(gate1, state1)
    return maximum(abs.(storage(state1 - state2)) )
end


function check_qham_fivebody(::Type{T}, L::Int, i::Int, j::Int, k::Int, l::Int, n::Int) where T
    errs = []
    push!(errs, check_qham_fivebody_single(ComplexF64, L, i,j,k,l,n))
    push!(errs, check_qham_fivebody_single(ComplexF64, L, i,j,l,n,k))
    push!(errs, check_qham_fivebody_single(ComplexF64, L, j,i,n,k,l))
    push!(errs, check_qham_fivebody_single(ComplexF64, L, j,n,i,l,k))
    push!(errs, check_qham_fivebody_single(ComplexF64, L, l,k,j,n,i))
    push!(errs, check_qham_fivebody_single(ComplexF64, L, n,k,i,l,j))
    return all(errs .< 1.0e-6)
end

function check_expec_fourbody_single(::Type{T}, L::Int, j::Int, k::Int, l::Int, m::Int) where T
    state = rand_state(T, L)
    m = QubitsTerm(j=>random_unitary(1), k=>random_unitary(1), l=>random_unitary(1), 
        m=>random_unitary(1), coeff=0.9)

    return abs(expectation(m, state) - expectation(matrix(L, m), state))
end


function check_expec_fourbody(::Type{T}, L::Int, i::Int, j::Int, k::Int, l::Int) where T
    errs = []
    push!(errs, check_expec_fourbody_single(T, L, i,j,k,l))
    push!(errs, check_expec_fourbody_single(T, L, i,j,l,k))
    push!(errs, check_expec_fourbody_single(T, L, j,i,k,l))
    push!(errs, check_expec_fourbody_single(T, L, j,i,l,k))
    push!(errs, check_expec_fourbody_single(T, L, l,k,j,i))
    push!(errs, check_expec_fourbody_single(T, L, k,i,l,j))
    return all(errs .< 1.0e-6)
end

function check_expec_fourbody_single_2(::Type{T}, L::Int, j::Int, k::Int, l::Int, m::Int) where T
    state1 = rand_state(T, L)
    state2 = rand_state(T, L)
    m = QubitsTerm(j=>random_unitary(1), k=>random_unitary(1), l=>random_unitary(1), 
        m=>random_unitary(1), coeff=0.7)

    return abs(expectation(state2, m, state1) - expectation(state2, matrix(L, m), state1))
end

function check_expec_fourbody_2(::Type{T}, L::Int, i::Int, j::Int, k::Int, l::Int) where T
    errs = []
    push!(errs, check_expec_fourbody_single_2(T, L, i,j,k,l))
    push!(errs, check_expec_fourbody_single_2(T, L, i,j,l,k))
    push!(errs, check_expec_fourbody_single_2(T, L, j,i,k,l))
    push!(errs, check_expec_fourbody_single_2(T, L, j,i,l,k))
    push!(errs, check_expec_fourbody_single_2(T, L, l,k,j,i))
    push!(errs, check_expec_fourbody_single_2(T, L, k,i,l,j))
    return all(errs .< 1.0e-6)
end

function check_expec_fivebody_single(::Type{T}, L::Int, j::Int, k::Int, l::Int, m::Int, n::Int) where T
    state = rand_state(T, L)
    m = QubitsTerm(j=>random_unitary(1), k=>random_unitary(1), l=>random_unitary(1),
     m=>random_unitary(1), n=>random_unitary(1), coeff=0.77)

    return abs(expectation(m, state) - expectation(matrix(L, m), state))
end

function check_expec_fivebody_single_2(::Type{T}, L::Int, j::Int, k::Int, l::Int, m::Int, n::Int) where T
    state1 = rand_state(T, L)
    state2 = rand_state(T, L)
    m = QubitsTerm(j=>random_unitary(1), k=>random_unitary(1), l=>random_unitary(1),
     m=>random_unitary(1), n=>random_unitary(1), coeff=1.23)

    return abs(expectation(state2, m, state1) - expectation(state2, matrix(L, m), state1))
end

function check_expec_fivebody(::Type{T}, L::Int, i::Int, j::Int, k::Int, l::Int, n::Int) where T
    errs = []
    push!(errs, check_expec_fivebody_single(T, L, j,i,n,k,l))
    push!(errs, check_expec_fivebody_single(T, L, j,n,i,l,k))
    push!(errs, check_expec_fivebody_single(T, L, j,n,i,k,l))
    push!(errs, check_expec_fivebody_single(T, L, l,k,j,n,i))
    push!(errs, check_expec_fivebody_single(T, L, n,k,i,l,j))
    push!(errs, check_expec_fivebody_single(T, L, i,j,k,l,n))
    return all(errs .< 1.0e-6)
end

function check_expec_fivebody_2(::Type{T}, L::Int, i::Int, j::Int, k::Int, l::Int, n::Int) where T
    errs = []
    push!(errs, check_expec_fivebody_single_2(T, L, j,i,n,k,l))
    push!(errs, check_expec_fivebody_single_2(T, L, j,n,i,l,k))
    push!(errs, check_expec_fivebody_single_2(T, L, j,n,i,k,l))
    push!(errs, check_expec_fivebody_single_2(T, L, l,k,j,n,i))
    push!(errs, check_expec_fivebody_single_2(T, L, n,k,i,l,j))
    push!(errs, check_expec_fivebody_single_2(T, L, i,j,k,l,n))
    return all(errs .< 1.0e-6)
end

@testset ""check high-qubit gate operations"" begin
    @test check_fourbody(ComplexF32, 4,1,2,3,4)
    @test check_fourbody(ComplexF64, 10,10,7,1,4)
    @test check_fivebody(ComplexF32, 5,1,2,3,5,4)
    @test check_fivebody(ComplexF32, 10,9,7,10,1,4)
end

@testset ""check high-qubit hamiltonian term operations"" begin
    @test check_qham_fourbody(ComplexF32, 4,1,2,3,4)
    @test check_qham_fourbody(ComplexF64, 10,6,7,1,4)
    @test check_qham_fivebody(ComplexF32, 5,1,2,3,5,4)
    @test check_qham_fivebody(ComplexF32, 11,9,11,10,1,4)
end

@testset ""check hamiltonion high-qubit term expectation value"" begin
    @test check_expec_fourbody(ComplexF64, 4, 1,2,3,4)
    @test check_expec_fourbody(ComplexF64, 9, 7,8,1,5)
    @test check_expec_fivebody(ComplexF64, 5, 1,2,3,5,4)
    @test check_expec_fivebody(ComplexF64, 10, 7,10,2,5,8)
    @test check_expec_fourbody_2(ComplexF32, 4, 1,2,3,4)
    @test check_expec_fourbody_2(ComplexF64, 10, 7,10,1,5)
    @test check_expec_fivebody_2(ComplexF64, 5, 1,2,3,5,4)
    @test check_expec_fivebody_2(ComplexF32, 10, 7,10,2,5,8)
end
","Julia"
"Conjugate","guochu/VQC.jl","test/check_state_init.jl",".jl","2164","48","
function check_statevector_init_1()
    a0 = storage(StateVector(1)) == Gates.ZERO
    a1 = storage(onehot_encoding([1])) == Gates.ONE
    a2 = storage(onehot_encoding([0])) == Gates.ZERO
    a3 = storage(onehot_encoding(2)) == kron(Gates.ZERO, Gates.ZERO)
    a4 = storage(onehot_encoding([1, 0])) == kron(Gates.ZERO, Gates.ONE)
    a5 = storage(onehot_encoding([0, 1])) == kron(Gates.ONE, Gates.ZERO)
    a6 = storage(onehot_encoding([1, 1])) == kron(Gates.ONE, Gates.ONE)
    a7 = storage(onehot_encoding([1,0,0])) == kron(Gates.ZERO, Gates.ZERO, Gates.ONE)
    a8 = storage(reset_onehot!(onehot_encoding([1, 1]), [0, 1])) == kron(Gates.ONE, Gates.ZERO)
    a9 = storage(reset_onehot!(onehot_encoding([1,0,1]), [0,0,1])) == kron(Gates.ONE, Gates.ZERO, Gates.ZERO)
    return a0 && a1 && a2 && a3 && a4 && a5 && a6 && a7 && a8 && a9
end 


function check_statevector_init_2()
    v = [sqrt(2)/2, sqrt(2)/2]
    a0 = isapprox(onehot_encoding([0]), qubit_encoding([0.]) )
    a1 = isapprox(onehot_encoding([1]), qubit_encoding([1.]))
    a2 = isapprox(onehot_encoding([1,0]), qubit_encoding([1.,0.]))
    a3 = isapprox(onehot_encoding([1,1]), qubit_encoding([1.,1.]))
    a4 = isapprox(storage(qubit_encoding([0.5])), v)
    a5 = isapprox(storage(qubit_encoding([0.5, 1])), kron(Gates.ONE, v))
    a6 = isapprox(storage(reset_qubit!(onehot_encoding([0, 1]), [0, 0.5])), kron(v, Gates.ZERO))
    a7 = isapprox(storage(reset_qubit!(onehot_encoding([1,1,1]), [0, 0.5, 0.5])), kron(v, v, Gates.ZERO))
    a8 = isapprox(storage(reset_qubit!(onehot_encoding([1,1,1,0,1]), [0, 0.5, 0.5, 1, 0])), kron(Gates.ZERO, Gates.ONE, v, v, Gates.ZERO))
    return a0 && a1 && a2 && a3 && a4 && a5 && a6 && a7 && a8
end


function check_statevector_init_3(L::Int)
	v = randn(L)
	a0 = isapprox(StateVector(qubit_encoding(v)), qubit_encoding(v), atol=1.0e-8)
	v = rand(0:1, L)
	a2 = isapprox(StateVector(onehot_encoding(v)), onehot_encoding(v), atol=1.0e-8)
	return a0 && a2
end


@testset ""check qubit encoding initialization of quantum state"" begin
	@test check_statevector_init_1()
	@test check_statevector_init_2()
	for L in [3,4]
	    @test check_statevector_init_3(L)
	end
end
","Julia"
"Conjugate","guochu/VQC.jl","test/check_measure.jl",".jl","1765","76","
function check_measure_1()
	state = rand_state(Float64, 3)
	i, p = measure!(state, 1, auto_reset=true)
	tmp, i1, p1 = measure(state, 1)
	return i1 == 0 && isapprox(p1, 1, atol=1.0e-10)
end

function check_measure_2()
	state = rand_state(ComplexF64, 3)
	i, p = measure!(state, 2, auto_reset=false)
	tmp, i1, p1 = measure(state, 2)
	return i1 == i && isapprox(p1, 1, atol=1.0e-10)
end

function check_select_1()
	state = rand_state(Float64, 3)
	post_select!(state, 2, 0)
	tmp, i1, p1 = measure(state, 2)
	return i1 == 0 && isapprox(p1, 1, atol=1.0e-10)
end

function check_select_2()
	state = rand_state(Float64, 3)
	post_select!(state, 3, 1)
	tmp, i1, p1 = measure(state, 3)
	return i1 == 1 && isapprox(p1, 1, atol=1.0e-10)
end

function check_select_3()
	state = (sqrt(2)/2) * (qubit_encoding([0, 0]) + qubit_encoding([1, 1]))
	r, p = post_select(state, 1, 0)
	return isapprox(storage(r), Gates.ZERO)
end

function check_select_4()
	state = (sqrt(2)/2) * (qubit_encoding([0, 0]) + qubit_encoding([1, 1]))
	r, p = post_select(state, 1, 1)
	return isapprox(storage(r), Gates.ONE)
end

function check_select_grad()
	initial_state = qubit_encoding([0, 1])
	function loss(s) 
		r, p = post_select(s, 2, 1)
		return distance(r, initial_state) + p^2
	end
	loss_fd(θs) = loss(StateVector(θs))

	x = rand_state(ComplexF64, 3)
	grad1 = storage(gradient(loss, x)[1])
	grad2 = fdm_gradient(loss_fd, storage(x))
	return maximum(abs.(grad1 - grad2)) < 1.0e-6
end

@testset ""check quantum measure"" begin
	@test check_measure_1()
	@test check_measure_2()
end

@testset ""check quantum select"" begin
	@test check_select_1()
	@test check_select_2()
	@test check_select_3()
	@test check_select_4()
end

@testset ""check quantum select grad"" begin
	@test check_select_grad()
end





","Julia"
"Conjugate","guochu/VQC.jl","test/parameter.jl",".jl","1332","55","
function test_parameter(L::Int, depth::Int)
	circuit = QCircuit()
	counts = 0
	vars = []
	for i in 1:L
	    push!(circuit, HGate(i))
	end
	for i in 1:L
		parameter = randn(Float64)
		# variable indicate a parameter
	    push!(circuit, RxGate(i, parameter, isparas=true))
	    counts += 1
	    push!(vars, parameter)
	    # this is not a parameter
	    push!(circuit, RxGate(i, parameter + 1, isparas=false))
	end
	for d in 1:depth
		for i in 1:(L-1)
	    	push!(circuit, CNOTGate(i, i+1))
		end
		for i in 1:L
			parameter = randn(Float64)
			# variable indicate a parameter
	    	push!(circuit, RxGate(i, parameter, isparas=true))
	    	counts += 1
	    	push!(vars, parameter)
	    	# this is not a parameter
	    	push!(circuit, RxGate(i, parameter + 1, isparas=false))
		end    
	end
	check1 = (nparameters(circuit) == counts)
	check2 = (active_parameters(circuit) == vars)
	new_vars = randn(Float64, size(vars)...)
	reset_parameters!(circuit, new_vars)
	check3 = (nparameters(circuit) == counts)
	check4 = (active_parameters(circuit) == new_vars)

	# println(""check1 $check1, check2 $check2, check3 $check3, check4 $check4"")
	return check1 && check2 && check3 && check4
end



@testset ""set the parameters of quantum circuit"" begin
	for L in 2:10
		for depth in 0:7
		    @test test_parameter(L, depth)
		end	    
	end
end



","Julia"
"Conjugate","guochu/VQC.jl","test/check_utility.jl",".jl","271","15","

function check_ptrace(sites)
	a = rand_state(6)
	b = DensityMatrix(a)
	return partial_tr(a, sites) ≈ partial_tr(b, sites)
end

@testset ""check partial trace of quantum state"" begin
	@test check_ptrace([1,2])
	@test check_ptrace([2,5])
	@test check_ptrace([6,3])
end

","Julia"
"Conjugate","guochu/VQC.jl","test/stategrad.jl",".jl","3059","117","
""""""
	state gradient with distance loss function
""""""
function state_grad_dot_real(L::Int, depth::Int)
	target_state = rand_state(ComplexF64, L)
	initial_state = rand_state(ComplexF64, L)
	circuit =  variational_circuit_1d(L, depth)

	loss(x) = real(dot(target_state, circuit * x))
	loss_fd(θs) = loss(StateVector(θs))

	grad1 = storage(gradient(loss, initial_state)[1])
	grad2 = fdm_gradient(loss_fd, amplitudes(initial_state))
	return maximum(abs.(grad1 - grad2)) < 1.0e-6
end

""""""
	state gradient with distance loss function
""""""
function state_grad_dot_imag(L::Int, depth::Int)
	target_state = rand_state(ComplexF64, L)
	initial_state = rand_state(ComplexF64, L)
	circuit =  variational_circuit_1d(L, depth)

	loss(x) = imag(dot(target_state, circuit * x))
	loss_fd(θs) = loss(StateVector(θs))

	grad1 = storage(gradient(loss, initial_state)[1])
	grad2 = fdm_gradient(loss_fd, amplitudes(initial_state))
	return maximum(abs.(grad1 - grad2)) < 1.0e-6
end

""""""
	state gradient with distance loss function
""""""
function state_grad_dot_abs(L::Int, depth::Int)
	target_state = rand_state(ComplexF64, L)
	initial_state = rand_state(ComplexF64, L)
	circuit =  variational_circuit_1d(L, depth)

	loss(x) = abs(dot(target_state, circuit * x))
	loss_fd(θs) = loss(StateVector(θs))

	grad1 = storage(gradient(loss, initial_state)[1])
	grad2 = fdm_gradient(loss_fd, amplitudes(initial_state))
	return maximum(abs.(grad1 - grad2)) < 1.0e-6
end

""""""
	state gradient with distance loss function
""""""
function state_grad_distance(L::Int, depth::Int)
	target_state = rand_state(ComplexF64, L)
	initial_state = rand_state(ComplexF64, L)
	circuit =  variational_circuit_1d(L, depth)

	loss(x) = distance(target_state, circuit * x)
	loss_fd(θs) = loss(StateVector(θs))

	grad1 = storage(gradient(loss, initial_state)[1])
	grad2 = fdm_gradient(loss_fd, amplitudes(initial_state))
	return maximum(abs.(grad1 - grad2)) < 1.0e-6
end


function qstate_grad(::Type{T}, L::Int) where {T<:Number}
	target_state = rand_state(T, L)
	loss(v) = abs(dot(target_state, qubit_encoding(T, v)))
	x = randn(L)

	grad1 = gradient(loss, x)[1]
	grad2 = fdm_gradient(loss, x)
	return maximum(abs.(grad1 - grad2)) < 1.0e-6
end

@testset ""gradient of quantum state with loss function real(dot(a, circuit*x))"" begin
	for L in 2:5
		for depth in 0:5
		    @test state_grad_dot_real(L, depth)
		end
	end
end

@testset ""gradient of quantum state with loss function imag(dot(a, circuit*x))"" begin
	for L in 2:5
		for depth in 0:5
		    @test state_grad_dot_imag(L, depth)
		end
	end
end

@testset ""gradient of quantum state with loss function abs(dot(a, circuit*x))"" begin
	for L in 2:5
		for depth in 0:5
		    @test state_grad_dot_abs(L, depth)
		end
	end
end

@testset ""gradient of quantum state with loss function distance(a, circuit*x)"" begin
	for L in 2:5
		for depth in 0:5
		    @test state_grad_distance(L, depth)
		end
	end
end


@testset ""gradient of quantum state initializer qstate"" begin
	for L in 2:5
		for T in [Float64, Complex{Float64}]
		    @test qstate_grad(T, L)
		end
	end
end
","Julia"
"Conjugate","guochu/VQC.jl","test/runtests.jl",".jl","1824","85","push!(LOAD_PATH, ""../src"")

include(""util.jl"")

using Test
using Zygote, LinearAlgebra

using QuantumCircuits, QuantumCircuits.Gates
using QuantumCircuits: n_qubits_mat_from_external
using VQC, VQC.Utilities
using VQC: apply_serial!

_check_unitary(m::AbstractMatrix) = isapprox(m' * m, LinearAlgebra.I) 

function from_external(key::NTuple{N, Int}, m::AbstractMatrix; check_unitary::Bool=true) where N
    (size(m, 1) == 2^N) || error(""wrong input matrix size."")
    if check_unitary
        _check_unitary(m) || error(""input matrix is not unitary."")
    end
    return QuantumGate(key, n_qubits_mat_from_external(m))
end  

function random_unitary(n::Int)
    L = 2^n
    m = randn(ComplexF64, L, L)
    return exp(im * (m + m'))
end


@testset ""test quantum gate operations"" begin
    include(""check_gateop.jl"")
    include(""check_high_qubit_gate.jl"")
end

@testset ""test quantum state initialization"" begin
    include(""check_state_init.jl"")
end


@testset ""test qubit hamiltonian operations"" begin
    include(""check_qubits_ham.jl"")
end

@testset ""test circuit parameters"" begin
    include(""parameter.jl"")
end

@testset ""test measure and select"" begin
    include(""check_measure.jl"")
end


@testset ""test quantum algorithm"" begin
    include(""algs.jl"")
end

@testset ""test utility"" begin
    include(""check_utility.jl"")
end


@testset ""test quantum circuit gradient"" begin
    include(""circuitgrad.jl"")
    include(""crxgategrad.jl"")
end


@testset ""test expectation value gradient"" begin
    include(""check_ham_expec_diff.jl"")
end

@testset ""test quantum state gradient (may not variable via a quantum computer)"" begin
    include(""stategrad.jl"")
end


@testset ""test density matrix operations"" begin
    include(""stategrad.jl"")
end

@testset ""test noisy quantum circuit"" begin
    include(""check_noisy_grad.jl"")
end

","Julia"
"Conjugate","guochu/VQC.jl","test/algs.jl",".jl","1954","88","
function to_digits(s::Vector{Int})
	r = 0.
	for i = 1:length(s)
		r = r + s[i]*(2.)^(-i)
	end
	return r
end

function phase_estimate_circuit(j::Vector{Int})
	L = length(j)
	circuit = QCircuit()
	phi = to_digits(j)
	U = [exp(2*pi*im*phi) 0; 0. 1.]
	for i = 1:L
		push!(circuit, (i, H))
	end

	tmp = U
	for i = L:-1:1
		push!(circuit, ((i, L+1), Gates.CONTROL(tmp)))
		tmp = tmp * tmp
	end
	push!(circuit, QFT(L)')
	return circuit
end


function simple_phase_estimation_1(L::Int, auto_reset::Bool=false)
	j = rand(0:1, L)
	state = StateVector(L+1)
	phi = to_digits(j)
	circuit = phase_estimate_circuit(j)
	apply!(circuit, state)
	res = Int[]
	for i = 1:(L+1)
		i, p = measure!(state, i, auto_reset=auto_reset)
		push!(res, i)
	end
	phi_out = to_digits(res)
	return (phi == phi_out) && (j[1:L] == res[1:L])
end

function simple_phase_estimation_1_dm(L::Int, auto_reset::Bool=false)
	j = rand(0:1, L)
	state = DensityMatrix(L+1)
	phi = to_digits(j)
	circuit = phase_estimate_circuit(j)
	apply!(circuit, state)
	res = Int[]
	for i = 1:(L+1)
		i, p = measure!(state, i, auto_reset=auto_reset)
		push!(res, i)
	end
	phi_out = to_digits(res)
	return (phi == phi_out) && (j[1:L] == res[1:L])
end

function simple_phase_estimation_2(L::Int)

	j = rand(0:1, L)
	state = StateVector(L+1)
	phi = to_digits(j)
	circuit = phase_estimate_circuit(j)
	apply!(circuit, state)
	res = Int[]
	for i = 1:(L+1)
		state, i, p = measure(state, 1)
		push!(res, i)
	end
	phi_out = to_digits(res)
	return length(storage(state))==1 && isapprox(state[1], 1, atol=1.0e-10) && (phi == phi_out) && (j[1:L] == res[1:L])
end

@testset ""simple phase estimation"" begin
    for L in 2:15
        @test simple_phase_estimation_1(L, false)
        @test simple_phase_estimation_1(L, true)
    end
    for L in 2:6
    	@test simple_phase_estimation_1_dm(L, false)
    	@test simple_phase_estimation_1_dm(L, true)
    end
    for L in 2:15
        @test simple_phase_estimation_2(L)
    end
end
","Julia"
"Conjugate","guochu/VQC.jl","test/check_gateop.jl",".jl","6318","186","



function check_onebody_single(::Type{T}, L::Int, c::Int) where {T<:Number}
    state1 = rand_state(T, L)
    state2 = copy(state1)
    gate = QuantumGate(c, random_unitary(1))
    apply_serial!(gate, state1)
    apply!(gate, state2)
    return maximum(abs.(storage(state1 - state2)) )
end

function check_onebody(::Type{T}, L::Int) where {T<:Number}
    errs = []
    for c in 1:L
        push!(errs, check_onebody_single(T, L, c))
    end
    # println(""total number of tests $(length(errs))."")
    return all(errs .< 1.0e-6)
end

function check_twobody_single(::Type{T}, L::Int, c::Int, t::Int) where {T<:Number}
    state1 = rand_state(T, L)
    state2 = copy(state1)
    gate = QuantumGate((c, t), random_unitary(2))
    apply_serial!(gate, state1)
    apply!(gate, state2)
    return maximum(abs.(storage(state1 - state2)) )
end

function check_twobody(::Type{T}, L::Int) where {T<:Number}
    errs = []
    for c in 1:2:L
        for t in 2:2:L
            if c != t
                push!(errs, check_twobody_single(T, L, c, t))
            end
        end
    end
    # println(""total number of tests $(length(errs))."")
    return all(errs .< 1.0e-6)
end

function check_threebody_single(::Type{T}, L::Int, a::Int, b::Int, c::Int) where {T<:Number}
    state1 = rand_state(T, L)
    state2 = copy(state1)
    gate = QuantumGate((a, b, c), random_unitary(3))
    apply_serial!(gate, state1)
    apply!(gate, state2)
    return maximum(abs.(storage(state1 - state2)) )
end

function check_threebody(::Type{T}, L::Int) where {T<:Number}
    errs = []
    for a in 1:2:L
        for b in 2:3:L
            for c in 3:5:L
                if a != b && a != c && b != c
                    push!(errs, check_threebody_single(T, L, a, b, c))
                end
            end
        end
    end
    # println(""total number of tests $(length(errs))."")
    return all(errs .< 1.0e-6)
end

function check_single_gate(::Type{T}, L::Int, gt) where {T<:Number}
    state1 = rand_state(T, L)
    state2 = copy(state1)
    apply!(gt, state1)
    apply!(gate(ordered_positions(gt), ordered_mat(gt)), state2)
    return maximum(abs.(storage(state1 - state2)) )
end

function check_specialized_onebody_gates(::Type{T}, L::Int) where {T<:Number}
    errs = []
    for c in 1:L
        gt = XGate(c)
        push!(errs, check_single_gate(T, L, gt))
        push!(errs, check_single_gate(T, L, gt'))
        gt = YGate(c)
        push!(errs, check_single_gate(T, L, gt))
        push!(errs, check_single_gate(T, L, gt'))
        gt = ZGate(c)
        push!(errs, check_single_gate(T, L, gt))
        push!(errs, check_single_gate(T, L, gt'))
        gt = TGate(c)
        push!(errs, check_single_gate(T, L, gt))
        push!(errs, check_single_gate(T, L, gt'))
        gt = PHASEGate(c, randn())
        push!(errs, check_single_gate(T, L, gt))
        push!(errs, check_single_gate(T, L, gt'))
    end
    return all(errs .< 1.0e-6)
end

function check_specialized_twobody_gates(::Type{T}, L::Int) where {T<:Number}
    errs = []
    for c in 1:2:L
        for t in 2:2:L
            if c != t
                gt = CONTROLGate((c, t), random_unitary(1))
                push!(errs, check_single_gate(T, L, gt))
                push!(errs, check_single_gate(T, L, gt'))
                gt = CRxGate(c, t, randn())
                push!(errs, check_single_gate(T, L, gt))
                push!(errs, check_single_gate(T, L, gt'))
                gt = CRyGate(c, t, randn())
                push!(errs, check_single_gate(T, L, gt))
                push!(errs, check_single_gate(T, L, gt'))
                gt = CRzGate(c, t, randn())
                push!(errs, check_single_gate(T, L, gt))
                push!(errs, check_single_gate(T, L, gt'))

                gt = CZGate(c, t)
                push!(errs, check_single_gate(T, L, gt))
                push!(errs, check_single_gate(T, L, gt'))
                gt = CNOTGate(c, t)
                push!(errs, check_single_gate(T, L, gt))
                push!(errs, check_single_gate(T, L, gt'))

                gt = CPHASEGate(c, t, randn())
                push!(errs, check_single_gate(T, L, gt))
                push!(errs, check_single_gate(T, L, gt'))

                gt = SWAPGate(c, t)
                push!(errs, check_single_gate(T, L, gt))
                push!(errs, check_single_gate(T, L, gt'))
                gt = iSWAPGate(c, t)
                push!(errs, check_single_gate(T, L, gt))
                push!(errs, check_single_gate(T, L, gt'))

                gt = FSIMGate(c, t, randn(5))
                push!(errs, check_single_gate(T, L, gt))
                push!(errs, check_single_gate(T, L, gt'))
            end
        end
    end
    return all(errs .< 1.0e-6)
end

function check_specialized_threebody_gates(::Type{T}, L::Int) where {T<:Number}
    errs = []
    for a in 1:2:L
        for b in 2:3:L
            for c in 3:5:L
                if a != b && a != c && b != c
                    gt = CONTROLCONTROLGate(a, b, c, random_unitary(1))
                    push!(errs, check_single_gate(T, L, gt))
                    push!(errs, check_single_gate(T, L, gt'))
                    gt = TOFFOLIGate(a, b, c)
                    push!(errs, check_single_gate(T, L, gt))
                    push!(errs, check_single_gate(T, L, gt'))
                    gt = FREDKINGate(a, b, c)
                    push!(errs, check_single_gate(T, L, gt))
                    push!(errs, check_single_gate(T, L, gt'))

                    gt = CCPHASEGate(a, b, c, randn())
                    push!(errs, check_single_gate(T, L, gt))
                    push!(errs, check_single_gate(T, L, gt'))
                end
            end
        end
    end
    return all(errs .< 1.0e-6)
end

@testset ""check generic gate operations"" begin
    @test check_onebody(ComplexF32, 16)
    @test check_onebody(ComplexF64, 15)
    for L in 5:10:15
        @test check_twobody(ComplexF32, L)
        @test check_twobody(ComplexF64, L)
    end
    @test check_threebody(ComplexF32, 16)
    @test check_threebody(ComplexF64, 15)
end

@testset ""check specialized gate operations"" begin
    @test check_specialized_onebody_gates(ComplexF32, 16)
    @test check_specialized_twobody_gates(ComplexF32, 16)
    @test check_specialized_threebody_gates(ComplexF64, 15)
end
","Julia"
"Conjugate","guochu/VQC.jl","test/check_noisy_grad.jl",".jl","1728","60","

function noisy_circuit(L, depth; kwargs...)
	circuit = variational_circuit_1d(L, depth; kwargs...)
	for i in 1:L
		push!(circuit, Depolarizing(i, p=0.1))
	end
	return circuit
end

function check_noisy_circuit_grad(L, depth)
	circuit = noisy_circuit(L, depth)
	initial_state = DensityMatrix(ComplexF64, L)

	loss(x) = real( sum(storage(x * initial_state)) )
	loss_fd(θs) = loss(noisy_circuit(L, depth, θs=θs))

	grad1 = gradient(loss, circuit)[1]
	grad2 = fdm_gradient(loss_fd, active_parameters(circuit))
	return maximum(abs.(grad1 - grad2)) < 1.0e-6
end

function check_noisy_circuit_expec_grad(L, depth)
	circuit = noisy_circuit(L, depth)
	m = QubitsTerm(1=>""+"", L-1=>""-"", coeff=0.7) + QubitsTerm(1=>""-"", L-1=>""+"", coeff=0.77) + QubitsTerm(1=>""X"", L=>""Y"", coeff=0.36)
	initial_state = DensityMatrix(ComplexF64, L)

	loss(x) = real(expectation(m, x * initial_state))
	loss_fd(θs) = loss(noisy_circuit(L, depth, θs=θs))

	grad1 = gradient(loss, circuit)[1]
	grad2 = fdm_gradient(loss_fd, active_parameters(circuit))
	# println(""error is $(maximum(abs.(grad1 - grad2)))"")
	return maximum(abs.(grad1 - grad2)) < 1.0e-6
end

function check_ham_term_grad(::Type{T}, L) where T
	state = rand_densitymatrix(T, L)

	m = QubitsTerm(1=>""+"", L-1=>""Y"", coeff=0.36)

	loss(x) = abs(expectation(m, x))
	loss_fd(θs) = loss(DensityMatrix(θs))

	grad1 = storage(gradient(loss, state)[1])
	grad2 = fdm_gradient(loss_fd, storage(state))
	return maximum(abs.(grad1 - grad2)) < 1.0e-6
end



@testset ""gradient of noisy quantum circuit"" begin
	for L in 2:5
		@test check_ham_term_grad(ComplexF64, L)
		for depth in 0:5
		    @test check_noisy_circuit_grad(L, depth)
		    @test check_noisy_circuit_expec_grad(L, depth)
		end	    
	end
end","Julia"
"Conjugate","guochu/VQC.jl","test/check_ham_expec_diff.jl",".jl","2292","78","
function check_ham_term_grad(::Type{T}, L) where T
	state = rand_state(T, L)

	m = QubitsTerm(1=>""+"", L-1=>""Y"", coeff=0.36)
	loss(x) = abs(expectation(m, x))
	loss_fd(θs) = loss(StateVector(θs))

	grad1 = storage(gradient(loss, state)[1])
	grad2 = fdm_gradient(loss_fd, amplitudes(state))
	return maximum(abs.(grad1 - grad2)) < 1.0e-6
end

function check_ham_expec_grad(::Type{T}, L) where T
	state = rand_state(T, L)

	m = QubitsTerm(1=>""+"", L-1=>""-"", coeff=0.77) + QubitsTerm(1=>""-"", L-1=>""+"", coeff=0.77) + QubitsTerm(1=>""X"", L=>""Y"", coeff=0.36)
	loss(x) = abs(expectation(m, x))
	loss_fd(θs) = loss(StateVector(θs))

	grad1 = storage(gradient(loss, state)[1])
	grad2 = fdm_gradient(loss_fd, amplitudes(state))
	return maximum(abs.(grad1 - grad2)) < 1.0e-6
end

function check_qterm_expec_grad_long(::Type{T}, L, n) where T
	state = rand_state(T, L)

	m = QubitsTerm(Dict(i=>""X"" for i in 1:n), coeff=0.77)
	loss(x) = abs(expectation(m, x))
	loss_fd(θs) = loss(StateVector(θs))

	grad1 = storage(gradient(loss, state)[1])
	grad2 = fdm_gradient(loss_fd, amplitudes(state))
	return maximum(abs.(grad1 - grad2)) < 1.0e-6
end

function check_ham_expec_grad_long(::Type{T}, L, n) where T
	state = rand_state(T, L)

	m = QubitsTerm(Dict(i=>""X"" for i in 1:n), coeff=0.77) + QubitsTerm(1=>""X"", coeff=1.2) + QubitsTerm(1=>""X"", 2=>""Z"", coeff=0.3)
	loss(x) = abs(expectation(m, x))
	loss_fd(θs) = loss(StateVector(θs))

	grad1 = storage(gradient(loss, state)[1])
	grad2 = fdm_gradient(loss_fd, amplitudes(state))
	return maximum(abs.(grad1 - grad2)) < 1.0e-6
end

function check_mps_ham_expec_grad(::Type{T}, L::Int) where {T<:Number}
	observer = QubitsTerm(1=>""Z"", 3=>""Z"")
	loss(v) = real(expectation(observer, qubit_encoding(T, v)))

	v = randn(L)

	grad1 = gradient(loss, v)[1]
	grad2 = fdm_gradient(loss, v)
	return maximum(abs.(grad1 - grad2)) < 1.0e-6	
end


@testset ""gradient of quantum operator expectation value"" begin
	for L in 3:6
		@test check_ham_term_grad(ComplexF64, L)
		@test check_ham_expec_grad(ComplexF64, L)
		for n in 1:L
		    @test check_qterm_expec_grad_long(ComplexF64, L, n)
		    @test check_ham_expec_grad_long(ComplexF64, L, n)
		end
	end
    for T in [Float64, ComplexF64]
    	for L in 3:6
			@test check_mps_ham_expec_grad(ComplexF64, L)
		end 
    end
end

","Julia"
"Conjugate","guochu/VQC.jl","test/util.jl",".jl","2855","110","

using FiniteDifferences


fdm_gradient(f, v; kwargs...) = error(""fdm_gradient not implemented for type $(typeof(v))"")

fdm_gradient(f, v::Real; order::Int=5, kwargs...) = central_fdm(order, 1; kwargs...)(f, v)
fdm_gradient(f, v::Complex; order::Int=5, kwargs...) = begin
    f_real(vr::Real) = f(complex(vr, imag(v)))
    f_imag(vi::Real) = f(complex(real(v), vi))
    m = central_fdm(order, 1; kwargs...)
    da = m(f_real, real(v))
    db = m(f_imag, imag(v))
    return complex(da, db)
end

fdm_gradient(f, v::AbstractArray; kwargs...) = begin
    # x = copy(v)
    tmp = copy(v)
    r = similar(v)
    for l in 1:length(v)
        g(s) = begin
            tmp[l] = s
            d = f(tmp)
            tmp[l] = v[l]
            return d
        end
        r[l] = fdm_gradient(g, v[l]; kwargs...)
        # tmp[l] = v[l]
    end
    return r
end


function fdm_gradient(f, args...; kwargs...)
    r = []
    v0 = f(args...)
    # args = [args...]
    L = length(args)
    for l in 1:L
        g(x) = f(args[1:(l-1)]..., x, args[(l+1):L]...)
        push!(r, fdm_gradient(g, args[l]; kwargs...))
    end
    return (r...,)
end

# collect_variables_impl!(a::Vector, b::Nothing) = nothing
# collect_variables_impl!(a::Vector, b::Number) = push!(a, b)
# function collect_variables_impl!(a::Vector, b::AbstractArray) 
#     for item in b
#         collect_variables_impl!(a, item)
#     end
# end

# function collect_variables_impl!(a::Vector, b::AbstractDict)
#     for (k, v) in b
#         collect_variables_impl!(a, v)
#     end
# end

# function collect_variables_impl!(a::Vector, b::NamedTuple)
#     for v in b
#         collect_variables_impl!(a, v)
#     end
# end

# function collect_variables_impl!(a::Vector, b::Tuple)
#     for v in b
#         collect_variables_impl!(a, v)
#     end
# end

# """"""
#     collect_variables(args...)
# Collect variables from args...
# """"""
# function collect_variables(args...)
#     a = Number[]
#     for item in args
#         collect_variables_impl!(a, item)
#     end
#     return a
# end



# """"""
#     check_gradient(f, args...; verbosity::Int=0)
# Check the gradient of a function f with arguments args...
# """"""
# function check_gradient(f, args...; verbosity::Int=0)
#     grad = collect_variables(gradient(f, args...))
#     tmpargs = collect(args)
#     f2(x) = begin
#         set_parameters!(x, tmpargs)
#         return f(tmpargs...)
#     end
#     grad1 = simple_gradient(f2, collect_variables(tmpargs), dt=dt)[1]

#     diffmax = maximum(abs.(grad - grad1))
#     v = diffmax <= atol
#     if (!v) && (verbosity > 0)
#         println(""largest difference is $diffmax."")
#         println(""auto gradient is $grad."")
#         println(""---------------------------------------------------------------------"")
#         println(""finite difference gradient is $grad1"")
#     end
#     return v
# end","Julia"
"Conjugate","guochu/VQC.jl","test/crxgategrad.jl",".jl","3816","150","

function crx_circuit(L::Int, depth::Int)
	n = 0
	circuit = QCircuit()
	for d in 1:depth
	   	for i in 1:L-1
	   		push!(circuit, CNOTGate((i, i+1)))
	   		push!(circuit, CRxGate((i, i+1), randn(), isparas=true))
	   		push!(circuit, CNOTGate((i, i+1)))
	   		n += 1
		end 
	end
	return circuit, n
end

""""""
	circuit gradient with dot loss function
""""""
function crx_circuit_grad_dot_real(L::Int, depth::Int)
	target_state = rand_state(ComplexF64, L)
	initial_state = StateVector(ComplexF64, L)
	circuit, n =  crx_circuit(L, depth)

	loss(x) = real(dot(target_state, x * initial_state))
	loss_fd(θs) = begin
		reset_parameters!(circuit, θs)
		return loss(circuit)
	end

	grad1 = gradient(loss, circuit)[1]
	grad2 = fdm_gradient(loss_fd, active_parameters(circuit))

	return nparameters(circuit)==n && maximum(abs.(grad1 - grad2)) < 1.0e-6
end


function gfsim1_circuit(L::Int, depth::Int)
	circuit = QCircuit()
	for i in 1:L
	    push!(circuit, HGate(i))
	end
	for d in 1:depth
	   	for i in 1:L-1
	   		push!(circuit, CNOTGate((i, i+1)))
	   		push!(circuit, FSIMGate((i, i+1), randn(5), isparas=[true, false, false, false, false]))
	   		push!(circuit, CNOTGate((i, i+1)))
		end 
	end
	return circuit
end

function gfsim2_circuit(L::Int, depth::Int)
	circuit = QCircuit()
	for i in 1:L
	    push!(circuit, HGate(i))
	end
	for d in 1:depth
	   	for i in 1:L-1
	   		push!(circuit, CNOTGate((i, i+1)))
	   		push!(circuit, FSIMGate((i, i+1), randn(5), isparas=[true, true, false, false, false]))
	   		push!(circuit, CNOTGate((i, i+1)))
		end 
	end
	return circuit
end

function gfsim5_circuit(L::Int, depth::Int)
	circuit = QCircuit()
	for i in 1:L
	    push!(circuit, HGate(i))
	end
	for d in 1:depth
	   	for i in 1:L-1
	   		push!(circuit, CNOTGate((i, i+1)))
	   		push!(circuit, FSIMGate((i, i+1), randn(5), isparas=[true, true, true, true, true]))
	   		push!(circuit, CNOTGate((i, i+1)))
		end 
	end
	return circuit
end

function bf_circuit_gfims1_grad_dot_abs(L::Int, depth::Int)
	target_state = rand_state(ComplexF64, L)
	initial_state = StateVector(ComplexF64, L)
	circuit =  gfsim1_circuit(L, depth)

	loss(x) = abs(dot(target_state, x * initial_state))
	loss_fd(θs) = begin
		reset_parameters!(circuit, θs)
		return loss(circuit)
	end

	grad1 = gradient(loss, circuit)[1]
	grad2 = fdm_gradient(loss_fd, active_parameters(circuit))
	return maximum(abs.(grad1 - grad2)) < 1.0e-6
end

function bf_circuit_gfims2_grad_dot_abs(L::Int, depth::Int)
	target_state = rand_state(ComplexF64, L)
	initial_state = StateVector(ComplexF64, L)
	circuit =  gfsim2_circuit(L, depth)

	loss(x) = abs(dot(target_state, x * initial_state))
	loss_fd(θs) = begin
		reset_parameters!(circuit, θs)
		return loss(circuit)
	end

	grad1 = gradient(loss, circuit)[1]
	grad2 = fdm_gradient(loss_fd, active_parameters(circuit))
	return maximum(abs.(grad1 - grad2)) < 1.0e-6
end

function bf_circuit_gfims5_grad_dot_abs(L::Int, depth::Int)
	target_state = rand_state(ComplexF64, L)
	initial_state = StateVector(ComplexF64, L)
	circuit =  gfsim5_circuit(L, depth)

	loss(x) = abs(dot(target_state, x * initial_state))
	loss_fd(θs) = begin
		reset_parameters!(circuit, θs)
		return loss(circuit)
	end

	grad1 = gradient(loss, circuit)[1]
	grad2 = fdm_gradient(loss_fd, active_parameters(circuit))
	return maximum(abs.(grad1 - grad2)) < 1.0e-6
end


@testset ""gradient of variable quantum circuit with parameterized controled rotational gate"" begin
	for L in 2:5
		for depth in 1:5
		    @test crx_circuit_grad_dot_real(L, depth)
		end	    
	end
end

@testset ""gradient of brute force quantum circuit with FSIM gate"" begin
	for L in 2:5
		for depth in 1:3
		    @test bf_circuit_gfims1_grad_dot_abs(L, depth)
		    @test bf_circuit_gfims2_grad_dot_abs(L, depth)
		    @test bf_circuit_gfims5_grad_dot_abs(L, depth)
		end
	end
end

","Julia"
"Conjugate","guochu/VQC.jl","test/check_dm.jl",".jl","1038","61","


function check_dm_expec_1() 
	psi = rand_state(ComplexF64, 7)
	rho = DensityMatrix(psi)

	h = QubitsTerm(1=>""X"")

	a1 = expectation(h, psi)
	a2 = expectation(h, rho)

	return abs(a1 - a2) < 1.0e-6
end

function check_dm_expec_2() 
	psi = rand_state(ComplexF64, 7)
	rho = DensityMatrix(psi)

	h = QubitsTerm(1=>""X"", 2=>""+"")

	a1 = expectation(h, psi)
	a2 = expectation(h, rho)

	return abs(a1 - a2) < 1.0e-6
end


function check_dm_expec_3() 
	psi = rand_state(ComplexF64, 7)
	rho = DensityMatrix(psi)

	h = QubitsTerm(1=>""X"", 2=>""+"", 4=>""-"")

	a1 = expectation(h, psi)
	a2 = expectation(h, rho)

	return abs(a1 - a2) < 1.0e-6
end

function check_dm_expec_4() 
	psi = rand_state(ComplexF64, 8)
	rho = DensityMatrix(psi)

	h = QubitsTerm(1=>""X"", 2=>""+"", 4=>""-"", 8=>""Z"")

	a1 = expectation(h, psi)
	a2 = expectation(h, rho)

	return abs(a1 - a2) < 1.0e-6
end


@testset ""check density matrix expectation value"" begin
    @test check_dm_expec_1()
    @test check_dm_expec_2()
    @test check_dm_expec_3()
    @test check_dm_expec_4()

end
","Julia"
"Conjugate","guochu/VQC.jl","test/check_qubits_ham.jl",".jl","8612","265","

function check_qham_onebody_single(::Type{T}, L::Int, j::Int) where T
    state1 = rand_state(T, L)
    m = random_unitary(1)
    gate1 = QuantumGate(j, m)
    h = QubitsOperator(QubitsTerm(j=>m))
    state2 = h * state1
    apply!(gate1, state1)
    return maximum(abs.(storage(state1 - state2)) )
end

function check_qham_onebody(::Type{T}, L::Int) where {T<:Number}
    errs = []
    for c in 1:L
        push!(errs, check_qham_onebody_single(T, L, c))
    end
    # println(""total number of tests $(length(errs))."")
    return all(errs .< 1.0e-6)
end

function check_qham_twobody_single(::Type{T}, L::Int, j::Int, k::Int) where T
    state1 = rand_state(T, L)
    m1 = random_unitary(1)
    m2 = random_unitary(1)
    gate1 = QuantumGate((j, k), kron(m1, m2))
    h = QubitsOperator(QubitsTerm(j=>m2, k=>m1))
    state2 = h * state1
    apply!(gate1, state1)
    return maximum(abs.(storage(state1 - state2)) )
end

function check_qham_twobody(::Type{T}, L::Int) where {T<:Number}
    errs = []
    for c in 1:2:L
        for t in 2:2:L
            if c != t
                push!(errs, check_qham_twobody_single(T, L, c, t))
            end
        end
    end
    # println(""total number of tests $(length(errs))."")
    return all(errs .< 1.0e-6)
end

function check_qham_threebody_single(::Type{T}, L::Int, a::Int, b::Int, c::Int) where {T<:Number}
    state1 = rand_state(T, L)
    m1 = random_unitary(1)
    m2 = random_unitary(1)
    m3 = random_unitary(1)
    gate1 = QuantumGate((a, b, c), kron(m1, m2, m3))
    h = QubitsOperator(QubitsTerm(a=>m3, b=>m2, c=>m1))
    state2 = h * state1
    apply!(gate1, state1)
   	return maximum(abs.(storage(state1 - state2)) )
end

function check_qham_threebody(::Type{T}, L::Int) where {T<:Number}
    errs = []
    for a in 1:2:L
        for b in 2:3:L
            for c in 3:5:L
                if a != b && a != c && b != c
                    push!(errs, check_qham_threebody_single(T, L, a, b, c))
                end
            end
        end
    end
    # println(""total number of tests $(length(errs))."")
    return all(errs .< 1.0e-6)
end

function check_term_matrix(L::Int)
    state = rand_state(ComplexF64, L)
    m = QubitsTerm(1=>""+"", L-1=>""-"", coeff=0.77)
    return maximum(abs.(storage(m * state - matrix(L, m) * state))) < 1.0e-6
end

function check_ham_matrix(L::Int)
    state = rand_state(ComplexF64, L)
    m = QubitsTerm(1=>""+"", L-1=>""-"", coeff=0.77) + QubitsTerm(1=>""-"", L-1=>""+"", coeff=0.77) + QubitsTerm(1=>""X"", L=>""Y"", coeff=0.36)
    return maximum(abs.(storage(m * state - matrix(L, m) * state))) < 1.0e-6
end

function check_term_expec(L::Int)
    state = rand_state(ComplexF64, L)
    m = QubitsTerm(1=>""+"", L-1=>""-"", coeff=0.77)
    return abs(expectation(m, state) - expectation(matrix(L, m), state)) < 1.0e-6
end

function check_ham_expec(L::Int)
    state = rand_state(ComplexF64, L)
    m = QubitsTerm(1=>""+"", 2=>""-"", coeff=0.77) + QubitsTerm(1=>""-"", 2=>""+"", coeff=0.77) + QubitsTerm(1=>""X"", L-1=>""Y"", coeff=0.36)
    return abs(expectation(m, state) - expectation(matrix(L, m), state)) < 1.0e-6
end

function check_ham_expec_long(L::Int, n::Int)
    state = rand_state(ComplexF64, L)
    m = QubitsTerm(Dict(i=>""X"" for i in 1:n), coeff=0.77) + QubitsTerm(1=>""X"", coeff=1.2) + QubitsTerm(1=>""X"", 2=>""Z"", coeff=0.3)
    return abs(expectation(m, state) - expectation(matrix(L, m), state)) < 1.0e-6
end

function check_expec_onebody_single(::Type{T}, L::Int, j::Int) where T
    state = rand_state(T, L)
    m = QubitsTerm(j=>random_unitary(1))

    return abs(expectation(m, state) - expectation(matrix(L, m), state))
end

function check_expec_onebody(::Type{T}, L::Int) where {T<:Number}
    errs = []
    for c in 1:L
        push!(errs, check_expec_onebody_single(T, L, c))
    end
    return all(errs .< 1.0e-6)
end

function check_expec_twobody_single(::Type{T}, L::Int, j::Int, k::Int) where T
    state = rand_state(T, L)
    m = QubitsTerm(j=>random_unitary(1), k=>random_unitary(1), coeff=0.73)

    return abs(expectation(m, state) - expectation(matrix(L, m), state))
end

function check_expec_twobody(::Type{T}, L::Int) where {T<:Number}
    errs = []
    for c in 1:2:L
        for t in 2:2:L
            if c != t
                push!(errs, check_expec_twobody_single(T, L, c, t))
            end
        end
    end
    # println(""total number of tests $(length(errs))."")
    return all(errs .< 1.0e-6)
end

function check_expec_threebody_single(::Type{T}, L::Int, j::Int, k::Int, l::Int) where T
    state = rand_state(T, L)
    m = QubitsTerm(j=>random_unitary(1), k=>random_unitary(1), l=>random_unitary(1), coeff=0.9)

    return abs(expectation(m, state) - expectation(matrix(L, m), state))
end

function check_expec_threebody(::Type{T}, L::Int) where {T<:Number}
    errs = []
    for a in 1:L
        for b in 1:L
            for c in 1:L
                if a != b && a != c && b != c
                    push!(errs, check_expec_threebody_single(T, L, a, b, c))
                end
            end
        end
    end
    # println(""total number of tests $(length(errs))."")
    return all(errs .< 1.0e-6)
end

function check_expec_onebody_single_2(::Type{T}, L::Int, j::Int) where T
    state1 = rand_state(T, L)
    state2 = rand_state(T, L)
    m = QubitsTerm(j=>random_unitary(1))

    return abs(expectation(state2, m, state1) - expectation(state2, matrix(L, m), state1))
end

function check_expec_onebody_2(::Type{T}, L::Int) where {T<:Number}
    errs = []
    for c in 1:L
        push!(errs, check_expec_onebody_single_2(T, L, c))
    end
    return all(errs .< 1.0e-6)
end

function check_expec_twobody_single_2(::Type{T}, L::Int, j::Int, k::Int) where T
    state1 = rand_state(T, L)
    state2 = rand_state(T, L)
    m = QubitsTerm(j=>random_unitary(1), k=>random_unitary(1), coeff=0.73)

    return abs(expectation(state2, m, state1) - expectation(state2, matrix(L, m), state1))
end

function check_expec_twobody_2(::Type{T}, L::Int) where {T<:Number}
    errs = []
    for c in 1:2:L
        for t in 2:2:L
            if c != t
                push!(errs, check_expec_twobody_single_2(T, L, c, t))
            end
        end
    end
    # println(""total number of tests $(length(errs))."")
    return all(errs .< 1.0e-6)
end

function check_expec_threebody_single_2(::Type{T}, L::Int, j::Int, k::Int, l::Int) where T
    state1 = rand_state(T, L)
    state2 = rand_state(T, L)
    m = QubitsTerm(j=>random_unitary(1), k=>random_unitary(1), l=>random_unitary(1), coeff=0.9)

    return abs(expectation(state2, m, state1) - expectation(state2, matrix(L, m), state1))
end

function check_expec_threebody_2(::Type{T}, L::Int) where {T<:Number}
    errs = []
    for a in 1:L
        for b in 1:L
            for c in 1:L
                if a != b && a != c && b != c
                    push!(errs, check_expec_threebody_single_2(T, L, a, b, c))
                end
            end
        end
    end
    # println(""total number of tests $(length(errs))."")
    return all(errs .< 1.0e-6)
end

@testset ""check hamiltonion term expectation value"" begin
    @test check_term_matrix(16)
    @test check_term_matrix(15)
    @test check_ham_matrix(6)
    @test check_ham_matrix(3)
    @test check_term_expec(16)
    @test check_term_expec(15)
    @test check_ham_expec(6)
    @test check_ham_expec(3)
    @test check_ham_expec_long(6, 5)
    @test check_ham_expec_long(6, 6)
    @test check_ham_expec_long(8, 8)
end

@testset ""check generic hamiltonion term operations"" begin
    @test check_qham_onebody(ComplexF32, 16)
    @test check_qham_onebody(ComplexF64, 15)
    for L in 5:10:15
        @test check_qham_twobody(ComplexF32, L)
        @test check_qham_twobody(ComplexF64, L)
    end
    @test check_qham_threebody(ComplexF32, 16)
    @test check_qham_threebody(ComplexF64, 15)

    @test (check_qham_onebody_single(ComplexF64, 2,2) < 1.0e-6)
    @test (check_qham_onebody_single(ComplexF64, 4,2) < 1.0e-6)
    @test (check_qham_twobody_single(ComplexF64, 2,2,1) < 1.0e-6)
    @test (check_qham_twobody_single(ComplexF64, 3,1,3) < 1.0e-6)
    @test (check_qham_threebody_single(ComplexF64, 3, 3,1,2) < 1.0e-6)
    @test (check_qham_threebody_single(ComplexF64, 4, 3,4,1) < 1.0e-6)
end


@testset ""check generic hamiltonion expectation value"" begin
    for L in 5:10:15
        @test check_expec_onebody(ComplexF64, L)
        @test check_expec_twobody(ComplexF64, L)
        @test check_expec_threebody(ComplexF64, L)

        @test check_expec_onebody_2(ComplexF64, L)
        @test check_expec_twobody_2(ComplexF64, L)
        @test check_expec_threebody_2(ComplexF64, L)
    end
end

","Julia"
"Conjugate","guochu/VQC.jl","test/circuitgrad.jl",".jl","3423","130","


""""""
	circuit gradient with dot loss function
""""""
function circuit_grad_dot_real(L::Int, depth::Int)
	target_state = rand_state(ComplexF64, L)
	initial_state = StateVector(ComplexF64, L)
	circuit =  variational_circuit_1d(L, depth)

	loss(x) = real(dot(target_state, x * initial_state))
	loss_fd(θs) = loss(variational_circuit_1d(L, depth, θs=θs))

	grad1 = gradient(loss, circuit)[1]
	grad2 = fdm_gradient(loss_fd, active_parameters(circuit))
	return maximum(abs.(grad1 - grad2)) < 1.0e-6
end


""""""
	circuit gradient with dot loss function
""""""
function circuit_grad_dot_imag(L::Int, depth::Int)
	target_state = rand_state(ComplexF64, L)
	initial_state = StateVector(ComplexF64, L)
	circuit =  variational_circuit_1d(L, depth)

	loss(x) = imag(dot(target_state, x * initial_state))
	loss_fd(θs) = loss(variational_circuit_1d(L, depth, θs=θs))

	grad1 = gradient(loss, circuit)[1]
	grad2 = fdm_gradient(loss_fd, active_parameters(circuit))
	return maximum(abs.(grad1 - grad2)) < 1.0e-6
end

""""""
	circuit gradient with dot loss function
""""""
function circuit_grad_dot_abs(L::Int, depth::Int)
	target_state = rand_state(ComplexF64, L)
	initial_state = StateVector(ComplexF64, L)
	circuit =  variational_circuit_1d(L, depth)

	loss(x) = abs(dot(target_state, x * initial_state))
	loss_fd(θs) = loss(variational_circuit_1d(L, depth, θs=θs))

	grad1 = gradient(loss, circuit)[1]
	grad2 = fdm_gradient(loss_fd, active_parameters(circuit))
	return maximum(abs.(grad1 - grad2)) < 1.0e-6
end

""""""
	circuit gradient with dot loss function
""""""
function circuit_grad_dot_abs2(L::Int, depth::Int)
	target_state = rand_state(ComplexF64, L)
	initial_state = StateVector(ComplexF64, L)
	circuit =  variational_circuit_1d(L, depth)

	loss(x) = abs2(dot(target_state, x * initial_state))
	loss_fd(θs) = loss(variational_circuit_1d(L, depth, θs=θs))

	grad1 = gradient(loss, circuit)[1]
	grad2 = fdm_gradient(loss_fd, active_parameters(circuit))
	return maximum(abs.(grad1 - grad2)) < 1.0e-6
end


""""""
	circuit gradient with distance loss function
""""""
function circuit_grad_distance(L::Int, depth::Int)
	target_state = rand_state(ComplexF64, L)
	initial_state = StateVector(ComplexF64, L)
	circuit =  variational_circuit_1d(L, depth)

	loss(x) = distance(target_state, x * initial_state)
	loss_fd(θs) = loss(variational_circuit_1d(L, depth, θs=θs))

	grad1 = gradient(loss, circuit)[1]
	grad2 = fdm_gradient(loss_fd, active_parameters(circuit))
	return maximum(abs.(grad1 - grad2)) < 1.0e-6
end


@testset ""gradient of quantum circuit with loss function real(dot(x, circuit*y))"" begin
	for L in 2:5
		for depth in 0:5
		    @test circuit_grad_dot_real(L, depth)
		end	    
	end
end

@testset ""gradient of quantum circuit with loss function imag(dot(x, circuit*y))"" begin
	for L in 2:5
		for depth in 0:5
		    @test circuit_grad_dot_imag(L, depth)
		end	    
	end
end

@testset ""gradient of quantum circuit with loss function abs(dot(x, circuit*y))"" begin
	for L in 2:5
		for depth in 0:5
		    @test circuit_grad_dot_abs(L, depth)
		end	    
	end
end


@testset ""gradient of quantum circuit with loss function abs2(dot(x, circuit*y))"" begin
	for L in 2:5
		for depth in 0:5
		    @test circuit_grad_dot_abs2(L, depth)
		end	    
	end
end


@testset ""gradient of quantum circuit with loss function distance(x, circuit*y)"" begin
	for L in 2:5
		for depth in 0:5
		    @test circuit_grad_distance(L, depth)
		end	    
	end
end


","Julia"
"Conjugate","guochu/VQC.jl","docs/make.jl",".jl","294","17","push!(LOAD_PATH, ""../src"")

using Documenter
using VQC

makedocs(
	sitename=""VQC.jl"",
	authors = ""Guo Chu"",
	pages=[""Home"" => ""index.md"",
	""gettingstarted.md"",
	""variational.md"",
	""ham.md"",
	""qctrl.md""],
	format = Documenter.HTML(
        prettyurls = get(ENV, ""CI"", nothing) == ""true""
    )
	)","Julia"
"Conjugate","guochu/VQC.jl","docs/src/variational.md",".md","2007","80","# Variational Quantum Circuit

In this section we will provide a simple pipeline to demonstrate how to
use VQC to build variational quantum circuits


## Creating a variational quantum circuit
```@example
push!(LOAD_PATH, ""../../src"")
using VQC
L = 3
depth = 2
circuit = QCircuit()
for i in 1:L
	push!(circuit, RzGate(i, Variable(rand())))
	push!(circuit, RyGate(i, Variable(rand())))
	push!(circuit, RzGate(i, Variable(rand())))
end
for l in 1:depth
	for i in 1:L-1
		push!(circuit, CNOTGate((i, i+1)))
	end
	for i in 1:L
		push!(circuit, RzGate(i, Variable(rand())))
		push!(circuit, RyGate(i, Variable(rand())))
		push!(circuit, RzGate(i, Variable(rand())))
	end
end	
# all the parameters of the circuit
paras = parameters(circuit)

# reset all the parameters of the circuit
new_paras = zeros(length(paras))
set_parameters!(new_paras, circuit)
paras = parameters(circuit)

# compute the gradient
using Zygote
target_state = qrandn(L)
initial_state = qstate(L)
loss(c) = distance(target_state, c * initial_state)
grad = gradient(loss, circuit)
```
The above definition has been predefined by the function variational_circuit
```@docs
variational_circuit(L::Int, depth::Int, g::Function=rand)
```

## A simple application of VQC and Flux
```@example
using VQC
using Zygote
using Flux.Optimise

circuit = variational_circuit(3, 2)
target_state = (sqrt(2)/2) *  (qstate([1,1,1]) + qstate([0,0,0]))
initial_state = qstate([0,0,0])
loss(c) = distance(target_state, c * initial_state)

opt = ADAM()
epoches = 10
x0 = parameters(circuit)
for i in 1:epoches
	grad = collect_variables(gradient(loss, circuit))
	Optimise.update!(opt, x0, grad)
	set_parameters!(x0, circuit)
	println(""loss value at $i-th iteration is $(loss(circuit))."")
end
```

## Some utility functions
```@docs
collect_variables(args...)
parameters(args...)
set_parameters!(coeff::AbstractVector{<:Number}, args...)
simple_gradient(f, args...; dt::Real=1.0e-6)
check_gradient(f, args...; dt::Real=1.0e-6, atol::Real=1.0e-4, verbose::Int=0)
```

","Markdown"
"Conjugate","guochu/VQC.jl","docs/src/qctrl.md",".md","645","35","# Quantum Control



VQC support variational hamiltonian evolutions.

```@docs
ctrlham(a::AbstractMatrix, b::Vector{<:AbstractMatrix}, nparas::Int)
```

The variational hamiltonian object can be used in the same way as a variational quantum circuit
```@example
push!(LOAD_PATH, ""../../src"")
using VQC
using Zygote

random_hermitian(n) = begin
	a = randn(n, n)
	return a + a'
end

H0 = random_hermitian(2)
H1 = [random_hermitian(2) for i in 1:2] 
h = ctrlham(H0, H1, 5)

initial_state = [1, 0]
target_state = randn(2)

loss(c) = distance(target_state, c * initial_state)

grad = gradient(loss, h)

# Check the gradient
check_gradient(loss, h)
```","Markdown"
"Conjugate","guochu/VQC.jl","docs/src/index.md",".md","1780","87","

Variational quantum circuit simulator in julia

# VQC.jl's documentation

VQC is a julia library for variational quantum circuit simulations. VQC 
aims to supprot automatic differentiation and allow users to easily build 
hybrid quantum-classical algorithms. Current VQC also has a basic support 
for variational Hamiltonian simulation.

A simple code snippet to create a two-qubit bell state
```@example
push!(LOAD_PATH, ""../../src"")
using VQC

state = qstate(2)
circuit = QCircuit()
push!(circuit, (1, H))
push!(circuit, ((1, 2), CNOT))

apply!(circuit, state)
amplitudes(state)

# Perform quantum measurement
i, prob = measure!(state, 1)
println(""probability of the 1-th qubit in state $i is $prob."")

# Obtain a particular amplitude
p = amplitude(state, [0, 1])
```

Build a variational quantum circuit is as simple as a normal quantum state
```@example
using VQC
using Zygote
L = 3
state = qstate(L)
circuit = QCircuit()
for i in 1:L
	push!(circuit, RzGate(i, Variable(rand())))
	push!(circuit, RyGate(i, Variable(rand())))
	push!(circuit, RzGate(i, Variable(rand())))
end

for depth in 1:2
	for i in 1:L-1
		push!(circuit, CNOTGate((i, i+1)))
	end
	for i in 1:L
		push!(circuit, RzGate(i, Variable(rand())))
		push!(circuit, RxGate(i, Variable(rand())))
		push!(circuit, RzGate(i, Variable(rand())))
	end
end

# Create a random quantum state of 3 qubits
target_state = qrandn(L)
loss(c) = distance(target_state, c * state)
v = loss(circuit)
grad = gradient(loss, circuit)
check_gradient(loss, circuit)
```


Start to use Meteor.jl from ""Getting Started"" section.

```@contents
Pages = [""gettingstarted.md""]
Depth = 2
```

```@contents
Pages = [""variational.md""]
Depth = 2
```

```@contents
Pages = [""ham.md""]
Depth = 2
```

```@contents
Pages = [""qctrl.md""]
Depth = 2
```
","Markdown"
"Conjugate","guochu/VQC.jl","docs/src/ham.md",".md","683","30","# Hamiltonian


VQC also has preliminary suport for hamiltonian evolution.

## A simple hamiltonian simulation
```@example
push!(LOAD_PATH, ""../../src"")
using VQC
ps = spin_half()
pb = boson(d=4)
ham = Hamiltonian([ps, pb])

add!(ham, (1,2), (""sp"", ""a""), coeff=1)
add!(ham, (1,2), (""sm"", ""adag""), coeff=1)
add!(ham, (1,), (""sz"",), coeff=0.5)
add!(ham, (2,), (""n"",), coeff=2)

state = kron(spin_half_state(0), fock_state(4, 2))

# unitary evolution
state = apply(ham, 0.5, state)

# Create an observer
observer = Observers(ham)
add!(observer, (1,), (""sz"",), name=""z"")
add!(observer, (2,), (""n"",), name=""n"")
add!(observer, (1,2), (""sp"", ""a""), name=""j"")
obs = apply(observer, state)
```","Markdown"
"Conjugate","guochu/VQC.jl","docs/src/gettingstarted.md",".md","2585","109","# Getting Started

In this section we will provide a simple pipeline to demonstrate how to
use VQC to build quantum computing applications


Pipeline for quantum circuit simulation

## Initialize a quantum state
Definition of function qstate
```@docs
qstate(::Type{T}, thetas::AbstractVector{<:Real}) where {T <: Number}
qstate(thetas::AbstractVector{<:Real})
qstate(::Type{T}, n::Int) where {T <: Number}
qstate(n::Int) 
```
Extract amplitudes from quantum state
```@docs
amplitude(s::AbstractVector, i::AbstractVector{Int}) 
amplitudes(s::AbstractVector)
```


Examples
```@example
push!(LOAD_PATH, ""../../src"")
using VQC
state = qstate(2)
state = qstate([1, 0])
state = qstate([0.5, 0.7])
```


## Quantum gate
Predefined elementary gates ""X, Y, Z, S, H, sqrtX, sqrtY, T, Rx, Ry, Rz, CONTROL, CZ, CNOT, CX, SWAP, iSWAP, XGate, YGate, ZGate, HGate, SGate, TGate, SqrtXGate, SqrtYGate, RxGate, RyGate, RzGate, CZGate, CNOTGate, SWAPGate, iSWAPGate, CRxGate, CRyGate, CRzGate, TOFFOLIGate""

```@example
using VQC

circuit = QCircuit()

# standard one-qubit gate
push!(circuit, (1, H))
empty!(circuit)
push!(circuit, HGate(1))
empty!(circuit)
push!(circuit, gate(1, H))
empty!(circuit)
# standard two-qubit gate
push!(circuit, ((1, 2), CZ))
empty!(circuit)
push!(circuit, CZGate((1, 2)))
empty!(circuit)
push!(circuit, gate((1,2), CZ))
empty!(circuit)
# a parameteric one-qubit gate
push!(circuit, RxGate(1, Variable(0.5)))
empty!(circuit)
# a parameteric two-qubit gate
push!(circuit, CRxGate((1,2), Variable(0.5)))
empty!(circuit)
# This will create a non-parameteric gate instead
push!(circuit, RxGate(1, 0.5))
```

## Quantum circuit
Adding new gates
```@docs
add!(x::AbstractCircuit, s)
Base.push!(x::AbstractCircuit, s::AbstractGate)
Base.append!(x::AbstractCircuit, y::AbstractCircuit)
Base.append!(x::AbstractCircuit, y::Vector{T}) where {T<:AbstractGate}
```

Circuit manipulations
```@example
using VQC
circuit = QCircuit()
push!(circuit, (1, H))
push!(circuit, ((1, 2), CZ))
c1 = transpose(circuit)
c2 = conj(circuit)
c3 = circuit'
```

## Apply quantum circuit to state
```@docs
apply!(circuit::AbstractCircuit, v::Vector)
*(circuit::AbstractCircuit, v::AbstractVector)
*(v::AbstractVector, circuit::AbstractCircuit)
```

## Quantum measurement
Measure and collapse a quantum state
```@docs
measure(qstate::AbstractVector, pos::Int)
measure!(qstate::AbstractVector, pos::Int; auto_reset::Bool=true)
```

Postselection
```@docs
post_select!(qstate::AbstractVector, key::Int, state::Int=0)
post_select(qstate::AbstractVector, key::Int, state::Int=0; keep::Bool=false)
```




","Markdown"