'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)

    qc.h(0)
    qc.ch(0, 1)
    qc.x(0)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    qc.h(0)
    qc.h(1)
    qc.cx(0,1)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:

    qc.h(0)
    qc.ch(0,1)
    qc.cx(1,0)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.cx(0,1)
    qc.x(0)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.h(1)
    qc.cx(0, 1)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:

    qc.h(0)
    qc.cx(0, 1)
    qc.x(0)
    qc.h(0)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc2 = QuantumCircuit(1)

    qc.h(0)
    qc.x(1)
    qc2.toffoli(qc[0], qc[1], qc2[0])
    qc.cx(qc2[0], qc[1])
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:

    qc.h(0)
    qc.x(0)
    qc.ch(0, 1)
    qc.x(0)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def setting():
    from qiskit_ibm_runtime import QiskitRuntimeService
    import os
    from dotenv import load_dotenv
    load_dotenv()
    TOKEN = os.getenv('qiskit_token')
    QiskitRuntimeService.save_account(channel="ibm_quantum", token=TOKEN, overwrite=True)

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    qc.h(0)
    qc.cx(0, 1)
    return qc

def draw_circuit(qc):
    qc.measure_all()
    qc.draw('mpl')
def simulate(qc):
    from qiskit.providers.basic_provider import BasicSimulator
    from qiskit.visualization import plot_histogram
    backend = BasicSimulator()
    result = backend.run(qc, shots=2000).result()
    counts = result.get_counts()
    plot_histogram(counts)

def debug(qc):
    draw_circuit(qc)
    simulate(qc)
def main():
    debug(solve())
if __name__ == "__main__":
    main()
'''


'''python
from qiskit import QuantumCircuit
from qiskit.quantum_info import Statevector

# def setting():
#     from qiskit_ibm_runtime import QiskitRuntimeService
#     import os
#     from dotenv import load_dotenv
#     load_dotenv()
#     TOKEN = os.getenv('qiskit_token')
#     QiskitRuntimeService.save_account(channel="ibm_quantum", token=TOKEN, overwrite=True)

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    qc.h(1)
    qc.cx(1, 0)
    qc.cx(0, 1)
    return qc

# def draw_circuit(qc):
#     qc.measure_all()
#     qc.draw('mpl')
# def simulate(qc):
#     from qiskit.providers.basic_provider import BasicSimulator
#     from qiskit.visualization import plot_histogram
#     backend = BasicSimulator()
#     result = backend.run(qc, shots=2000).result()
#     counts = result.get_counts()
#     plot_histogram(counts)

# def debug(qc):
#     draw_circuit(qc)
#     simulate(qc)
# def main():
#     debug(solve())
if __name__ == "__main__":
    qc = solve()
    print(Statevector(qc))
    print(qc.draw("text"))
'''


'''python
from qiskit import QuantumCircuit
from qiskit.quantum_info import Statevector

# def setting():
#     from qiskit_ibm_runtime import QiskitRuntimeService
#     import os
#     from dotenv import load_dotenv
#     load_dotenv()
#     TOKEN = os.getenv('qiskit_token')
#     QiskitRuntimeService.save_account(channel="ibm_quantum", token=TOKEN, overwrite=True)

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    qc.h(1)
    qc.cx(1, 0)
    qc.cx(0, 1)
    return qc

# def draw_circuit(qc):
#     qc.measure_all()
#     qc.draw('mpl')
# def simulate(qc):
#     from qiskit.providers.basic_provider import BasicSimulator
#     from qiskit.visualization import plot_histogram
#     backend = BasicSimulator()
#     result = backend.run(qc, shots=2000).result()
#     counts = result.get_counts()
#     plot_histogram(counts)

# def debug(qc):
#     draw_circuit(qc)
#     simulate(qc)
# def main():
#     debug(solve())
# if __name__ == "__main__":
#     qc = solve()
#     from qiskit.quantum_info import Statevector
#     print(Statevector(qc))
#     print(qc.draw("text"))
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    qc.h(1)
    qc.cx(1, 0)
    qc.cx(0, 1)
    return qc
if __name__ == "__main__":
    qc = solve()
    from qiskit.quantum_info import Statevector
    print(Statevector(qc))
    print(qc.draw("text"))
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    qc.h(1)
    qc.cx(1, 0)
    qc.cx(0, 1)
    return qc
# if __name__ == "__main__":
#     qc = solve()
#     # from qiskit.quantum_info import Statevector
#     print(Statevector(qc))
#     print(qc.draw("text"))
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    qc.h(0)
    qc.cx(0, 1)
    qc.cx(1, 0)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    qc.h(0)
    qc.ch(0, 1)
    qc.cx(1, 0)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    qc.h(0)
    qc.ch(0, 1)
    qc.ch(1, 1)
    return qc

## 00
## 0(0+1)
## 00 01
## 00+10+11
## 00+10+01
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    qc.h(0)
    qc.ch(0, 1)
    qc.cx(1, 1)
    return qc

## 00
## 0(0+1)
## 00 01
## 00+10+11
## 00+10+01
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    qc.h(0)
    qc.ch(0, 1)
    qc.cx(1, 0)
    return qc

## 00
## (0+1)0
## 00+10
## 00+1(0+1)
## 00+10+11
## 00+10+01
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.ch(0,1)
    qc.cx(1,0)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.h(1)
    qc.cx(0,1)
    qc.cx(1,0)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.x(0)
    qc.cx(0,1)
    qc.x(1)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.x(0)
    qc.ch(0,1)
    qc.x(1)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.x(0)
    qc.ch(0,1)
    qc.x(0)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.h(1)
    qc.cx(0, 1)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(1)
    qc.ch(1,0)
    qc.cx(0,1)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.ch(0,1)
    qc.cx(1,0)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.cx(0,1)
    qc.h(1)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.cx(0,1)
    qc.cx(1,1)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.cx(0,1)
    qc.cx(1,0)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.cx(1,0)
    return qc
'''


'''python
from qiskit import QuantumCircuit
import math

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.h(1)
    qc.ry(math.pi/4, 0)
    qc.ry(math.pi/4, 1)
    qc.cx(0, 1)
    qc.ry(-math.pi/4, 0)
    qc.ry(math.pi/2, 1)
    qc.x(0)
    qc.x(1)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:

    return qc
'''


'''python
from qiskit import QuantumCircuit
from math import pi

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    qc.h(0)
    qc.cry(pi/2,0,1)
    qc.cx(1,0)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.cx(0, 1)
    qc.y(0)
    return qc
'''


'''python
from qiskit import QuantumCircuit
import numpy as np

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    a0 = np.complex(1/np.sqrt(2), 1)
    a1 = np.complex(1/np.sqrt(2), 1)
    a2 = 1
    qc.initialize([a0, a1, a2, 0], [0, 1])
    return qc
'''


'''python
from qiskit import QuantumCircuit
import numpy as np

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    a0 = 1
    a1 = 1
    a2 = 1
    qc.initialize([a0, a1, a2, 0], [0, 1])
    return qc
'''


'''python
from qiskit import QuantumCircuit
import numpy as np

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    a0 = 1/np.sqrt(3)
    qc.initialize([a0, a0, a0, 0], [0, 1])
    return qc
'''


'''python
from qiskit import QuantumCircuit
import numpy as np

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.cx(0, 1)
    qc.x(1)
    qc.h(0)
    qc.z(1)
    return qc
'''


'''python
from qiskit import QuantumCircuit
import numpy as np

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.cx(0, 1)
    #qc.x(1)
    qc.h(0)
    qc.cp(-2 * np.arccos(1/np.sqrt(3)), 0, 1)
    #qc.z(1)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.h(1)
    qc.h(2)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.cx(0, 1)
    qc.cx(1, 0)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.x(0)
    qc.x(1)
    qc.cx(0, 1)
    qc.cx(1, 0)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.cx(1, 0)
    qc.cx(0, 1)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.x(0)
    qc.x(1)
    qc.cx(1, 0)
    qc.cx(0, 1)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.x(0)
    qc.x(1)
    qc.x(0)
    qc.x(1)
    qc.x(0)
    qc.x(1)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.x(0)
    qc.x(1)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h([0,1])
    qc.x([0,1])
    qc.x([0,1])
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h([0,1])
    qc.x([0,1])
    qc.y([0,1])
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h([0,1])
    qc.cx(0,1)
    qc.x([0,1])
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h([0,1])
    qc.x(0)
    qc.x([0,1])
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.y([0,1])
    qc.cx(1,0)
    qc.cx(0,1)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h([0,1])
    qc.cx(1,0)
    qc.cx(0,1)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h([0,1])
    qc.cx(0,1)
    qc.cx(1,0)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.cx(0,1)
    qc.cx(1,0)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.cx(1,0)
    qc.cx(0,1)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.i([1,0])
    qc.cx(1,0)
    qc.cx(0,1)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.i([1,0])
    qc.cx(0,1)
    qc.cx(1,0)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.cx(0,1)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.cx(1,0)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.x([0,1])
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.i([0,1])
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h([0,1])
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.cx([0,1],[1,0])
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h([0,1])
    qc.x([0,1])
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.x(1)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.x(0)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    cq.cx(0,1,1)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    cq.crx(0.2, 0, 1, control_state=1)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    cq.crx(0.2, 0, 1, ctrl_state=1)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.crx(0.2, 0, 1, ctrl_state=1)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.crx(0.2, 0, 1, ctrl_state=0)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.cx(0,1)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.h(1)
    qc.z(1)
    qc.h(0)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.h(1)
    qc.h(1)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.h(1)
    qc.y(0)
    qc.y(1)
    qc.x(0)
    qc.x(1)
    qc.h(1)
    qc.h(0)
    qc.cx(1,0)
    qc.x(0)
    qc.x(1)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    from qiskit.circuit.library import YGate
    for i in range(2):
        qc.h(i)
        qc.append(YGate,i)
        qc.x(i)

    qc.h(1)
    qc.cx(1,0)
    qc.h(1)
    qc.x(0)
    qc.x(1)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    for i in range(2):
        qc.h(i)
        qc.y(i)
        qc.x(i)

    qc.h(1)
    qc.cx(1,0)
    qc.h(1)
    qc.x(0)
    qc.x(1)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.cx(0,1)
    qc.z(1)
    qc.h(0)
    qc.h(1)
    qc.cx(0,1)
    qc.h(1)
    qc.x(0)
    qc.x(1)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.cx(0,1)
    qc.z(1)
    qc.h(0)
    qc.h(1)
    qc.ch(1,0)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.cx(0,1)
    qc.z(1)
    qc.h(0)
    qc.h(1)
    qc.ch(1,0)
    qc.x(0)
    qc.x(1)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.h(1)
    qc.cz(0,1)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.ch(1)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.ch(0,1)
    qc.x(0)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.ch(0, 1)
    qc.cx(0,1)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.ch(0, 1)
    qc.cx(1,0)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.ch(0, 1)
    qc.cx(1, 0)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.cx(0,1)
    qc.cx(1,0)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.ch(0,1)
    qc.cx(1,)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.ch(0,1)
    qc.cx(1,0)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.rx(0.1,0)
    qc.crx(0.1, 0, 1)
    qc.x(0)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.x(1)
    qc.ch(0,1)
    qc.x([0,1])
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.h(0)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.h(1)
    qc.cx(0, 1)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.cx(0, 1)
    qc.h(0)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.cx(0, 1)
    qc.x(0)
    qc.h(0)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.h(1)
    qc.ch(0, 1)

    return qc
'''


'''python
from qiskit import QuantumCircuit
import math

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    theta = 2 * math.asin(math.sqrt(1/3))
    qc.ry(theta, 0)
    qc.cx(0,1)

    return qc
'''


'''python
from qiskit import QuantumCircuit
import math

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    theta = 2 * math.asin(math.sqrt(1/3)
    theta1 = 2 * math.asin(math.sqrt(1/2)
    qc.ry(theta, 0)
    qc.ry(theta1, 1)
    qc.cx(0,1)

    return qc
'''


'''python
from qiskit import QuantumCircuit
import math

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    theta = 2 * math.asin(math.sqrt(1/3)
    qc.ry(theta, 0)
    qc.ry(math.pi/2, 1)
    qc.cy(0,1)
    qc.cx(0,1)

    return qc
'''


'''python
from qiskit import QuantumCircuit
import math

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    theta = 2 * math.asin(math.sqrt(1/3))
    qc.ry(theta, 0)
    qc.ry(math.pi/2, 1)
    qc.cy(0,1)
    qc.cx(0,1)

    return qc
'''


'''python
from qiskit import QuantumCircuit
import math

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    theta = 2 * math.asin(math.sqrt(1/3))
    qc.ry(theta, 0)
    qc.ry(math.pi/2, 1)
    qc.cry(math.pi/2,0,1)
    qc.cx(0,1)

    return qc
'''


'''python
from qiskit import QuantumCircuit
def solve() -> QuantumCircuit:
  qc = QuantumCircuit(2)
  qc.h(0)
  qc.ch(0, 1)
  qc.x(0)
  return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.u(2*math.acos(1/np.sqrt(3)),0,0,0)
    qc.u(0,0,-math.pi/2,1)
    qc.cx(0,1)
    qc.u(math.pi/4,0,-math.pi/2,1)
    qc.cx(0,1)
    qc.u(math.pi,0,-math.pi/2,0)
    qc.u(math.pi/4,0,math.pi,1)
    return qc
'''


'''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import CHGate

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc = QuantumCircuit(2)
    qc.h(0)
    qc.cx(0,1)
    qc.append(CHGate(ctrl_state=0),[0,1])
    return qc
'''


'''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import CHGate

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc = QuantumCircuit(2)
    qc.h(0)
    qc.append(CHGate(ctrl_state=0),[0,1])
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)

    qc.h(0)
    qc.ch(0, 1)
    qc.cx(1, 0)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.cx(0, 1)
    qc.ch(0, 1)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.ch(0, 1)
    qc.x(0)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    qc.h(0)
    qc.x(1)
    qc.cnot(0,1)
    # Write your code here:

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    qc.h(0)
    qc.x(1)
    qc.cnot(0,1)
    qc.z(0)
    qc.z(1)
    # Write your code here:

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    qc.h(0)
    qc.h(1)
    qc.cnot(0,1)
    qc.h(0)
    qc.h(1)
    # Write your code here:

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    qc.h(0)
    qc.cnot(0,1)
    qc.h(1)
    # Write your code here:

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    qc.h(0)
    qc.cz(0,1)
    # Write your code here:

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    qc.h(0)
    qc.y(1)
    qc.h(1)
    # Write your code here:

    return qc
'''


'''python
from qiskit import QuantumCircuit
import math

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    qc.ry(1.2310,0)
    qc.ry(math.pi/4,1)
    qc.x(0)
    qc.cnot(0,1)
    qc.x(0)
    qc.ry(-1*math.pi/4,1)
    # Write your code here:

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.ch(0, 1)
    qc.cx(1, 0)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.ch(0, 1)
    qc.x(0)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(1)
    qc.ch(1,0)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(1)
    qc.ch(1,0)
    qc.x(1)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.ch(0,1)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.x(0)
    qc.ch(0,1)
    qc.x(0)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.h(1)
    qc.cx(0,1)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    a0 = 1
    a1 = 1
    a2 = 1
    a3 = 0

    norm = (a0**2 + a1**2 + a2**2 + a3**2)**0.5
    state = [a0/norm, a1/norm, a2/norm, a3/norm]

    # Initialize the qubits to the desired state
    qc.initialize(state, [0, 1])
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    theta1 = 2 * np.arccos(a0 / np.sqrt(a0**2 + a1**2))
    qc.ry(theta1, 0)  # RY rotation on the first qubit

    # Step 2: Apply a controlled RY gate to the second qubit based on the first
    theta2 = 2 * np.arccos(np.sqrt(a0**2 + a1**2) / np.sqrt(a0**2 + a1**2 + a2**2))
    qc.cry(theta2, 0, 1)  # Controlled RY gate

    # Step 3: Apply a Pauli-X gate to flip the first qubit
    qc.cx(0, 1)

    # Initialize the qubits to the desired state
    qc.initialize(state, [0, 1])
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    theta1 = 2 * math.acos(a0 / math.sqrt(a0**2 + a1**2))
    qc.ry(theta1, 0)  # RY rotation on the first qubit

    # Step 2: Apply a controlled RY gate to the second qubit based on the first
    theta2 = 2 * math.acos(math.sqrt(a0**2 + a1**2) / math.sqrt(a0**2 + a1**2 + a2**2))
    qc.cry(theta2, 0, 1)  # Controlled RY gate

    # Step 3: Apply a CNOT gate to entangle the qubits
    qc.cx(0, 1)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.cx(0,1)
    qc.x(0)
    qc.cx(1,0)
    qc.x(1)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    theta1 = 2 * math.acos(a0 / math.sqrt(a0**2 + a1**2))
    qc.ry(theta1, 0)

    # Step 2: Apply Controlled RY gate on qubit 1 based on qubit 0 to adjust amplitude for |01>
    theta2 = 2 * math.acos(a2 / math.sqrt(a1**2 + a2**2))
    qc.ry(theta2, 1)

    qc.cx(0, 1)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.ch(0,1)
    qc.x(0)

    return qc
'''


'''python
from qiskit import QuantumCircuit
#from qiskit.quantum_info import Statevector
import numpy as np

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.ch(0,1)
    qc.cx(1,0)
    # qc.rxx(np.pi/10,0,1)
    return qc

qc = solve()
print(qc)
#print(Statevector(qc))
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:

    from qiskit.circuit.library import HGate, CXGate, MCPhaseGate, MCMT
    qc.h(0)

    ch = MCMT(HGate, 1, 1)
    qc.append(ch)

    qc.x(0)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:

    from qiskit.circuit.library import HGate, CXGate, MCPhaseGate, MCMT
    qc.h(0)

    ch = MCMT(HGate, 1, 1)
    qc.append(ch, qargs = [0, 1])

    qc.x(0)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:

    from qiskit.circuit.library import HGate, CXGate, MCPhaseGate, MCMT
    qc.h(0)

    qc.ch(0, 1)

    qc.x(0)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.ch(0,1)
    qc.cx(1,0)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:

    qc.h(0)
    qc.ch(0, 1)
    qc.cx(1, 0)
    return qc
'''


'''python
from qiskit import QuantumCircuit
from math import asin, sqrt

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    theta = asin(1 / sqrt(3))
    qc.ry(theta * 2, 0)
    qc.x(0)
    qc.ch(0, 1)
    qc.x(0)

    return qc
'''


'''python
from qiskit import QuantumCircuit
from numpy import*

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.cx(0,1)
    qc.cry(arccos(2*1/sqrt(3),0,1))
    qc.cx(0,1)
    return qc
'''


'''python
from qiskit import QuantumCircuit
from numpy import*

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.cx(0,1)
    qc.cry(2*arccos(1/sqrt(3),0,1))
    qc.cx(0,1)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.cx(0,1)
    qc.cry(2*arccos(1/sqrt(3),0,1))
    qc.cx(0,1)
    return qc
'''


'''python
from qiskit import QuantumCircuit
from numpy import as np

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.cx(0,1)
    qc.cry(2*np.arccos(1/np.sqrt(3),0,1))
    qc.cx(0,1)
    return qc
'''


'''python
from qiskit import QuantumCircuit
from numpy import as np

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.cx(0,1)
    qc.cry(np.arccos(1/np.sqrt(3),1,0))
    qc.cx(0,1)
    return qc
'''


'''python
from qiskit import QuantumCircuit
import math

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.cx(0,1)
    qc.cry(math.acos(1/math.sqrt(3),1,0))
    qc.cx(0,1)
    return qc
'''


'''python
from qiskit import QuantumCircuit
import math

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.cx(0,1)
    qc.cry(math.acos(1/math.sqrt(3)),1,0)
    qc.cx(0,1)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:

    qc.x([0, 1])
    qc.cx(0, 1)
    qc.cx(1, 0)
    qc.x([0, 1])

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:

    qc.h([0, 1])
    qc.x([0, 1])
    qc.cx(0, 1)
    qc.cx(1, 0)
    qc.x([0, 1])

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:

    qc.h(0)
    qc.ch(0, 1)
    qc.x(0)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:

    qc.h(0)
    qc.h(1)
    qc.cx(0,1)
    qc.cx(1,0)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:

    qc.h(0)
    qc.cx(0,1)
    qc.cx(1,0)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:

    qc.h(0)
    qc.h(1)
    qc.cx(0,1)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:

    qc.x(1)
    qc.h(0)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:

    qc.h(00)
    qc.x(01)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:

    qc.h(0)
    qc.x(1)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:

    qc.h([0,1])
    qc.x(1)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:

    qc.h([0,1])
    qc.cx(1,0)
    qc.cx(0,1)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h([0,1])
    qc.cx(1,0)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h([0,1])
    qc.x(1)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h([0,1])
    qc.x(1)
    qc.cx(0,1)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.x(1)
    qc.cx(0,1)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    qc.h(0)
    qc.ch(0, 1)
    qc.cx(1, 0)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.h(1)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)

    theta_b = 1
    theta_c = 0

    qc.cry(theta_b, 0, 1)

    qc.x(0)
    qc.cry(theta_c, 0, 1)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.cx(0,1)
    qc.cz(1,1)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.cx(0,1)
    qc.cz(1,0)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.cx(0,1)
    qc.cz(0,1)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.cx(0,1)
    qc.cx(1,0)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.cx(0,1)
    qc.cy(1,0)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.cx(1,1)
    qc.cx(0,1)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.ch(0,1)
    qc.x(0)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    qc.h(0)
    qc.h(1)
    qc.cnot(0, 1)

    return qc
'''


'''python
from qiskit import QuantumCircuit
from qiskit.circuit.library.standard_gates import HGate

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    qc.h(0)
    cntl_h = HGate().control(1)
    qc.append(cntl_h, [1,0])

    return qc
'''


'''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import *

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    qc.h(0)
    cntl_h = HGate().control(1)
    qc.append(cntl_h, [1,0])

    return qc
'''


'''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import HGate

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    qc.h(0)
    cntl_h = HGate().control(1)
    qc.append(cntl_h, [1,0])

    return qc
'''


'''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import HGate

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    qc.h(0)
    qc.h(1)
    cntl_h = HGate().control(1)
    qc.append(cntl_h, [1,0])

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.CHGate(0, 1)
    qc.x(1)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.ch(0, 1)
    qc.x(1)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.c(0, 1)
    qc.x(0)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.ch(0, 1)
    qc.x()

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.ch(0, 1)
    qc.x(0)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    qc.h(0)
    qc.h(1)
    qc.cnot(0, 1)
    # Write your code here:

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    qc.h(0)
    qc.h(1)
    qc.cx(0, 1)
    # Write your code here:

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    qc.h(0)
    qc.cx(0, 1)
    # Write your code here:

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    qc.h(0)
    # crx 90
    qc.cry(0.1, 0, 1)
    qc.x(0)
    # Write your code here:

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    a = 1 / math.sqrt(3)
    qc.initialize([a, a, a, 0], [0, 1])
    return qc
'''


'''python
from qiskit import QuantumCircuit
import math

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    a = 1 / math.sqrt(3)
    qc.initialize([a, a, a, 0], [0, 1])
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    qc.h(0)
    qc.h(1)
    qc.ch(1,0)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(range(n))
    qc.x(1)
    qc.cx(0,1)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.x((0,1))
    qc.ch(0,1)
    qc.x((0,1))

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:

    qc.h(0)
    qc.cx(0,1)
    qc.h(1)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:

    qc.h(0)
    qc.cx(0,1)
    qc.ch(1,0)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:

    qc.h(0)
    qc.cx(0,1)
    qc.ch(1,0)
    qc.x(1)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.ch(0,1)
    qc.cx(0,1)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.ch(0,1)
    qc.cx(1,0)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.ch(0,1)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.ch(0,1)
    qc.x(0)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.h(1)
    qc.cx(0, 1)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.h(1)

# Sゲートを適用して位相を変更
    qc.s(0)

# Tゲートを適用して位相を変更
    qc.t(1)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.h(1)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.cx(0, 1)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)

    # 結果の状態をシミュレーターで取得
    simulator = Aer.get_backend('statevector_simulator')
    compiled_circuit = transpile(qc, simulator)
    result = simulator.run(compiled_circuit).result()

    # 量子ビットの状態ベクトルを取得
    statevector = result.get_statevector()

    # 1/sqrt(3) を掛ける
    statevector /= (statevector[0] + statevector[2] + statevector[3]) / 3.0

    # 量子回路を再構築
    qc = QuantumCircuit(2)
    qc.initialize(statevector, [0, 1])
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    qc.h(0)
    qc.h(0)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    qc.x(0)

# CNOTゲートを適用
    qc.cx(0, 1)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Hadamardゲートを適用して重ね合わせ状態を生成
    qc.h(0)

    # 2番目のキュビットにXゲートを適用して|1⟩状態を作成
    qc.x(1)

    # 制御位相回転ゲートを適用して目標の状態を生成
    qc.cu3(2 * a1.real, 0, 0, 1, 0)  # cu3(theta, phi, lambda, control_qubit, target_qubit)
    qc.cu3(2 * a2.real, 0, 0, 0, 1)

    qc.u1(2 * a0.imag, 0)  # u1(lambda, target_qubit)
    qc.u1(2 * a1.imag, 1)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Hadamardゲートを適用して重ね合わせ状態を生成
    qc.h(0)

    # 2番目のキュビットにXゲートを適用して|1⟩状態を作成
    qc.x(1)

    # 制御位相回転ゲートを適用して目標の状態を生成
    qc.cu3(2 * 0.1, 0, 0, 1, 0)  # cu3(theta, phi, lambda, control_qubit, target_qubit)
    qc.cu3(2 * 0.2, 0, 0, 0, 1)

    qc.u1(2 * 0.1, 0)  # u1(lambda, target_qubit)
    qc.u1(2 * 0.1, 1)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    qc.h(0)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    qc.h(0)
    qc.cx(0,1)
    qc.h(0)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    qc.h(0)
    qc.cx(0,1)
    qc.h(1)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    qc.h(0)
    qc.h(1)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    qc.h(0)
    qc.h(1)
    qc.cx(0,1)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    qc.h(0)
    qc.x(1)
    qc.h(1)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    qc.h(0)
    qc.x(1)
    qc.h(1)
    qc.cx(0, 1)  # CXゲートを追加して|11⟩を回避
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)

    qc.h(0)
    qc.x(1)
    qc.h(1)
    qc.cx(0, 1)  # CXゲートを追加して|11⟩を回避
    qc.h(0)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)

    qc.h(0)
    qc.h(1)
    qc.cx(0, 1)  # CXゲートを追加して|11⟩を回避
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)

    qc.h(0)
    qc.h(1)

    # CNOTゲートを適用してエンタングル状態を作成
    qc.cx(0, 1)
    qc.cx(1, 0)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)

    qc.h(0)
    qc.h(1)

    # CNOTゲートを適用してエンタングル状態を作成
    qc.cx(0, 1)
    #qc.cx(1, 0)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)

    qc.h(0)
    qc.h(1)

    # CNOTゲートを適用してエンタングル状態を作成
    #qc.cx(0, 1)
    qc.cx(1, 0)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)

    qc.h(0)
    qc.h(1)

    qc.cz(1, 0)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)

    qc.h(0)
    qc.h(1)

    qc.cx(1, 0)
    qc.cz(1, 0)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)

    qc.h(0)
    #qc.h(1)

    qc.cx(1, 0)
    qc.cz(1, 0)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)

    qc.h(0)
    #qc.h(1)

    qc.cx(1, 0)
    qc.h(1)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)

    qc.h(0)
    #qc.h(1)

    qc.cx(1, 0)
    qc.h(0)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)

    qc.h(0)
    qc.h(1)

    # 制御NOTゲートを適用してエンタングル状態を作成
    qc.cx(0, 1)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)

    qc.h(0)
    qc.swap(0, 1)
    qc.h(1)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)

    qc.h(0)
    qc.swap(0, 1)
    qc.h(0)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)

    qc.h(0)
    qc.swap(0, 1)
    qc.h(1)
    qc.cx(0,1)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)

    qc.h(0)
    qc.swap(0, 1)
    qc.h(0)
    qc.cx(0,1)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)

    qc.h(0)
    qc.cz(0, 1)
    qc.h(0)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)

    qc.h(0)
    qc.h(1)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    qc.h(0)
    qc.cx(1)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.cx(0, 1)
    qc.x(1)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.cx(0, 1)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    U = np.array([[1, 0, 0, 0],
                  [0, 0, 1, 0],
                  [0, 1, 0, 0],
                  [0, 0, 0, 1]])
    qc.unitary(Operator(U), [0, 1])
    return qc
'''


'''python
from qiskit import QuantumCircuit
from qiskit.quantum_info import Operator
import numpy as np

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    U = np.array([[1, 0, 0, 0],
                  [0, 0, 1, 0],
                  [0, 1, 0, 0],
                  [0, 0, 0, 1]])
    qc.unitary(Operator(U), [0, 1])
    return qc
'''


'''python
from qiskit import QuantumCircuit
import math

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    a0 = 1 / math.sqrt(3)
    a1 = 1 / math.sqrt(3)
    a2 = 1 / math.sqrt(3)

    qc.ry(2 * math.acos(a2), 0)

    qc.cx(0, 1)
    qc.ry(2 * math.asin(a1 / math.sqrt(a1**2 + a0**2)), 1)
    qc.cx(0, 1)
    return qc
'''


'''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import HGate, XGate, RXGate
import math

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
     qc.append(HGate(), [0])

    qc.append(XGate(), [1])
    qc.append(RXGate(math.pi / 2), [1])
    qc.append(XGate(), [1])
    return qc
'''


'''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import HGate, XGate, RXGate
import math

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.append(HGate(), [0])

    qc.append(XGate(), [1])
    qc.append(RXGate(math.pi / 2), [1])
    qc.append(XGate(), [1])
    return qc
'''


'''python
from qiskit import QuantumCircuit
from math import pi

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)

    qc.cry(pi/2, 0, 1)

    qc.x(0)
    qc.cry(-pi/2, 0, 1)
    qc.x(0)
    return qc
'''


'''python
from qiskit import QuantumCircuit
from math

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.cry(2 * math.acos(1 / math.sqrt(3)), 0, 1)
    return qc
'''


'''python
from qiskit import QuantumCircuit
from math

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.cp(math.pi/2, 0, 1)
    qc.cx(0, 1)
    return qc
'''


'''python
from qiskit import QuantumCircuit
from math

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.cx(1, 1)
    return qc
'''


'''python
from qiskit import QuantumCircuit
from math

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.cry(2 * np.arctan((a1 + a2) / (a0 + a2)), 0, 1)
    qc.crz(2 * np.arctan(a2 / a1), 0, 1)
    qc.h(0)
    return qc
'''


'''python
from qiskit import QuantumCircuit
from math

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.cry(2 * math.atan((a1 + a2) / (a0 + a2)), 0, 1)
    qc.crz(2 * math.atan(a2 / a1), 0, 1)
    qc.h(0)
    return qc
'''


'''python
from qiskit import QuantumCircuit
from math

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.cry(2 * math.atan(2/ 3), 0, 1)
    qc.crz(2 * math.atan(1 / 3), 0, 1)
    qc.h(0)
    return qc
'''


'''python
from qiskit import QuantumCircuit
from math

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.h(1)
    qc.rz(2 * math.atan(2/3), 0, 1)
    qc.rz(2 * math.atan(1/3), 0, 1)
    qc.cx(0, 1)
    return qc
'''


'''python
from qiskit import QuantumCircuit
from math

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.h(1)
    qc.rz(2 * math.atan(2/3), 0)
    qc.rz(2 * math.atan(1/3), 0)
    qc.cx(0, 1)
    return qc
'''


'''python
from qiskit import QuantumCircuit
import math

def solve(n: int, L: int) -> QuantumCircuit:
    qc = QuantumCircuit(n)
    # Write your code here:
    for i in range(L):
        qc.append(ZGate().control(n - 1), range(n))
    theta = math.acos(1 / 3 ** 0.5)
    qc.rx(theta, 1)
    qc.ch(1, 0)
    qc.cp(-math.pi / 4, 1, 0)
    qc.cx(0, 1)
    return qc
'''


'''python
from qiskit import QuantumCircuit
import mat

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    theta = math.acos(1 / (3 ** 0.5))
    qc.rx(theta, 1)
    qc.ch(1, 0)
    qc.cp(-math.pi / 4, 1, 0)
    qc.cx(0, 1)
    return qc
'''


'''python
from qiskit import QuantumCircuit
import math

def solve() -> QuantumCircuit:
    qc = QuantumCircuit()
    # Write your code here:
    theta = math.acos(1 / (3 ** 0.5))
    qc.rx(theta, 1)
    qc.ch(1, 0)
    qc.cp(-math.pi / 4, 1, 0)
    qc.cx(0, 1)
    return qc
'''


'''python
from qiskit import QuantumCircuit
import math

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    theta = math.acos(1 / (3 ** 0.5))
    qc.rx(theta, 1)
    qc.ch(1, 0)
    qc.cp(-math.pi / 4, 1, 0)
    qc.cx(0, 1)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.ch(0, 1)
    qc.x(0)
    return qc
'''


'''python
from qiskit import QuantumCircuit
from math import sqrt

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.initialize([1/sqrt(3),1/sqrt(3),1/sqrt(3),0],[0,1])

    return qc
'''


'''python
from qiskit import QuantumCircuit
from math import sqrt

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.ch(0,1)
    qc.cx(1,0)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.h(1)
    qc.cnot(1,0)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.h(1)
    qc.cnot(0,1)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.h(1)
    qc.cnot(0,1)
    qc.u(1,0,0, qubit=0)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc = QuantumCircuit(2)
    qc.u(1.91,0, math.pi,0)
    qc.cnot(0,1)

    return qc
'''


'''python
from qiskit import QuantumCircuit
import math

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.u(1.91, 0, math.pi,0)
    qc.cnot(0,1)

    return qc
'''


'''python
from qiskit import QuantumCircuit
import math

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.u(1.91, 0, math.pi,0)
    qc.cnot(1,0 )

    return qc
'''


'''python
from qiskit import QuantumCircuit
import math

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.cx(1, 0)
    qc.csx(0, 1)
    qc.cx(1, 0)

    return qc
'''


'''python
from qiskit import QuantumCircuit
import math

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.u(1.91, 0, math.pi, qubit=0)
    qc.cx(1, 0)
    qc.csx(0, 1)
    qc.cx(1, 0)

    return qc
'''


'''python
from qiskit import QuantumCircuit
import math

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.cnot(0, 1)
    qc.h(1)
    qc.cry(math.pi/2, 0, 1)

    return qc
'''


'''python
from qiskit import QuantumCircuit
import math

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)

    theta = 2 * math.acos(math.sqrt(2/3))
    qc.ry(theta, 0)
    qc.x(0)
    qc.ch(0, 1)
    qc.x(0)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    qc.h(0)
    qc.ch(0,1)
    qc.cnot(0,1)
    # Write your code here:

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    qc.h(0)
    qc.ch(0,1)
    qc.cnot(1,0)
    # Write your code here:

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(1)
    qc.ch(1, 0)
    qc.cx(0, 1)

    return qc
'''


'''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import RYGate
from numpy import arccos, sqrt

def solve(a0: float, a1: float, a2: float) -> QuantumCircuit:
    qc = QuantumCircuit(2)

    # Step 1: Normalize coefficients
    norm = sqrt(a0**2 + a1**2 + a2**2)
    a0 /= norm
    a1 /= norm
    a2 /= norm

    # Step 2: Create superposition using Ry gate
    theta1 = 2 * arccos(a0)
    qc.ry(theta1, 0)

    # Step 3: Use CNOT to entangle qubits
    if a1 != 0:
        qc.cx(0, 1)

    # Step 4: Adjust the amplitude using Ry gate on the second qubit
    if a2 != 0:
        theta2 = 2 * arccos(a2 / sqrt(a1**2 + a2**2))
        qc.ry(theta2, 1)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve(a0: float, a1: float, a2: float) -> QuantumCircuit:
    qc = QuantumCircuit(2)

    # Step 1: Normalize coefficients
    norm = sqrt(a0**2 + a1**2 + a2**2)
    a0 /= norm
    a1 /= norm
    a2 /= norm

    # Step 2: Create superposition using Ry gate
    theta1 = 2 * arccos(a0)
    qc.ry(theta1, 0)

    # Step 3: Use CNOT to entangle qubits
    if a1 != 0:
        qc.cx(0, 1)

    # Step 4: Adjust the amplitude using Ry gate on the second qubit
    if a2 != 0:
        theta2 = 2 * arccos(a2 / sqrt(a1**2 + a2**2))
        qc.ry(theta2, 1)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve(a0: float, a1: float, a2: float) -> QuantumCircuit:
    qc = QuantumCircuit(2)

    # Step 1: Normalize coefficients
    norm = sqrt(a0**2 + a1**2 + a2**2)
    a0 /= norm
    a1 /= norm
    a2 /= norm

    # Step 2: Create superposition using Ry gate
    theta1 = 2 * arccos(a0)
    qc.ry(theta1, 0)

    # Step 3: Use CNOT to entangle qubits
    if a1 != 0:
        qc.cx(0, 1)

    # Step 4: Adjust the amplitude using Ry gate on the second qubit
    #if a2 != 0:
    #    theta2 = 2 * arccos(a2 / sqrt(a1**2 + a2**2))
    #    qc.ry(theta2, 1)

    return qc
'''


'''python
import math
import numpy
from qiskit import QuantumCircuit
from qiskit.circuit.library import RYGate, CXGate

def solve(a0: float, a1: float, a2: float) -> QuantumCircuit:
    qc = QuantumCircuit(2)

    # Step 1: Normalize coefficients
    norm = math.sqrt(a0**2 + a1**2 + a2**2)
    a0 /= norm
    a1 /= norm
    a2 /= norm

    # Step 2: Apply RY gate to the first qubit to create superposition
    theta1 = 2 * math.acos(a0)
    qc.append(RYGate(theta1), [0])

    # Step 3: Apply CNOT gate to entangle qubits
    qc.append(CXGate(), [0, 1])

    # Step 4: Adjust the second qubit's state based on the desired superposition
    if a1 != 0 or a2 != 0:
        theta2 = 2 * math.acos(a2 / math.sqrt(a1**2 + a2**2))
        qc.append(RYGate(theta2), [1])

    return qc
'''


'''python
from qiskit import QuantumCircuit
import numpy as np

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)

    # Step 1: Create a superposition state on the first qubit using a custom unitary operation
    theta = 2 * np.arccos(1/np.sqrt(3))
    qc.ry(theta, 0)

    # Step 2: Apply a CNOT gate to create entanglement between the first and second qubit
    qc.cx(0, 1)

    # Step 3: Apply an X gate on the second qubit to get the superposition of 00, 10, and 01
    qc.x(1)

    return qc
'''


'''python
from qiskit import QuantumCircuit
import numpy as np

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)

    qc.h(0)

    # Step 2: Apply a CNOT gate to entangle the qubits
    qc.cx(0, 1)

    # Step 3: Apply an X gate to the first qubit to flip its state (inverting the first qubit)
    qc.x(0)

    # Step 4: Apply another Hadamard gate to the first qubit to adjust the superposition
    qc.h(0)

    return qc
'''


'''python
def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Step 1: Set the first qubit in a superposition state using H gate and phase rotation
    qc.h(0)
    qc.p(np.pi/2, 0)  # Apply phase to match the desired amplitudes

    # Step 2: Use Ry gate to adjust the amplitude for the |10⟩ and |01⟩ components
    qc.ry(2*np.arccos(1/np.sqrt(2)), 0)  # Adjust the first qubit's amplitude

    # Step 3: Entangle the qubits using a CNOT gate
    qc.cx(0, 1)

    # Step 4: Apply Ry gate on the second qubit to adjust the amplitude for the |01⟩ state
    qc.ry(np.pi/2, 1)  # Adjust the second qubit's amplitude

    return qc
'''


'''python
from qiskit import QuantumCircuit
import numpy as np

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Step 1: Set the first qubit in a superposition state using H gate and phase rotation
    qc.h(0)
    qc.p(np.pi/2, 0)  # Apply phase to match the desired amplitudes

    # Step 2: Use Ry gate to adjust the amplitude for the |10⟩ and |01⟩ components
    qc.ry(2*np.arccos(1/np.sqrt(2)), 0)  # Adjust the first qubit's amplitude

    # Step 3: Entangle the qubits using a CNOT gate
    qc.cx(0, 1)

    # Step 4: Apply Ry gate on the second qubit to adjust the amplitude for the |01⟩ state
    qc.ry(np.pi/2, 1)  # Adjust the second qubit's amplitude

    return qc
'''


'''python
from qiskit import QuantumCircuit
import numpy as np

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    qc.h(0)
    qc.ch(0, 1)
    qc.cx(1, 0)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.ch(0, 1)
    qc.cx(1, 0)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    qc.h(0)
    qc.ch(0, 1)
    qc.cx(1, 0)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    q.h(range(2))
    q.cx(0,1)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    q.h(0)
    q.h(1)
    q.cx(0,1)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    q.h(0)
    q.ch(0,1)
    q.cx(1,0)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.ch(0,1)
    qc.cx(1,0)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:

    qc.h(0)
    qc.cx(0, 1)
    qc.ch(0, 1)
    qc.cx(1, 0)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.ry(0, 0.1)
    qc.ch(0,1)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.ry(0.1, 0)
    qc.ch(0,1)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.x(0)
    qc.ch(0,1)
    qc.x(0)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.x(1)
    qc.ch(1,0)
    qc.x(1)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.ch(0,1, ctrl_state=0)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.ch(1,0, ctrl_state=0)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(1)
    qc.ch(1,0, ctrl_state=0)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.ch(0, 1)
    qc.x(0)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.ch(0,1)
    qc.cx(1,0)

    return qc
'''


'''python
from qiskit import QuantumCircuit
from qiskit.circuit import Parameter

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)

    a0 = Parameter('a0')
    a1 = Parameter('a1')
    a2 = Parameter('a2')

    # Prepare the state |ψ⟩ = a0|00⟩ + a1|10⟩ + a2|01⟩
    qc.initialize([a0, 0, a2, 0, a1, 0, 0, 0], [0, 1])

    return qc
'''


'''python
from qiskit import QuantumCircuit
import numpy as np

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)

    # Define arbitrary non-zero probability amplitudes
    a0 = np.sqrt(0.5)  # Example value for a0
    a1 = np.sqrt(0.3)  # Example value for a1
    a2 = np.sqrt(0.2)  # Example value for a2

    # Apply the appropriate gates to prepare the state |ψ⟩
    qc.initialize([a0, 0, a1, 0, a2, 0, 0, 0], [0, 1])

    return qc
'''


'''python
from qiskit import QuantumCircuit
import numpy as np

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)

    a0 = np.sqrt(0.5)  # Example amplitude for |00>
    a1 = np.sqrt(0.3)  # Example amplitude for |10>
    a2 = np.sqrt(0.2)  # Example amplitude for |01>

    # Apply a rotation to create the superposition state
    qc.ry(2 * np.arccos(a0), 0)  # Rotate qubit 0
    qc.ry(2 * np.arccos(a1 / np.sqrt(1 - a0**2)), 1)  # Rotate qubit 1

    # Apply a controlled rotation to create the |01> component
    qc.cu3(2 * np.arccos(a2 / np.sqrt(1 - a0**2 - a1**2)), 0, 0, 0, 1)  # Controlled rotation

    return qc
'''


'''python
from qiskit import QuantumCircuit
from qiskit.circuit.library.standard_gates import RY, RZ, CX

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)

    # Define arbitrary non-zero probability amplitudes
    a0 = 1 / math.sqrt(2)  # Amplitude for |00>
    a1 = 1 / math.sqrt(2)  # Amplitude for |10>
    a2 = 0                 # Amplitude for |01> (set to 0 for this example)

    # Prepare the state |ψ> = a0|00> + a1|10> + a2|01>
    # Apply RY and RZ rotations to create the superposition
    qc.ry(2 * math.acos(a0), 0)  # Rotate qubit 0
    qc.ry(2 * math.acos(a1), 1)  # Rotate qubit 1

    # Apply a controlled-X gate to create the |10> state
    qc.cx(0, 1)

    return qc
'''


'''python
from qiskit import QuantumCircuit
from qiskit.circuit.library.standard_gates import HGate, CXGate
import numpy as np

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)

    # Define arbitrary amplitudes
    a0 = np.sqrt(0.5)  # Amplitude for |00>
    a1 = np.sqrt(0.3)  # Amplitude for |10>
    a2 = np.sqrt(0.2)  # Amplitude for |01>

    # Apply a Hadamard gate to create superposition
    qc.h(0)  # Create superposition on qubit 0

    # Apply a controlled-X (CNOT) gate to entangle qubits
    qc.cx(0, 1)  # Control qubit 0, target qubit 1

    # Apply rotation gates to adjust amplitudes
    qc.ry(2 * np.arccos(a0), 0)  # Adjust amplitude for |00>
    qc.ry(2 * np.arccos(a1), 1)  # Adjust amplitude for |10>

    return qc
'''


'''python
from qiskit import QuantumCircuit
import numpy as np

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)

    # Define arbitrary amplitudes
    a0 = np.sqrt(0.5)  # Amplitude for |00>
    a1 = np.sqrt(0.3)  # Amplitude for |10>
    a2 = np.sqrt(0.2)  # Amplitude for |01>

    # Apply a Hadamard gate to create superposition
    qc.h(0)  # Create superposition on qubit 0

    # Apply a controlled-X (CNOT) gate to entangle qubits
    qc.cx(0, 1)  # Control qubit 0, target qubit 1

    # Apply rotation gates to adjust amplitudes
    qc.ry(2 * np.arccos(a0), 0)  # Adjust amplitude for |00>
    qc.ry(2 * np.arccos(a1), 1)  # Adjust amplitude for |10>

    return qc
'''


'''python
from qiskit import QuantumCircuit
import numpy as np

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)

    # Define arbitrary amplitudes
    a0 = np.sqrt(0.5)  # Amplitude for |00>
    a1 = np.sqrt(0.3)  # Amplitude for |10>
    a2 = np.sqrt(0.2)  # Amplitude for |01>

    # Apply a Hadamard gate to create superposition
    qc.h(0)  # Create superposition on qubit 0

    # Apply a controlled-X (CNOT) gate to entangle qubits
    qc.ch(0, 1)  # Control qubit 0, target qubit 1

    # Apply rotation gates to adjust amplitudes
    qc.ry(2 * np.arccos(a0), 0)  # Adjust amplitude for |00>
    qc.ry(2 * np.arccos(a1), 1)  # Adjust amplitude for |10>

    return qc
'''


'''python
from qiskit import QuantumCircuit
import numpy as np

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)

    a0 = np.sqrt(0.5)  # Example amplitude for |00>
    a1 = np.sqrt(0.3)  # Example amplitude for |10>
    a2 = np.sqrt(0.2)  # Example amplitude for |01>

    # Apply a rotation to create the superposition state
    qc.ry(2 * np.arccos(a0), 0)  # Rotate qubit 0
    qc.ry(2 * np.arccos(a1 / np.sqrt(1 - a0**2)), 1)  # Rotate qubit 1

    # Apply a controlled rotation to create the |01> component
    qc.cx(0, 1)  # Control qubit 0 to qubit 1

    return qc
'''


'''python
from qiskit import QuantumCircuit
import numpy as np

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)

    # Define the amplitudes
    a0 = 1 / np.sqrt(2)
    a1 = 1 / np.sqrt(3)
    a2 = 1 / np.sqrt(6)

    # Apply RY rotations to create the superposition
    # The angles are derived from the amplitudes
    theta1 = 2 * np.arccos(a0)  # For |00>
    theta2 = 2 * np.arccos(np.sqrt(a1 / (a1 + a2)))  # For |10> and |01>

    # Create the state |00> + |10> + |01>
    qc.ry(theta1, 0)  # Rotate qubit 0
    qc.ry(theta2, 1)  # Rotate qubit 1

    # Apply a controlled rotation to create the |10> and |01> states
    qc.cx(0, 1)  # CNOT gate to create the |10> state

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.rx(2*pi, 1)
    qc.rx(2*pi, 0)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.cx(0,1)
    qc.ch(0,1)
    qc.cx(1,0)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.ch(0,1)
    qc.cx(1,0)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.cx(0, 1)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.h(1)
    qc.cx(0, 1)
    qc.cx(1, 0)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.ch(0, 1)
    qc.cx(1, 0)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.ch(0,1)
    qc.cz(1,0)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.ch(0,1)
    qc.cx(1,0)

    return qc
'''


'''python
from qiskit import QuantumCircuit
import numpy as np

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    a0 = 1/np.sqrt(3)  # Example amplitude for |00>
    a1 = 1/np.sqrt(3)  # Example amplitude for |10>
    a2 = 1/np.sqrt(3)  # Example amplitude for |01>

    # Normalize the amplitudes to ensure they form a valid quantum state
    norm = np.sqrt(abs(a0)**2 + abs(a1)**2 + abs(a2)**2)
    a0, a1, a2 = a0 / norm, a1 / norm, a2 / norm

    # The target state vector: [a0, a2, a1, 0]
    state_vector = [a0, a2, a1, 0]

    # Initialize the qubits to the desired state
    qc.initialize(state_vector, [0, 1])
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    a0 = 1/np.sqrt(3)  # Example amplitude for |00>
    a1 = 1/np.sqrt(3)  # Example amplitude for |10>
    a2 = 1/np.sqrt(3)  # Example amplitude for |01>

    # Normalize the amplitudes to ensure they form a valid quantum state
    norm = np.sqrt(abs(a0)**2 + abs(a1)**2 + abs(a2)**2)
    a0, a1, a2 = a0 / norm, a1 / norm, a2 / norm

    # The target state vector: [a0, a2, a1, 0]
    state_vector = [a0, a2, a1, 0]

    # Initialize the qubits to the desired state
    qc.initialize(state_vector, [0, 1])
    return qc
'''


'''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import HGate, CXGate, CHGate

def solve() -> QuantumCircuit:
	qc = QuantumCircuit(2)
	# Write your code here:
	qc.append(HGate(), [0])
	qc.append(CHGate(), [0, 1])
	qc.append(CXGate(), [1, 0])
	return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    qc.h(0)
    qc.ch(0, 1)
    qc.cx(1, 0)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:

    qc.h(0)
    qc.ch(0,1)
    qc.cx(1,0)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:

    qc.h(0)
    qc.ch(0, 1)
    qc.cx(1, 0)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.h(1)

    qc.cx(0, cx(1,1))
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)

    qc.ch(0,1)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.h(1)

    qc.ch(0,1)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.h(1)
    qc.cx(1,1)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:

    qc.h(0)
    qc.ch(0, 1)
    qc.x(0)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.rx(math.pi / 3, 0)
    qc.h(1)

    return qc
'''


'''python
from qiskit import QuantumCircuit
import math

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.rx(math.pi / 3, 0)
    qc.h(1)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.ch(0, 1)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.x(0)
    qc.ch(0, 1)
    qc.x(0)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:

    alpha0 = np.exp(1j * np.pi / 4)  # 例えば、45度の位相を持つ複素数
    alpha1 = np.exp(1j * np.pi / 3)  # 例えば、60度の位相を持つ複素数
    alpha2 = np.exp(1j * np.pi / 6)  # 例えば、30度の位相を持つ複素数

    # 各量子ビットに対して任意の複素振幅を設定
    qc.initialize([alpha0, alpha1, alpha2, 0], [0, 1])

    return qc
'''


'''python
from qiskit import QuantumCircuit
import numpy as np

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:

    alpha0 = np.exp(1j * np.pi / 4)  # 例えば、45度の位相を持つ複素数
    alpha1 = np.exp(1j * np.pi / 3)  # 例えば、60度の位相を持つ複素数
    alpha2 = np.exp(1j * np.pi / 6)  # 例えば、30度の位相を持つ複素数

    # 各量子ビットに対して任意の複素振幅を設定
    qc.initialize([alpha0, alpha1, alpha2, 0], [0, 1])

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:

    alpha0 = np.exp(1j * 3.14 / 4)  # 例えば、45度の位相を持つ複素数
    alpha1 = np.exp(1j * 3.14 / 3)  # 例えば、60度の位相を持つ複素数
    alpha2 = np.exp(1j * 3.14 / 6)  # 例えば、30度の位相を持つ複素数

    # 各量子ビットに対して任意の複素振幅を設定
    qc.initialize([alpha0, alpha1, alpha2, 0], [0, 1])

    return qc
'''


'''python
from qiskit import QuantumCircuit
import cmath

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:

    # 例として、任意の複素振幅を設定
    alpha0 = cmath.exp(1j * cmath.pi / 4)  # 例えば、45度の位相を持つ複素数
    alpha1 = cmath.exp(1j * cmath.pi / 3)  # 例えば、60度の位相を持つ複素数
    alpha2 = cmath.exp(1j * cmath.pi / 6)  # 例えば、30度の位相を持つ複素数

    # 各量子ビットに対して任意の複素振幅を設定
    qc.initialize([alpha0, alpha1, alpha2, 0], [0, 1])

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:

    # 例として、任意の複素振幅を設定
    alpha0 = ComplexNumber(0.92388, 0.38268)  # 例えば、45度の位相を持つ複素数
    alpha1 = ComplexNumber(0.5, 0.86603)      # 例えば、60度の位相を持つ複素数
    alpha2 = ComplexNumber(0.70711, 0.70711)  # 例えば、45度の位相を持つ複素数

    # 各量子ビットに対して任意の複素振幅を設定
    state_vector = [ComplexNumber(alpha0.real, alpha0.imag),
                    ComplexNumber(alpha1.real, alpha1.imag),
                    ComplexNumber(alpha2.real, alpha2.imag),
                    ComplexNumber(0, 0)]
    qc.initialize(state_vector, [0, 1])

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.cx(0, 1)
    qc.x(1)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.uc(0, 1)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.toffoli(0, 0, 1)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.x(1)
    qc.toffoli(0, 1, 1)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(3)
    # Write your code here:
    qc.h(0)
    qc.x(1)
    qc.toffoli(0, 1, 2)
    qc.cx(2, 1)

    return qc[:2]
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(3)
    # Write your code here:
    qc.h(0)
    qc.x(1)
    qc.toffoli(0, 1, 2)
    qc.cx(2, 1)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(3)
    # Write your code here:
    qc.h(0)
    qc.x(1)
    qc.toffoli(0, 1, 2)
    qc.cx(2, 1)
    qc.remove_gate(2)

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    qr = QuantumRegister(1)
    # Write your code here:
    qc.h(0)
    qc.cx(0,1)
    qc.toffoli(0, 1, qr)
    qc.cx(qr, 1)

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    qr = QuantumRegister(1)
    # Write your code here:
    qc.h(0)
    qc.ccx(0, 1)

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    qr = QuantumRegister(1)
    # Write your code here:
    qc.xor(0, 1)

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(1)
    qc.h(range(2))

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.h(range(2))

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.x(1)
    qc.h(range(2))

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.ch(0, 1)

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(1)
    qc.ch(1, 0)

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(1)
    qc.x(1)
    qc.ch(1, 0)

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.x(0)
    qc.ch(0, 1)

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.x(1)
    qc.h(1)
    qc.x(1)
    qc.ch(1, 0)

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.x(1)
    qc.h(1)
    qc.ch(1, 0)
    qc.x(1)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.ch(0, 1)
    qc.x(0)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:

    qc.u3(1.91,pi,0)
    qc.swap(0,1)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:

    qc.h(0)
    qc.h(1)
    qc.cx(0,1).c_if(0,1).c_if(1,1)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:

    qc.h(0)
    qc.h(1)
    qc.cx(0,1).c_if(0,1)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.cx(0, 1)
    qc.x(1)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.ch(0, 1)
    qc.cx(1, 0)

    return qc
'''


'''python
from qiskit import QuantumCircuit
from math import acos, sqrt

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    theta = 2 * acos(1/sqrt(3))
    qc.h(0)
    qc.ry(-theta, 0)
    qc.cx(0,1)
    qc.ry(theta, 0)

    return qc
'''


'''python
from qiskit import QuantumCircuit
from math import acos

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    theta = 2*acos(1/sqrt(3))
    qc.cry(theta, 0, 1)
    return qc
'''


'''python
from qiskit import QuantumCircuit
from math import acos, sqrt

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    theta = 2*acos(1/sqrt(3))
    qc.cry(theta, 0, 1)
    return qc
'''


'''python
from qiskit import QuantumCircuit
from math import acos, sqrt

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    theta = 2*acos(1/sqrt(3))
    qc.cry(theta, 0, 1)
    qc.x(0)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.ch(0,1)
    qc.cx(1,0)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.ch(0,1)
    qc.x(0)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(1)
    qc.ch(1, 0)
    qc.x(1)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(1)
    qc.ch(1,0)
    qc.x(1)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    for i in range(2):
        qc.h(i)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.ch(0, 1)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.h(1)
    qc.ch(0,1)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.cz(0, 1)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.cz(0, 1)
    qc.cx(0, 1)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.cz(0, 1)
    qc.cx(0, 1)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.cz(0, 1)
   #qc.cx(0, 1)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.cx(0, 0)
   #qc.cx(0, 1)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.cx(1, 0)
   #qc.cx(0, 1)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.cy(0, 1)
   #qc.cx(0, 1)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.cx(1, 1)
   #qc.cx(0, 1)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(range(2))
    qc.cx(1, 1)
   #qc.cx(0, 1)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.cx(1, 1)
    #qc.cx(0, 1)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.cz(0, 1)
    #qc.cx(0, 1)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.z(1)
    #qc.cx(0, 1)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.z(0)
    qc.h(0)
       #qc.cx(0, 1)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
   qc.cz(0, 1)
   qc.h(0)
       #qc.cx(0, 1)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.h(1)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(1)
    qc.cx(1, 0)
    qc.x(1)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.cx(0, 1)
    qc.x(0)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.ry(2 * np.arctan(np.sqrt(2/1)), 0)
    qc.cry(2 * np.arctan(np.sqrt(1/1)), 0, 1)
    qc.cx(1, 0)
    return qc
'''


'''python
from qiskit import QuantumCircuit
import numpy as np

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.ry(2 * np.arctan(np.sqrt(2/1)), 0)
    qc.cry(2 * np.arctan(np.sqrt(1/1)), 0, 1)
    qc.cx(1, 0)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.ch(1,0)
    qc.x(0)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.ch(0,1)
    qc.x(0)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:

    qc = QuantumCircuit(2)
    qc.h(0)
    qc.x(0)
    qc.ch(0,1)
    qc.x(0)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.cx(0,1)
    qc.ch(1,0)
    qc.cx(0,1)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.ch(0, 1)
    qc.cx(1, 0)

    return qc
'''


'''python
from qiskit import QuantumCircuit
import math

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    theta_0 = math.acos(1 / math.sqrt(3))
    theta_1 = math.pi / 2

    qc.ry(theta_0, 0)
    qc.x(0)
    qc.cry(theta_1, 0, 1)
    qc.x(0)

    return qc
'''


'''python
from qiskit import QuantumCircuit
from qiskit.circuit import Parameter

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    theta_0 = Parameter('theta0')
    phi_0 = Parameter('phi0')
    lambda_0 = Parameter('lambda0')

    theta_1 = Parameter('theta1')
    phi_1 = Parameter('phi1')
    lambda_1 = Parameter('lambda1')

    qc = QuantumCircuit(2)

    qc.u3(theta_0, phi_0, lambda_0, 0)
    qc.u3(theta_1, phi_1, lambda_1, 1)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.x(1)
    qc.h(1)

    qc.ch(0, 1)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.x(1)
    qc.h(1)
    qc.x(1)

    qc.ch(0, 1)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.h(1)

    qc.ch(0, 1)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    theta = math.acos(math.sqrt(1/3)) * 2
    qc.ry(theta, 0)
    qc.ch(0, 1)
    qc.x(0)
    return qc
'''


'''python
from qiskit import QuantumCircuit
import math

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    theta = math.acos(math.sqrt(1/3)) * 2
    qc.ry(theta, 0)
    qc.ch(0, 1)
    qc.x(0)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.ch(0, 1)
    qc.x(0)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    qc.h(0)
    qc.ch(0, 1)
    qc.x(0)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    qc.h(range(2))
    qc.z(1)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    qc.h(0)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.ch(0, 1)
    qc.x(0)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.ch(0, 1)
    qc.cx(1, 0)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(1)
    qc.ch(1,0)
    qc.x(1)

    return qc
'''


'''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import Initialize
import numpy as np

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(4)

    # Example amplitudes (normalize them)
    a0, a1, a2 = 0.5, 0.5, 0.70710678
    norm = np.sqrt(abs(a0)**2 + abs(a1)**2 + abs(a2)**2)
    a0, a1, a2 = a0/norm, a1/norm, a2/norm

    # Target vector [a0, a2, a1, 0] in basis order
    vec = [a0, a2, a1, 0]

    init = Initialize(vec)

    qc.append(init, [0, 1])  # first |ψ⟩
    qc.append(init, [2, 3])  # second |ψ⟩

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.ch(0,1)
    qc.x(0)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.cnot(1,0)
    qc.ry(0.1,1)
    qc.cnot(0,1)
    qc.ry(-0.1,1)
    qc.cnot(1,0)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve(n: int) -> QuantumCircuit:
    qc = QuantumCircuit(2)
    qc.h(0)
    qc.ch(0, 1)
    return qc

# if __name__ == "__main__":
#     from qiskit.quantum_info import Statevector
#     qc = solve()
#     print(Statevector(qc))
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    qc.h(0)
    qc.ch(0, 1)
    return qc

# if __name__ == "__main__":
#     from qiskit.quantum_info import Statevector
#     qc = solve()
#     print(Statevector(qc))
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    qc.h(0)
    qc.ch(0, 1)
    qc.x(0)
    return qc

# if __name__ == "__main__":
#     from qiskit.quantum_info import Statevector
#     qc = solve()
#     print(Statevector(qc))
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0),
    qc.ch(0,1),
    qc.x(0)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.h(1)
    qc.ry(0.5, 0)
    qc.ry(0.5, 1)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.h(1)
    qc.ry(1.57, 0)
    qc.ry(1.57, 1)
    qc.x(0)
    qc.x(1)
    return qc
'''