'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.h(1)
    qc.ry(np.pi/2, 0)
    qc.ry(np.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:
    qc.h(0)
    alpha_1 = 0.5
    qc.u1(alpha_1, 1)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    qc.h(0)
    qc.h(1)
    qc.cx(0, 1)
    a0, a1, a2 = 0.5, 0.3, 0.8
    qc.u3(2 * a0, 0, 0, 0)  # a0を適用
    qc.u3(2 * a1, 0, 0, 1)  # a1を適用
    qc.h(0)
    qc.h(1)
    return qc
'''


'''python
from qiskit import QuantumCircuit

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


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    qc.initialize([1, 0], 0)
    qc.initialize([0, 1], 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.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.h(1)
    theta = 0.5
    qc.rz(theta, 1)

    return qc
'''


'''python
from qiskit import QuantumCircuit

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

    return qc
'''


'''python
from qiskit import QuantumCircuit

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

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    theta_0 = 0.1
    theta_1 = 0.2
    theta_2 = 0.3

    qc.ry(theta_0, 0)
    qc.ry(theta_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.h(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.sdg(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.h(1)
    qc.cp(2 * 3.141592653589793 / 3, 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)

    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.ccx(0, 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).c_if(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)

    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)

    # 最初の量子ビットを状態 |+⟩ にする
    qc.h(0)

    # 制御されたY回転を使って振幅を調整し、重ね合わせを作成する
    theta = 2 * np.arccos(1/np.sqrt(3))
    qc.cry(theta, 0, 1)

    # Toffoli（CCX）ゲートを使用して最後の振幅を調整（状態 |11⟩ を |01⟩ に変換）
    qc.cx(0, 1)

    # この時点で量子回路は次の状態になっている
    # (1/√3)(|00⟩ + |01⟩ + |10⟩)

    return qc
'''


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

def solve() -> QuantumCircuit:
    # Create a quantum circuit with 2 qubits
    qc = QuantumCircuit(2)

    # Apply Hadamard gate to qubit 0 to create an equal superposition of |0> and |1>
    qc.h(0) # This creates the state (|0> + |1>) for qubit 0

    # Apply a controlled NOT gate (CNOT) with qubit 0 as control and qubit 1 as target
    qc.cx(0, 1)

    # Apply rotation to undo the effect of cx on |11>
    qc.ry(-2 * sqrt(2)/sqrt(3), 1)

    # Apply a controlled Y-rotation to create the state (|00> + |01> + |10>)/sqrt(3), ignoring global phase
    qc.cry(2 * sqrt(2)/sqrt(3), 0, 1)

    # Apply extra gates to balance global phase, if necessary (problem statement omits requirement)

    # Return the quantum circuit
    return qc
'''


'''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import U3Gate
from math import sqrt

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

    # Apply H gate to qubit 0 to get (|0> + |1>)/sqrt(2)
    qc.h(0)

    # Apply U3 gate to qubit 0 to adjust amplitude from 1/sqrt(2) to 1/sqrt(3)
    theta = 2 * acos(sqrt(2/3))
    qc.u3(theta, 0, 0, 0)

    # Controlled-U3 operation with angle to get 1/sqrt(3) amplitude for |01>
    # Since qubit 1 is our target, we invert our control and target for CU3
    qc.x(0)
    qc.cu3(2*acos(1/sqrt(3)), 0, 0, 0, 1)
    qc.x(0)

    return qc
'''


'''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import U3Gate
from math import sqrt, acos

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

    # Apply H gate to qubit 0 to get (|0> + |1>)/sqrt(2)
    qc.h(0)

    # Apply U3 gate to qubit 0 to adjust amplitude from 1/sqrt(2) to 1/sqrt(3)
    theta = 2 * acos(sqrt(2/3))
    qc.u3(theta, 0, 0, 0)

    # Controlled-U3 operation with angle to get 1/sqrt(3) amplitude for |01>
    # Since qubit 1 is our target, we invert our control and target for CU3
    qc.x(0)
    qc.cu3(2*acos(1/sqrt(3)), 0, 0, 0, 1)
    qc.x(0)

    return qc
'''


'''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import U3Gate
from math import sqrt, arccos as acos

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

    # Apply H gate to qubit 0 to get (|0> + |1>)/sqrt(2)
    qc.h(0)

    # Apply U3 gate to qubit 0 to adjust amplitude from 1/sqrt(2) to 1/sqrt(3)
    theta = 2 * acos(sqrt(2/3))
    qc.u3(theta, 0, 0, 0)

    # Controlled-U3 operation with angle to get 1/sqrt(3) amplitude for |01>
    # Since qubit 1 is our target, we invert our control and target for CU3
    qc.x(0)
    qc.cu3(2*acos(1/sqrt(3)), 0, 0, 0, 1)
    qc.x(0)

    return qc
'''


'''python
from math import sqrt
from qiskit import QuantumCircuit
from qiskit.circuit.library import QFT  # QFT is not used in this problem but included due to unclear wording

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Initialize amplitudes
    amplitude = 1 / sqrt(3)

    # Apply a Hadamard gate to the first qubit to create a superposition
    qc.h(0)  # This creates the state (|0⟩ + |1⟩) / sqrt(2) for the first qubit
    # Now we need to adjust the first qubit's probabilities to create the state (2|0⟩ + |1⟩) / sqrt(3)
    # We can apply a controlled rotation to achieve this
    angle = 2 * acos(sqrt(2/3))  # Calculate the required rotation angle
    qc.cry(angle, 0, 1)  # Apply controlled rotation to the second qubit
    qc.cx(0, 1)  # Use the first qubit to control the NOT gate on the second qubit
    qc.x(0)  # Apply a NOT gate to the first qubit to create the state |10⟩

    return qc
'''


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

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

    # 3つの状態の重ね合わせで、それぞれの振幅が1/sqrt(3)
    # |0⟩(|00⟩)の振幅は既に1なので変更不要。

    # |1⟩(|10⟩)の振幅を設定するために、制御NOTを1量子ビット目に適用
    qc.cx(0, 1)
    qc.ry(2 * acos(1 / sqrt(3)), 0)  # Y軸周りの回転で振幅を調整
    qc.cx(0, 1)

    # |2⟩(|01⟩)の振幅を設定するために、必要な操作を適用
    qc.x(0)  # |00⟩の状態を反転して|01⟩にする
    qc.ry(2 * acos(1 / sqrt(3)), 1)  # Y軸周りの回転で振幅を調整
    qc.x(0)  # |01⟩の状態を|00⟩に戻す

    return qc
'''


'''python
from math import sqrt, acos

from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    theta = 2 * acos(sqrt(1/3))
    theta2 = 2 * acos(sqrt(1/2))

    qc.ry(theta, 0)
    qc.cry(theta2, 0, 1)
    qc.x(0)

    return qc
'''


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

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

    qc.p(2 * acos(sqrt(2) / sqrt(3)), 0)
    qc.h(1)
    qc.ch(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.p(2 * acos(sqrt(2) / sqrt(3)), 0)
    qc.ch(1, 0)

    return qc
'''


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

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

    qc.ry(2 * acos(sqrt(2) / sqrt(3)), 0)
    qc.ch(1, 0)

    return qc
'''


'''python
from qiskit import QuantumCircuit
import math

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

    t = 4 * math.atan(math.sqrt(3) / (3 + math.sqrt(6)))
    qc.ry(t, 0)
    qc.ch(1, 0)

    return qc
'''


'''python
from qiskit import QuantumCircuit
import math

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

    t = 4 * math.acos(math.sqrt(2) / math.sqrt(3))
    qc.ry(t, 0)
    qc.ch(1, 0)

    return qc
'''


'''python
from qiskit import QuantumCircuit
import math

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

    t = 4 * math.acos(math.sqrt(2) / math.sqrt(3))
    qc.ry(t, 0)
    qc.ch(0, 1)

    return qc
'''


'''python
from qiskit import QuantumCircuit
import math

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

    t = 2 * math.acos(math.sqrt(2) / math.sqrt(3))
    qc.ry(t, 0)
    qc.ch(0, 1)

    return qc
'''


'''python
from qiskit import QuantumCircuit
import math

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

    t = 2 * math.acos(math.sqrt(2) / math.sqrt(3))
    qc.ry(t, 1)
    qc.ch(1, 0)

    return qc
'''


'''python
from qiskit import QuantumCircuit
import math

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

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

    return qc
'''


'''python
from qiskit import QuantumCircuit
import math

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

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

    return qc
'''


'''python
from qiskit import QuantumCircuit
import math

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

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

    return qc
'''


'''python
from qiskit import QuantumCircuit
import math

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    qc.r(2*math.acos(1.0/math.sqrt(3.0)), math.pi/2, 0)
    qc.ch(0, 1)
    qc.x(0)
    return qc
'''


'''python
from qiskit import QuantumCircuit
import math

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    theta=4*math.atan(math.sqrt(6)/(3+math.sqrt(3)))
    # Write your code here:
    qc.ry(theta,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:
    qc.ry(2*acos(1/sqrt(3)),0)
    qc.x(0)
    qc.ch(0,1)
    qc.x(0)
    return qc
'''


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

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


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

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.ry(2*asin(1/sqrt(3)),0)
    qc.x(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 = 2 * math.acos(1 / math.sqrt(3))
    qc.ry(theta, 0)
    qc.cx(0, 1)
    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 = 2 * math.acos(1 / math.sqrt(3))
    qc.ry(theta, 0)
    qc.cx(0, 1)
    qc.ch(0, 1)
    qc.x(1)
    qc.x(0)

    return qc
'''


'''python
from qiskit import QuantumCircuit
import math

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

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

    return qc
'''


'''python
from qiskit import QuantumCircuit
import math

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

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

    return qc
'''


'''python
from qiskit import QuantumCircuit
import math

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

    theta = math.atan(math.sqrt(2))

    qc.ry(theta, 0)
    qc.ch(0, 1)
    qc.cx(1, 0)

    return qc
'''


'''python
from qiskit import QuantumCircuit
import math

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

    theta = 2 * math.atan(math.sqrt(2))

    qc.ry(theta, 0)
    qc.ch(0, 1)
    qc.cx(1, 0)

    return qc
'''


'''python
import
from qiskit import QuantumCircuit

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


'''python
import math
from qiskit import QuantumCircuit

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


'''python
import mat
from qiskit import QuantumCircuit

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


'''python
import math
from qiskit import QuantumCircuit

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


'''python
from qiskit import QuantumCircuit
import math

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    t=2*math.acos(1/sqrt(3))
    qc.rx(t,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:
    t=2*math.acos(1/math.sqrt(3))
    qc.rx(t,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:
    t=4*math.atan(math.sqrt(6)/(math.sqrt(3)+3))
    qc.ry(t,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 = math.atan(math.sqrt(2))
    qc.ry(2*theta, 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=4*math.atan(math.sqrt(6)/(3+math.sqrt(3)))
    qc.ry(theta,0)
    qc.cx(0,1)
    qc.ry(theta,1)
    qc.cx(1,2)
    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.arccos(1/np.sqrt(3)),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:
    qc.p(math.asin(1/math.sqrt(3),0),0)
    qc.x(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:
    qc.p(math.asin(1/math.sqrt(3)),0)
    qc.x(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:
    qc.p(math.acos(1/math.sqrt(3),),0)
    qc.x(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:
    qc.rz(math.asin(1/math.sqrt(3)),0)
    qc.x(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:
    qc.ry(math.asin(1/math.sqrt(3)),0)
    qc.x(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:
    qc.ry(math.acos(1/math.sqrt(3)),0)
    qc.x(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:
    qc.ry(2*math.asin(1/math.sqrt(3)),0)
    qc.x(0)
    qc.ch(0,1)
    qc.x(0)
    return qc
'''


'''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
import math

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

    # Apply a Hadamard gate to the first qubit
    qc.h(0)

    # Apply a CNOT gate with the first qubit as control and the second as target
    qc.cx(0, 1)

    # Manipulate the probabilities to remove |11> state
    # This might involve applying additional gates and requires careful design
    # One possible way is to apply a controlled Z gate with a phase shift
    qc.cz(0,1)
    qc.p(-math.pi/2, 1)

    return qc
'''


'''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZGate
import math
def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    theta = 2*math.atan(-(math.sqrt(2)-1)/(math.sqrt(2)+1))
    # Apply a Hadamard gate to the first qubit
    qc.h(0)
    qc.ry(theta,0)
    qc.h(1)
    qc.ch(0,1)
    #qc.ry(math.pi/2,1)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    theta = 4 * math.atan(math.sqrt(6)/ (3 + math.sqrt(3)))

    qc.ry(theta, 0)
    qc.ch(0, 1)
    qc.cx(1, 0)

    return qc
'''


'''python
from qiskit import QuantumCircuit
import math

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    theta = 4 * math.atan(math.sqrt(6)/ (3 + math.sqrt(3)))

    qc.ry(theta, 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:
    qc.h(0)
    qc.rz(math.acos(1/3),0)
    qc.h(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:
    qc.h(0)
    qc.rz(2*math.acos(1/3),0)
    qc.h(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:
    qc.ry(2*math.acos(1/math.sqrt(3)),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:
    qc.r(math.pi/4, math.pi/2, 0)
    qc.u(1.23, 0, 0, 1)
    qc.cx(0,1)
    qc.r(math.pi/4, math.pi/2, 0)
    qc.cx(0,1)
    return qc
'''


'''python
from qiskit import QuantumCircuit
import math

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    initial_state = np.array([1, 1, 1, 0], dtype=float)
    initial_state /= np.linalg.norm(initial_state)
    qc.initialize(initial_state)
    return qc
'''


'''python
from qiskit import QuantumCircuit
import math

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.u(math.pi/2,0,0,0)
    qc.u(math.pi/2,0,0,1)
    qc.cx(1,0)
    qc.u(0,0,0,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.u(math.pi/4,0,0,0)
    qc.u(1.23,0,0,1)
    qc.cx(1,0)
    qc.u(math.pi/4,0,0,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.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
import math
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
import math
from qiskit.circuit.library import CHGate

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    theta = 4 * math.atan(math.sqrt(6)/ (3 + math.sqrt(3)))

    qc.ry(theta, 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:
    desired_vector = [
        1/ math.sqrt(3),
        1/ math.sqrt(3),
        1/ math.sqrt(3),
        0,
    ]
    qc.initialize(desired_vector)

    return qc
'''


'''python
#%%
from qiskit import QuantumCircuit
import math

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

    return qc
'''


'''python
#%%
from qiskit import QuantumCircuit
import math

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    theta = math.acos(math.sqrt(2./3.))*2.0
    qc.h(0)
    qc.x(0)
    qc.crx(-theta, 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(2./3.))*2.0
    qc.rx(theta, 0)
    qc.x(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(2./3.))*2.0
    qc.rx(-theta, 0)
    qc.x(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(2./3.))*2.0
    qc.ry(theta, 0)
    qc.x(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:
    qc.h(0)
    qc.ch(0,1)
    qc.cx(1,0)
    qc = qc*

    return qc
'''


'''python
from qiskit import QuantumCircuit
import math

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    theta = 4 * math.atan(math.sqrt(6)/ (3 + math.sqrt(3)))

    qc.ry(theta, 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)
    # 00 10
    # 00 の割合多くしたいね
    print(atan((2*sqrt(3)-3) / (3+sqrt(6))*4))
    qc.ry(atan(0.35),0)
    ## 00 -> 01 or 10
    # 0.7 0.5 0.5 0
    qc.ch(0,1)
    qc.cx(1, 0)
    #qc.rx(np.pi/ 2,0)

    # Write your code here:

    return qc
'''


'''python
from qiskit import QuantumCircuit
from math import atan

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

    qc.ry(atan(0.35),0)
    ## 00 -> 01 or 10
    # 0.7 0.5 0.5 0
    qc.ch(0,1)
    qc.cx(1, 0)
    #qc.rx(np.pi/ 2,0)

    # Write your code here:

    return qc
'''


'''python
from qiskit import QuantumCircuit
from math import ata

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

    qc.ry(atan(0.353555),0)
    ## 00 -> 01 or 10
    # 0.7 0.5 0.5 0
    qc.ch(0,1)
    qc.cx(1, 0)
    #qc.rx(np.pi/ 2,0)

    # Write your code here:

    return qc
'''


'''python
from qiskit import QuantumCircuit
from math import atan

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

    qc.ry(atan(0.353555),0)
    ## 00 -> 01 or 10
    # 0.7 0.5 0.5 0
    qc.ch(0,1)
    qc.cx(1, 0)
    #qc.rx(np.pi/ 2,0)

    # Write your code here:

    return qc
'''


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

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    from qiskit.circuit.library.standard_gates import HGate

    qc.u(-np.arcsin(np.sqrt(2)/np.sqrt(3))*2,np.pi,0,0)
    c3h_gate = HGate().control(1)
    qc.append(c3h_gate,[0,1])
    qc.cnot(1,0)

    return qc
'''


'''python
from qiskit import QuantumCircuit
import math

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    from qiskit.circuit.library.standard_gates import HGate

    qc.u(-math.asin(math.sqrt(2)/math.sqrt(3))*2,math.pi,0,0)
    c3h_gate = HGate().control(1)
    qc.append(c3h_gate,[0,1])
    qc.cnot(1,0)

    return qc
'''


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

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

    qc.u(-math.asin(math.sqrt(2)/math.sqrt(3))*2,math.pi,0,0)
    c3h_gate = HGate().control(1)
    qc.append(c3h_gate,[0,1])
    qc.cnot(1,0)

    return qc
'''


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

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

    theta = 2*atan(sqrt(2))

    qc.ry(theta, 0)
    qc.ch(0,1)
    qc.cx(1,0)
    # qc.remove_final_measurements()  # no measurements allowed
    # from qiskit.quantum_info import Statevector
    # statevector = Statevector(qc)

    return qc
'''


'''python
from qiskit import QuantumCircuit
import math

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

    theta = 4 * math.atan(math.sqrt(6)/ (3 + math.sqrt(3)))

    qc.ry(theta, 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:
    qc.ry(2*math.acos(math.sqrt(1/3)), 0)
    qc.cry(math.pi/2, 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.atan(math.sqrt(2))
    qc.rx(theta,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=math.degrees(math.atan(math.sqrt(2)))
    qc.rx(theta,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=math.atan(math.sqrt(2))
    qc.ry(2*theta,0)
    qc.ch(0,1)
    qc.cx(1,0)

    return qc
'''


'''python
from qiskit import QuantumCircuit
import math

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

    return qc
'''


'''python
from qiskit import QuantumCircuit
import math

def solve() -> QuantumCircuit:
    p=math.pi
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.rx(4 * math.atan(math.sqrt(6)/ (3 + math.sqrt(3))),0)
    qc.ch(0,1)
    qc.x(0)

    return qc
'''


'''python
from qiskit import QuantumCircuit
import math

def solve() -> QuantumCircuit:
    p=math.pi
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.ry(4 * math.atan(math.sqrt(6)/ (3 + math.sqrt(3))),0)
    qc.ch(0,1)
    qc.x(0)

    return qc
'''


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

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


'''python
from qiskit import QuantumCircuit
import math

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    qc.ry(math.pi/1.644,0)
    qc.ch(0,1)
    qc.cx(1,0)
    return qc
'''


'''python
from qiskit import QuantumCircuit
import math

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    qc.ry(math.pi/1.644270554,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:
    PI = 3.14159265358979323846264338
    qc.ry(PI*2/3,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:
    qc.ry(math.radians(120),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:
    qc.u(math.radians(120),0,0,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 = 2 * math.acos(math.sqrt(2/3))
    qc.u(theta,0,0,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:
    qc.ry(math.radians(120),0)
    qc.rx(math.radians(45),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:
    qc.h(0)
    qc.ry(2 * -0.7297, 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:
    qc.(math.radians(120),0,math.radians(180),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:
    qc.(math.radians(90),0,math.radians(180),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:
    qc.u(math.radians(120),0,math.radians(180),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:
    qc.u(math.radians(120),math.radians(45),math.radians(180),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:
    qc.h(0);
    qc.u(math.radians(30),0,math.radians(180),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:
    qc.h(0);
    qc.u(math.radians(30),math.radians(30),math.radians(180),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:
    qc.h(0);
    qc.u(math.radians(30),math.radians(30),0,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:
    qc.h(0);
    qc.u(0,math.radians(30),0,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:
    qc.h(0);
    qc.u(math.radians(30),0,0,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:
    qc.h(0);
    qc.u(0,0,math.radians(30),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:
    qc.h(0);
    qc.u(0,math.radians(30),math.radians(30),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:
    qc.h(0);
    qc.u(math.radians(30),0,math.radians(30),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:
    qc.rx(math.radians(120),0)
    qc.rz(math.radians(120),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:
    angle = 2 * math.asin(math.sqrt(1/3))
    qc.rx(angle, 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:
    angle = 2 * math.asin(math.sqrt(2/3))
    qc.rx(angle, 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:
    angle = 2 * math.asin(math.sqrt(2/3))
    qc.rz(angle, 0)
    qc.ch(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.ry(2*math.atan(math.sqrt(2)))
    qc.ch(0,1)
    qc.cx(1,0)

    return qc
'''


'''python
from qiskit import QuantumCircuit
from math

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

    return qc
'''


'''python
from qiskit import QuantumCircuit
from math

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    theta = 2*math.atan(math.sqrt(2))
    qc.ry(theta,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 = 2*math.atan(math.sqrt(2))
    qc.ry(theta,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 = 2 * math.atan(math.sqrt(2))
    qc.ry(theta, 0)
    qc.ch(1)
    qc.x(0)
    return qc
'''


'''python
from qiskit import QuantumCircuit
import math

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    theta = 2 * math.atan(math.sqrt(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)
    theta = 2 * math.atan(2 ** 0.5)
    qc.ry(theta, 0)
    qc.ch(0, 1)
    qc.cx(1, 0)
    return qc
'''


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

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
 theta = 2 * acos(1/sqrt(3))
    qc.ry(theta, 0)  # Ryゲートで |00⟩, |10⟩ の重ね合わせを作る

    # 量子ビット1に対しても同様の回転ゲートを適用
    qc.ry(theta, 1)
    return qc
'''


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

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    theta = 2 * acos(1/sqrt(3))
    qc.ry(theta, 0)  # Ryゲートで適切な重ね合わせを作成

    # 量子ビット1に対しても同様の回転ゲートを適用
    qc.ry(theta, 1)
    return qc
'''


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

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.ry(1.23096, 0)  # 1.23096 ≒ 2*acos(2/3)

    # 量子ビット1に適切なRyを適用
    qc.ry(1.23096, 1)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.ry(1.23096, 0)  # 1.23096 ≒ 2*acos(2/3)

    # 量子ビット1に適切なRyを適用
    qc.ry(1.23096, 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
import mat

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    theta = 4 * math.atan(math.sqrt(6)/ (3 + math.sqrt(3)))

    qc.ry(theta, 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 = 4 * math.atan(math.sqrt(6)/ (3 + math.sqrt(3)))

    qc.ry(theta, 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
import math

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    qc.u(-math.pi*2/3, 0, 0)(0)
    qc.ch(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.u(-math.pi*2/3, 0, 0)
    qc.ch(0, 1)

    return qc
'''


'''python
from qiskit import QuantumCircuit
import math

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.x(0)
    qc.cu((2.0/3.0)**(0.5), 0, 0, 0, 0, 1)
    qc.x(1)
    qc.ch(1, 0)
    qc.x(0)
    qc.x(1)

    return qc
'''


'''python
from qiskit import QuantumCircuit
import math

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.x(0)
    qc.cu(math.arcsin((2.0/3.0)**(0.5)), 0, 0, 0, 0, 1)
    qc.x(1)
    qc.ch(1, 0)
    qc.x(0)
    qc.x(1)

    return qc
'''


'''python
from qiskit import QuantumCircuit
import math

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.x(0)
    qc.cu(math.asin((2.0/3.0)**(0.5)), 0, 0, 0, 0, 1)
    qc.x(1)
    qc.ch(1, 0)
    qc.x(0)
    qc.x(1)

    return qc
'''


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

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.ry(np.pi / 3.0, 0)
    qc.cry(np.pi / 3.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.ry(2 * np.pi / 3.0, 0)
    qc.cry(2 * np.pi / 3.0, 0 ,1)
    return qc
'''


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

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


'''python
from qiskit import QuantumCircuit
import math

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


'''python
from qiskit import QuantumCircuit
import math

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


'''python
from qiskit import QuantumCircuit
import math

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


'''python
from qiskit import QuantumCircuit
import math

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


'''python
from qiskit import QuantumCircuit
import math

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


'''python
from qiskit import QuantumCircuit
import math

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


'''python
from qiskit import QuantumCircuit
import math

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.ry(2 * math.atan(math.sqrt(2)),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 = 4 * math.atan(math.sqrt(6)/ (3 + math.sqrt(3)))

    qc.ry(theta, 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:
    qc.ry(2*math.acos(math.sqrt(2/3)),1)

    qc.x(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:
    theta = 4 * math.atan(math.sqrt(6) / (3.0 + math.sqrt(3)))

    qc.ry(theta, 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 = 4 * math.atan(math.sqrt(6) / (3.0 + math.sqrt(3)))

    qc.ry(theta, 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.h(0)
    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(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 = 2 * math.acos(1 / math.sqrt(3))
    qc.ry(theta, 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:
    for i in range(100):
        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 = 4 * math.atan(math.sqrt(6) / (3 + math.sqrt(3)))
    qc.ry(theta, 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:
    qc.ry(2 * math.acos(math.sqrt(2)/math.sqrt(3)), 0)
    qc.x(0)
    qc.ch(0, 1)
    qc.x(0)
    return qc
'''


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

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    t = 4.0 * atan(sqrt(6) / (3 + sqrt(3)))
    qc.ry(t, 0)
    qc.ch(0, 1)
    qc.cx(1, 0)
    return qc
'''


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

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    t = 4.0 * artan(sqrt(6) / (3 + sqrt(3)))
    qc.ry(t, 0)
    qc.ch(0, 1)
    qc.cx(1, 0)
    return qc
'''


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

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    t = 4.0 * atan(sqrt(6) / (3 + sqrt(3)))
    qc.ry(t, 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(1)
    qc.cx(0,1)
    qc.x(1)
    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(1)
    qc.cx(0,1)
    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.h()
    qc.cx(0,1)
    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.h(0)
    qc.cx(0,1)
    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:
    from math import sqrt
    init_state = [sqrt(3)/sqrt(2), 0, 0, 0]
    qc.initialize(int_state, 0, 1)
    qc.h(1)
    qc.cx(0,1)
    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:
    from math import sqrt
    init_state = [sqrt(3)/sqrt(2), 0, 0, 0]
    qc.initialize(int_state, [0, 1])
    qc.h(1)
    qc.cx(0,1)
    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:
    from math import sqrt
    init_state = [sqrt(3)*sqrt(2), 0, 0, 0]
    qc.initialize(int_state, [0, 1])
    qc.h(1)
    qc.cx(0,1)
    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:
    from math import sqrt
    init_state = [sqrt(3)*sqrt(2), 0, 0, 0]
    qc.initialize(int_state, 0, 1)
    qc.h(1)
    qc.cx(0,1)
    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:
    from math import sqrt
    init_state = [sqrt(3)*sqrt(4), 0, 0, 0]
    qc.initialize(int_state, 0, 1)
    qc.h(1)
    qc.cx(0,1)
    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:
    from math import sqrt
    init_state = [sqrt(3)*2, 0, 0, 0]
    qc.initialize(int_state, 0, 1)
    qc.h(1)
    qc.cx(0,1)
    qc.x(1)
    qc.ch(1,0)
    qc.x(1)
    return qc
'''


'''python
from qiskit import QuantumCircuit

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

    return qc
'''


'''python
from qiskit import QuantumCircuit

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

    return qc
'''


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

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

    qc.ry(acos(1/sqrt(2)), 0)
    qc.ch(0, 1)
    qc.cx(1, 0)

    return qc
'''


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

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

    qc.ry(acos(1/sqrt(2))/2, 0)
    qc.ch(0, 1)
    qc.cx(1, 0)

    return qc
'''


'''python
from qiskit import QuantumCircuit
from math

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

    qc.ry(2*math.acos(1/math.sqrt(2)), 0)
    qc.ch(0, 1)
    qc.cx(1, 0)

    return qc
'''


'''python
from qiskit import QuantumCircuit
import math

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

    qc.ry(2*math.acos(1/math.sqrt(2)), 0)
    qc.ch(0, 1)
    qc.cx(1, 0)

    return qc
'''


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

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

    qc.ry(2*acos(1/(2**(1/2))), 0)
    qc.ch(0, 1)
    qc.cx(1, 0)

    return qc
'''


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

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

    qc.ry(2*acos(1/(3**(1/2))), 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.cz(0, 1)
    qc.ry(-2 * np.arccos(1 / np.sqrt(3)), 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.cz(0, 1)
    qc.ry(-2 * math.acos(1 / math.sqrt(3)), 0)

    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, 1)

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

    return qc
'''


'''python
from qiskit import QuantumCircuit

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

    return qc
'''


'''python
from qiskit import QuantumCircuit
import math

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

    prob_amp = math.sqrt(1 / 3)
    rot_ang = 2 * math.acos(prob_amp)
    qc.cry(rot_ang, 0, 1)
    qc.cx(1, 0)

    prob_amp = math.sqrt(1 / 2)
    rot_ang = 2 * math.acos(prob_amp)
    qc.cry(rot_ang, 1, 0)

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

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    lis = []
    k = 3
    tmp = 0
    while(k>0):
        if k%2:
            lis = lis + [tmp]
        tmp += 1
        k = k //2
    m = 2 ** (lis[0])

    for i in range(1,len(lis)):
        qc.x(lis[i])
    if lis[0] > 0:
        for i in range(lis[0]):
            qc.h(i)
    qc.ry(-2*math.acos(math.sqrt(m / 3)), lis[1])
    qc.x(lis[1])
    for i in range(lis[0],lis[1]):
        qc.ch(lis[1], i)
    qc.x(lis[1])
    for i in range(1,len(lis) - 1):
        qc.x(lis[i])
        qc.cry(-2 * math.acos(math.sqrt(2 ** lis[i] / (3 - m))), lis[i], lis[i+1])
        qc.x(lis[i])
        qc.x(lis[i+1])
        for j in range(lis[i],lis[i+1]):
            qc.ch(lis[i+1],j)
        qc.x(lis[i+1])
        m = m + 2 ** (lis[i])
    return qc
'''


'''python
from qiskit import QuantumCircuit

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


'''python
from qiskit import QuantumCircuit
import math

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    lis = []
    k = 3
    tmp = 0
    while(k>0):
        if k%2:
            lis = lis + [tmp]
        tmp += 1
        k = k //2
    m = 2 ** (lis[0])

    for i in range(1,len(lis)):
        qc.x(lis[i])
    if lis[0] > 0:
        for i in range(lis[0]):
            qc.h(i)
    qc.ry(-2*math.acos(math.sqrt(m / 3)), lis[1])
    qc.x(lis[1])
    for i in range(lis[0],lis[1]):
        qc.ch(lis[1], i)
    qc.x(lis[1])
    for i in range(1,len(lis) - 1):
        qc.x(lis[i])
        qc.cry(-2 * math.acos(math.sqrt(2 ** lis[i] / (3 - m))), lis[i], lis[i+1])
        qc.x(lis[i])
        qc.x(lis[i+1])
        for j in range(lis[i],lis[i+1]):
            qc.ch(lis[i+1],j)
        qc.x(lis[i+1])
        m = m + 2 ** (lis[i])
    return qc
'''


'''python
from qiskit import QuantumCircuit

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

    theta = 4 * math.atan(math.sqrt(6)/ (3 + math.sqrt(3)))

    qc.ry(theta, 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 = 4 * math.atan(math.sqrt(6)/ (3 + math.sqrt(3)))

    qc.ry(theta, 0)
    qc.ch(0, 1)
    qc.cx(1, 0)
    return qc
'''


'''python
from qiskit import QuantumCircuit
from math import atan

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

    return qc
'''


'''python
from qiskit import QuantumCircuit
from math import atan

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

    return qc
'''


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

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

    return qc
'''


'''python
from qiskit import QuantumCircuit
import math

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.rx(math.pi * 2/ 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)
    qc.x(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:
    qc.rx(math.acos(1 / 3))
    qc.x(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:
    qc.rx(math.acos(1 / math.sqrt(3)))
    qc.x(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:
    # qc.rx(math.acos(1 / math.sqrt(3)))
    qc.rx(math.pi * 1 / 3)
    qc.x(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:
    qc.rx(math.acos(2 / math.sqrt(3)))
    # qc.rx(math.pi * 1 / 3)
    qc.x(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:
    # x qc.rx(math.acos(2 / math.sqrt(3)))
    qc.rx(math.acos(1 / math.sqrt(3)))
    qc.x(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:
    # x qc.rx(math.acos(2 / math.sqrt(3)))
    # x qc.rx(math.acos(1 / math.sqrt(3)))
    qc.ry(math.acos(math.sqrt(1/3)))
    qc.x(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:
    # x qc.rx(math.acos(2 / math.sqrt(3)))
    # x qc.rx(math.acos(1 / math.sqrt(3)))
    qc.rx(math.pi * 2 * sqrt(2/3))
    qc.x(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:
    # x qc.rx(math.acos(2 / math.sqrt(3)))
    # x qc.rx(math.acos(1 / math.sqrt(3)))
    qc.rx(2 * math.acos(sqrt(2/3)), 0)
    qc.x(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:
    # x qc.rx(math.acos(2 / math.sqrt(3)))
    # x qc.rx(math.acos(1 / math.sqrt(3)))
    qc.rx(2 * math.acos(math.sqrt(2/3)), 0)
    qc.x(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:
    # x qc.rx(math.acos(2 / math.sqrt(3)))
    # x qc.rx(math.acos(1 / math.sqrt(3)))
    qc.rx(2 * math.acos(math.sqrt(2/3)), 0) # 00->1/3, 01->1/3
    qc.cx(0)
    qc.ch(0, 1)
    qc.cx(0)

    return qc
'''


'''python
from qiskit import QuantumCircuit
import math

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

    return qc
'''


'''python
from qiskit import QuantumCircuit
import math

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    qc.rx(2 * math.acos(math.sqrt(2/3)), 0) # 00->1/3, 01->1/3
    qc.x(0)
    qc.ch(0, 1)
    qc.x(0)

    return qc
'''


'''python
from qiskit import QuantumCircuit
import math

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    qc.rx(2 * math.acos(math.sqrt(2/3)), 0) # 00->2/3, 01->1/3
    qc.x(0)
    qc.ch(0, 1)
    qc.x(0)

    return qc
'''


'''python
from qiskit import QuantumCircuit
import math

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    qc.rx(2 * math.acos(math.sqrt(2/3)), 0) # 00->2/3, 01->1/3
    qc.x(0)
    qc.ch(0, 1)
    qc.x(0)
    qc.s(0)

    return qc
'''


'''python
from qiskit import QuantumCircuit
import math
def solve() -> QuantumCircuit:
  qc = QuantumCircuit(2)
  qc.ry(2 * math.atan(math.sqrt(2)), 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:
    import math
    qc.r(2*math.pi/3,0,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:
    import math
    qc.rx(2*math.pi/3,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:
    import math
    qc.rx(math.pi/3,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:
    import math
    qc.r(2*math.acos(1/math.sqrt(3)),0,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:
    import math
    qc.r(1,0,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:
    import math
    qc.r(2.0,0.0,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:
    import math
    qc.r(math.pi/3,0,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:
    import math
    qc.r(2*math.pi/3,0,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:
    import math
    qc.r(2*math.acos(1/math.sqrt(3)),0,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:
    import math
    qc.r(math.acos(1/math.sqrt(3)),0,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:
    import math
    qc.rx(2*math.acos(1/math.sqrt(3)),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:
    import math
    qc.rx(math.acos(1/math.sqrt(3)),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:
    import math
    qc.ry(math.acos(1/math.sqrt(3)),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:
    import math
    qc.ry(2*math.acos(1/math.sqrt(3)),0)
    qc.ch(0,1)
    qc.cx(1,0)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2, 2)
    # Write your code here:
     # Hadamardゲートを2つの量子ビットに適用
    qc.h(0)
    qc.h(1)
    qc.ch(0, 1)
    qc.measure(1, 1)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2, 2)
    # Write your code here:
     # Hadamardゲートを2つの量子ビットに適用
    qc.h(0)
    qc.h(1)
    qc.ch(0, 1)
    qc.measure(0, 0)

    return qc
'''


'''python
from qiskit import QuantumCircuit
import math

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

    return qc
'''


'''python
import math
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    qc.h(0)
    qc.ry(math.asin(1 / 3), 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
import math

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


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

def solve() -> QuantumCircuit:
	qc = QuantumCircuit(2)
	theta = 2 * acos(1 / sqrt(3))
	qc.x(0)
	qc.cry(theta, 0, 1)
	qc.ch(1, 0)
	qc.cz(0, 1)
	qc.x(0)
	qc.x(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
import math
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    theta = 2 * math.atan(math.sqrt(2))
    qc.ry(theta=theta, qubit=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:
    qc.h(0)
    qc.ry(4*math.atan(math.sqrt(3)/(3+math.sqrt(6))))
    qc.cry(-math.pi/2, 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.ry(4*math.atan(math.sqrt(3)/(3+math.sqrt(6))), 1)
    qc.cry(-math.pi/2, 1, 0)

    return qc
'''


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

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

    # Specific rotation angles to create equal superposition of 3 states
    theta1 = 2 * np.arccos(np.sqrt(2/3))  # ≈ 1.231 radians
    theta2 = np.pi/2  # 90 degrees

    qc.ry(theta1, 1)        # Rotate qubit 1
    qc.cry(theta2, 1, 0)    # Controlled rotation on qubit 0

    return qc
'''


'''python
from qiskit import QuantumCircuit
import math

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    t = 2 * math.atan(math.sqrt(2))
    qc.ry(t,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:
    import math
    qc.u3(math.acos(2/math.sqrt(3))*2,0,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:
    import math
    qc.u3(math.acos(math.sqrt(2/3))*2,0,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:
    import math
    qc.u3(0,0,0,1)
    qc.ch(1,0)
    qc.x(1)
    return qc
'''


'''python
from qiskit import QuantumCircuit
import math

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.u3(0,0,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:
    import math
    qc.u3(PI()/2,0,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:
    import math
    qc.u3(2*math.acos(math.sqrt(2/3)),0,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:
    import math
    qc.u(2*math.acos(math.sqrt(2/)),0,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:
    import math
    uni=np.array()
    qc.rx(2*math.acos(math.sqrt(1/3)),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:
    import math
    qc.rx(2*math.acos(math.sqrt(1/3)),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:
    import math
    qc.rx(2*math.acos(math.sqrt(2/3)),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:
    import math
    qc.rx(math.acos(math.sqrt(1/3)),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:
    import math
    qc.rx(math.acos(math.sqrt(2/3)),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:
    import math
    qc.rx(2*(math.acos(math.sqrt(2/3))),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:
    import math
    theta=2*(math.acos(math.sqrt(2/3)))
    qc.rx(theta,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:
    import math
    theta=math.acos(math.sqrt(1/3))
    qc.ry(theta,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:
    import math
    theta=2*math.acos(math.sqrt(1/3))
    qc.ry(theta,1)
    qc.ch(1,0)
    qc.x(1)
    return qc
'''


'''python
from qiskit import QuantumCircuit
import math

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    theta = 2*math.acos(1/math.sqrt(3))
    qc.ry(theta, 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:

    wanted_cos = (2/3)**0.5
    theta = math.acos(wanted_cos) * 2

    qc.x(0)
    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:

    wanted_cos = (2/3)**0.5
    theta = math.acos(wanted_cos) * 2

    qc.x(0)
    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:

    wanted_cos = (2/3)**0.5
    theta = - math.acos(wanted_cos) * 2

    qc.x(0)
    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 = 4 * math.atan(math.sqrt(6)/(3+math.sqrt((3))))
    qc.ry(thata, 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 = 4 * math.atan(math.sqrt(6)/(3+math.sqrt(3)))
    qc.ry(thata, 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 = 4 * math.atan(math.sqrt(6)/(3+math.sqrt(3)))
    qc.ry(theta, 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:
    state = (np.sqrt(3) ** -1) * np.array([1,1,1,0])
    qc.initialize(state)
    qc = qc.decompose().decompose().decompose().decompose().decompose().decompose()
    return qc
'''


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

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


'''python
from qiskit import QuantumCircuit
import math

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    theta = 2.0*math.arccos(1/math.sqrt(3))
    qc.ry(theta,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 = 2.0*math.acos(1/math.sqrt(3))
    qc.ry(theta,0)
    qc.ch(0,1)
    qc.cx(1,0)
    return qc
'''


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

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    U = np.array([[1/math.sqrt(3),1/math.sqrt(3),1/math.sqrt(3),0], [0,1,0,0], [0,0,1,0], [0,0,0,1]])
    qc.unitary(U, qubits = qc.qubits, label = "U")
    return qc
'''


'''python
from qiskit import QuantumCircuit
import math

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    theta = 4 * math.atan(math.sqrt(6)/ (3 + math.sqrt(3)))
    qc.ry(theta, 0) # to get 1/sqrt(3)|00> + sqrt(2)/sqrt(3)|10>
    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.h(1)

    # CNOTゲートを使用してエンタングルメントを作り出す
    qc.cx(0, 1)

    # 各量子ビットにアダマールゲートを再度適用
    qc.h(0)
    qc.h(1)

    return qc
'''


'''python
from qiskit import QuantumCircuit
import 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)
    qc.x(0)
    return qc
'''


'''python
from qiskit import QuantumCircuit
import math

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


'''python
from qiskit import QuantumCircuit
import math

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


'''python
from qiskit import QuantumCircuit
import math

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


'''python
from qiskit import QuantumCircuit
import math

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


'''python
from qiskit import QuantumCircuit
import math

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


'''python
from qiskit import QuantumCircuit
import math

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


'''python
from qiskit import QuantumCircuit
import math

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


'''python
from qiskit import QuantumCircuit
import math

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.h(0)
    angle = 2 * math.asin(math.sqrt(1/3))
    qc.cry(angle, 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.cry(2 * math.asin(1 / math.sqrt(3)), 0, 1)
    return qc
'''


'''python
from qiskit import QuantumCircuit
import math

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


'''python
from qiskit import QuantumCircuit
import math

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


'''python
from qiskit import QuantumCircuit
import math

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


'''python
from qiskit import QuantumCircuit
import math

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


'''python
from qiskit import QuantumCircuit
import math

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


'''python
from qiskit import QuantumCircuit
import math

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


'''python
from qiskit import QuantumCircuit
import math

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


'''python
from qiskit import QuantumCircuit
import math

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


'''python
from qiskit import QuantumCircuit
import math

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


'''python
from qiskit import QuantumCircuit
import math

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


'''python
from qiskit import QuantumCircuit
import math

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    theta = 2.0*math.acos(1.0/sqrt(3.0))
    # Write your code here:
    qc.u(theta,0,0,0)
    qc.x(0)
    qc.ch(0,1)
    qc.x(0)

    return qc
'''


'''python
from qiskit import QuantumCircuit
import math

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    theta = 2.0*math.acos(1.0/math.sqrt(3.0))
    # Write your code here:
    qc.u(theta,0,0,0)
    qc.x(0)
    qc.ch(0,1)
    qc.x(0)

    return qc
'''


'''python
from qiskit import QuantumCircuit
import math

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    theta = 2.0*math.acos(1.0/math.sqrt(3.0))
    # Write your code here:
    qc.u(theta,0,0,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:
    t = 4 * math.atan(math.sqrt(6)/ (3 + math.sqrt(3)))
    qc.ry(t, 0)
    qc.ch(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:
    t = 4 * math.atan(math.sqrt(6)/ (3 + math.sqrt(3)))
    qc.ry(t, 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:
    angle = 2*math.acos(1/math.sqrt(3))
    qc.ry(angle, 0)
    qc.cx(0,1)
    qc.ch(1,0)
    qc.cp(math.pi, 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:
    angle = 2*math.acos(1/math.sqrt(3))
    qc.ry(angle, 0)
    qc.cx(0,1)
    qc.ch(1,0)
    qc.cp(math.pi, 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:
    val = 1 / math.sqrt(3)
    gate = Operator([
        [val, 0, 0, 0],
        [val, 0, 0, 0],
        [val, 0, 0, 0],
        [0, 0, 0, 0]
    ])

    qc.g(gate)

    return qc
'''


'''python
from qiskit import QuantumCircuit
import math

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

    qc.g(gate)

    return qc
'''


'''python
from qiskit import QuantumCircuit
from qiskit.quantum_info import Operator
import math

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

    qc.g(gate)

    return qc
'''


'''python
from qiskit import QuantumCircuit
import math

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    val = 1.0 / math.sqrt(3)
    gate = np.array([
        [val, 0, 0, 0],
        [val, 0, 0, 0],
        [val, 0, 0, 0],
        [0, 0, 0, 0]
    ])

    qc.g(gate)

    return qc
'''


'''python
from qiskit import QuantumCircuit
import math

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    val = 1.0 / math.sqrt(3)

    return qc
'''


'''python
from qiskit import QuantumCircuit
import math

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    val = 1.0 / math.sqrt(3)

    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.cx(0,1)
    qc.ry(2 * sqrt(1/3), 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.h(0)
    qc.ry(2.0944, 0)
    return qc
'''


'''python
from qiskit import QuantumCircuit

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


'''python
from qiskit import QuantumCircuit

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


'''python
from qiskit import QuantumCircuit

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

    qc.h(0) # Apply on the 1st qubit to create the superposition

    qc.ry(2 * np.arccos(1 / np.sqrt(3)), 1)

    qc.cx(0, 1)

    qc.ry(2 * np.arcsin(1 / np.sqrt(2)), 0)

    return qc
'''


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

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

    # Step 1: Apply Ry gate to the first qubit to create the right superposition
    theta = 2 * np.arcsin(np.sqrt(1/3))
    qc.ry(theta, 0)  # Rotates the first qubit to prepare part of the superposition

    # Step 2: Apply a CNOT gate controlled on the first qubit to the second qubit
    qc.cx(0, 1)  # Entangles the first and second qubits

    return qc
'''


'''python
from qiskit import QuantumCircuit
import math

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

    theta = 4 * math.atan(math.sqrt(6)/ (3 + math.sqrt(3)))

    qc.ry(theta, 0)
    qc.ch(0, 1)
    qc.cx(1, 0)

    return qc
'''


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

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

    qc.h(0)
    qc.cry(pi/180*a, 0, 1)
    qc.cx(1,0)
    qc.cry(pi/180*b, 1, 0)
    return qc
'''


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

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

    qc.h(0)
    qc.cry(a, 0, 1)
    qc.cx(1,0)
    qc.cry(b, 1, 0)
    return qc
'''


'''python
from qiskit import QuantumCircuit
import math

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    theta =  math.atan(math.sqrt(2))
    qc.rx(theta)
    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 =  math.atan(math.sqrt(2),0)
    qc.rx(theta)
    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 =  math.atan(math.sqrt(2))
    qc.rx(theta,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 =  math.atan(math.sqrt(2))
    qc.rx(theta,1)
    qc.ch(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.atan(2*math.sqrt(2)/(1-math.sqrt(2)))
    qc.ry(theta,1)
    qc.ch(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.atan(-(2*math.sqrt(2)+4))
    qc.ry(theta,1)
    qc.ch(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.atan(-(2*math.sqrt(2)+4))
    qc.rx(theta,1)
    qc.ch(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.atan(-(2*math.sqrt(2)))
    qc.rx(theta,1)
    qc.ch(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 = 4 * math.atan(math.sqrt(6)/ (3 + math.sqrt(3)))

    qc.ry(theta, 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:
    rad = 2 / 3**0.5
    qc.rx(rad, 1)
    qc.cx(0, 1)
    qc.rx(rad, 1)
    qc.rz(rad, 1)
    return qc
'''


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

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    rad = 2 / sqrt(3)
    qc.rx(rad, 1)
    qc.cx(0, 1)
    qc.rx(rad, 1)
    qc.rz(rad, 1)
    return qc
'''


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

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    qc.h(0)
    qc.cx(0, 1)
    qc.ry(2*asin(sqrt(1/sqrt(3))), 1)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    from math import sqrt, acos
    coef = sqrt(1/3)
    theta = acos(coef) * 2

    qc.u(theta, 0, 0, 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:
    from math import sqrt, acos
    coef = sqrt(1/3)
    theta = acos(coef) * 2

    qc.u(theta, 0, 0, 0)
    qc.ch(0, 1)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    from math import sqrt, acos
    coef = sqrt(1/3)
    theta = acos(coef) * 2

    qc.u(theta, 0, 0, 0)
    qc.ch(0, 1)

    qc.x(0)

    return qc
'''


'''python
from qiskit import QuantumCircuit
import math

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    qc.ry(2.*math.acos(1./math.sqrt(3.)),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:

    theta = 4 * math.atan(math.sqrt(6)/ (3 + math.sqrt(3)))

    qc.ry(theta, 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 = 4 * math.atan(math.sqrt(6)/ (3 + math.sqrt(3)))

    qc.ry(theta, 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 = 2 * arccos(1 / (3**0.5))
    qc.ry(theta,0),
    qc.ch(1),
    qc.x(0),

    return qc
'''


'''python
from qiskit import QuantumCircuit
import math

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

    return qc
'''


'''python
from qiskit import QuantumCircuit
import math

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

    return qc
'''


'''python
from qiskit import QuantumCircuit
import math

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    theta = 2 * math.acos(1/math.sqrt(3))
    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:

    qc.ry(math.acos(1 / sqrt(3)), 0)
    qc.ch(0, 1)
    qc.c(1, 0)
    return qc
'''


'''python
from qiskit import QuantumCircuit
import math

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

    qc.ry(math.acos(1 / math.sqrt(3)), 0)
    qc.ch(0, 1)
    qc.c(1, 0)
    return qc
'''


'''python
from qiskit import QuantumCircuit
import math

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

    qc.ry(math.acos(1 / math.sqrt(3)), 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:

    th = 2 * math.atan(math.sqrt(2))
    qc.ry(th, 0)
    qc.ch(0, 1)
    qc.cx(1, 0)
    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.ry(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.ry(math.pi/3,0)
    qc.h(1)
    return qc
'''


'''python
from qiskit import QuantumCircuit
import mat

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


'''python
from qiskit import QuantumCircuit
import mat

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.ry(math.pi/3,0)
    qc.append(CRYGate, [0, 1])
    qc.x(0)

    return qc
'''


'''python
from qiskit import QuantumCircuit
import math

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

    qc.append(CRYGate, [0, 1])
    qc.x(0)

    return qc
'''


'''python
from qiskit import QuantumCircuit
import math

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

    qc.append(CRYGate(math.pi/2), [0, 1])
    qc.x(0)

    return qc
'''


'''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import CRYGate
import math

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

    qc.append(CRYGate(math.pi/2), [0, 1])
    qc.x(0)

    return qc
'''


'''python
from qiskit import QuantumCircuit
from qiskit.circuit.library import CRYGate
import math

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.ry(math.pi/3,0)
    qc.x(0)
    qc.append(CRYGate(math.pi/2), [0, 1])
    qc.x(0)

    return qc
'''


'''python
from qiskit import QuantumCircuit
import math

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    qc.ry(math.pi/3,0)
    qc.x(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:
    qc.ry(math.acos(1/3),0)
    qc.x(0)
    qc.ch(0,1)
    qc.x(0)
    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    import math
    qc.r(math.acos(-1/3)/2,math.pi/2,0)
    qc.ch(0,1)

    return qc
'''


'''python
from qiskit import QuantumCircuit

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    import math
    qc.ry((math.acos(-1/3))/2,0)
    qc.ch(0,1)
    qc.cx(1,0)

    return qc
'''


'''python
from qiskit import QuantumCircuit
import math

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

    theta = 2 * math.acos(sqrt(2/3))
    qc.ry(theta, 0)

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

    theta2 = math.pi / 2
    qc.cry(theta2, 0, 1)

    return qc
'''


'''python
from qiskit import QuantumCircuit, Aer, transpile, assemble, execute
from math import sqrt, acos

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

    theta = 2 * acos(sqrt(2/3))
    qc.ry(theta, 0)

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

    theta2 = math.pi / 2
    qc.cry(theta2, 0, 1)

    return qc
'''


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

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

    theta = 2 * acos(sqrt(2/3))
    qc.ry(theta, 0)

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

    theta2 = math.pi / 2
    qc.cry(theta2, 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.cx(0, 1)
    qc.x(1)

    theta2 = math.pi / 2
    qc.cry(theta2, 0, 1)

    return qc
'''


'''python
from qiskit import QuantumCircuit
import mat

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
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)
    # Write your code here:
    qc.x(0)

    theta = 2 * np.arccos(np.sqrt(1 / 3))
    qc.cu(theta, 0, 0, 0, 0, 1)
    qc.cx(1, 0)
    qc.ch(1,2)
    qc.cx(2,1)
    return qc
'''


'''python
from qiskit import QuantumCircuit
import math

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

    theta = 2 * arccos(sqrt(1 / 3))
    qc.cu(theta, 0, 0, 0, 0, 1)
    qc.cx(1, 0)
    qc.ch(1, 2)
    qc.cx(2, 1)
    return qc
'''


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

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

    theta = 2 * arccos(sqrt(1 / 3))
    qc.cu(theta, 0, 0, 0, 0, 1)
    qc.cx(1, 0)
    qc.ch(1, 0)
    qc.x(range(2))
    return qc
'''


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

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

    theta = 2 * np.arccos(np.sqrt(1 / 3))
    qc.cu(theta, 0, 0, 0, 0, 1)
    qc.cx(1, 0)
    qc.ch(1, 0)
    qc.x(range(2))
    return qc
'''


'''python
from qiskit import QuantumCircuit
import math

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    theta = math.atan((2-math.sqrt(2))/(2+math.sqrt(2)))
    qc.h(0)
    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 = 2 * math.atan((2-math.sqrt(2))/(2+math.sqrt(2)))
    qc.h(0)
    qc.ry(theta, 0)
    qc.ch(0, 1)
    qc.x(0)

    return qc
'''


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

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

    qc.h(pi/3, 0)
    qc.h(1)
    qc.ch(1, 0)

    return qc
'''


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

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

    qc.ry(pi/3, 0)
    qc.h(1)
    qc.ch(1, 0)

    return qc
'''