# Class: com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.EUtil

Utility methods to manipulate [IR expressions](IEGeneric).

## Static Method: abs
- parameter: `ctx`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.IERoutineContext`
- parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IECond`

Description: Absolute\-value operation applied to [IEGeneric](IEGeneric).
parameter: ctx: routine context
parameter: a: operand
return: conditional absolute\-value expression

## Static Method: add
- parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `b`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation`


## Static Method: add
- parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `b`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `c`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation`


## Static Method: adjustBranchToIRInstruction
- parameter: `stm`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEStatement`
- parameter: `currentTargetIROffset`, type: `int`
- parameter: `newTargetIROffset`, type: `int`
- return type: `int`


## Static Method: andB
- parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `b`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation`


## Static Method: andL
- parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `b`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation`


## Static Method: buildCarryFlag
- parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `b`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `result`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `addition`, type: `boolean`
- parameter: `nativeOp`, type: `boolean`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`

Description: Generate an IR expression computing the carry flag bit of an integer addition or subtraction operation. 

 The carry flag is used to indicate wrap\-around for **unsigned** operations.
parameter: a: operand a
parameter: b: operand b
parameter: result: result c \(may have an additional carry flag added before\)
parameter: addition: true if the carry is to be computed for "a \+ b", false for "a \- b"
parameter: nativeOp: indicate it [OperationType#CARRY](OperationType#CARRY) / [OperationType#LT_U](OperationType#LT_U) can be            used over complex xor expression
return: a one\-bit overflow flag IR expression

## Static Method: buildLogicalOperation
- parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation`

Description: Transform the operands of an operation into logical operands \(LOG\_NEQ with 0\).
parameter: e: operation to transform
return: transformed operation, or the input if no transformation was needed

## Static Method: buildOverflowFlag
- parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `b`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `result`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `addition`, type: `boolean`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`

Description: Generate an IR expression computing the overflow flag bit of an integer addition or subtraction operation. 

 The Overflow flag is used to indicate wrap\-around for **signed** operations. 

 Note: The generated IR is equivalent to: `MSB((a ^ c) & ~(a ^ b))` for an addition, or `MSB((a ^ c) & (a ^ b))` for a subtraction.
parameter: a: operand a
parameter: b: operand b
parameter: result: result c, comprising an optional carry flag added beforehand
parameter: addition: true if the overflow is to be computed for "a \+ b", false for "a \- b"
return: a one\-bit overflow flag IR expression

## Static Method: buildStrictLogicalECond
- parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IECond`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IECond`

Description: Check if the ECond predicate is a ""boolean"", i.e. a logical operation. 

 In case it is not, a new ECond with a boolean predicate is built \(based on LOG\_NEQ 0\).
parameter: e: conditional expression to transform
return: transformed IRE

## Static Method: buildStrictLogicalOperation
- parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation`

Description: Check if the operands of logical OR, AND and NOT are ""booleans"", i.e. logical operations. 

 In case they are not, a new operation with boolean operands is built \(based on LOG\_NEQ 0\).
parameter: e: operation to transform
return: transformed IRE

## Static Method: calculateComplexity
- parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `int`

Description: Calculate the trivial complexity metric for the provided IR expression. Every IR element has a weight of 1.
parameter: e: expression to inspect
return: trivial complexity value

## Static Method: checkCallReturnAddress
- parameter: `ctx`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.IERoutineContext`
- parameter: `cfg`, type: `com.pnfsoftware.jeb.core.units.code.asm.cfg.CFG<com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEStatement>`
- parameter: `b`, type: `com.pnfsoftware.jeb.core.units.code.asm.cfg.BasicBlock<com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEStatement>`
- parameter: `insnIndex`, type: `int`
- return type: `java.lang.Boolean`

Description: 
parameter: ctx: 
parameter: cfg: 
parameter: b: 
parameter: insnIndex: 
return: null if the return address is not set; true if it is an immediate value matching the         call expected return address \(i.e., following the call instruction itself\); false         otherwise

## Static Method: checkFalse
- parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`


## Static Method: checkTrue
- parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`


## Static Method: cmpFloat
- parameter: `op`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.OperationType`
- parameter: `op1`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `op2`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`


## Static Method: collectVars
- parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `java.util.Set<com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEVar>`


## Static Method: collectVars
- parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `sink`, type: `java.util.Collection<com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEVar>`

Description: Collect all EVars of an expression. If the expression is an EVar, it will be collected.
parameter: e: IR expression
parameter: sink: a recipient for collected EVars. Note that a set may be used to collect unique            EVars, or a list may be used to collect all encountered EVars

## Static Method: compose
- parameter: `ctx`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.IERoutineContext`
- parameter: `elts`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric[]`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`

Description: Create a composition if the provided list of elements contains at least two entries, else return the single element.
parameter: ctx: routine context used to create the composition
parameter: elts: elements to compose
return: composed expression, or the sole element if only one was provided

## Static Method: compose
- parameter: `ctx`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.IERoutineContext`
- parameter: `elts`, type: `java.util.Collection<com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric>`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`

Description: Create a composition if the provided list of elements contains at list two entries, else return the single element.
parameter: ctx: routine context used to create the composition
parameter: elts: elements to compose
return: composed expression, or the sole element if only one was provided

## Static Method: composeImms
- parameter: `g`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.IEGlobalContext`
- parameter: `elts`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEImm[]`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEImm`


## Static Method: contains
- parameter: `target`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `token`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `boolean`

Description: Indicates if the target expression contains any token expression
parameter: target: expression to search into
parameter: token: token to search
return: true if target contains token

## Static Method: containsMemoryAccess
- parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `boolean`

Description: Indicates if the generic expression contains any memory access \(meaning [IEMem](IEMem)\)
parameter: e: [IEGeneric](IEGeneric)
return: true if the expression contains memory access.

## Static Method: containsUndeterminedInvocations
- parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `boolean`

Description: Indicates if the generic expression invokes any undetermined kind of call \(meaning [IECall](IECall), [IEJumpFar](IEJumpFar) or [IEUntranslatedInstruction](IEUntranslatedInstruction)\)
parameter: e: [IEGeneric](IEGeneric)
return: true if the expression contains undetermined invocation.

## Static Method: countExpressionPresence
- parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `target`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `int`

Description: Recursively count \(using deep equality\) how many times the provided target is seen in the input expression.
parameter: e: expression to be examined
parameter: target: target
return: presence count

## Static Method: countExpressionsPresence
- parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `targets`, type: `java.util.List<com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric>`
- parameter: `acounts`, type: `int[]`

Description: Recursively count \(using deep equality\) how many times each of the provided targets is seen in the input expression.
parameter: e: expression to be examined
parameter: targets: targets
parameter: acounts: output counts, the array size must match target's, and counts must be            initially set to 0

## Static Method: countSubExpressions
- parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `int`

Description: Collect sub\-expressions of the input expression and return the cardinal of that collection. Simply calls [IEGeneric#collectSubExpressions(java.util.Collection)](IEGeneric#collectSubExpressions(java.util.Collection)). Not recursive\!
parameter: e: expression to inspect
return: number of direct sub\-expressions

## Static Method: countVariablePresence
- parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `target`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEVar`
- return type: `int`

Description: Count the number of times an [IEVar](IEVar) is present in an expression. \(Defined vars are counted as well.\)
parameter: e: expression to inspect
parameter: target: [IEVar](IEVar) to count
return: number of occurrences

## Static Method: countVariableUse
- parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `int`


## Static Method: createConversionOperation
- parameter: `convOperator`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.OperationType`
- parameter: `src`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `dstSize`, type: `int`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation`

Description: Create a conversion operation: an integer truncation, integer extension \(zero or signed\), float truncation or extension, float\-to\-int and int\-to\-float conversion.
parameter: convOperator: one of for which [OperationType#isConversion()](OperationType#isConversion()) returns true \(eg,            [OperationType#CAST](OperationType#CAST), [OperationType#CAST_S](OperationType#CAST_S),            [OperationType#FP2FP](OperationType#FP2FP), [OperationType#FP2INT](OperationType#FP2INT),            [OperationType#INT2FP](OperationType#INT2FP)\)
parameter: src: operand to be extended, truncated, or converted
parameter: dstSize: resulting bitsize
return: the operation IRE

## Static Method: createResizeOperation
- parameter: `src`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `dstSize`, type: `int`
- parameter: `signed`, type: `boolean`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation`

Description: Create a resize operation operation: truncation, zero\-extension, or sign\-extension.
parameter: src: the source to be extended \(`dstSize > srcSize`\) or truncated            \(`dstSize < srcSize`\)
parameter: dstSize: the destination size; should be different than the source's
parameter: signed: for extensions, else N/A
return: the operation IRE

## Static Method: determineArgumentStackSlotCount
- parameter: `prototype`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IWildcardPrototype`
- parameter: `varArgTypes`, type: `java.util.Collection<com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IWildcardType>`
- return type: `int`

Description: Determine the number of stacks slots used by invoking a method having the provided prototype and an optional list of additional arguments.
parameter: prototype: 
parameter: varArgTypes: optional; the prototype MUST be marked VarArg for this to not be            disregarded
return: 

## Static Method: determineReturnValuesStackSlotCount
- parameter: `prototype`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IWildcardPrototype`
- parameter: `inputStackSlotCount`, type: `int`
- return type: `int`

Description: Determine the number of stack slots filled out when a routine with the provided prototype returns.
parameter: prototype: 
parameter: inputStackSlotCount: the number of stack slots used for input \(arguments\); depending on            the calling convention specified in the prototype, this value may be needed in            order to calculate the count correctly
return: 

## Static Method: div
- parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `b`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `signed`, type: `boolean`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation`

Description: Alias for [#divS(IEGeneric, IEGeneric)](#divS(IEGeneric, IEGeneric)) / [#divU(IEGeneric, IEGeneric)](#divU(IEGeneric, IEGeneric)).
parameter: a: dividend
parameter: b: divisor
parameter: signed: true to create a signed division
return: division operation

## Static Method: divS
- parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `b`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation`


## Static Method: divU
- parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `b`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation`


## Static Method: dump
- parameter: `cfg`, type: `com.pnfsoftware.jeb.core.units.code.asm.cfg.CFG<com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEStatement>`
- parameter: `filename`, type: `java.lang.String`

Description: Dump an IR\-CFG to a Graphviz `dot` file in the user's temporary folder.
parameter: cfg: CFG
parameter: filename: filename \(the ".dot" extension will be appended if necessary\)

## Static Method: dump
- parameter: `cfg`, type: `com.pnfsoftware.jeb.core.units.code.asm.cfg.CFG<com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEStatement>`
- parameter: `filename`, type: `java.lang.String`
- parameter: `title`, type: `java.lang.String`

Description: Dump an IR\-CFG to a Graphviz `dot` file in the user's temporary folder.
parameter: cfg: CFG
parameter: filename: filename \(the ".dot" extension will be appended if necessary\)
parameter: title: optional title or header string

## Static Method: eq
- parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `b`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation`


## Static Method: evalAsPositiveInt
- parameter: `imm`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEImm`
- return type: `int`

Description: Evaluate an immediate to a 32\-bit positive int. Apply Integer positive mask is greater than [Integer#MAX_VALUE](Integer#MAX_VALUE).
parameter: imm: 
return: 

## Static Method: evalAsSaturatedPositiveInt
- parameter: `imm`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEImm`
- return type: `int`

Description: Evaluate and convert a positive immediate to a 32\-bit int. If the immediate is greater than [Long#MAX_VALUE](Long#MAX_VALUE), the method will throw. It the evaluated value is greater than [Integer#MAX_VALUE](Integer#MAX_VALUE), Integer\#MAX\_VALUE will be returned.
parameter: imm: immediate to be evaluated
return: a 32\-bit positive or zero int
see also: IEImm#getValueAsUnsignedLong()

## Static Method: evaluateAddress_preVerified
- parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `state`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.EState`
- return type: `long`


## Static Method: evaluateAddress_preVerified
- parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `long`


## Static Method: evaluateUnsignedLong_preVerified
- parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `state`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.EState`
- return type: `long`


## Static Method: evaluateUnsignedLong_preVerified
- parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `long`


## Static Method: evaluate_preVerified
- parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `state`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.EState`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEImm`


## Static Method: evaluate_preVerified
- parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEImm`


## Static Method: expandCalls
- parameter: `ctx`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.IERoutineContext`
- parameter: `alsoExpandPCAssign`, type: `boolean`
- return type: `boolean`

Description: Call/PC\-assign expansion: augment the size to at least 2, to accommodate splitting:
 \- if an EReturn is to be inserted \(tail\-calls\) in lieu of a ECall
 \- if a raw PC\-assign cannot be converted to a single EJumpFar
parameter: ctx: routine context
parameter: alsoExpandPCAssign: if true, PC\-assigns will also be expanded; else, only ECalls are            expanded
return: success indicator

## Static Method: expandStatementSize
- parameter: `ectx`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.IERoutineContext`
- parameter: `stm0`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEStatement`
- parameter: `minSize`, type: `int`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.cfg.CFG<com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEStatement>`

Description: Expand the [size](IInstruction#getSize()) of a statement. 

 CAREFUL\! This method can modify the structure of the CFG \(block order, block count, etc.\).
parameter: ectx: 
parameter: stm0: 
parameter: minSize: 
return: the resulting CFG \(it may be the original CFG\)

## Static Method: expandStatementSizes
- parameter: `ectx`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.IERoutineContext`
- parameter: `stmcoll`, type: `java.util.Collection<com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEStatement>`
- parameter: `minSize`, type: `int`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.cfg.CFG<com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEStatement>`

Description: Expand the [sizes](IInstruction#getSize()) of a collection of statements. 

 CAREFUL\! This method can modify the structure of the CFG \(block order, block count, etc.\).
parameter: ectx: 
parameter: stmcoll: 
parameter: minSize: 
return: the resulting CFG \(it may be the original CFG\)

## Static Method: extend
- parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `bitsize`, type: `int`
- parameter: `signExtend`, type: `boolean`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`

Description: Extend an [IEGeneric](IEGeneric). Return null if provided [IEGeneric](IEGeneric) is null.
parameter: a: expression to extend
parameter: bitsize: target bitsize
parameter: signExtend: true to sign\-extend, false to zero\-extend
return: extended expression, or null if `a` is null

## Static Method: fabs
- parameter: `ctx`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.IERoutineContext`
- parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IECond`

Description: Operation [Math#abs(float)](Math#abs(float)) applied to [IEGeneric](IEGeneric).
parameter: ctx: routine context
parameter: a: operand
return: conditional absolute\-value expression

## Static Method: fmax
- parameter: `ctx`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.IERoutineContext`
- parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `b`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IECond`

Description: Operation [Math#max(float, float)](Math#max(float, float)) applied to [IEGeneric](IEGeneric)
parameter: ctx: routine context
parameter: a: first operand
parameter: b: second operand
return: conditional maximum expression

## Static Method: fmin
- parameter: `ctx`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.IERoutineContext`
- parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `b`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IECond`

Description: Operation [Math#min(float, float)](Math#min(float, float)) applied to [IEGeneric](IEGeneric)
parameter: ctx: routine context
parameter: a: first operand
parameter: b: second operand
return: conditional minimum expression

## Static Method: formatIR
- parameter: `ectx`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.IERoutineContext`
- return type: `java.lang.String`

Description: Format an IR\-CFG.
parameter: ectx: routine context
return: the formatted CFG

## Static Method: formatIR
- parameter: `ectx`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.IERoutineContext`
- parameter: `displayOffsets`, type: `boolean`
- parameter: `displayDataChains`, type: `boolean`
- parameter: `displayTypes`, type: `boolean`
- return type: `java.lang.String`

Description: Format an IR\-CFG.
parameter: ectx: routine context
parameter: displayOffsets: true to display IR offsets
parameter: displayDataChains: true to display data\-flow information
parameter: displayTypes: true to display expression types
return: the formatted CFG

## Static Method: formatStatements
- parameter: `irlist`, type: `java.util.List<? extends com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEStatement>`
- return type: `java.lang.String`


## Static Method: formatVars
- parameter: `ctx`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.IERoutineContext`
- parameter: `varids`, type: `java.util.Collection<java.lang.Integer>`
- return type: `java.lang.String`


## Static Method: formatVars
- parameter: `ctx`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.IERoutineContext`
- parameter: `varids`, type: `int[]`
- return type: `java.lang.String`


## Static Method: gatherArgumentTypes
- parameter: `prototype`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IWildcardPrototype`
- parameter: `varArgTypes`, type: `java.util.Collection<com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IWildcardType>`
- return type: `java.util.List<com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IWildcardType>`

Description: Retrieve the list of input types, by examining the provided prototype and optional list of additional arguments.
parameter: prototype: 
parameter: varArgTypes: optional; the prototype MUST be marked VarArg for this to not be            disregarded
return: 

## Static Method: geS
- parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `b`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation`


## Static Method: geU
- parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `b`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation`


## Static Method: getAssigningFromMemory
- parameter: `stm`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEStatement`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEMem`

Description: Determine if the statement is an [IEAssign](IEAssign) from an [IEMem](IEMem). If so, return the memory source.
parameter: stm: 
return: a memory IRE or null

## Static Method: getAssigningToMemory
- parameter: `stm`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEStatement`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEMem`

Description: Determine if the statement is an [IEAssign](IEAssign) to an [IEMem](IEMem). If so, return the memory target. 

```

 DST = mXX[???]
 
```
parameter: stm: 
return: a memory IRE or null

## Static Method: getAssignmentDestination
- parameter: `stm`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEStatement`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`

Description: Retrieve the destination of an [IEAssign](IEAssign) \(or null if is not an assignment\).
parameter: stm: 
return: 

## Static Method: getAssignmentSource
- parameter: `stm`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEStatement`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`

Description: Retrieve the source of an [IEAssign](IEAssign) \(or null if is not an assignment\).
parameter: stm: 
return: 

## Static Method: getBestType
- parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IWildcardType`
- parameter: `b`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IWildcardType`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IWildcardType`

Description: 
parameter: a: 
parameter: b: 
return: 

## Static Method: getMirrorOperation
- parameter: `optype`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.OperationType`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.OperationType`


## Static Method: getOperation
- parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `optypes`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.OperationType[]`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.OperationType`


## Static Method: getOperation
- parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation`
- parameter: `optypes`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.OperationType[]`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.OperationType`


## Static Method: getParents
- parameter: `expression`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `value`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `java.util.List<com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric>`

Description: Retrieve all the parents of a value. The search is done by reference.
parameter: expression: expression to search into.
parameter: value: value to be searched.
return: the list of direct parents.

## Static Method: getReverseOperation
- parameter: `optype`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.OperationType`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.OperationType`


## Static Method: getSignExtensionBase
- parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`

Description: Check if an IR expression looks like a sign\-extension operation, and if so, provide the base expression.
parameter: e: expression to inspect
return: base expression if the input looks like a sign extension, null otherwise

## Static Method: getSignExtensionBase
- parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IECompose`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`

Description: Check if the composition is a sign\-extension of a base expression, and if so, provide the base expression.
parameter: e: expression to test that should be a signExtend
return: the base expression

## Static Method: getSignExtensionBase
- parameter: `base`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `extend`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`

Description: Check if the composition of both expressions make up a sign\-extension, and if so, provide the base expression. 

 if the input expression is as such: `COMPOSE(base, MSB(base) ? -1: 0)`, then return: `base`
parameter: base: candidate base \(i.e., base we expect to retrieve\)
parameter: extend: candidate sign\-extension expression, extending `base`
return: base on success, else null

## Static Method: getSubExpressions
- parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `java.util.List<com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric>`

Description: Collect the sub\-expressions of an IRE. Simply calls [IEGeneric#collectSubExpressions(java.util.Collection)](IEGeneric#collectSubExpressions(java.util.Collection)). Not recursive\!
parameter: e: expression to inspect
return: direct sub\-expressions

## Static Method: getUsedVarIds
- parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `java.util.Set<java.lang.Integer>`


## Static Method: getVarSlice
- parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEVar`


## Static Method: getVarSliceId
- parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `java.lang.Integer`


## Static Method: getVars
- parameter: `ctx`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.IERoutineContext`
- parameter: `varids`, type: `java.util.Collection<java.lang.Integer>`
- return type: `java.util.List<com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEVar>`


## Static Method: getWildcardTypes
- parameter: `etypeman`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IWildcardTypeManager`
- parameter: `elts`, type: `java.util.Collection<com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric>`
- return type: `java.util.List<com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IWildcardType>`


## Static Method: gtS
- parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `b`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation`


## Static Method: gtU
- parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `b`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation`


## Static Method: hasExplicitlyUsedVar
- parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `target`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEVar`
- return type: `boolean`


## Static Method: hasLinearControlFlow
- parameter: `ctx`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.IERoutineContext`
- return type: `boolean`

Description: Checks if an IR routine contains only basic blocks with one parent and one child \(no merge or disjunction of control\-flow\).
return: 

## Static Method: hasNoSideEffect
- parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `boolean`

Description: Determine if an IR expression is side\-effect free. 

 This method is taking a liberal approach to side\-effects: Side effects include invocations to other routines determined to be non side\-effect\-free, voluntarily throwing an exception, or performing a memory\-access that will trigger an exception. 

 The opposite of [#hasSideEffect(IEGeneric)](#hasSideEffect(IEGeneric)).
parameter: e: 
return: 

## Static Method: hasNoTypeInfo
- parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `boolean`

Description: Determine if the provided IR expression embeds *no amount at all* of type information.
parameter: e: 
return: 

## Static Method: hasSameType
- parameter: `e1`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `e2`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `boolean`

Description: 
parameter: e1: 
parameter: e2: 
return: 

## Static Method: hasSideEffect
- parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `boolean`

Description: The opposite of [#hasNoSideEffect(IEGeneric)](#hasNoSideEffect(IEGeneric)).
parameter: e: 
return: 

## Static Method: hasTypeInfo
- parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `boolean`

Description: Determine if the provided IR expression embeds some type information. Note that the sub\-expressions are **not** examined.
parameter: e: 
return: 

## Static Method: identL
- parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`


## Static Method: imm
- parameter: `val`, type: `long`
- parameter: `bitsize`, type: `int`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEImm`

Description: Create an immediate, limited to 64 bits.
parameter: val: immediate value
parameter: bitsize: immediate bitsize
return: immediate expression

## Static Method: imm
- parameter: `val`, type: `byte[]`
- parameter: `bitsize`, type: `int`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEImm`

Description: Create an arbitrary\-long immediate.
parameter: val: big\-endian bytes of the value
parameter: bitsize: immediate bitsize
return: immediate expression

## Static Method: imm
- parameter: `val`, type: `java.math.BigInteger`
- parameter: `bitsize`, type: `int`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEImm`

Description: Create an arbitrary\-long immediate.
parameter: val: value
parameter: bitsize: immediate bitsize
return: immediate expression

## Static Method: imm
- parameter: `val`, type: `java.lang.String`
- parameter: `bitsize`, type: `int`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEImm`

Description: Create an arbitrary\-long immediate.
parameter: val: string representation of the integer immediate
parameter: bitsize: immediate bitsize
return: immediate expression

## Static Method: immToInt32Array
- parameter: `val`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEImm`
- return type: `int[]`


## Static Method: immToInt32Array
- parameter: `val`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEImm`
- parameter: `dst`, type: `int[]`
- parameter: `index`, type: `int`


## Static Method: int32ArrayToImm
- parameter: `g`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.IEGlobalContext`
- parameter: `dst`, type: `int[]`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEImm`


## Static Method: int32ArrayToImm
- parameter: `g`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.IEGlobalContext`
- parameter: `dst`, type: `int[]`
- parameter: `index`, type: `int`
- parameter: `indexEnd`, type: `int`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEImm`


## Static Method: isAssignedIn
- parameter: `bb`, type: `com.pnfsoftware.jeb.core.units.code.asm.cfg.BasicBlock<com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEStatement>`
- parameter: `checkedDst`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `boolean`

Description: Check that an IRE is assigned in a basic block. 

 This method does not rely on data flow analysis; it simply searches for an assignment to the given IRE.
parameter: bb: basic block to inspect
parameter: checkedDst: destination expression to search for
return: true if the destination is assigned in the block

## Static Method: isBitOne
- parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `boolean`

Description: Verify that an IRE is a single\-bit immediate set to 1 \(technically, \-1\).
parameter: e: expression to test
return: true if the expression is a one\-bit immediate set to 1

## Static Method: isBitZero
- parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `boolean`

Description: Verify that an IRE is a single\-bit immediate set to 0.
parameter: e: expression to test
return: true if the expression is a one\-bit immediate set to 0

## Static Method: isComparableIntegerOperation
- parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation`
- return type: `boolean`


## Static Method: isComparableOperation
- parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `boolean`

Description: ""Boolean"" comparable operation \(eq/neq and all greater/lesser comparisons\)
parameter: e: IR expression
return: true if this is a comparable operation

## Static Method: isComparableOperation
- parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation`
- return type: `boolean`


## Static Method: isComparableOperation
- parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation`
- parameter: `allowUnsigned`, type: `boolean`
- parameter: `allowFloat`, type: `boolean`
- return type: `boolean`


## Static Method: isComparableSignedOperation
- parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation`
- return type: `boolean`


## Static Method: isCondEAssign
- parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEStatement`
- return type: `boolean`


## Static Method: isConditionalJump
- parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEStatement`
- return type: `boolean`


## Static Method: isExpressionModified
- parameter: `insn`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEStatement`
- parameter: `target`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `defuse`, type: `boolean`
- return type: `boolean`


## Static Method: isFirstBit
- parameter: `s2`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IESlice`
- return type: `boolean`


## Static Method: isImmNonZero
- parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `boolean`


## Static Method: isImmSize
- parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `bitsize`, type: `int`
- return type: `boolean`


## Static Method: isImmValue
- parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `value`, type: `long`
- return type: `boolean`


## Static Method: isImmValue
- parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `value`, type: `java.math.BigInteger`
- return type: `boolean`


## Static Method: isImmZero
- parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `boolean`


## Static Method: isImmediate
- parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `boolean`

Description: Determine if the [IEGeneric](IEGeneric) is an [IEImm](IEImm). Use when e can be null, otherwise prefer native [IEGeneric#isImm()](IEGeneric#isImm())
parameter: e: IR expression
return: `e != null && e.IsImm()`

## Static Method: isJump
- parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `boolean`


## Static Method: isLastBit
- parameter: `s2`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IESlice`
- return type: `boolean`


## Static Method: isLegalSignedImmediate
- parameter: `v`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEImm`
- parameter: `checkedBitsize`, type: `int`
- return type: `boolean`

Description: Verify that the provided immediate is a legal signed value if it were to be treated as a signed integer of \`checkedBitsize\`. 

 Examples: 

```

 the 64-bit value 0x00000000_07FFFFFFF is legal if treated as a 32-bit signed immediate
 the 64-bit value 0xFFFFFFFF_FFFFE0000 is legal if treated as a 32-bit signed immediate
 the 64-bit value 0x00000000_87FFFFFFF is ILLEGAL if treated as a 32-bit signed immediate
 the 64-bit value 0x00100000_000000012 is ILLEGAL if treated as a 32-bit signed immediate
 the 64-bit value 0xFFFF00FF_FFFFE0000 is ILLEGAL if treated as a 32-bit signed immediate
 
```
parameter: v: 
parameter: checkedBitsize: 
return: 

## Static Method: isLegalUnsignedImmediate
- parameter: `v`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEImm`
- parameter: `checkedBitsize`, type: `int`
- return type: `boolean`

Description: Verify that the provided immediate is a legal unsigned value if it were to be treated as an unsigned integer of \`checkedBitsize\`.
parameter: v: 
parameter: checkedBitsize: 
return: 

## Static Method: isLikeImmediate
- parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `boolean`

Description: Determine if the IRE is an EImm or a slice or composition of immediates.
parameter: a: 
return: 

## Static Method: isLikeLongImmediate
- parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `boolean`

Description: Determine if the expression is equivalent to an EImm that can be read as a `long` primitive.
parameter: e: expression
return: 

## Static Method: isLikeLongImmediate
- parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `unsigned`, type: `boolean`
- return type: `boolean`

Description: Determine if the expression is equivalent to an EImm that can be read as a `long` primitive.
parameter: e: expression
parameter: unsigned: 
return: 

## Static Method: isLogicalOperation
- parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `boolean`

Description: ""Boolean"" operation \(and, or, not, eq/neq and all greater/lesser comparisons\)
parameter: e: IR expression
return: true if this is a logical operation

## Static Method: isLongImmediate
- parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `boolean`

Description: Determine if the expression is an EImm that can be read as a `long` primitive.
parameter: e: expression
return: 

## Static Method: isLongImmediate
- parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `unsigned`, type: `boolean`
- return type: `boolean`

Description: Determine if the expression is an EImm that can be read as a `long` primitive.
parameter: e: expression
parameter: unsigned: 
return: 

## Static Method: isMatchDuaryOperation
- parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `wantedOperationType`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.OperationType`
- parameter: `wantedOperand1`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `wantedOperand2`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `boolean`


## Static Method: isMinusOne
- parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `boolean`

Description: Verify that an IRE is an immediate holding the value \-1.
parameter: e: expression to test
return: true if the expression is an immediate holding \-1

## Static Method: isNBit
- parameter: `s2`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IESlice`
- parameter: `n`, type: `int`
- return type: `boolean`


## Static Method: isNaN
- parameter: `op`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`

Description: As per IEEE 754\-1985 floating\-point standard, is NaN a number which exponent is filled with ones and a non\-zero number in the mantissa
parameter: op: floating\-point expression to test
return: expression evaluating to true if the operand is NaN

## Static Method: isNotPredicate
- parameter: `p`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `p2`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `boolean`

Description: Indicate if p == \!p2. Search for reversed operator as well as mirrored predicate. Do not consider NOT operations.
parameter: p: reference predicate
parameter: p2: predicate to test
return: true if `p2` is the negation of `p`

## Static Method: isOne
- parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `boolean`

Description: Verify that an IRE is an immediate holding 1. 

 IMPORTANT: i1:1 will fail the test since it is equal to \-1. Consider using [#isBitOne(IEGeneric)](#isBitOne(IEGeneric)) or [#isMinusOne(IEGeneric)](#isMinusOne(IEGeneric)) instead.
parameter: e: expression to test
return: true if the expression is an immediate holding 1

## Static Method: isOperation
- parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `optype`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.OperationType`
- return type: `boolean`

Description: Determine if the [IEGeneric](IEGeneric) is an [IEOperation](IEOperation). Use when e can be null, otherwise prefer native [IEGeneric#isOperation(OperationType)](IEGeneric#isOperation(OperationType))
parameter: e: IR expression
parameter: optype: operation type to test
return: `e != null && e.IsOperation(optype)`

## Static Method: isOperation
- parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `optypes`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.OperationType[]`
- return type: `boolean`

Description: Determine if the [IEGeneric](IEGeneric) is an [IEOperation](IEOperation). Use when e can be null, otherwise prefer native [IEGeneric#isOperation(OperationType...)](IEGeneric#isOperation(OperationType...))
parameter: e: IR expression
parameter: optypes: operation types to test
return: `e != null && e.IsOperation(optypes)`

## Static Method: isOperationSize
- parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `bitsize`, type: `int`
- return type: `boolean`


## Static Method: isPCAssign
- parameter: `stm`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEStatement`
- return type: `boolean`

Description: Determine if the provided statement is a PC\-assign: `PC = ...`
parameter: stm: a statement
return: true if the statement assigns the program counter

## Static Method: isSPAssign
- parameter: `stm`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEStatement`
- return type: `boolean`

Description: Determine if the provided statement is a SP\-assign: `SP = ...` or `SP[slice] = ...`.
parameter: stm: a statement
return: true if the statement assigns the stack pointer

## Static Method: isSPAssignOrPCAssign
- parameter: `stm`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEStatement`
- return type: `boolean`

Description: Determine if the provided statement is assigning the stack pointer or the program counter. Combines [#isSPAssign(IEStatement)](#isSPAssign(IEStatement)) [#isPCAssign(IEStatement)](#isPCAssign(IEStatement)) in a single efficient call.
parameter: stm: a statement
return: true if the statement assigns the stack pointer or the program counter

## Static Method: isSameType
- parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IWildcardType`
- parameter: `b`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IWildcardType`
- return type: `boolean`

Description: 
parameter: a: 
parameter: b: 
return: 

## Static Method: isStrictLogicalOperation
- parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `boolean`

Description: Logical operations that should have logical operands \(and, or, not\).
parameter: e: expression to test
return: true if the expression is a strict logical operation

## Static Method: isStrictLogicalOperation
- parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation`
- return type: `boolean`


## Static Method: isTrampoline
- parameter: `bb`, type: `com.pnfsoftware.jeb.core.units.code.asm.cfg.BasicBlock<com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEStatement>`
- return type: `boolean`


## Static Method: isUnconditionalJump
- parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEStatement`
- return type: `boolean`


## Static Method: isVar
- parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `id`, type: `int`
- return type: `boolean`


## Static Method: isVarOrVarSlice
- parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `boolean`


## Static Method: isVariableAssigned
- parameter: `stm`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEStatement`
- parameter: `var`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEVar`
- return type: `boolean`

Description: 
parameter: stm: 
parameter: var: 
return: 

## Static Method: isZero
- parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `boolean`

Description: Verify that an IRE is a Zero representation \(EImm\(0\) or ESlice\(0, x, x\)\).
parameter: e: expression to test
return: true if the expression is zero

## Static Method: isZeroExtend
- parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `boolean`


## Static Method: isZeroExtend
- parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IECompose`
- return type: `boolean`


## Static Method: leS
- parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `b`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation`


## Static Method: leU
- parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `b`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation`


## Static Method: looksLikeSignExtension
- parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IECompose`
- return type: `boolean`

Description: Determine if a composition looks like a sign\-extension operation.
parameter: e: composition to inspect
return: true if the composition looks like a sign extension

## Static Method: ltS
- parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `b`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation`


## Static Method: ltU
- parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `b`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation`


## Static Method: makeUncond
- parameter: `j`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEJumpWithOptionalCondition`

Description: Make a jump unconditional.
parameter: j: jump to update
throws: if the jump condition contains undetermined invocations

## Static Method: mask
- parameter: `bitsize`, type: `int`
- parameter: `maskbits`, type: `int`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEImm`

Description: Create a bit mask, eg mask\(16, 4\) will create the mask: `b0000000000001111`
parameter: bitsize: immediate bitsize
parameter: maskbits: number of low bits to set; must be less than or equal to `bitsize`
return: mask immediate

## Static Method: mask
- parameter: `bitsize`, type: `int`
- parameter: `maskbegin`, type: `int`
- parameter: `maskend`, type: `int`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEImm`

Description: Create a bit mask, eg mask\(16, 1, 5\) will create the mask: `b0000000000011110`
parameter: bitsize: immediate bitsize
parameter: maskbegin: start bit of the mask, inclusive
parameter: maskend: end bit of the mask, exclusive
return: mask immediate

## Static Method: max
- parameter: `ctx`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.IERoutineContext`
- parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `b`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `signed`, type: `boolean`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IECond`

Description: Operation [Math#max(int, int)](Math#max(int, int)) applied to [IEGeneric](IEGeneric).
parameter: ctx: routine context
parameter: a: first operand
parameter: b: second operand
parameter: signed: true to use signed comparison
return: conditional maximum expression

## Static Method: min
- parameter: `ctx`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.IERoutineContext`
- parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `b`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `signed`, type: `boolean`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IECond`

Description: Operation [Math#min(int, int)](Math#min(int, int)) applied to [IEGeneric](IEGeneric).
parameter: ctx: routine context
parameter: a: first operand
parameter: b: second operand
parameter: signed: true to use signed comparison
return: conditional minimum expression

## Static Method: minusOne
- parameter: `bitsize`, type: `int`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEImm`

Description: Generates the value \-1, ie an [IEImm](IEImm) filled with ones.
parameter: bitsize: bitsize of the [IEImm](IEImm)
return: immediate expression

## Static Method: mul
- parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `b`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation`


## Static Method: ne
- parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `b`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation`


## Static Method: notB
- parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`


## Static Method: notL
- parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`


## Static Method: notL
- parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `allowOpt`, type: `boolean`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`


## Static Method: one
- parameter: `bitsize`, type: `int`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEImm`

Description: Generates the value 1L with defined bitsize. Do not mistake [one](#one(int)) for [minusOne](#minusOne(int))
parameter: bitsize: bitsize of the [IEImm](IEImm)
return: immediate expression

## Static Method: op
- parameter: `operator`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.OperationType`
- parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation`


## Static Method: op
- parameter: `operator`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.OperationType`
- parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `b`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation`


## Static Method: orB
- parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `b`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation`


## Static Method: orL
- parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `b`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation`


## Static Method: pow
- parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `b`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation`


## Static Method: remS
- parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `b`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation`


## Static Method: remU
- parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `b`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation`


## Static Method: replaceSubExpressionRecursive
- parameter: `stm`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `src`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `dst`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`


## Static Method: replaceSubExpressionRecursive
- parameter: `stm`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `src`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `dst`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `results`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.EVisitResults`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`


## Static Method: requiresExplicitCast
- parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IWildcardType`
- parameter: `b`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IWildcardType`
- return type: `boolean`

Description: Determine if type \`b\` can be implicitly converted to type \`a\`, without a cast.
parameter: a: 
parameter: b: 
return: 

## Static Method: resize
- parameter: `e`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `wantedBitsize`, type: `int`
- parameter: `signExtend`, type: `boolean`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`


## Static Method: resolveExpressionsBackward
- parameter: `name`, type: `java.lang.Object`
- parameter: `conv`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.IEConverter<?>`
- parameter: `r`, type: `java.util.List<com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEStatement>`
- parameter: `targets`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric[]`
- return type: `boolean`

Description: Apply a list of IEStatements to user targets, resolving expression starting from last [IEStatement](IEStatement) to first. If any error occur \(something can not be translated for example\), this method returns false. As an example: 

```

 r = {R0 = 7; R0 = R0 + 4; R1 = 8}
 targets = [R0, R1]

 i = 2 => targets = [R0, 8]
 i = 1 => targets = [R0+4, 8]
 i = 0 => targets = [11, 8]
 return true
 
```
parameter: name: 
parameter: conv: 
parameter: r: 
parameter: targets: 
return: 

## Static Method: reversePredicate
- parameter: `predicate`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`


## Static Method: safeExtend
- parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `bitsize`, type: `int`
- parameter: `signExtend`, type: `boolean`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`

Description: Safely extend an [IEGeneric](IEGeneric). Return null if provided [IEGeneric](IEGeneric) is null. If bitsize is less that current [IEGeneric](IEGeneric), the [IEGeneric](IEGeneric) relative part is returned.
parameter: a: expression to extend or truncate
parameter: bitsize: target bitsize
parameter: signExtend: true to sign\-extend, false to zero\-extend
return: resized expression, or null if `a` is null

## Static Method: sameBitsize
- parameter: `elts`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric[]`
- return type: `int`

Description: If all the provided expressions have the same bitsize, return it. Null elements are considered invalid and will result in a failure \(the method will return 0\).
parameter: elts: a list of IRE
return: the common bitsize of all provided elements; 0 if the elements do not have the same         bitsize

## Static Method: sameBitsizeAllowNulls
- parameter: `elts`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric[]`
- return type: `int`

Description: If all the provided expressions have the same bitsize, return it. Null elements are ignored.
parameter: elts: a list of IRE
return: the common bitsize of all provided elements; 0 if the elements do not have the same         bitsize

## Static Method: sar
- parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `b`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation`


## Static Method: setLowerLevelAddress
- parameter: `addr`, type: `long`
- parameter: `list`, type: `java.util.List<com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEStatement>`


## Static Method: setLowerLevelAddress
- parameter: `addr`, type: `long`
- parameter: `list`, type: `java.util.List<com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEStatement>`
- parameter: `fromIndex`, type: `int`
- parameter: `toIndex`, type: `int`


## Static Method: setLowerLevelAddressIfNone
- parameter: `addr`, type: `long`
- parameter: `list`, type: `java.util.List<com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEStatement>`


## Static Method: setLowerLevelAddressIfNone
- parameter: `addr`, type: `long`
- parameter: `list`, type: `java.util.List<com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEStatement>`
- parameter: `fromIndex`, type: `int`
- parameter: `toIndex`, type: `int`


## Static Method: shl
- parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `b`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation`


## Static Method: shr
- parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `b`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation`


## Static Method: signExt
- parameter: `src`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `dstSize`, type: `int`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`

Description: Sign\-extend operation IRE.
parameter: src: expression to extend
parameter: dstSize: must be greater or equal than src's size
return: sign\-extended expression

## Static Method: sub
- parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `b`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation`


## Static Method: sxr
- parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `b`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `signedExtension`, type: `boolean`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation`


## Static Method: truncate
- parameter: `src`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `dstSize`, type: `int`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`

Description: Truncate operation IRE.
parameter: src: expression to truncate
parameter: dstSize: must be less or equal than src's size
return: truncated expression

## Static Method: verify
- parameter: `ctx`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.IERoutineContext`

Description: Verify an IR\-CFG. This method relies on the [ECFGVerifier](ECFGVerifier) and throws on error.
parameter: ctx: IR context

## Static Method: verify
- parameter: `cfg`, type: `com.pnfsoftware.jeb.core.units.code.asm.cfg.CFG<com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEStatement>`

Description: Verify an IR\-CFG. This method relies on the [ECFGVerifier](ECFGVerifier) and throws on error.
parameter: cfg: IR graph

## Static Method: xorB
- parameter: `a`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `b`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation`


## Static Method: zero
- parameter: `bitsize`, type: `int`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEImm`

Description: Generates the value 0 with defined bitsize.
parameter: bitsize: bitsize of the [IEImm](IEImm)
return: immediate expression

## Static Method: zeroExt
- parameter: `src`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `dstSize`, type: `int`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`

Description: Zero\-extend operation IRE.
parameter: src: expression to extend
parameter: dstSize: must be greater or equal than src's size
return: zero\-extended expression

