o o h@s,ddlmZddlmZddlmZddlmZmZm Z m Z m Z m Z ddl mZddlmZddlmZddlmZdd lmZdd lmZdd lmZdd lmZdd lmZmZGdddZ Gddde!Z"Gddde#Z$ddZ%GdddeZ&d%ddZ'ddZ(d&ddZ)d d!Z*d'd#d$Z+dS)() annotations)Anywraps)AddMulPowSsympifyFloat)Basic)UnevaluatedExpr)Lambda) _keep_coeff)default_sort_key)Symbol)re) StrPrinter) precedence PRECEDENCEc@s eZdZdZddZddZdS)requiresz: Decorator for registering requirements on print methods. cKs ||_dSN)_req)selfkwargsrn/var/www/html/construction_image-detection-poc/venv/lib/python3.10/site-packages/sympy/printing/codeprinter.py__init__ zrequires.__init__csfdd}t|S)Ncs:jD] \}}t|||q|g|Ri|Sr)ritemsgetattrupdate)self_argsrkvmethodrrr_method_wrappersz*requires.__call__.._method_wrapperr)rr'r(rr&r__call__s zrequires.__call__N)__name__ __module__ __qualname____doc__rr)rrrrrs rc@eZdZdZdS)AssignmentErrorzA Raised if an assignment variable for a loop is missing. Nr*r+r,r-rrrrr/r/c@r.)PrintMethodNotImplementedErrorz@ Raised if a _print_* method is missing in the Printer. Nr0rrrrr2%r1r2cCsHt|trddlm}|dd|DSt|tr"tdd|DS|S)Nr)Listcs|]}t|VqdSr_convert_python_lists.0errr .z(_convert_python_lists..csr4rr5r7rrrr:0r;) isinstancelistsympy.codegen.abstract_nodesr3tuple)argr3rrrr6+s   r6c s\eZdZUdZddddZdddd d dddd Zd ed <iddgfddgfddgfddgfddgfddgfddgfddgfddgfddgfd dgfd!dgfd"d#gfd$d%gfd&d%gfd'd#gfd(dd)gfid*d+gfd,d#gfd-d#d)gfd.d/gfd0d#d)gfd1d#d)gfd2d#gfd3d+gfd4d)gfd5d)gfd6d)gfd7d8gfd9d8gfd:d;gfdgfd?d>d#gfd@d)gfiZdfdAdB ZdCdDZ ddEdFZ ddGdHZ dIdJZ dKdLZ dMdNZdOdPZdQdRZdSdTZdUdVZdWdXZdYdZZd[d\Zd]d^Zd_d`ZdadbZdcddZdedfZdgdhZdidjZfdkdlZdmdnZdodpZeZ dZ!dqdrZ"dsdtZ#dudvZ$dwdxZ%dydzZ&d{d|Z'd}d~Z(ddZ)ddZ*ddZ+ddZ,ddZ-ddZ.ddZ/ddZ0e0Z1e0Z2e0Z3e0Z4e0Z5e0Z6e0Z7e0Z8e0Z9e0Z:e0Z;e0Ze0Z?e0Z@e0ZAe0ZBe0ZCe0ZDe0ZEe0ZFe0ZGZHS) CodePrinterz6 The base class for code-printing subclasses. z&&z||!)andornotNautoF_T)order full_precerror_on_reservedreserved_word_suffixhumaninlineallow_unknown_functionsstrictzdict[str, Any]_default_settingscottancscsinseccosacotatanacscasinasecacoscothexpcschsechacothlogacschasechcatalangamma fibonaccisqrtlucasbetasinc PiecewiseModfloor factorial factorial2 subfactorial uppergammaRisingFactorialFallingFactorialbinomialfracMaxMin Heavisideerf2erferfcLiliEi dirichlet_etazeta riemann_xiSingularityFunctioncsRtj|d|jdddkr|jdddk|jd<t|ds't|_dSdS)N)settingsrOTrLreserved_words)superr _settingsgethasattrsetr)rr __class__rrrts   zCodePrinter.__init__cCs|tddS)NcSs"t|tr |jdjr |St|S)Nr)r<r r#is_realr)r@rrr}s  z5CodePrinter._handle_UnevaluatedExpr..)replacerrexprrrr_handle_UnevaluatedExpr|sz#CodePrinter._handle_UnevaluatedExprc sLddlmddlmmfddt|}||}|}t_t_  | }j drg}jr`| djtjtdD] }| t|jqRtj tdD] \}}| ||qg||}|}d |}n|}fd d j D}|jd |f}t_t_ |S) a Print the expression as code. Parameters ---------- expr : Expression The expression to be printed. assign_to : Symbol, string, MatrixSymbol, list of strings or Symbols (optional) If provided, the printed code will set the expression to a variable or multiple variables with the name or names given in ``assign_to``. r MatrixSymbol) CodeBlock Assignmentcs|durt|St|ttfr1t|t|kr#tdt|t|fddt||DSt|trH|j rC|g|j R}nt |}nt|t sZt dtjt|||S)Nz;Failed to assign an expression of length {} to {} variablescsg|] \}}||qSrr)r8lhsrhs)_handle_assign_torr szBCodePrinter.doprint.._handle_assign_to..z%{} cannot assign to object of type {})r r<r=r?len ValueErrorformatzipstr is_Matrixshaperr TypeErrortyper*)r assign_torrrrrrrrs    z.CodePrinter.doprint.._handle_assign_torLzNot supported in {}:key csh|] \}}||fqSr_print)r8r$r%rrr sz&CodePrinter.doprint..)"sympy.matrices.expressions.matexprrsympy.codegen.astrrr6rr_not_supported_number_symbolsr splitlinesrappend _get_commentrlanguagesortedrrr*_declare_number_const _format_codejoin) rrrlines frontlinesnamevalueresultnum_symsrrrdoprints8        zCodePrinter.doprintc Cs|jddrddlm}|||}||}ng}d|fi}||\}}d|vr5t|t|d}nt|d}| |} g} || krb| ||durX| d| |f}| || ||D]n} t | tr|| |}||\} } || D]U}||vrdd||Ddd||Dkstd |durtd ||rtd | || | d| t|||f}| | || | | |q|qdd | S) NcontractTr)get_contraction_structure%s = %scSsg|]}t|qSr)r=keysr8frrrrz.CodePrinter._doprint_loops..cSsg|]}dgqSrrrrrrrsz0FIXME: no support for contractions in factor yetz"need assignment variable for loopszZFIXME: lhs present in rhs, this is undefined in CodePrinterr)rr sympy.tensorr_get_expression_indices_get_loop_opening_endingrrrrextend_get_statementrr<r?_sort_optimizedNotImplementedErrorr/hasrr)rrrrindicesdummiesopenloop closelooptext lhs_printedrd openloop_d closeloop_dtermrrr_doprint_loopss^                  zCodePrinter._doprint_loopscCsPddlm}||\}}||\}}|r|s|}||kr"td||||S)Nr) get_indicesz2lhs indices must match non-dummy rhs indices in %s)rrrr)rrrrrindsjunklindsrrrrs    z#CodePrinter._get_expression_indicesc sddlm}|s gSi|D]}d|<q||}|D]"}t|jD]\}}z |||7<Wq#ty=Yq#wqt|fdddS)Nr)Indexedcs|Srr)x score_tablerrr5sz-CodePrinter._sort_optimized..r)sympy.tensor.indexedratoms enumerater_rate_index_positionKeyErrorr) rrrriarraysarrpindrrrr s    zCodePrinter._sort_optimizedcCtd)zfunction to calculate score based on position among indices This method is used to sort loops in an optimized order, see CodePrinter._sort_optimized() =This function must be implemented by subclass of CodePrinter.r)rrrrrr7sz CodePrinter._rate_index_positioncCr)z1Formats a codestring with the proper line ending.rr)r codestringrrrr@zCodePrinter._get_statementcCr)z#Formats a text string as a comment.rr)rrrrrrErzCodePrinter._get_commentcCr)z3Declare a numeric constant at the top of a functionrr)rrrrrrrJrz!CodePrinter._declare_number_constcCr)z~Take in a list of lines of code, and format them accordingly. This may include indenting, wrapping long lines, etc...rr)rrrrrrOszCodePrinter._format_codecCr)zOReturns a tuple (open_lines, close_lines) containing lists of codelinesrr)rrrrrrVsz$CodePrinter._get_loop_opening_endingcCs&|jdr d|jSd|j|jfS)NDummy_rGz%s_%d)r startswith dummy_indexrrrr _print_Dummy\s  zCodePrinter._print_Dummycsdfdd|jDS)Nrcsg|]}|qSrr)r8rrrrrcsz0CodePrinter._print_CodeBlock..)rr#rrrr_print_CodeBlockbszCodePrinter._print_CodeBlockcCst|Sr)rrstringrrr _print_StringeszCodePrinter._print_StringcCs d|jS)Nz"%s")r)rr@rrr_print_QuotedStringhrzCodePrinter._print_QuotedStringcCs|t|Sr)rrrrrr_print_CommentkzCodePrinter._print_CommentcCs@ddlm}ddlm}ddlm}ddlm}|j}|j }t |j |rIg}g} |j D]\} } | ||| | | q+|t || } || St ||rvg} ||D]\}}||||f|||f} || }| |qUd| S|jddr||s||r|||S||}||}|d ||fS) Nr)r)rlr) IndexedBaserrFr)rr$sympy.functions.elementary.piecewiserlrrrrrrr<r#rrr_traverse_matrix_indicesrrrrrr)rrrrlrrrr expressions conditionsr9ctemprrjcode0lhs_coderhs_coderrr_print_Assignmentns8              zCodePrinter._print_Assignmentcs>|j}|j}djfdd||j|fDS)Nz{} {} {}c3|]}|VqdSrrr8r@rrrr:z9CodePrinter._print_AugmentedAssignment..)rrrrrop)rrrrrrr_print_AugmentedAssignments  z&CodePrinter._print_AugmentedAssignmentcs$d|jdfdd|jDfS)N%s(%s), c3rrrr rrrr:r z2CodePrinter._print_FunctionCall..)rr function_argsrrrr_print_FunctionCallszCodePrinter._print_FunctionCallcCs ||jSr)rsymbolrrrr_print_Variables zCodePrinter._print_VariablecsDt|}||jvr |jdrd}t||||jdS|S)NrJzVThis expression includes the symbol "{}" which is a reserved keyword in this language.rK)r _print_Symbolrrrr)rrrmsgrrrrs   zCodePrinter._print_SymbolcCs||jvp t|d|dS)z Check if function ``name`` is either a known function or has its own printing method. Used to check if rewriting is possible.z _print_{}F)known_functionsr r)rrrrr _can_printszCodePrinter._can_printc sh|jjjvrSj|jj}t|trd||jdfS|D] \}}||jr+nq |durRz |fdd|jDWStyQd||jdfYSwn@t|drgt|j t rg |j |jS|jjj vrj |jj\}} |rtfdd|Drd ||d S|jrjd d rd |jdtj |jfS|S) Nr rcsg|]}|dqS)r parenthesize)r8itemrrrrrz/CodePrinter._print_Function.._imp_c3rr)rrrrrr:r z.CodePrinter._print_Function..()rNF)funcr*rr<r stringifyr#rrrrr_rewriteable_functionsrallrewrite is_Functionrrrmap_print_not_supported)rr cond_funccondrtarget_f required_fsrrr_print_Functions0     $ zCodePrinter._print_FunctioncCsP|jddr|t||jdS|j|t||jdft|S)NrMF precision)rrrr evalfraddrrrrr_print_NumberSymbols zCodePrinter._print_NumberSymbolcC ||Srr-rrrr_print_CatalanrzCodePrinter._print_CatalancCr.rr/rrrr_print_EulerGammarzCodePrinter._print_EulerGammacCr.rr/rrrr_print_GoldenRatiorzCodePrinter._print_GoldenRatiocCr.rr/rrrr_print_TribonacciConstantrz%CodePrinter._print_TribonacciConstantcCr.rr/rrrr _print_Exp1rzCodePrinter._print_Exp1cCr.rr/rrrr _print_PirzCodePrinter._print_Pic6t|djdfddt|jtdDS)N %s rCc3|] }|VqdSrrr8aPRECrrrr:z)CodePrinter._print_And..rr _operatorsrrr#rrrr;r _print_And zCodePrinter._print_Andcr6)Nr7rDc3r8rrr9r;rrr:r=z(CodePrinter._print_Or..rr>rrr;r _print_OrrAzCodePrinter._print_OrcLjddur|St|djdfdd|jDS)Nxorr7c3r8rrr9r;rrr:r=z)CodePrinter._print_Xor..r?rrto_nnfrrr#rrr;r _print_Xor zCodePrinter._print_XorcrC)N equivalentr7c3r8rrr9r;rrr:r=z0CodePrinter._print_Equivalent..rErrr;r_print_EquivalentrHzCodePrinter._print_EquivalentcCs$t|}|jd||jd|S)NrEr)rr?rr#)rrr<rrr _print_NotszCodePrinter._print_NotcCs||Sr)rrFrrrr_print_BooleanFunctionrz"CodePrinter._print_BooleanFunctionc st||\}}|dkrt| |}d}nd}g}g}g}jdvr)|}nt|}|D]I} | jrt| jrt| j j rt| j j rt| j dkrS| t | j| j ddq0t| jdjdkrht| jtrh| | | t | j| j q0| | q0|ptjg}t|dkr|dkr|dd td td g} n fd d |D} fdd |D} |D]} | j|vrd| || j| || j<q|s|d| St|dkr|d| d| dS|d| dd| S)Nr-)oldnoneF)evaluateg?rrcg|]}|qSrrr8rprecrrrr5rz*CodePrinter._print_Mul..crTrrrUrVrrr6rz(%s)*/z/(%s))r as_coeff_MulrrHas_ordered_factorsr make_argsis_commutativeis_Powr^ is_Rational is_negativerrbaserr#r<r Onerrindexr) rrrr9signr:b pow_parenr#ra_strb_strrrVr _print_Mul sD          $   zCodePrinter._print_MulcCs`|jddrtdtt|tt|fdz|j|Wn ty*Ynw||S)NrOFzUnsupported by %s: %szV Set the printer option 'strict' to False in order to generate partially printed code.) rrr2rrrr,r emptyPrinterrrrrr$Ds  z CodePrinter._print_not_supportedr)Ir*r+r,r-r?rP__annotations__rrrrrrrrrrrrrrrrrrrr rrrrr) _print_Expr_print_Heavisider-r0r1r2r3r4r5r@rBrGrJrKrLrir$ _print_Basic_print_ComplexInfinity_print_Derivative_print_ExprCondPair_print_GeometryEntity_print_Infinity_print_Integral_print_Interval_print_AccumulationBounds _print_Limit_print_MatrixBase_print_DeferredVector _print_NaN_print_NegativeInfinity _print_Order _print_RootOf_print_RootsOf_print_RootSum_print_Uniform _print_Unit _print_Wild_print_WildFunction_print_Relational __classcell__rrrrrA5s,           ! "#&  CO %   :  rANc99cK$ddlm}|||||S)aConverts an expr to a string of c code Parameters ========== expr : Expr A SymPy expression to be converted. assign_to : optional When given, the argument is used as the name of the variable to which the expression is assigned. Can be a string, ``Symbol``, ``MatrixSymbol``, or ``Indexed`` type. This is helpful in case of line-wrapping, or for expressions that generate multi-line statements. standard : str, optional String specifying the standard. If your compiler supports a more modern standard you may set this to 'c99' to allow the printer to use more math functions. [default='c89']. precision : integer, optional The precision for numbers such as pi [default=17]. user_functions : dict, optional A dictionary where the keys are string representations of either ``FunctionClass`` or ``UndefinedFunction`` instances and the values are their desired C string representations. Alternatively, the dictionary value can be a list of tuples i.e. [(argument_test, cfunction_string)] or [(argument_test, cfunction_formater)]. See below for examples. dereference : iterable, optional An iterable of symbols that should be dereferenced in the printed code expression. These would be values passed by address to the function. For example, if ``dereference=[a]``, the resulting code would print ``(*a)`` instead of ``a``. human : bool, optional If True, the result is a single string that may contain some constant declarations for the number symbols. If False, the same information is returned in a tuple of (symbols_to_declare, not_supported_functions, code_text). [default=True]. contract: bool, optional If True, ``Indexed`` instances are assumed to obey tensor contraction rules and the corresponding nested loops over indices are generated. Setting contract=False will not generate loops, instead the user is responsible to provide values for the indices in the code. [default=True]. Examples ======== >>> from sympy import ccode, symbols, Rational, sin, ceiling, Abs, Function >>> x, tau = symbols("x, tau") >>> expr = (2*tau)**Rational(7, 2) >>> ccode(expr) '8*M_SQRT2*pow(tau, 7.0/2.0)' >>> ccode(expr, math_macros={}) '8*sqrt(2)*pow(tau, 7.0/2.0)' >>> ccode(sin(x), assign_to="s") 's = sin(x);' >>> from sympy.codegen.ast import real, float80 >>> ccode(expr, type_aliases={real: float80}) '8*M_SQRT2l*powl(tau, 7.0L/2.0L)' Simple custom printing can be defined for certain types by passing a dictionary of {"type" : "function"} to the ``user_functions`` kwarg. Alternatively, the dictionary value can be a list of tuples i.e. [(argument_test, cfunction_string)]. >>> custom_functions = { ... "ceiling": "CEIL", ... "Abs": [(lambda x: not x.is_integer, "fabs"), ... (lambda x: x.is_integer, "ABS")], ... "func": "f" ... } >>> func = Function('func') >>> ccode(func(Abs(x) + ceiling(x)), standard='C89', user_functions=custom_functions) 'f(fabs(x) + CEIL(x))' or if the C-function takes a subset of the original arguments: >>> ccode(2**x + 3**x, standard='C99', user_functions={'Pow': [ ... (lambda b, e: b == 2, lambda b, e: 'exp2(%s)' % e), ... (lambda b, e: b != 2, 'pow')]}) 'exp2(x) + pow(3, x)' ``Piecewise`` expressions are converted into conditionals. If an ``assign_to`` variable is provided an if statement is created, otherwise the ternary operator is used. Note that if the ``Piecewise`` lacks a default term, represented by ``(expr, True)`` then an error will be thrown. This is to prevent generating an expression that may not evaluate to anything. >>> from sympy import Piecewise >>> expr = Piecewise((x + 1, x > 0), (x, True)) >>> print(ccode(expr, tau, standard='C89')) if (x > 0) { tau = x + 1; } else { tau = x; } Support for loops is provided through ``Indexed`` types. With ``contract=True`` these expressions will be turned into loops, whereas ``contract=False`` will just print the assignment expression that should be looped over: >>> from sympy import Eq, IndexedBase, Idx >>> len_y = 5 >>> y = IndexedBase('y', shape=(len_y,)) >>> t = IndexedBase('t', shape=(len_y,)) >>> Dy = IndexedBase('Dy', shape=(len_y-1,)) >>> i = Idx('i', len_y-1) >>> e=Eq(Dy[i], (y[i+1]-y[i])/(t[i+1]-t[i])) >>> ccode(e.rhs, assign_to=e.lhs, contract=False, standard='C89') 'Dy[i] = (y[i + 1] - y[i])/(t[i + 1] - t[i]);' Matrices are also supported, but a ``MatrixSymbol`` of the same dimensions must be provided to ``assign_to``. Note that any expression that can be generated normally can also exist inside a Matrix: >>> from sympy import Matrix, MatrixSymbol >>> mat = Matrix([x**2, Piecewise((x + 1, x > 0), (x, True)), sin(x)]) >>> A = MatrixSymbol('A', 3, 1) >>> print(ccode(mat, A, standard='C89')) A[0] = pow(x, 2); if (x > 0) { A[1] = x + 1; } else { A[1] = x; } A[2] = sin(x); r)c_code_printers)sympy.printing.crlowerr)rrstandardrrrrrccodems rcKtt|fi|dS)z0Prints C representation of the given expression.N)printrrrrrr print_ccodesrcKsddlm}||||S)aKConverts an expr to a string of fortran code Parameters ========== expr : Expr A SymPy expression to be converted. assign_to : optional When given, the argument is used as the name of the variable to which the expression is assigned. Can be a string, ``Symbol``, ``MatrixSymbol``, or ``Indexed`` type. This is helpful in case of line-wrapping, or for expressions that generate multi-line statements. precision : integer, optional DEPRECATED. Use type_mappings instead. The precision for numbers such as pi [default=17]. user_functions : dict, optional A dictionary where keys are ``FunctionClass`` instances and values are their string representations. Alternatively, the dictionary value can be a list of tuples i.e. [(argument_test, cfunction_string)]. See below for examples. human : bool, optional If True, the result is a single string that may contain some constant declarations for the number symbols. If False, the same information is returned in a tuple of (symbols_to_declare, not_supported_functions, code_text). [default=True]. contract: bool, optional If True, ``Indexed`` instances are assumed to obey tensor contraction rules and the corresponding nested loops over indices are generated. Setting contract=False will not generate loops, instead the user is responsible to provide values for the indices in the code. [default=True]. source_format : optional The source format can be either 'fixed' or 'free'. [default='fixed'] standard : integer, optional The Fortran standard to be followed. This is specified as an integer. Acceptable standards are 66, 77, 90, 95, 2003, and 2008. Default is 77. Note that currently the only distinction internally is between standards before 95, and those 95 and after. This may change later as more features are added. name_mangling : bool, optional If True, then the variables that would become identical in case-insensitive Fortran are mangled by appending different number of ``_`` at the end. If False, SymPy Will not interfere with naming of variables. [default=True] Examples ======== >>> from sympy import fcode, symbols, Rational, sin, ceiling, floor >>> x, tau = symbols("x, tau") >>> fcode((2*tau)**Rational(7, 2)) ' 8*sqrt(2.0d0)*tau**(7.0d0/2.0d0)' >>> fcode(sin(x), assign_to="s") ' s = sin(x)' Custom printing can be defined for certain types by passing a dictionary of "type" : "function" to the ``user_functions`` kwarg. Alternatively, the dictionary value can be a list of tuples i.e. [(argument_test, cfunction_string)]. >>> custom_functions = { ... "ceiling": "CEIL", ... "floor": [(lambda x: not x.is_integer, "FLOOR1"), ... (lambda x: x.is_integer, "FLOOR2")] ... } >>> fcode(floor(x) + ceiling(x), user_functions=custom_functions) ' CEIL(x) + FLOOR1(x)' ``Piecewise`` expressions are converted into conditionals. If an ``assign_to`` variable is provided an if statement is created, otherwise the ternary operator is used. Note that if the ``Piecewise`` lacks a default term, represented by ``(expr, True)`` then an error will be thrown. This is to prevent generating an expression that may not evaluate to anything. >>> from sympy import Piecewise >>> expr = Piecewise((x + 1, x > 0), (x, True)) >>> print(fcode(expr, tau)) if (x > 0) then tau = x + 1 else tau = x end if Support for loops is provided through ``Indexed`` types. With ``contract=True`` these expressions will be turned into loops, whereas ``contract=False`` will just print the assignment expression that should be looped over: >>> from sympy import Eq, IndexedBase, Idx >>> len_y = 5 >>> y = IndexedBase('y', shape=(len_y,)) >>> t = IndexedBase('t', shape=(len_y,)) >>> Dy = IndexedBase('Dy', shape=(len_y-1,)) >>> i = Idx('i', len_y-1) >>> e=Eq(Dy[i], (y[i+1]-y[i])/(t[i+1]-t[i])) >>> fcode(e.rhs, assign_to=e.lhs, contract=False) ' Dy(i) = (y(i + 1) - y(i))/(t(i + 1) - t(i))' Matrices are also supported, but a ``MatrixSymbol`` of the same dimensions must be provided to ``assign_to``. Note that any expression that can be generated normally can also exist inside a Matrix: >>> from sympy import Matrix, MatrixSymbol >>> mat = Matrix([x**2, Piecewise((x + 1, x > 0), (x, True)), sin(x)]) >>> A = MatrixSymbol('A', 3, 1) >>> print(fcode(mat, A)) A(1, 1) = x**2 if (x > 0) then A(2, 1) = x + 1 else A(2, 1) = x end if A(3, 1) = sin(x) r) FCodePrinter)sympy.printing.fortranrr)rrrrrrrfcodes trcKr)z|Prints the Fortran representation of the given expression. See fcode for the meaning of the optional arguments. N)rrrrrr print_fcodensrc++11cKr)z$ C++ equivalent of :func:`~.ccode`. r)cxx_code_printers)sympy.printing.cxxrrr)rrrrrrrrcxxcodeus r)Nrr)Nr), __future__rtypingr functoolsr sympy.corerrrr r r sympy.core.basicr sympy.core.exprr sympy.core.functionrsympy.core.mulrsympy.core.sortingrsympy.core.symbolr$sympy.functions.elementary.complexesrsympy.printing.strrsympy.printing.precedencerrr Exceptionr/rr2r6rArrrrrrrrrs8              < x