code: 
  
  
  '''simple docstring'''
  
  
  
  
  
  import textwrap
  
  import pyarrow as pa
  import pytest
  
  from datasets import Features, Value
  from datasets.packaged_modules.json.json import Json
  
  
  
  
  
  
  @pytest.fixture
  def   __lowerCamelCase	(       lowerCamelCase__		:	str			):
  
  
  
  
  
  			'''simple docstring'''
  
  
  
  
  			lowerCamelCase								=     tmp_path / """file.jsonl"""
  			lowerCamelCase								=     textwrap.dedent(
  			    """\
          {\"col_1\": -1}
          {\"col_1\": 1, \"col_2\": 2}
          {\"col_1\": 10, \"col_2\": 20}
          """			)
  			with open(lowerCamelCase__     ,       """w"""			) as f:
  						f.write(lowerCamelCase__			)
  			return str(lowerCamelCase__			)
  
  
  
  
  
  
  @pytest.fixture
  def   __lowerCamelCase	(       lowerCamelCase__		:	Dict			):
  
  
  
  
  
  			'''simple docstring'''
  
  
  
  
  			lowerCamelCase								=     tmp_path / """file_utf16_encoded.jsonl"""
  			lowerCamelCase								=     textwrap.dedent(
  			    """\
          {\"col_1\": -1}
          {\"col_1\": 1, \"col_2\": 2}
          {\"col_1\": 10, \"col_2\": 20}
          """			)
  			with open(lowerCamelCase__     ,       """w"""     ,       encoding="""utf-16"""			) as f:
  						f.write(lowerCamelCase__			)
  			return str(lowerCamelCase__			)
  
  
  
  
  
  
  @pytest.fixture
  def   __lowerCamelCase	(       lowerCamelCase__		:	Union[str, Any]			):
  
  
  
  
  
  			'''simple docstring'''
  
  
  
  
  			lowerCamelCase								=     tmp_path / """file_with_list_of_dicts.json"""
  			lowerCamelCase								=     textwrap.dedent(
  			    """\
          [
              {\"col_1\": -1},
              {\"col_1\": 1, \"col_2\": 2},
              {\"col_1\": 10, \"col_2\": 20}
          ]
          """			)
  			with open(lowerCamelCase__     ,       """w"""			) as f:
  						f.write(lowerCamelCase__			)
  			return str(lowerCamelCase__			)
  
  
  
  
  
  
  @pytest.fixture
  def   __lowerCamelCase	(       lowerCamelCase__		:	str			):
  
  
  
  
  
  			'''simple docstring'''
  
  
  
  
  			lowerCamelCase								=     tmp_path / """file_with_list_of_dicts_field.json"""
  			lowerCamelCase								=     textwrap.dedent(
  			    """\
          {
              \"field1\": 1,
              \"field2\": \"aabb\",
              \"field3\": [
                  {\"col_1\": -1},
                  {\"col_1\": 1, \"col_2\": 2},
                  {\"col_1\": 10, \"col_2\": 20}
              ]
          }
          """			)
  			with open(lowerCamelCase__     ,       """w"""			) as f:
  						f.write(lowerCamelCase__			)
  			return str(lowerCamelCase__			)
  
  
  
  
  
  
  @pytest.mark.parametrize(
      """file_fixture, config_kwargs"""     ,       [
          ("""jsonl_file""", {}),
          ("""jsonl_file_utf16_encoded""", {"""encoding""": """utf-16"""}),
          ("""json_file_with_list_of_dicts""", {}),
          ("""json_file_with_list_of_dicts_field""", {"""field""": """field3"""}),
      ]     ,       )
  def   __lowerCamelCase	(       lowerCamelCase__		:	List[str]     ,       lowerCamelCase__		:	str     ,       lowerCamelCase__		:	Any			):
  
  
  
  
  
  			'''simple docstring'''
  
  
  
  
  			lowerCamelCase								=     Json(**lowerCamelCase__			)
  			lowerCamelCase								=     json._generate_tables([[request.getfixturevalue(lowerCamelCase__			)]]			)
  			lowerCamelCase								=     pa.concat_tables([table for _, table in generator]			)
  			assert pa_table.to_pydict() == {"col_1": [-1, 1, 10], "col_2": [None, 2, 20]}
  
  
  
  
  
  
  @pytest.mark.parametrize(
      """file_fixture, config_kwargs"""     ,       [
          (
              """jsonl_file""",
              {"""features""": Features({"""col_1""": Value("""int64"""			), """col_2""": Value("""int64"""			), """missing_col""": Value("""string"""			)}			)},
          ),
          (
              """json_file_with_list_of_dicts""",
              {"""features""": Features({"""col_1""": Value("""int64"""			), """col_2""": Value("""int64"""			), """missing_col""": Value("""string"""			)}			)},
          ),
          (
              """json_file_with_list_of_dicts_field""",
              {
                  """field""": """field3""",
                  """features""": Features(
                      {"""col_1""": Value("""int64"""			), """col_2""": Value("""int64"""			), """missing_col""": Value("""string"""			)}			),
              },
          ),
      ]     ,       )
  def   __lowerCamelCase	(       lowerCamelCase__		:	Tuple     ,       lowerCamelCase__		:	Union[str, Any]     ,       lowerCamelCase__		:	Tuple			):
  
  
  
  
  
  			'''simple docstring'''
  
  
  
  
  			lowerCamelCase								=     Json(**lowerCamelCase__			)
  			lowerCamelCase								=     json._generate_tables([[request.getfixturevalue(lowerCamelCase__			)]]			)
  			lowerCamelCase								=     pa.concat_tables([table for _, table in generator]			)
  			assert pa_table.to_pydict() == {"col_1": [-1, 1, 10], "col_2": [None, 2, 20], "missing_col": [None, None, None]}
  
  
style_context: 
  
  
  import math
  
  import qiskit
  from qiskit import Aer, ClassicalRegister, QuantumCircuit, QuantumRegister, execute
  
  
  
  
  
  
  def   __lowerCamelCase	(       lowerCamelCase__		:	int = 1     ,       lowerCamelCase__		:	int = 1			):
  
  
  
  
  
  			'''simple docstring'''
  
  
  
  
  			if isinstance(lowerCamelCase__     ,       lowerCamelCase__			) or isinstance(lowerCamelCase__     ,       lowerCamelCase__			):
  						raise TypeError("""inputs must be integers."""			)
  			if (bit_a < 0) or (bit_a < 0):
  						raise ValueError("""inputs must be positive."""			)
  			if (math.floor(lowerCamelCase__			) != bit_a) or (math.floor(lowerCamelCase__			) != bit_a):
  						raise ValueError("""inputs must be exact integers."""			)
  			if (bit_a > 1) or (bit_a > 1):
  						raise ValueError("""inputs must be less or equal to 1."""			)
  
  			# build registers
  			lowerCamelCase								=     QuantumRegister(2     ,       """qr"""			)
  			lowerCamelCase								=     ClassicalRegister(2     ,       """cr"""			)
  
  			lowerCamelCase								=     QuantumCircuit(lowerCamelCase__     ,       lowerCamelCase__			)
  
  			# entanglement the qubits
  			quantum_circuit.h(1			)
  			quantum_circuit.cx(1     ,       0			)
  
  			# send the information
  			lowerCamelCase								=     str(lowerCamelCase__			) + str(lowerCamelCase__			)
  
  			if c_information == "11":
  						quantum_circuit.x(1			)
  						quantum_circuit.z(1			)
  			elif c_information == "10":
  						quantum_circuit.z(1			)
  			elif c_information == "01":
  						quantum_circuit.x(1			)
  			else:
  						quantum_circuit.i(1			)
  
  			# unentangled the circuit
  			quantum_circuit.cx(1     ,       0			)
  			quantum_circuit.h(1			)
  
  			# measure the circuit
  			quantum_circuit.measure(lowerCamelCase__     ,       lowerCamelCase__			)
  
  			lowerCamelCase								=     Aer.get_backend("""aer_simulator"""			)
  			lowerCamelCase								=     execute(lowerCamelCase__     ,       lowerCamelCase__     ,       shots=1000			)
  
  			return job.result().get_counts(lowerCamelCase__			)
  
  
  if __name__ == "__main__":
  		print(f"""Counts for classical state send: {superdense_coding(1,1)}""")
  
  