classiq 0.62.0__py3-none-any.whl → 0.63.0__py3-none-any.whl

classiq/open_library/functions/__init__.py

@@ -0,0 +1,130 @@
+from .amplitude_estimation import *
+from .discrete_sine_cosine_transform import *
+from .discrete_sine_cosine_transform import _qct_d_operator, _qct_pi_operator
+from .grover import *
+from .hea import *
+from .linear_pauli_rotation import *
+from .linear_pauli_rotation import _single_pauli
+from .modular_exponentiation import *
+from .modular_exponentiation import _check_msb, _ctrl_x
+from .qaoa_penalty import *
+from .qft_functions import *
+from .qpe import *
+from .qsvt import *
+from .state_preparation import *
+from .state_preparation import _prepare_uniform_trimmed_state_step
+from .swap_test import *
+from .utility_functions import *
+from .variational import *
+
+OPEN_LIBRARY_FUNCTIONS = [
+    qpe_flexible,
+    qpe,
+    _single_pauli,
+    linear_pauli_rotations,
+    amplitude_estimation,
+    phase_oracle,
+    reflect_about_zero,
+    grover_diffuser,
+    grover_operator,
+    grover_search,
+    hadamard_transform,
+    apply_to_all,
+    qft_no_swap,
+    qft_space_add_const,
+    cc_modular_add,
+    c_modular_multiply,
+    multiswap,
+    inplace_c_modular_multiply,
+    modular_exp,
+    qsvt_step,
+    qsvt,
+    projector_controlled_double_phase,
+    projector_controlled_phase,
+    qsvt_inversion,
+    qsvt_lcu,
+    qsvt_lcu_step,
+    allocate_num,
+    qaoa_mixer_layer,
+    qaoa_cost_layer,
+    qaoa_layer,
+    qaoa_init,
+    qaoa_penalty,
+    full_hea,
+    swap_test,
+    prepare_uniform_trimmed_state,
+    prepare_uniform_interval_state,
+    prepare_ghz_state,
+    prepare_exponential_state,
+    prepare_bell_state,
+    inplace_prepare_int,
+    prepare_int,
+    switch,
+    qct_qst_type1,
+    qct_qst_type2,
+    qct_type2,
+    qst_type2,
+    modular_increment,
+    qft,
+    _ctrl_x,
+    _prepare_uniform_trimmed_state_step,
+    _qct_d_operator,
+    _qct_pi_operator,
+    _check_msb,
+    encode_in_angle,
+    encode_on_bloch,
+]
+
+__all__ = [
+    "_single_pauli",
+    "allocate_num",
+    "amplitude_estimation",
+    "apply_to_all",
+    "c_modular_multiply",
+    "cc_modular_add",
+    "encode_in_angle",
+    "encode_on_bloch",
+    "full_hea",
+    "grover_diffuser",
+    "grover_operator",
+    "grover_search",
+    "hadamard_transform",
+    "inplace_c_modular_multiply",
+    "inplace_prepare_int",
+    "linear_pauli_rotations",
+    "modular_exp",
+    "modular_increment",
+    "multiswap",
+    "phase_oracle",
+    "prepare_bell_state",
+    "prepare_exponential_state",
+    "prepare_ghz_state",
+    "prepare_int",
+    "prepare_uniform_interval_state",
+    "prepare_uniform_trimmed_state",
+    "projector_controlled_double_phase",
+    "projector_controlled_phase",
+    "qaoa_cost_layer",
+    "qaoa_init",
+    "qaoa_layer",
+    "qaoa_mixer_layer",
+    "qaoa_penalty",
+    "qct_qst_type1",
+    "qct_qst_type2",
+    "qct_type2",
+    "qft",
+    "qft_no_swap",
+    "qft_space_add_const",
+    "qpe",
+    "qpe_flexible",
+    "qst_type2",
+    "qsvt",
+    "qsvt_inversion",
+    "qsvt_lcu",
+    "qsvt_lcu_step",
+    "qsvt_step",
+    "reflect_about_zero",
+    "suzuki_trotter",
+    "swap_test",
+    "switch",
+]

classiq/{qmod/builtins → open_library}/functions/amplitude_estimation.py

@@ -1,5 +1,5 @@
-from classiq.qmod.builtins.functions.grover import grover_operator
-from classiq.qmod.builtins.functions.qpe import qpe
+from classiq.open_library.functions.grover import grover_operator
+from classiq.open_library.functions.qpe import qpe
 from classiq.qmod.qfunc import qfunc
 from classiq.qmod.qmod_variable import QArray, QBit, QNum
 from classiq.qmod.quantum_callable import QCallable

classiq/{qmod/builtins → open_library}/functions/discrete_sine_cosine_transform.py

@@ -1,8 +1,10 @@
-from classiq.qmod.builtins.functions.arithmetic import modular_increment
-from classiq.qmod.builtins.functions.qft_functions import qft
+from classiq.open_library.functions.qft_functions import qft
+from classiq.open_library.functions.utility_functions import (
+    apply_to_all,
+    modular_increment,
+)
+from classiq.qmod.builtins.functions import allocate
 from classiq.qmod.builtins.functions.standard_gates import PHASE, H, S, X, Z
-from classiq.qmod.builtins.functions.state_preparation import allocate
-from classiq.qmod.builtins.functions.utility_functions import apply_to_all
 from classiq.qmod.builtins.operations import bind, control, invert, repeat, within_apply
 from classiq.qmod.qfunc import qfunc
 from classiq.qmod.qmod_variable import QArray, QBit, QNum

classiq/{qmod/builtins → open_library}/functions/grover.py

@@ -1,6 +1,6 @@
+from classiq.open_library.functions.utility_functions import hadamard_transform
+from classiq.qmod.builtins.functions import allocate
 from classiq.qmod.builtins.functions.standard_gates import H, U, X
-from classiq.qmod.builtins.functions.state_preparation import allocate
-from classiq.qmod.builtins.functions.utility_functions import hadamard_transform
 from classiq.qmod.builtins.operations import (
     bind,
     control,

classiq/{qmod/builtins → open_library}/functions/linear_pauli_rotation.py

@@ -1,7 +1,7 @@
 from typing import Annotated
 
+from classiq.open_library.functions.utility_functions import switch
 from classiq.qmod.builtins.enums import Pauli
-from classiq.qmod.builtins.functions.operators import switch
 from classiq.qmod.builtins.functions.standard_gates import IDENTITY, RX, RY, RZ
 from classiq.qmod.builtins.operations import control, repeat
 from classiq.qmod.qfunc import qfunc

classiq/{qmod/builtins → open_library}/functions/modular_exponentiation.py

@@ -1,7 +1,7 @@
+from classiq.open_library.functions.qft_functions import qft, qft_no_swap
 from classiq.qmod.builtins.classical_functions import qft_const_adder_phase
-from classiq.qmod.builtins.functions.qft_functions import qft, qft_no_swap
+from classiq.qmod.builtins.functions import allocate
 from classiq.qmod.builtins.functions.standard_gates import PHASE, SWAP, X
-from classiq.qmod.builtins.functions.state_preparation import allocate
 from classiq.qmod.builtins.operations import bind, control, invert, repeat, within_apply
 from classiq.qmod.cparam import CInt
 from classiq.qmod.qfunc import qfunc

classiq/{qmod/builtins → open_library}/functions/qpe.py

@@ -1,6 +1,6 @@
-from classiq.qmod.builtins.functions.qft_functions import qft
+from classiq.open_library.functions.qft_functions import qft
+from classiq.open_library.functions.utility_functions import apply_to_all
 from classiq.qmod.builtins.functions.standard_gates import H
-from classiq.qmod.builtins.functions.utility_functions import apply_to_all
 from classiq.qmod.builtins.operations import control, invert, power, repeat
 from classiq.qmod.cparam import CInt
 from classiq.qmod.qfunc import qfunc

classiq/{qmod/builtins → open_library}/functions/state_preparation.py

@@ -1,13 +1,15 @@
 from typing import Literal
 
-from classiq.qmod.builtins.functions.arithmetic import modular_increment
+from classiq.open_library.functions.utility_functions import (
+    hadamard_transform,
+    modular_increment,
+)
+from classiq.qmod.builtins.functions import allocate
 from classiq.qmod.builtins.functions.standard_gates import CX, IDENTITY, RY, H, X
-from classiq.qmod.builtins.functions.utility_functions import hadamard_transform
 from classiq.qmod.builtins.operations import control, if_, repeat
 from classiq.qmod.cparam import CBool, CInt
 from classiq.qmod.qfunc import qfunc
-from classiq.qmod.qmod_parameter import CArray, CReal
-from classiq.qmod.qmod_variable import Input, Output, QArray, QBit, QNum
+from classiq.qmod.qmod_variable import Output, QArray, QBit, QNum
 from classiq.qmod.symbolic import (
     asin,
     atan,
@@ -21,31 +23,6 @@ from classiq.qmod.symbolic import (
 )
 
 
-@qfunc(external=True)
-def allocate(
-    num_qubits: CInt, out: Output[QArray[QBit, Literal["num_qubits"]]]
-) -> None:
-    """
-    [Qmod core-library function]
-
-    Allocates the specified number of qubits to a given quantum variable and initializes
-    them in the zero state:
-
-    $$
-        \\left|\\text{out}\\right\\rangle = \\left|0\\right\\rangle^{\\otimes \\text{num_qubits}}
-    $$
-
-    Args:
-        num_qubits: The number of qubits to allocate. Must be a positive integer.
-        out: The quantum variable that will receive the allocated qubits. Must be uninitialized before allocation.
-
-    Notes:
-        1. If the output variable has been declared with a specific number of qubits, the number of qubits allocated must match the declared number.
-        2. The synthesis engine automatically handles the allocation, either by drawing new qubits from the available pool or by reusing existing ones.
-    """
-    pass
-
-
 @qfunc
 def allocate_num(
     num_qubits: CInt,
@@ -68,126 +45,6 @@ def allocate_num(
     allocate(num_qubits, out)
 
 
-@qfunc(external=True)
-def free(in_: Input[QArray[QBit]]) -> None:
-    """
-    [Qmod core-library function]
-
-    Releases the qubits allocated to a quantum variable, allowing them to be reused.
-
-    Args:
-        in_: The quantum variable that will be freed. Must be initialized before.
-
-    Note:
-        This operation does not uncompute the qubits. It is the responsibility of the user to ensure that the qubits are at the zero state before freeing them.
-    """
-    pass
-
-
-@qfunc(external=True)
-def prepare_state(
-    probabilities: CArray[CReal],
-    bound: CReal,
-    out: Output[QArray[QBit, Literal["log(get_field(probabilities, 'len'), 2)"]]],
-) -> None:
-    """
-    [Qmod core-library function]
-
-    Initializes a quantum variable in a state corresponding to a given probability distribution:
-
-    $$
-        \\left|\\text{out}\\right\\rangle = \\sum_{i=0}^{\\text{len(probabilities)}-1} \\sqrt{\\text{probabilities}[i]} \\left|i\\right\\rangle
-    $$
-
-    with $i = 0, 1, 2, ..., \\text{len(amplitudes)}-1$ corresponding to computational basis states.
-
-    Args:
-        probabilities: The probability distribution to initialize the quantum variable. Must be a valid probability distribution, i.e., a list of non-negative real numbers that sum to 1. Must have a valid length (a power of 2).
-        bound: An error bound, expressed as the $L^{2}$ norm between the expected and actual distributions. A larger bound can reduce the circuit size at the expense of accuracy. Must be a positive real number.
-        out: The quantum variable that will receive the initialized state. Must be uninitialized.
-
-    Notes:
-        1. If the output variable has been declared with a specific number of qubits, the number of qubits formed by the distribution must match the declared number.
-        2. The synthesis engine automatically handles the allocation, either by drawing new qubits from the available pool or by reusing existing ones.
-    """
-    pass
-
-
-@qfunc(external=True)
-def prepare_amplitudes(
-    amplitudes: CArray[CReal],
-    bound: CReal,
-    out: Output[QArray[QBit, Literal["log(get_field(amplitudes, 'len'), 2)"]]],
-) -> None:
-    """
-    [Qmod core-library function]
-
-    Initializes a quantum variable in a state corresponding to the given amplitudes:
-
-    $$
-        \\left|\\text{out}\\right\\rangle = \\sum_{i=0}^{\\text{len(amplitudes)}-1} \\text{amplitudes}[i] \\left|i\\right\\rangle
-    $$
-
-    with $i = 0, 1, 2, ..., \\text{len(amplitudes)}-1$ corresponding to computational basis states.
-
-    Args:
-        amplitudes: The amplitudes to initialize the quantum variable. Must be a valid real quantum state vector, i.e., the sum of squares should be 1. Must have a valid length (a power of 2).
-        bound: An error bound, expressed as the $L^{2}$ norm between the expected and actual distributions. A larger bound can reduce the circuit size at the expense of accuracy. Must be a positive real number.
-        out: The quantum variable that will receive the initialized state. Must be uninitialized.
-
-    Notes:
-        1. If the output variable has been declared with a specific number of qubits, the number of qubits formed by the distribution must match the declared number.
-        2. The synthesis engine automatically handles the allocation, either by drawing new qubits from the available pool or by reusing existing ones.
-    """
-    pass
-
-
-@qfunc(external=True)
-def inplace_prepare_state(
-    probabilities: CArray[CReal],
-    bound: CReal,
-    target: QArray[QBit, Literal["log(get_field(probabilities, 'len'), 2)"]],
-) -> None:
-    """
-    [Qmod core-library function]
-
-    Transforms a given quantum variable in the state |0> to the state per the specified probability distribution
-    (similar to `prepare_state` but preformed on an initialized variable).
-
-    Args:
-        probabilities: The probability distribution corresponding to the quantum variable state. Must be a valid probability distribution, i.e., a list of non-negative real numbers that sum to 1. Must have a valid length (a power of 2).
-        bound: An error bound, expressed as the $L^{2}$ norm between the expected and actual distributions. A larger bound can reduce the circuit size at the expense of accuracy. Must be a positive real number.
-        target: The quantum variable to act upon.
-
-    This is useful as part of quantum building blocks like the Grover diffuser operator, $\\left|\\psi\\right\\rangle\\left\\langle\\psi\\right| \\left( 2\\left|0\\right\\rangle\\left\\langle0\\right| - \\mathcal{I} \\right)$, where the output state of the oracle is reflected about this state.
-
-    """
-    pass
-
-
-@qfunc(external=True)
-def inplace_prepare_amplitudes(
-    amplitudes: CArray[CReal],
-    bound: CReal,
-    target: QArray[QBit, Literal["log(get_field(amplitudes, 'len'), 2)"]],
-) -> None:
-    """
-    [Qmod core-library function]
-
-    Transforms a given quantum variable in the state |0> to the state per the specified amplitudes
-    (similar to `prepare_amplitudes` but preformed on an initialized variable).
-
-    Args:
-        amplitudes: The amplitudes to initialize the quantum variable. Must be a valid real quantum state vector, i.e., the sum of squares should be 1. Must have a valid length (a power of 2).
-        bound: An error bound, expressed as the $L^{2}$ norm between the expected and actual distributions. A larger bound can reduce the circuit size at the expense of accuracy. Must be a positive real number.
-        target: The quantum variable to act upon.
-
-    This is useful as part of quantum building blocks like the Grover diffuser operator, $\\left|\\psi\\right\\rangle\\left\\langle\\psi\\right| \\left( 2\\left|0\\right\\rangle\\left\\langle0\\right| - \\mathcal{I} \\right)$, where the output state of the oracle is reflected about this state.
-
-    """
-    pass
-
-
 def prepare_uniform_trimmed_state_apply_rotation(
     size_lsb: CInt, lsbs_val: CInt, rotation_var: QBit
 ) -> None:

classiq/{qmod/builtins → open_library}/functions/swap_test.py

@@ -1,5 +1,5 @@
+from classiq.qmod.builtins.functions import allocate
 from classiq.qmod.builtins.functions.standard_gates import SWAP, H
-from classiq.qmod.builtins.functions.state_preparation import allocate
 from classiq.qmod.builtins.operations import control, repeat
 from classiq.qmod.qfunc import qfunc
 from classiq.qmod.qmod_variable import Output, QArray, QBit

classiq/open_library/functions/utility_functions.py

@@ -0,0 +1,81 @@
+from typing import Annotated
+
+from classiq.open_library.functions.qft_functions import qft
+from classiq.qmod.builtins.functions.standard_gates import PHASE, H
+from classiq.qmod.builtins.operations import bind, repeat, within_apply
+from classiq.qmod.cparam import CInt
+from classiq.qmod.qfunc import qfunc
+from classiq.qmod.qmod_variable import QArray, QBit, QCallable, QNum
+from classiq.qmod.quantum_callable import QCallableList
+from classiq.qmod.symbolic import pi
+
+
+@qfunc
+def apply_to_all(
+    gate_operand: QCallable[Annotated[QBit, "target"]], target: QArray[QBit]
+) -> None:
+    """
+    [Qmod Classiq-library function]
+
+    Applies the single-qubit operand `gate_operand` to each qubit in the qubit
+    array `target`.
+
+    Args:
+        gate_operand: The single-qubit gate to apply to each qubit in the array.
+        target: The qubit array to apply the gate to.
+    """
+    repeat(target.len, lambda index: gate_operand(target[index]))
+
+
+@qfunc
+def hadamard_transform(target: QArray[QBit]) -> None:
+    """
+    [Qmod Classiq-library function]
+
+    Applies Hadamard transform to the target qubits.
+
+    Corresponds to the braket notation:
+
+    $$
+     H^{\\otimes n} |x\rangle = \frac{1}{\\sqrt{2^n}} \\sum_{y=0}^{2^n - 1} (-1)^{x \\cdot y} |y\rangle
+    $$
+
+    Args:
+        target:  qubits to apply to Hadamard transform to.
+
+    """
+    apply_to_all(H, target)
+
+
+@qfunc
+def switch(selector: CInt, cases: QCallableList) -> None:
+    cases[selector]()
+
+
+@qfunc
+def modular_increment(a: CInt, x: QNum) -> None:
+    """
+    [Qmod Classiq-library function]
+
+    Adds $a$ to $x$ modulo the range of $x$, assumed that $x$ is a non-negative integer and $a$ is an integer.
+    Mathematically it is described as:
+
+    $$
+        x = (x+a)\\ \\mod \\ 2^{x.size}-1
+    $$
+
+    Args:
+        a: A classical integer to be added to x.
+        x: A quantum number that is assumed to be non-negative integer.
+
+    """
+    array_cast: QArray = QArray("array_cast")
+    within_apply(
+        lambda: (  # type:ignore[arg-type]
+            bind(x, array_cast),  # type:ignore[func-returns-value]
+            qft(array_cast),
+        ),
+        lambda: repeat(
+            x.size, lambda i: PHASE(a * 2 * pi * 2**i / (2**x.size), array_cast[i])
+        ),
+    )

classiq/{qmod/builtins → open_library}/functions/variational.py

@@ -1,5 +1,5 @@
+from classiq.qmod.builtins.functions import allocate
 from classiq.qmod.builtins.functions.standard_gates import RX, RY, RZ
-from classiq.qmod.builtins.functions.state_preparation import allocate
 from classiq.qmod.builtins.operations import repeat
 from classiq.qmod.cparam import CReal
 from classiq.qmod.qfunc import qfunc

classiq/qmod/builtins/functions/__init__.py

@@ -1,29 +1,12 @@
-from .amplitude_estimation import *
+from .allocation import *
 from .arithmetic import *
 from .benchmarking import *
 from .chemistry import *
-from .discrete_sine_cosine_transform import *
-from .discrete_sine_cosine_transform import _qct_d_operator, _qct_pi_operator
 from .exponentiation import *
 from .finance import *
-from .grover import *
-from .hea import *
-from .linear_pauli_rotation import *
-from .linear_pauli_rotation import _single_pauli
-from .modular_exponentiation import *
-from .modular_exponentiation import _check_msb, _ctrl_x
 from .operators import *
-from .qaoa_penalty import *
-from .qft_functions import *
-from .qpe import *
 from .qsvm import *
-from .qsvt import *
 from .standard_gates import *
-from .state_preparation import *
-from .state_preparation import _prepare_uniform_trimmed_state_step
-from .swap_test import *
-from .utility_functions import *
-from .variational import *
 
 CORE_LIB_DECLS = [
     func.func_decl
@@ -87,70 +70,8 @@ CORE_LIB_DECLS = [
     )
 ]
 
-OPEN_LIBRARY_FUNCTIONS = [
-    qpe_flexible,
-    qpe,
-    _single_pauli,
-    linear_pauli_rotations,
-    amplitude_estimation,
-    phase_oracle,
-    reflect_about_zero,
-    grover_diffuser,
-    grover_operator,
-    grover_search,
-    hadamard_transform,
-    apply_to_all,
-    qft_no_swap,
-    qft_space_add_const,
-    cc_modular_add,
-    c_modular_multiply,
-    multiswap,
-    inplace_c_modular_multiply,
-    modular_exp,
-    qsvt_step,
-    qsvt,
-    projector_controlled_double_phase,
-    projector_controlled_phase,
-    qsvt_inversion,
-    qsvt_lcu,
-    qsvt_lcu_step,
-    allocate_num,
-    qaoa_mixer_layer,
-    qaoa_cost_layer,
-    qaoa_layer,
-    qaoa_init,
-    qaoa_penalty,
-    full_hea,
-    swap_test,
-    prepare_uniform_trimmed_state,
-    prepare_uniform_interval_state,
-    prepare_ghz_state,
-    prepare_exponential_state,
-    prepare_bell_state,
-    inplace_prepare_int,
-    prepare_int,
-    switch,
-    qct_qst_type1,
-    qct_qst_type2,
-    qct_type2,
-    qst_type2,
-    modular_increment,
-    qft,
-    _ctrl_x,
-    _prepare_uniform_trimmed_state_step,
-    _qct_d_operator,
-    _qct_pi_operator,
-    _check_msb,
-    encode_in_angle,
-    encode_on_bloch,
-]
-
 STD_QMOD_OPERATORS = [func.func_decl for func in (apply, permute)]
 
-BUILTIN_FUNCTION_DECLARATIONS = {
-    func_decl.name: func_decl for func_decl in STD_QMOD_OPERATORS + CORE_LIB_DECLS
-}
-
 __all__ = [  # noqa: RUF022
     "CCX",
     "CH",
@@ -181,83 +102,36 @@ __all__ = [  # noqa: RUF022
     "X",
     "Y",
     "Z",
-    "_single_pauli",
     "add",
     "allocate",
-    "allocate_num",
-    "amplitude_estimation",
     "apply",
-    "apply_to_all",
     "bloch_sphere_feature_map",
-    "c_modular_multiply",
-    "cc_modular_add",
-    "encode_in_angle",
-    "encode_on_bloch",
     "exponentiation_with_depth_constraint",
     "fock_hamiltonian_hartree_fock",
     "fock_hamiltonian_hva",
     "fock_hamiltonian_ucc",
     "free",
-    "full_hea",
     "gaussian_finance",
-    "grover_diffuser",
-    "grover_operator",
-    "grover_search",
-    "hadamard_transform",
-    "inplace_c_modular_multiply",
     "inplace_prepare_amplitudes",
-    "inplace_prepare_int",
     "inplace_prepare_state",
     "integer_xor",
-    "linear_pauli_rotations",
     "log_normal_finance",
     "modular_add",
     "modular_add_constant",
-    "modular_exp",
-    "modular_increment",
     "molecule_hartree_fock",
     "molecule_hva",
     "molecule_ucc",
-    "multiswap",
     "pauli_feature_map",
     "permute",
-    "phase_oracle",
     "prepare_amplitudes",
-    "prepare_bell_state",
-    "prepare_exponential_state",
-    "prepare_ghz_state",
-    "prepare_int",
     "prepare_state",
-    "prepare_uniform_interval_state",
-    "prepare_uniform_trimmed_state",
-    "projector_controlled_double_phase",
-    "projector_controlled_phase",
-    "qaoa_cost_layer",
-    "qaoa_init",
-    "qaoa_layer",
-    "qaoa_mixer_layer",
-    "qaoa_penalty",
-    "qct_qst_type1",
-    "qct_qst_type2",
-    "qct_type2",
     "qdrift",
-    "qft",
-    "qft_no_swap",
-    "qft_space_add_const",
-    "qpe",
-    "qpe_flexible",
-    "qst_type2",
-    "qsvt",
-    "qsvt_inversion",
-    "qsvt_lcu",
-    "qsvt_lcu_step",
-    "qsvt_step",
     "randomized_benchmarking",
     "real_xor_constant",
-    "reflect_about_zero",
     "single_pauli_exponent",
     "suzuki_trotter",
-    "swap_test",
-    "switch",
     "unitary",
 ]
+BUILTIN_FUNCTION_DECLARATIONS = {
+    func_decl.name: func_decl for func_decl in STD_QMOD_OPERATORS + CORE_LIB_DECLS
+}