Symbolon

Use when printf statements output strings without trailing newlines

Use when array is accessed with direct user input as index (0-based indexing)

Use when the program accesses a precomputed table using an offset (e.g., arr[n-1]) that introduces an arithmetic operation between the symbolic input and the index

Use when loop variables iterate over character values (e.g., ASCII codes) to represent different operations or choices

Use when code uses a loop to search for an input value in an array and then uses the found index for further computation

Use when code reads a fixed number of characters into an array and only accesses individual elements

Use when code uses an array to store a single character/value that is only accessed at one index

Use when code reads fixed-size input into an array and only accesses individual elements

Use when code uses arithmetic operations (like subtraction) to check character ranges or ASCII values

Use when code performs arithmetic operations on symbolic input values

Use when input is read into an array and then accessed with arithmetic operations to form values

Use when code uses a conditional branch to reset/clamp a counter (e.g., `if(cnt < 0){ fill++; cnt = 0; }`) that introduces an extra control-flow path on every loop iteration

Use when code uses complex arithmetic expressions with modulo operations in conditional statements, especially involving multiple variables

Use when the solution computes a result via deep tail-style recursion that mixes arithmetic accumulation with the base case (e.g., recursing through y/x*x*2 + f(y%x,x) until x==0)

Use when code uses early return statements inside nested loops to exit upon finding a condition

Use when code uses explicit if-else statements to handle different input cases

Use when code uses explicit if-else branches based on input comparisons

Use when code computes large values through repeated multiplication in loops (e.g., computing powers)

Use when integer values are updated using floating-point multiplication (e.g., y = y * 1.01) inside a loop condition that KLEE must symbolically reason about

Use when code reads an integer with scanf and performs arithmetic/logical operations on it

Use when intermediate variables are used to store simple arithmetic expressions before using them in conditional statements

Use when GCD/LCM is computed via an iterative loop that mutates the input parameters and reuses them as both state and divisor, creating loop-carried symbolic dependencies

Use when code uses large fixed-size arrays (e.g., box[55555]) for sieve-based algorithms or marking/filtering operations

Use when code declares large static/global arrays that are accessed with symbolic indices

Use when code uses a loop to search for a value that satisfies an equation or constraint

Use when computing square root through iterative loop (while i*i < target)

Use when a loop performs repeated multiplication where the loop bound depends on symbolic input

Use when code uses modulo operations (%) in conditional expressions that involve symbolic variables

Use when code uses modulo operator (%) to extract digits or parts of a number

Use when a branch condition uses multiplication of two symbolic inputs (e.g., s*t < d) creating a nonlinear constraint

Use when the condition involves nonlinear arithmetic over symbolic integers (e.g., multiplications like 4*a*b or squaring (c-a-b)*(c-a-b)) that the SMT solver struggles to reason about

Use when using puts() function for string output

Use when the code computes modular inverses via Fermat's little theorem using a power function with a data-dependent loop (pw(x, mod-2)) called repeatedly inside combinatorial helpers

Use when the algorithm pads a 2D array with sentinel border values and uses nested initialization loops with per-cell conditionals to set them, creating extra symbolic branches per cell

Use when code introduces an extra variable mutation (e.g., K-=1) before using the value as an array index, creating additional symbolic state updates

Use when input variables are modified and reused for computation instead of using separate variables

Use when using scanf() to read a single character into an integer variable

Use when a for-loop's update expression uses the comma operator to embed I/O or computation with side effects (e.g., printf with a conditional argument), mixing loop control with branching logic

Use when loop counters are initialized outside the loop and side-effecting expressions (like printf with branching arguments) are embedded in the for-statement's increment clause

Use when the code branches on equality of input parameters and returns early via specialized closed-form computations (e.g., Pow) for degenerate cases