Patent Application
20230042366
The disclosure pertains to cryptographic computing applications, more specifically to improving efficiency of cryptographic operations using addition/subtraction processing units that utilize Montgomery reduction techniques for improving streaming computations.
The present disclosure will be understood more fully from the detailed description given below and from the accompanying drawings of various implementations of the disclosure.
Aspects of the present disclosure are directed to hardware cryptographic engines for improving computational efficiency and memory utilization in cryptographic applications that include, but are not limited to, public-key cryptography operations. More specifically, aspects of the present disclosure are directed to efficient streaming processing of public key and private key operations, key generation, modular multiplication, Montgomery multiplication, modular inversion, elliptic curve cryptographic operations, and numerous other cryptographic applications.
Various cryptographic applications may involve operations that are efficiently performed by offloading them from a main processor to a dedicated cryptographic engine (accelerator) that includes hardware circuits designed to improve speed and efficiency of arithmetic operations (multiplication, division, addition, etc.) and memory accesses. For example, in Rivest-Shamir-Adelman (RSA) public key/private key applications, large prime numbers p and q may be selected to generate a pair of a public (encryption) exponent e and a secret (decryption) exponent d such that e and d are inverse of each other modulo a certain number. The encryption exponent and the product p·q may be revealed as part of the public key while the numbers p, q, and the decryption exponent d are stored in secret as parts of the private key. A message may be encrypted using modular exponentiation based on the product p·q and the encryption exponent and may be decrypted using the private exponent d. To prevent unauthorized actors from recovering the private exponent d, the prime multipliers p and q are typically selected to be large numbers, e.g., 1024-bit numbers.
Some applications use elliptic curve cryptography that involves operations with points (x,y) on an elliptic curve, e.g., an elliptic Weierstrass curve, y2=x3+ax+b. Arithmetic operations (such as addition, doubling, and infinity operations) are defined via a set of geometric rules; e.g., a sum of three points on an elliptic curve is zero, P1+P2+P3=0, if the points P1, P2, P3 are located at the intersection of the elliptic curve with a straight line. The strength of the elliptic curve cryptography is based on the fact that for large values of k, a product Q=P·k can be practically anywhere on the elliptic curve. As a result, the inverse operation to determine an unknown value of (e.g., private key) k from a known public value Q can be a prohibitively difficult computational operation. In elliptic curve cryptography applications, 256-bit numbers are often used.
Decryption and encryption operations often require performance of a large number of arithmetic operations, which may take many clock cycles, especially when performed on low-bit microprocessors, such as smart card readers, wireless sensor nodes, and so on. Cryptographic engines (accelerators, co-processors) are specially designed circuits that execute specialized computationally intensive cryptographic operations more efficiently than a general purpose processor. Because in many applications (including network and cloud applications) cryptographic operations may constitute a significant portion of the total computational load, small and efficient cryptographic engines are highly desired.
Various cryptographic computations are often performed modulo some number p, which is often selected to be a prime number. Modular arithmetic operations may involve a reduction step of bringing an intermediate result to the interval [0, p−1]. The number of computational operations, required to perform such reduction steps, may add up quickly and increase the computational costs of cryptographic algorithms. Fewer operations may be needed to reduce results of intermediate computations to an expanded interval [0, 2p−1] or to a more symmetric interval [−p, p−1], with the most significant bit of the number being interpreted as the sign of the number (e.g., 0 indicating a positive sign and 1 indicating a negative sign). Addition (or subtraction) operations of numbers (e.g., x and y) within such interval may be performed based on the relative sign of the numbers. For example, if during an addition operation it is determined that the sign bits of x and y are opposite (e.g., XOR addition of the sign bits yields 1), the sum x+y is within the [−p, p−1] interval. If the signs of the numbers are both negative, adding modulus p to the sum x+y ensures that the number x+y+p is within the target interval [−p, p−1]. If the signs of the numbers are both positive, subtracting modulus p from the sum x+y ensures that the number x+y−p is within the target interval [−p, p−1]. Similarly, by an appropriate addition or subtraction of p, based on the values of the sign bits of x and y, a subtraction operation x−y may be performed with the output being within the target interval. As a result, modular addition or subtraction may be executed without comparing the result x±y to the modulus number p. Techniques in which values are reduced mod p, but to intervals with more than p elements, are called “non-canonical reduction” because the same value mod p may have more than one possible representation it is not reduced to a single canonical representation.
In some cryptographic engines, a sign of x and/or y may not be available until some time that occurs during later cycles of a cryptographic operation. For example, one of the numbers x or y (or both) may be output by a previous, e.g., multiplication, operation. Multiplication operation may be performed in a streaming fashion, with the multiplication unit processing the least significant bits or words (groups of bits) of multiplier and multiplicand first (e.g., as in the schoolbook multiplication algorithm) and processing the most significant bits or words last. Because the sign of a modular multiplication (the most significant bit) may not be known until all bits of the multiplier and multiplicand are processed, a subsequent addition operation may need to wait until the last cycle of the multiplication operation. This creates a computational bottleneck and increases latency. To remove the bottleneck, the processing has to be modified in a way that brings the number x±y (or some other number that represents ±y) within the target interval [−p, p−1] regardless of the signs of x and y. The combination (x±y)/2 satisfies the desired conditions when the numbers x and y have the same parity, but not when one of the numbers is even and the other number is odd (which happens in 50% of the instances).
Aspects and implementations of the present disclosure describe a method and cryptographic accelerators capable of performing the method of efficient addition and subtraction of numbers that can be performed in a streaming fashion, starting with the least significant bits of the addends without waiting for the more significant bits to be output by preceding operations. In some implementations, the sum or difference x±y of the input numbers may be modified by a product of a Montgomery factor m, which depends on x and y, and the modulus p. This may place the sum (or difference) within an expanded interval [−Rp, R(p−1)], where R is a predefined integer (Montgomery radix). A subsequent reduction by R brings the output within the target interval [−p, p−1] regardless of the sign of x and y. The described techniques allow processing of addition and subtraction operations in a streaming fashion, starting from the least significant bits, and avoid delaying operations until all words of x and y are available. Various implementations of efficient additions/subtractions with Montgomery reduction are described below in conjunction with cryptographic processors capable of performing such operations.
The system architecture 100 may further include an input/output (I/O) interface 104 to facilitate connection of the computer system 102 to peripheral hardware devices 106 such as card readers, terminals, printers, scanners, internet-of-things devices, and the like. The system architecture 100 may further include a network interface 108 to facilitate connection to a variety of networks (Internet, wireless local area networks (WLAN), personal area networks (PAN), public networks, private networks, etc.), and may include a radio front end module and other devices (amplifiers, digital-to-analog and analog-to-digital converters, dedicated logic units, etc.) to implement data transfer to/from the computer system 102. Various hardware components of the computer system 102 may be connected via a system bus 112 that may include its own logic circuits, e.g., a bus interface logic unit (not shown).
The computer system 102 may support one or more cryptographic applications 110-n, such as an embedded cryptographic application 110-1 and/or external cryptographic application 110-2. The cryptographic applications 110-n may be secure authentication applications, encrypting applications, decrypting applications, secure storage applications, and so on. The external cryptographic application 110-2 may be instantiated on the same computer system 102, e.g., by an operating system executed by the processor 120 and residing in the memory device 130. Alternatively, the external cryptographic application 110-2 may be instantiated by a guest operating system supported by a virtual machine monitor (hypervisor) executed by the processor 120. In some implementations, the external cryptographic application 110-2 may reside on a remote access client device or a remote server (not shown), with the computer system 102 providing cryptographic support for the client device and/or the remote server.
The processor 120 may include one or more processor cores having access to a single or multi-level cache and one or more hardware registers. In implementations, each processor core may execute instructions to run a number of hardware threads, also known as logical processors. Various logical processors (or processor cores) may be assigned to one or more cryptographic applications 110, although more than one processor core (or a logical processor) may be assigned to a single cryptographic application for parallel processing. A multi-core processor 120 may simultaneously execute multiple instructions. A single core processor 120 may typically execute one instruction at a time (or process a single pipeline of instructions). The processor 120 may be implemented as a single integrated circuit, two or more integrated circuits, or may be a component of a multi-chip module.
The memory device 130 may refer to a volatile or non-volatile memory and may include a read-only memory (ROM) 132, a random-access memory (RAM) 134, high-speed cache 136, as well as (not shown) electrically erasable programmable read-only memory (EEPROM), flash memory, flip-flop memory, or any other device capable of storing data. The RAM 134 may be a dynamic random-access memory (DRAM), synchronous DRAM (SDRAM), a static memory, such as static random-access memory (SRAM), and the like. Some of the cache 136 may be implemented as part of the hardware registers of the processor 120. In some implementations, the processor 120 and the memory device 130 may be implemented as a single field-programmable gate array (FPGA).
The computer system 102 may include a cryptographic engine (processor, co-processor, accelerator. etc.) 200 for fast and efficient performance of cryptographic computations, as described in more detail below. Cryptographic engine 200 may include processing and memory components, as described in more detail below. Cryptographic engine 200 may perform authentication of applications, users, access requests, in association with operations of the cryptographic applications 110-n or any other applications operating on or in conjunction with the computer system 102. Cryptographic engine 200 may further perform encryption and decryption of secret data.
Cryptographic engine 200 may further include a number of memory circuits, such as static random-access memory (SRAM), e.g., SRAM 240-1 and 240-2, and scratchpad memory (SP), such as 242-1, 242-2, and 242-3. Even though two SRAM and three SP are shown in
Each of the MUL units 220-n and ADD units 230-n may be a circuit that operates on N-bit words (e.g., 64-bit inputs or inputs of any other suitable size) and may have at least two inputs (indicated by horizontal arrows). Additionally, MUL units 220-1 . . . 220-3 may stream outputs (as well as inputs, in some instances) of multiplications performed by the respective circuits as inputs into subsequent MUL units 220-2 . . . 220-4 (as depicted by the downward arrows). For example, an output of MUL unit 220-1 may be provided to the next MUL unit 220-2 or to the ALU bus 232. From ALU bus 232 the outputs of multiplications may be delivered to any of the ADD units 230-n (or buffer 234) or any of the memory circuits (SRAM 240-n or SP 242-n). In some instances, when an addition operation involves a number that is not an output of a previous multiplication operation, an input into an addition operation may be delivered via bus 244 from one of the memory circuits 240-n or 242-n (as depicted by the upward arrow between bus 244 and ALU bus 232).
An additional ALU support unit 260 may include circuits that perform operations different from multiplications or additions. ALU support unit 260 may include a read-only memory (ROM) 262, which may store constants (such as modulus p, Montgomery radix R, numbers R−1mod p, etc.), various instructions for control unit 250, and so on. ALU support unit 260 may further include a random number generator (RNG) 264 for generation of random (or pseudorandom) numbers, an XOR unit 266 for performing XOR operations, a shift unit 268 to perform bit shifting and bit masking, a compare unit 270 to perform comparison of input numbers, a copy unit 272 for copying numbers, an arithmetic-to-Boolean and/or Boolean-to-arithmetic conversion (A2B/B2A) unit 274. The A2B/B2A unit 274 may be used for handling keys and other secret data that is stored in masked Boolean or masked arithmetic form (e.g., as a plurality of randomized values whose Boolean or arithmetic sum, difference, etc. represents a secret value). For example, A2B/B2A unit 274 may convert data stored in a Boolean-masked form to an arithmetic-masked form (if a cryptographic application is configured to process data in the latter form), and/or vice versa. ALU support unit 260 may also include other auxiliary units (circuits) performing various functions that may be used in operations of cryptographic engine 200.
The cryptographic engine 200 may be capable of performing streaming computations in which results of various operations (e.g., multiplications, additions, subtractions, etc.) are streamed into a subsequent operation before the previous operation is completed. For example, a multiplication X·Y may be computed by splitting the multiplier (and/or, similarly, the multiplicand) into words (e.g., 32-bit words, 64-bit words, etc.) Xj, e.g. X=ΣjXj·wj, where w=2N is the size of one word. The product Z=X·Y may be computed starting with low words of the multiplier, X0, X1 . . . and low words of the multiplicand Y0, Y1 . . . , and determining the product Z in the order of increased significance of its words, Z0, Z1 . . . . For example, Z0 may be determined as the low word of the product X0·Y0; similarly, Z1 may be determined as the low word of the product X0·Y1+X1·Y0 (plus the high word carry of the product X0·Y0), and so on. Streaming processing allows to use the words of the product Z0, Z1 . . . in subsequent operations before more senior words of the same product are identified. For example, MUL unit 220-1 may be computing Z=X·Y and providing (streaming) the words of the product to a next processing unit, e.g., SE ADD unit 230-3 or MUL unit 220-2.
The numbers input into SE ADD unit 300 may be mod p numbers. Numbers x and y may be streamed into SE ADD unit 300. Each number modulo p may be represented by k bits (e.g., k=128, 256, 1024, etc.), with 2k>p:
This provides for x to be contained in the interval [0, p−1]. The bit size k may instead be chosen so that 2k>2p, or some other multiple of p, so that a faster, non-canonical reduction algorithm can be used without exceeding the representation's bit size. Additionally or alternatively, x may be encoded in a 2's complement signed representation, so that the interval used may be negative, e.g.
or [−p, p−1] instead of [0, p−1] or [0, 2p−1]. In 2's complement notation, the most significant bit xk-1 is treated as the sign bit, meaning that
Rescaling sub-unit 310 may receive the input numbers and may optionally multiply (rescale) each input number by some power of 2, e.g., x→a·x; y→b·y, where a=2α and b=2β. In some implementations, rescaling unit 310 may include one or more shift registers and the rescaling may be performed by shifting x by a bits to the left and by shifting y by β bits to the left. As depicted schematically in
The multiplication sub-unit 330 may then compute the product of the reduction factor and the modulus: m·p. (In some implementations, only the high k≥r bits of the product m·p are computed.) The computed product may then be provided back to the addition sub-unit 320 where the sum A+m·p may be computed. This sum is divisible by radix R since, by construction, 1+p·s=0 mod R. Namely,
Correspondingly, the sum A+m·p may be passed to a shifting sub-unit 340 that performs the division by radix R by shifting the sum A+m·p to the right by r bits (whose values are zero, by construction). All bits of the sum may be shifted with the exception of the sign bit, e.g., the most significant bit, with the second most significant bit acquiring value 0. In some implementations, the shifting sub-unit 340 and the rescaling sub-unit 310 may be combined into a single sub-unit (e.g., having one or more shift registers). The resulting Montgomery-reduced number
is an integer within the target interval [−p, p−1] provided that a and b are appropriately bounded. More specifically, since a·x is defined on the interval [−a·p, a·p−1], b·y is defined on the interval [−b·p, b·p−1], and m·p is defined on the interval [−R·p/2, R·p/2−1], the resulting number AM is defined on interval [−c·p, c·p−1], where c=(R/2+a+b)/R. The number AM is, therefore, defined on the interval that does not exceed the target interval, provided that c≤1, implying that a+b≤R/2. This condition ensures that the output is within the target interval for any input numbers x and y. In some instances, additional information may be available about one or both of the inputs, x and y, and a less rigorous condition may suffice. For example, if y is known to be much smaller than R (e.g., smaller by at least factor of 8), e.g. if y is a small constant number, then it may suffice to choose any a<R/2. Likewise, if x is known to be 0, then the value b=R may be used.
In one implementation, radix R=4 and a=b=1; accordingly, AM=(x+y)/4 mod p. In another implementation, R=16 and a=4, b=1; accordingly, AM (4x+y)/16 mod p. When radix R=16 is used and a combination (x/4+y/8) mod p is to be computed, this combination may be computed as (4x+2y)/16 mod p.
The Montgomery reduction techniques described above yield a sum (or difference) value AM that is within the target interval for all sign values of x and y. Consequently, the computation of the sum (or difference) may be started as soon as the low bits (e.g., one or more low words) of x and y become available (e.g., being output by a multiplication circuit) and before all bits of x and y are computed. For example, a 64-bit j-th word A1 of AM may be computed as soon as 64-bit words xj and yj (of x and y, respectively) and the first log2 R bits of each of xj+1 and yj+1 become available.
The Montgomery-reduced number AM may be provided to a scale-balanced processing 350. Scale-balanced processing 350 may be any collection of operations, e.g., multiplication, addition, etc., operations performed on various MUL units 220-n, ADD units 230-n (including sign-efficient ADD units), e.g., performed based on instructions from control unit 250. Scale-balanced processing 350 may be performed to ensure that the difference between AM=(x+y)/R mod p and A=x+y mod p is compensated in the course of various operations being performed. Such operation may include, but need not be limited to, ECC operations in projective coordinates. As one illustrative non-limiting example, a cryptographic processor may perform a computation
where x and y are outputs of multiplication operations (e.g., performed by MUL unit 220-1 and MUL unit 220-2). The cryptographic processor may use a sign-efficient ADD unit to use the Montgomery-reduced sum and difference, e.g., as described below (radix R=16 operations are illustrated):
Operations illustrated in Table 1 use balanced Montgomery-reduced addition and subtraction operations. Specifically, the addition operation is performed with a=b=1, and the subtraction operation is performed with a=b=4, resulting in the computation
As another illustrative example, a cryptographic processor may perform a computation
via the following sequence of operations (radix R=4 operations are illustrated):
A cryptographic processor that performs method 400 may include a plurality of two or more multiplication circuits (e.g., MUL units 220-n). The cryptographic processor may further include at least one addition circuit (e.g., ADD units 230-n). Some of the operations of the method 400 may be performed by a sign-efficient addition circuit (e.g., SE ADD unit 300 of
The cryptographic processor may further include a memory system having two or more memory units. Each of the memory units may be communicatively coupled to at least one of the multiplication circuits and at least one of the addition circuits. One or more of the memory units may be double-port memory units capable of performing a read operation and a write operation within a same cycle of cryptographic processor operations.
At block 410, one or more circuits (e.g., SE ADD unit 300) of the cryptographic processor performing method 400 may receive a first number (e.g., x) and a second number (e.g., y). The first number and the second number may be modular numbers within a first interval, e.g., an interval defined by a modulus p, such as the interval [0, 2p). In some implementations, the first interval includes negative numbers between zero and minus the modulus, e.g., the first interval may be [−p, p). (The terms “first” and “second,” as used herein, should be understood as mere identifiers and may refer to any numbers, intervals, cycles, etc., and do not presuppose any functional or temporal order.) The first number and the second number may be large numbers, e.g., 128-bit numbers, 256-bit numbers, 1024 numbers, and the like. In some implementations, the modulus p may be an odd number. At least one of x or y (or both) may be obtained from one of the plurality of multiplication circuits of the cryptographic engine. In some implementations, each of the first number and the second number may include multiple words, e.g., 32-bit words, 64-bit words, and the like.
Each of the words of the first (and second) number may be received (e.g., by SE ADD unit 300) during a respective one of a plurality of computational cycles, starting with a word that includes the least significant bits of the first (second) number. For example, during the first cycle, SE ADD unit 300 may receive the lowest 64 bits (the first word) of the first number; during the second cycle, SE ADD unit 300 may receive the second lowest 64 bits (the second word) of the first number; and so on. The words may be received as soon as the computation of the respective word is completed (e.g., by the multiplication circuit) and before more significant words are computed.
At block 420, method 400 may continue with the one or more circuits (e.g., SE ADD unit 300) performing a modular operation. The modular operation may be based on the first number and the second number and may determine a third number using a Montgomery reduction, e.g., a number (a·x±b·y)/R mod p, where R is a Montgomery radix. In some implementations, the Montgomery radix R is a power-of-two number, e.g., 4, 8, 16, 32, not exceeding a number that can be stored in a single word (e.g., 64-bit word) of the first (and/or second) number. The third number (a·x±b·y)/R mod p may be within the first interval [−p, p) and may represents a sum or a difference of a rescaled first number and a rescaled second number.
As illustrated by the blowout portion of
At block 424, method 400 may continue with determining a Montgomery reduction factor m=(a×b·y)·s mod R that is based on the first number and the second number and is within a second interval. In some implementations, the second interval includes negative numbers between zero and minus one half of the Montgomery radix, e.g., [−R/2, R/2). At block 426, method 400 may continue with the one or more circuits adding a sum of the first modified number and the second modified number, a×b·y, to a Montgomery reduction factor m multiplied by a modulus p of the modular operation: a×b·y±m·p. It shall be understood that the term “sum” encompasses both the outputs of addition operations as well as subtraction operations. At block 428, method 400 may continue with reducing the output by the Montgomery radix R, e.g., by shifting the output to the right by log2 R bits.
Example computer system 500 may include a processing device 502 (also referred to as a processor or CPU), a main memory 504 (e.g., read-only memory (ROM), flash memory, dynamic random access memory (DRAM) such as synchronous DRAM (SDRAM), etc.), a static memory 506 (e.g., flash memory, static random access memory (SRAM), etc.), and a secondary memory (e.g., a data storage device 518), which may communicate with each other via a bus 530.
Processing device 502 represents one or more general-purpose processing devices such as a microprocessor, central processing unit, or the like. More particularly, processing device 502 may be a complex instruction set computing (CISC) microprocessor, reduced instruction set computing (RISC) microprocessor, very long instruction word (VLIW) microprocessor, processor implementing other instruction sets, or processors implementing a combination of instruction sets. Processing device 502 may also be one or more special-purpose processing devices such as an application specific integrated circuit (ASIC), a field programmable gate array (FPGA), a digital signal processor (DSP), network processor, or the like. In accordance with one or more aspects of the present disclosure, processing device 502 may be configured to execute instructions implementing method 400 of sign-efficient addition or subtraction that uses Montgomery reduction.
Example computer system 500 may further comprise a network interface device 508, which may be communicatively coupled to a network 520. Example computer system 500 may further comprise a video display 510 (e.g., a liquid crystal display (LCD), a touch screen, or a cathode ray tube (CRT)), an alphanumeric input device 512 (e.g., a keyboard), a cursor control device 514 (e.g., a mouse), and an acoustic signal generation device 516 (e.g., a speaker).
Data storage device 518 may include a computer-readable storage medium (or, more specifically, a non-transitory computer-readable storage medium) 528 on which is stored one or more sets of executable instructions 522. In accordance with one or more aspects of the present disclosure, executable instructions 522 may comprise executable instructions implementing method 400 of sign-efficient addition or subtraction that uses Montgomery reduction.
Executable instructions 522 may also reside, completely or at least partially, within main memory 504 and/or within processing device 502 during execution thereof by example computer system 500, main memory 504 and processing device 502 also constituting computer-readable storage media. Executable instructions 522 may further be transmitted or received over a network via network interface device 508.
While the computer-readable storage medium 528 is shown in
Some portions of the detailed descriptions above are presented in terms of algorithms and symbolic representations of operations on data bits within a computer memory. These algorithmic descriptions and representations are the means used by those skilled in the data processing arts to most effectively convey the substance of their work to others skilled in the art. An algorithm is here, and generally, conceived to be a self-consistent sequence of steps leading to a desired result. The steps are those requiring physical manipulations of physical quantities. Usually, though not necessarily, these quantities take the form of electrical or magnetic signals capable of being stored, transferred, combined, compared, and otherwise manipulated. It has proven convenient at times, principally for reasons of common usage, to refer to these signals as bits, values, elements, symbols, characters, terms, numbers, or the like.
It should be borne in mind, however, that all of these and similar terms are to be associated with the appropriate physical quantities and are merely convenient labels applied to these quantities. Unless specifically stated otherwise, as apparent from the following discussion, it is appreciated that throughout the description, discussions utilizing terms such as “identifying,” “determining,” “storing,” “adjusting,” “causing,” “returning,” “comparing,” “creating,” “stopping,” “loading,” “copying,” “throwing,” “replacing,” “performing,” or the like, refer to the action and processes of a computer system, or similar electronic computing device, that manipulates and transforms data represented as physical (electronic) quantities within the computer system's registers and memories into other data similarly represented as physical quantities within the computer system memories or registers or other such information storage, transmission or display devices.
Examples of the present disclosure also relate to an apparatus for performing the methods described herein. This apparatus may be specially constructed for the required purposes, or it may be a general purpose computer system selectively programmed by a computer program stored in the computer system. Such a computer program may be stored in a computer readable storage medium, such as, but not limited to, any type of disk including optical disks, CD-ROMs, and magnetic-optical disks, read-only memories (ROMs), random access memories (RAMs), EPROMs, EEPROMs, magnetic disk storage media, optical storage media, flash memory devices, other type of machine-accessible storage media, or any type of media suitable for storing electronic instructions, each coupled to a computer system bus.
The methods and displays presented herein are not inherently related to any particular computer or other apparatus. Various general purpose systems may be used with programs in accordance with the teachings herein, or it may prove convenient to construct a more specialized apparatus to perform the required method steps. The required structure for a variety of these systems will appear as set forth in the description below. In addition, the scope of the present disclosure is not limited to any particular programming language. It will be appreciated that a variety of programming languages may be used to implement the teachings of the present disclosure.
It is to be understood that the above description is intended to be illustrative, and not restrictive. Many other implementation examples will be apparent to those of skill in the art upon reading and understanding the above description. Although the present disclosure describes specific examples, it will be recognized that the systems and methods of the present disclosure are not limited to the examples described herein, but may be practiced with modifications within the scope of the appended claims. Accordingly, the specification and drawings are to be regarded in an illustrative sense rather than a restrictive sense. The scope of the present disclosure should, therefore, be determined with reference to the appended claims, along with the full scope of equivalents to which such claims are entitled.
This application claims the benefit of U.S. Provisional Patent Application No. 63/203,471, filed Jul. 23, 2021, which is hereby incorporated herein by reference.
| Number | Date | Country | |
|---|---|---|---|
| 63203471 | Jul 2021 | US |
