

import math

import qiskit
def 							__SCREAMING_SNAKE_CASE     (   a__    :   int = 1			,a__    :   int = 1			,a__    :   int = 1       )					->				Any:
	if (
	    isinstance(a__			,a__       )
	    or isinstance(a__			,a__       )
	    or isinstance(a__			,a__       )
	):
		raise TypeError("""inputs must be integers."""       )

	if (input_a < 0) or (input_a < 0) or (carry_in < 0):
		raise ValueError("""inputs must be positive."""       )

	if (
	    (math.floor(a__       ) != input_a)
	    or (math.floor(a__       ) != input_a)
	    or (math.floor(a__       ) != carry_in)
	):
		raise ValueError("""inputs must be exact integers."""       )

	if (input_a > 2) or (input_a > 2) or (carry_in > 2):
		raise ValueError("""inputs must be less or equal to 2."""       )

	# build registers
	__A :			List[Any]		    =			qiskit.QuantumRegister(4			,"""qr"""       )
	__A :			List[Any]		    =			qiskit.ClassicalRegister(2			,"""cr"""       )
	# list the entries
	__A :			str		    =			[input_a, input_a, carry_in]

	__A :			Tuple		    =			qiskit.QuantumCircuit(a__			,a__       )

	for i in range(0			,3       ):
		if entry[i] == 2:
			quantum_circuit.h(a__       )  # for hadamard entries
		elif entry[i] == 1:
			quantum_circuit.x(a__       )  # for 1 entries
		elif entry[i] == 0:
			quantum_circuit.i(a__       )  # for 0 entries

    # build the circuit
	quantum_circuit.ccx(0			,1			,3       )  # ccx = toffoli gate
	quantum_circuit.cx(0			,1       )
	quantum_circuit.ccx(1			,2			,3       )
	quantum_circuit.cx(1			,2       )
	quantum_circuit.cx(0			,1       )

	quantum_circuit.measure([2, 3]			,a__       )  # measure the last two qbits

	__A :			Tuple		    =			qiskit.Aer.get_backend("""aer_simulator"""       )
	__A :			Any		    =			qiskit.execute(a__			,a__			,shots=1000       )

	return job.result().get_counts(a__       )


if __name__ == "__main__":
			print(f"""Total sum count for state is: {quantum_full_adder(1, 1, 1)}""")







'''simple docstring'''
import numpy as np







def 		A_(     A						:		str		,     A						:		Optional[Any]		,     A						:		Tuple		,     A						:		Optional[int]		,     A						:		str):
							UpperCamelCase   			=     int(np.ceil((x_end - xa) / h))
							UpperCamelCase   			=     np.zeros((n + 1,))
							UpperCamelCase   			=     ya
							UpperCamelCase   			=     xa

							for k in range(A):
														UpperCamelCase   			=     f(A		,     y[k])
														UpperCamelCase   			=     f(x + 0.5 * h		,     y[k] + 0.5 * h * ka)
														UpperCamelCase   			=     f(x + 0.5 * h		,     y[k] + 0.5 * h * ka)
														UpperCamelCase   			=     f(x + h		,     y[k] + h * ka)
														UpperCamelCase   			=     y[k] + (1 / 6) * h * (ka + 2 * ka + 2 * ka + ka)
														x += h

							return y


if __name__ == "__main__":
						import doctest

						doctest.testmod()




