'''python
from qiskit import QuantumCircuit

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
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

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

    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
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)
    theta = math.acos(math.sqrt(1 / 3)) * 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)
    theta = math.acos(math.sqrt(1 / 3)) * 2
    qc.u(theta, 0, 0, 0)
    qc.ch(0, 1)
    qc.x(0)
    return qc
'''


'''python
from qiskit import QuantumCircuit

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


'''python
from qiskit import QuantumCircuit

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


'''python
from qiskit import QuantumCircuit

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


'''python
from qiskit import QuantumCircuit

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

    return qc
'''


'''python
from qiskit import QuantumCircuit

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


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

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

    return qc
'''


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

def get_bit(x, y):
    return 1 if x & int(2 ** y) != 0 else 0

def solve2(qc, n: int, L: int) -> QuantumCircuit:
    M = L
    # Write your code here:
    ls = [i for i in range(n) if get_bit(M, i)]
    if len(ls) == 0:
        return qc
    for l in ls:
        qc.x(l)
    l0 = ls[0]
    if len(ls) == 1:
        for i in range(l0):
            qc.h(i)
        return qc
    l1 = ls[1]
    M0 = 2 ** l0
    if l0 > 0:
        for i in range(l0):
            qc.h(i)
    theta0 = -2 * acos(sqrt(M0 / M))
    qc.ry(theta0, l1)
    qc.x(l1)
    for i in range(l0, l1):
        qc.ch(l1, i)
    qc.x(l1)

    k = len(ls) - 1

    Mm = M0

    for m in range(1, k):
        theta_m = -2 * acos(sqrt(2 ** ls[m] / (M - Mm)))
        qc.x(l[m])
        qc.cry(theta_m, l[m+1], l[m])
        qc.x(l[m])
        qc.x(l[m+1])
        for i in range(l[m], l[m+1]):
            qc.ch(l[m+1], i)
        qc.x(l[m+1])
        Mm = Mm + 2 ** l[m]

    return qc

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    return solve2(qc, 2, 3)
'''


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

def get_bit(x, y):
    return 1 if x & int(2 ** y) != 0 else 0

def solve2(qc, n: int, L: int) -> QuantumCircuit:
    M = L
    # Write your code here:
    ls = [i for i in range(n) if get_bit(M, i)]
    if len(ls) == 0:
        for i in range(n):
            qc.h(i)
        return qc
    for l in ls[1:]:
        qc.x(l)

    l0 = ls[0]
    if len(ls) == 1:
        print(l0)
        for i in range(l0):
            qc.h(i)
        return qc

    l1 = ls[1]
    M0 = 2 ** l0
    if l0 > 0:
        for i in range(l0):
            qc.h(i)
    theta0 = -2 * acos(sqrt(M0 / M))
    qc.ry(theta0, l1)

    qc.x(l1)
    for i in range(l0, l1):
        qc.ch(l1, i)
    qc.x(l1)

    k = len(ls) - 1

    Mm = M0

    for m in range(1, k):
        theta_m = -2 * acos(sqrt(2 ** ls[m] / (M - Mm)))
        qc.x(ls[m])
        qc.cry(theta_m, ls[m], ls[m+1])
        qc.x(ls[m])
        qc.x(ls[m+1])
        for i in range(ls[m], ls[m+1]):
            qc.ch(ls[m+1], i)
        qc.x(ls[m+1])
        Mm = Mm + 2 ** ls[m]

    return qc

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    # Write your code here:
    return solve2(qc, 2, 3)
'''


'''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:
    import math
    qc.ry(4 * math.atan(math.sqrt(6)/ (3 + 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:
    # Apply the U gate on q0 with parameters (π/4, 0, 0)
    qc.u(pi/4, 0, 0, 0)

    # Apply the U gate on q1 with parameters (1.23, 0, 0)
    qc.u(1.23, 0, 0, 1)

    # Add a CX (CNOT) gate with q0 as control and q1 as target
    qc.cx(1, 0)

    # Apply another U gate on q0 with parameters (π/4, 0, 0)
    qc.u(pi/4, 0, 0, 0)

    # Add another CX gate with q0 as control and q1 as target
    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:
    # Apply the U gate on q0 with parameters (π/4, 0, 0)
    qc.u(pi/4, 0, 0, 0)

    # Apply the U gate on q1 with parameters (1.23, 0, 0)
    qc.u(1.23, 0, 0, 1)

    # Add a CX (CNOT) gate with q0 as control and q1 as target
    qc.cx(1, 0)

    # Apply another U gate on q0 with parameters (π/4, 0, 0)
    qc.u(pi/4, 0, 0, 0)

    # Add another CX gate with q0 as control and q1 as target
    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)

# CXゲートを使用してエンタングルメントを作成
    qc.cx(0, 1)
    return qc
'''


'''python
from qiskit import QuantumCircuit

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

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


'''python
from qiskit import QuantumCircuit
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

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

    qc.s(0).inverse()

    # CXゲートを1番目の量子ビットを制御ビット、2番目の量子ビットをターゲットビットに適用
    qc.cx(0, 1)
    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:

    # CNOT
    if x.size == 0:
        pass
    elif x.size == 1:
        qc.cx(x, y)

    return qc

# if __name__ == "__main__":
#     qc = solve()
#     print(qc)
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)

    qc.cx(x, y)

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

# from qiskit import (BasicAer,execute)

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

# from qiskit import (BasicAer,execute)

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:

    qc.cx(x, y)
    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:

    qc.cx(0, 1)

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    qc.cx(x[0],y[0])

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:
    qc.cz(y,x)
    qc.h(y)
    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:
    qc.cz(x,y)
    qc.h(x)
    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:
    qc.cz(x,y)
    qc.h(y)
    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    qc.cz(y,x)
    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    qc.cz(y,x)
    qc.z(x)
    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    qc.cz(y,x)
    qc.x(x)
    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    qc.x(x)
    qc.cz(y,x)
    qc.x(x)
    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    qc.x(x)
    qc.h(y)
    qc.cz(x,y)
    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    qc.x(y)
    qc.h(x)
    qc.cz(y,x)
    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    qc.cx(y,x)
    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    qc.cx(x,y)
    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:

    qc.cx(0,1)

    return qc
'''


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

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)

    qc.cnot(x, y)

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)

    qc.cx(x,y)

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:

    qc.cx(x, y)

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:

    qc.h(y[0])
    qc.cx(y[0],x[0])
    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:

    qc.cx(x[0],y[0])
    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:
    qc.h(0)
    qc.h(1)
    # 0が0→そのまま, 0が1→反転
    qc.cz(x[0],x[1])
    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:
    qc.h(0)
    qc.h(1)
    # 0が0→そのまま, 0が1→反転
    qc.cz(x[0],y[1])
    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:
    # 0が0→そのまま, 0が1→反転
    qc.cz(0,1)
    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:
    # 0が0→そのまま, 0が1→反転
    qc.cz(1,0)
    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:
    # 0が0→そのまま, 0が1→反転
    qc.h(0)
    qc.h(1)
    qc.cz(0,1)
    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:
    # xが0, yが1の2量子ビット回路とみなす
    # 0ビット目はそのまま，1ビット目を入力0ビットと1ビットの排他的論理和を取る
    # つまり．|00> => |00>, |01> => |11>, |10> => |10>, |11> => |01>
    qc.cx(0,1)
    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    def oracle(qci,x,y_fx):
        qci.cx(x,y_fx)
        qci.x(y_fx)
    qc.x(1)
    for i range(2):
        qc.h([i])
    oracle(qc,0,1)
    for i in range(2):
        qc.h([i])

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    def oracle(qci,x,y_fx):
        qci.cx(x,y_fx)
        qci.x(y_fx)
        qc.x(1)
    for i range(2):
        qc.h([i])
    oracle(qc,0,1)
    for i in range(2):
        qc.h([])

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)

    for i in range(2):       qc.h([i])
    qc.cz(0,1)
    for i in range(2):       qc.h([i])
    for i in range(2):       qc.x([i])
    qc.cz(0,1)
    for i in range(2):       qc.x([i])
    for i in range(2):       qc.h([i])
    return rc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)

    def c_oracle(qci,x,y_fx):
        qci.x(y_fx)
    qc.x(1)
    for i in range(2):
        qc.h([i])
    c_oracle(qc,0,1)
    for i in range(2):
        qc.h([i])

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)

   def dj_oracle(qci,x0,f_x):
    qci.cx(x0,f_x)
    qc.x(2)
    for i in range(2):
        qc.h([i])
    dj_oracle(qc,0,1)
    for i in range(2):
        qc.h([i])

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)

    oracle = LogicalExpressionOracle(expression)
    qc.oracle

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
def bv_oracle(qci,x0,f_x)
    qci.cx(x0,f_x)
    qc.x([1])
    for i in range(2):
        qc.h([i])
    for i in range(2):
        qc.h([i])

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
def oracle(qc):
    # 例として、00の状態に対して位相を反転するオラクルを実装
    qc.cz(0, 1)  # 00の状態に対してCZゲートを適用

    oracle(qc)

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
def oracle(qc):
    # 例として、00の状態に対して位相を反転するオラクルを実装
    qc.cz(0, 1)  # 00の状態に対してCZゲートを適用

    oracle(qc)

return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)

    qc.cz(0, 1)  # 00の状態に対してCZゲートを適用

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)

    qc.cz(0, 1)  # 00の状態に対してCZゲートを適用
    qc.cx(0,1)

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:

    # CNOTゲートを使用して制御ビットと対象ビットのXORを実行
    qc.cx(0, 1)

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:

    qc.cx(0, 1)

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister
import math
def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    qc.cx(0, 1)
    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    return qc
'''


'''python
# \lvert x \rangle \lvert y \rangle \xrightarrow{O} \lvert x \rangle \lvert y \oplus x \rangle

from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:

    qc.cx(0, 1)

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:

    qc.cx(x,y)

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    qc = QuantumCircuit(2)
    x, y = QuantumRegister(1), QuantumRegister(1)

    qc.cnot(x, y)

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:

    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    qc.cx(x, y)

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


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

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

    return qc

qc = solve()
print(qc)
#print(Statevector(qc)) #こことimportを消す
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    qc.cx(0, 1)

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:

    qc.cx(x,y)

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:

    qc.cx(x, y)

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    qc.cx(0, 1)

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister
def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:
    qc.cx(1, 0)
    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister
def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:
    qc.cx(0, 1)
    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:

    qc.cx(0, 1)

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    qc.cx(0,1)

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Apply a CNOT gate
    qc.cx(x[0], y[0])
    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:

    qc.cx(x, y)

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
import math
from qiskit import QuantumCircuit

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

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    qc.cx(x, y)

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)

    qc.cx(x, y)

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)

    # Write your code here:
    qc.cx(x,y)
    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:

    qc.cx(x, y)

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:

    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)

    qc.cx(x, y)

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:

    qc.h(x)
    qc.x(y)
    qc.cnot(x, y)

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:

    qc.h(x)
    qc.cnot(x, y)

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:

    qc.cnot(x, y)

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


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

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)

    # Apply CNOT gate to implement the oracle
    qc.cx(x, y)

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    qc.cnot(0,1)

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:

    qc.cx(0,1)

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:

    qc.cx(x, y)

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)

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

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
	x, y = QuantumRegister(1), QuantumRegister(1)
	qc = QuantumCircuit(x, y)
	qc.cx(0, 1)
	return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister
def solve() -> QuantumCircuit:
  x, y = QuantumRegister(1), QuantumRegister(1)
  qc = QuantumCircuit(x, y)
  qc.cx(0, 1)
  return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:

    qc.o(0)

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:

    qc.u(0)

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    qc.cx(x, y)

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

from qiskit import transpile
from qiskit.circuit.library import RealAmplitudes
from qiskit.quantum_info import SparsePauliOp
from qiskit_aer import AerSimulator
from qiskit import QuantumCircuit
from qiskit.visualization import plot_histogram, plot_state_city

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    circ = QuantumCircuit(x, y)
    # Write your code here:

    circ = QuantumCircuit(2)
    circ.cx(0, 1)
    return circ
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    circ = QuantumCircuit(x, y)
    # Write your code here:

    circ = QuantumCircuit(2)
    circ.cx(0, 1)
    return circ
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    qc.cx(x, y);
    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    # CXゲートを使用してエンタングルメントを作成
    qc.cx(x[0], y[0])

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    # CXゲートを使用してエンタングルメントを作成
    qc.cx(x, y)

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    # CXゲートを使用してエンタングルメントを作成
    qc.cx(x[0], y[0])

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)

    # Hadamardゲートを適用して重ね合わせ状態を生成
    qc.h(x[0])

    # CXゲートを使用してエンタングルメントを作成
    qc.cx(x[0], y[0])

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)

    qc.cx(x, y)

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:
    qc.x(x^y)

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:
    y ^= x

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:

    qc.cx(x,y)

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:

    qc.cx(0, 1)

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:

    qc.cx(0,1)

    return qc
'''


'''python
#%%
from qiskit import QuantumCircuit, QuantumRegister

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

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    qc.cx(x, y)
    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:

    qc.cx(x,y)
    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:
    oracle = "i"
    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    qc.cx(x,y)

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:

    qc.cx(x, y)

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    qc.cnot(x,y)

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)

    qc.h(0)

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)

    qc.h(0)
    qc.measure(0, 0)

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)

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

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)

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

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)

    # Implement the oracle O using a CNOT gate
    qc.cx(x[0], y[0])  # CNOT gate: x[0] controls y[0]

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:
    qc.cz(x,y)

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    qc.cx(x, y)

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    qc.cx(x, y)
    return qc

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    return qc
'''


'''python
def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)

    qc.cx(x, y)

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)

    qc.cx(x, y)

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:

    qc.cx(x,y)

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    qc.cx(x, y)
    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    qc.cx(0,1)

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    qc.cx(x, y)

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    # それぞれ1量子ビットを持つ量子レジスタを作成
    x, y = QuantumRegister(1), QuantumRegister(1)
    # 2つの量子レジスタを持つ量子回路を作成
    qc = QuantumCircuit(x, y)

    # 排他的論理和（XOR）を実装
    # コントロールされたNOTゲート（CNOT）を用いて、
    # xが|1⟩のときにのみyを反転
    qc.cx(x[0], y[0])

    return qc

# 注意：このコードは、競技プログラミング向けのテンプレートであり
# 実際には量子コンピュータもしくはシミュレータ上で実行する必要がある
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    qc.cx(0, 1)
    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)

    qc.cx(0, 1)

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:

    qc.cx(x, y)

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    return qc

# 0 0 0
# 0 1 1
# 1 0 1
# 1 1 0
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    return qc

# 0 0 0
# 0 1 1
# 1 0 1
# 1 1 0
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    return qc

# 0 0 0
# 0 1 1
# 1 0 1
# 1 1 0
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library import CXGate

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)  # 2つの量子ビットを作成
    qc = QuantumCircuit(x, y)  # 量子回路を作成

    # オラクルの実装:
    qc.cx(x[0], y[0])  # xを制御ビット、yをターゲットビットとしてCNOTゲートを適用

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve() -> QuantumCircuit:
    x, y = QuantumRegister(1), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:

    qc.cx(x,y)

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

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

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve(n: int) -> QuantumCircuit:
    x, y = QuantumRegister(n), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:
    for i in range(n):
        qc.x(i)
        qc.mcx(list(range(n)), n)
        qc.x(i)
    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve(n: int) -> QuantumCircuit:
    x, y = QuantumRegister(n), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:
    for i in range(n):
        for j in range(n):
            if j != i:
                qc.x(j)
        qc.mcx(list(range(n)), n)
        for j in range(n):
            if j != i:
                qc.x(j)
    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve(n: int) -> QuantumCircuit:
    x, y = QuantumRegister(n), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:
    for i in range(n):
        qc.cx(i, n)
    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve(n: int) -> QuantumCircuit:
    x, y = QuantumRegister(n), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    for i in range(n):
        qc.cx(i,n)

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve(n: int) -> QuantumCircuit:
    x, y = QuantumRegister(n), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    for i in range(n):
        qc.cx(i, n)

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve(n: int) -> QuantumCircuit:
    x, y = QuantumRegister(n), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:
    for i in range(n):
        qc.cx(x[i],y)
    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve(n: int) -> QuantumCircuit:
    x, y = QuantumRegister(n), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    for i in range(n):
        qc.cx(n,i)

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve(n: int) -> QuantumCircuit:
    x, y = QuantumRegister(n), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    for i in range(n):
        qc.cz(i,y)
    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve(n: int) -> QuantumCircuit:
    x, y = QuantumRegister(n), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    for i in range(n):
        qc.cx(i,y)
    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve(n: int) -> QuantumCircuit:
    x, y = QuantumRegister(n), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:
    for i in len(n):
        qc.x(i)
    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve(n: int) -> QuantumCircuit:
    x, y = QuantumRegister(n), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:
    for i in range(0,n):
        qc.x(i)
    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve(n: int) -> QuantumCircuit:
    x, y = QuantumRegister(n), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:
    for i in range(0,n-1):
        qc.cx(i,n)
    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve(n: int) -> QuantumCircuit:
    x, y = QuantumRegister(n), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:
    for i in range(0,n-1):
        qc.cx(n,i)
    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve(n: int) -> QuantumCircuit:
    x, y = QuantumRegister(n), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:
    for i in range(0,len(x)-1):
        qc.cx(n,i)
    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve(n: int) -> QuantumCircuit:
    x, y = QuantumRegister(n), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:
    for i in range(0,len(x)-1):
        qc.cx(i,len(x))
    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve(n: int) -> QuantumCircuit:
    x, y = QuantumRegister(n), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:
    n = len(x)
    for i in range(0,n-1):
        qc.h(n).cx(i,n).h(n)
    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve(n: int) -> QuantumCircuit:
    x, y = QuantumRegister(n), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:
    n = len(x)
    for i in range(0,n-1):
        qc.h(n)
        qc.cx(i,n)
        qc.h(n)
    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve(n: int) -> QuantumCircuit:
    x, y = QuantumRegister(n), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:
    n = len(x)
    for i in range(0,n-1):
        qc.h(i)
        qc.cx(i,n)
        qc.h(i)
    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve(n: int) -> QuantumCircuit:
    x, y = QuantumRegister(n), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:
    for i in range(n):
        qc.cx(x[i], y)
    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve(n: int) -> QuantumCircuit:
    x, y = QuantumRegister(n), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:

    for i in range(n - 1):
        qc.cn(i, i + 1)
    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve(n: int) -> QuantumCircuit:
    x, y = QuantumRegister(n), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:

    for i in range(n - 1):
        qc.cx(i, i + 1)
    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve(n: int) -> QuantumCircuit:
    x, y = QuantumRegister(n), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:

    for i in range(n - 1):
        qc.c(i + 1, i)
    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve(n: int) -> QuantumCircuit:
    x, y = QuantumRegister(n), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:

    for i in range(n - 1):
        qc.cx(i + 1, i)
    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve(n: int) -> QuantumCircuit:
    x, y = QuantumRegister(n), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:

    for i in range(n):
        qc.cx(i, n + 1)
    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve(n: int) -> QuantumCircuit:
    x, y = QuantumRegister(n), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:

    for i in range(n):
        qc.cx(n + 1, i)
    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve(n: int) -> QuantumCircuit:
    x, y = QuantumRegister(n), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:

    for i in range(n):
        qc.cx(n, i)
    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve(n: int) -> QuantumCircuit:
    x, y = QuantumRegister(n), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:

    for i in range(n - 1):
        qc.cx(n, i)
    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve(n: int) -> QuantumCircuit:
    x, y = QuantumRegister(n), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:

    for i in range(n - 1):
        qc.cx(0, i + 1)
    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve(n: int) -> QuantumCircuit:
    x, y = QuantumRegister(n), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:

    for i in range(n):
        qc.cx(i + 1, 0)
    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve(n: int) -> QuantumCircuit:
    x, y = QuantumRegister(n), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:

    for i in range(n):
        qc.cx(x[i], y)
    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve(n: int) -> QuantumCircuit:
    x, y = QuantumRegister(n), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:
    for i in range(n):
        qc.cx(x,y)
    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve(n: int) -> QuantumCircuit:
    x, y = QuantumRegister(n), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:
    for i in range(len(x)):
        qc.cx(x,y)
    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve(n: int) -> QuantumCircuit:
    x, y = QuantumRegister(n), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:
    for i in x:
        qc.cx(i,y)
    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve(n: int) -> QuantumCircuit:
    x, y = QuantumRegister(n), QuantumRegister(1)
    qc = QuantumCircuit(x, y)

    # Write your code here:
    # CNOTゲートを使用して、xの各ビットのXORをyに制御された方法で適用します。
    for i in range(n):
        qc.cx(x[i], y[0])

    return qc

# 以下はプログラムをテストするための初期化ブロックです。
# ただし、条件によってはこれは与えられたプログラムに含まれない場合があります。
if __name__ == "__main__":
    n = 3  # 例として3量子ビットのオラクルを作成します。
    oracle_circuit = solve(n)
    oracle_circuit.draw('mpl')

    # 出力した回路の図示やシミュレーションなどは、
    # 上記環境での実行に依存し、これは単に一例です。
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve(n: int) -> QuantumCircuit:
    x, y = QuantumRegister(n), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:

    qc.cx(x)

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve(n: int) -> QuantumCircuit:
    x, y = QuantumRegister(n), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:

    qc.cx(x, y)

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve(n: int) -> QuantumCircuit:
    x, y = QuantumRegister(n), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:
    for _ in range(n):
        qc.cx(x[_],y[0])
    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve(n: int) -> QuantumCircuit:
    x, y = QuantumRegister(n), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:
    for i in range(n):
        qc.cx(x[i], y)

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve(n: int) -> QuantumCircuit:
    x, y = QuantumRegister(n), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:

    for i in range(n):
        qc.cx(x[i], y)

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve(n: int) -> QuantumCircuit:
    x, y = QuantumRegister(n), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:

    # 各ビットに対してCNOTゲートを使用してXORを実行
    for i in range(n):
        qc.cx(i, n)

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve(n: int) -> QuantumCircuit:
    x, y = QuantumRegister(n), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:
    n = len(x)
    for i in range(n):
        qc.cx(0,i)
    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve(n: int) -> QuantumCircuit:
    x, y = QuantumRegister(n), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:
    for i in range(n):
        qc.cx(i,n)
    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve(n: int) -> QuantumCircuit:
    x, y = QuantumRegister(n), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:
    for i in range(n):
        qc.cx(i, n+1)
    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve(n: int) -> QuantumCircuit:
    x, y = QuantumRegister(n), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:
    for i in range(n):
        qc.cx(i, n)
    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve(n: int) -> QuantumCircuit:
    x, y = QuantumRegister(n), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:
    for i in range(n):
        qc.cx(i, n)

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve(n: int) -> QuantumCircuit:
    x, y = QuantumRegister(n), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:
    qc.h(range(len(x)))
    for i in range(n):
        qc.cx(i, n)
    qc.h(range(len(x)))

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve(n: int) -> QuantumCircuit:
    x, y = QuantumRegister(n), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:
    qc.h(range(len(x)))
    for i in range(n):
        qc.cx(i, n)

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve(n: int) -> QuantumCircuit:
    x, y = QuantumRegister(n), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    for i in range(0, n):
        qc.cx(x[i], y)

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve(n: int) -> QuantumCircuit:
    x, y = QuantumRegister(n), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:
    for i in range(n):
        qc.cx(x[i], y[0])
    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve(n: int) -> QuantumCircuit:
    x, y = QuantumRegister(n), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:
    # n個の量子ビットの長さ"n"を"len(x)"で取得する。
    n = len(x)

    #n個の各量子ビットを制御ビットとして、1量子ビットに制御Xゲートを作用させる。
    for i in n:
        qc.cx(x[i],n)

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve(n: int) -> QuantumCircuit:
    x, y = QuantumRegister(n), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:
    # n個の量子ビットの長さ"n"を"len(x)"で取得する。
    n = len(x)

    #n個の各量子ビットを制御ビットとして、1量子ビットに制御Xゲートを作用させる。
    i = 0
    for i in n-1:
        qc.cx(x[i],n)

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve(n: int) -> QuantumCircuit:
    x, y = QuantumRegister(n), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:
    # n個の量子ビットの長さ"n"を"len(x)"で取得する。
    n = len(x)

    #n個の各量子ビットを制御ビットとして、1量子ビットに制御Xゲートを作用させる。
    i = 0
    for i in n-1:
        qc.cx(x[i],y)

    return qc
'''


'''python
from qiskit import QuantumCircuit, QuantumRegister

def solve(n: int) -> QuantumCircuit:
    x, y = QuantumRegister(n), QuantumRegister(1)
    qc = QuantumCircuit(x, y)
    # Write your code here:
    # n個の量子ビットの長さ"n"を"len(x)"で取得する。
    n = len(x)

    #n個の各量子ビットを制御ビットとして、1量子ビットに制御Xゲートを作用させる。
    i = 0
    for i in lange(n):
        qc.cx(x[i],y)

    return qc
'''