


import qiskit






def 			UpperCamelCase (     __magic_name__					:							int   ,   __magic_name__					:							int					)       ->  qiskit.result.counts.Counts:
		"""simple docstring"""




		lowercase__					      =		qiskit.Aer.get_backend("""aer_simulator"""					)

		lowercase__					      =		qiskit.QuantumCircuit(4   ,   2					)
		# encode inputs in qubits 0 and 1
		if bita == 1:
				qc_ha.x(0					)
		if bita == 1:
				qc_ha.x(1					)
		qc_ha.barrier()

		# use cnots to write XOR of the inputs on qubit2
		qc_ha.cx(0   ,   2					)
		qc_ha.cx(1   ,   2					)

		# use ccx / toffoli gate to write AND of the inputs on qubit3
		qc_ha.ccx(0   ,   1   ,   3					)
		qc_ha.barrier()

		# extract outputs
		qc_ha.measure(2   ,   0					)  # extract XOR value
		qc_ha.measure(3   ,   1					)  # extract AND value

		# Execute the circuit on the qasm simulator
		lowercase__					      =		qiskit.execute(__magic_name__   ,   __magic_name__   ,   shots=1000					)

		# Return the histogram data of the results of the experiment
		return job.result().get_counts(__magic_name__					)


if __name__ == "__main__":
	A	:		Optional[int]    =       half_adder(1, 1)
	print(F'Half Adder Output Qubit Counts: {counts}')





def 			UpperCamelCase (     __magic_name__					:							str					)       ->  List[str]:  # noqa: E741
		"""simple docstring"""




		lowercase__					      =		len(__magic_name__					)
		lowercase__					      =		0
		lowercase__					      =		[0] * n
		lowercase__					      =		[False] * n
		lowercase__					      =		[False] * n

		def dfs(__magic_name__					:							str   ,   __magic_name__					:							List[str]   ,   __magic_name__					:							str   ,   __magic_name__					:							Any					):
				if parent == root:
						out_edge_count += 1
				lowercase__					      =		True
				lowercase__					      =		at

				for to in l[at]:
						if to == parent:
								pass
						elif not visited[to]:
								lowercase__					      =		dfs(__magic_name__   ,   __magic_name__   ,   __magic_name__   ,   __magic_name__					)
								lowercase__					      =		min(low[at]   ,   low[to]					)

								# AP found via bridge
								if at < low[to]:
										lowercase__					      =		True
								# AP found via cycle
								if at == low[to]:
										lowercase__					      =		True
						else:
								lowercase__					      =		min(low[at]   ,   __magic_name__					)
				return out_edge_count

		for i in range(__magic_name__					):
				if not visited[i]:
						lowercase__					      =		0
						lowercase__					      =		dfs(__magic_name__   ,   __magic_name__   ,   -1   ,   __magic_name__					)
						lowercase__					      =		out_edge_count > 1

		for x in range(len(__magic_name__					)					):
				if is_art[x] is True:
						print(__magic_name__					)


# Adjacency list of graph
A	:		List[str]    =       {
    0: [1, 2],
    1: [0, 2],
    2: [0, 1, 3, 5],
    3: [2, 4],
    4: [3],
    5: [2, 6, 8],
    6: [5, 7],
    7: [6, 8],
    8: [5, 7],
}







compute_ap(data)

