


"""simple docstring"""


def  UpperCAmelCase__	():
  """simple docstring"""

  _snake_case							:		Union[str, Any]								=  [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]

  _snake_case							:		List[Any]								=  6
  _snake_case							:		Optional[Any]								=  1
  _snake_case							:		Dict								=  19_01

  _snake_case							:		List[str]								=  0

  while year < 20_01:
    day += 7

    if (year % 4 == 0 and year % 1_00 != 0) or (year % 4_00 == 0):
      if day > days_per_month[month - 1] and month != 2:
        month += 1
        _snake_case							:		Union[str, Any]								=  day - days_per_month[month - 2]
      elif day > 29 and month == 2:
        month += 1
        _snake_case							:		Optional[int]								=  day - 29
    else:
      if day > days_per_month[month - 1]:
        month += 1
        _snake_case							:		int								=  day - days_per_month[month - 2]

    if month > 12:
      year += 1
      _snake_case							:		Dict								=  1

    if year < 20_01 and day == 1:
      sundays += 1
  return sundays


if __name__ == "__main__":
     print(solution())








"""simple docstring"""


import math

import numpy as np
import qiskit
from qiskit import Aer, ClassicalRegister, QuantumCircuit, QuantumRegister, execute


def  UpperCAmelCase__	(snake_case__							: int = 3   ):
  """simple docstring"""

  if isinstance(snake_case__		,       snake_case__   ):
    raise TypeError("""number of qubits must be a integer."""   )
  if number_of_qubits <= 0:
    raise ValueError("""number of qubits must be > 0."""   )
  if math.floor(snake_case__   ) != number_of_qubits:
    raise ValueError("""number of qubits must be exact integer."""   )
  if number_of_qubits > 10:
    raise ValueError("""number of qubits too large to simulate(>10)."""   )

  _snake_case							:		Optional[int]								=  QuantumRegister(snake_case__		,       """qr"""   )
  _snake_case							:		List[Any]								=  ClassicalRegister(snake_case__		,       """cr"""   )

  _snake_case							:		Optional[int]								=  QuantumCircuit(snake_case__		,       snake_case__   )

  _snake_case							:		Dict								=  number_of_qubits

  for i in range(snake_case__   ):
    quantum_circuit.h(number_of_qubits - i - 1   )
    counter -= 1
    for j in range(snake_case__   ):
      quantum_circuit.cp(np.pi / 2 ** (counter - j)		,       snake_case__		,       snake_case__   )

  for k in range(number_of_qubits // 2   ):
    quantum_circuit.swap(snake_case__		,       number_of_qubits - k - 1   )

  # measure all the qubits
  quantum_circuit.measure(snake_case__		,       snake_case__   )
  # simulate with 10000 shots
  _snake_case							:		Optional[int]								=  Aer.get_backend("""qasm_simulator"""   )
  _snake_case							:		Optional[int]								=  execute(snake_case__		,       snake_case__		,       shots=1_00_00   )

  return job.result().get_counts(snake_case__   )


if __name__ == "__main__":
     print(
         F'''Total count for quantum fourier transform state is: \
    {quantum_fourier_transform(3)}'''
     )


