1. Arithmetic and Logical Operations
Modify Bit Masking
Misalignment in Arithmetic and Bitwise Operations
Bitwise XOR to AND Mutation
Increase Nested Shift Depth
Introduce Redundant Bitwise Masking
Increase Shift Value by One
Arithmetical Operation Replacement with Subtraction
Manipulate Non-Literal Exponent
Remove Zero Out on Overflow in Logical Shifts
Promote Exponent Type to Match Base Type
Excessive Shift Adjustment
Change Comparison Operator
Modify Lock Condition
Introduce Floating-Point Arithmetic
Adjust Hash Preimage Length
Introduce Logical Error in Condition
Modify Cache Invalidation Condition
Invert Condition Logic
Change Left Operand Type to String
Remove Redundant Storage Access
Use Unsupported Comparison Operator
Add Zero Check Before Mulmod
Insert Logical AND Condition
Insert False Condition
Delay Storage Load to Next Logical Operation
Insert Logical Contradiction
Use Division Before Comparison
Generate Negative Comparison Result
Swap Order of Mulmod Operands
Add Incompatible Type Element
Misalign Memory Accesses
Modify Integer Size Extension
Modify Multipliers to Invalid Types
Insert Duplicate Storage Write
Add Address Arithmetic Operation
Insert Overflow Check
Modify Pointer Validity During Integer Conversion
Modify Length Assignment
Insert Error via Incorrect Index Calculation
Modify Divisor with Random Variable
Replace Multiplication with Unsupported Operation
Insert Unsupported Bitwise Operation
Introduce Unchecked Rational Multiplication
Insert Power Operator
Insert NOT Operation
Replace Equality with Inequality
Modify Intermediate Memory References
Replace XOR Operand with Incompatible Type
Modify Bitwise NOT Target Variable
Modify Boolean Conversion Logic
Add Unexpected Negation to Less Than Operation
Replace Less-Than with Unrecognized Comparison Operator
Convert Unsigned to Signed Before Shift
Replace Bytes with Uint8
Insert Rounding Adjustment
Insert Irrational Number Multiplication
Replace Multiplication with Modulus to Test Edge Cases
Replace * with Custom Multiply Function
Modify Conversion to Handle Negative Values
Replace Uint8 with Int16 in Conversion
Replace Mulmod with Inline Assembly
Replace Bool with Uint8
Modify Array Index Calculation
Swap Argument Positions in Function Call
Modify Index Increment Logic
Insert Contradictory Storage Update
Use Incompatible Index Type
Insert Shift Amount Variable
Simplify Fraction Decomposition Logic
Introduce Large Exponent Value
Add Rational Part Check
Alter Decimal Point Handling
Add Unnecessary Decimal Point
Convert Integer to Scientific Notation
Increase Exponential Range
Add Safety Checks for Overflow
Cap Exponent Value to Prevent Overflows
Enforce Integer-Rational Balance
Insert Fraction for Floating Number
Insert Binary Prefix
Insert Invalid Size in Array Declaration
Modify Hexadecimal Letters to Uppercase
Insert Invalid Character in Number
Add Leading and Trailing Underscores to Integer
Add Parsing Function for Exponential Literals
Add Trailing Zero After Decimal Point
Modify Rational to Negative Number
Add Exponential Calculation Function
Switch to Scientific Notation with Leading Zeros
Generate Large Test Values
Add Integer Overflow Error Handling
Convert Binary to Decimal
Convert to Logarithmic Scale
Implement Integer Bound Check
2. Data Type and Encoding Modifications
Alter Keccak256 Argument Order  
Incorrect Byte Clearing on Element Update  
Replace String Literals with Empty String  
Incorrect Boolean Interpretation in Delegatecall  
ContractTypeInHashInsteadOfAddress  
Modify Constant Value  
Modify Sign-Extension Handling in Inline Assembly  
Memory to Storage Pointer Confusion  
Incorrect Hash Calculation in Event Emission  
Replace Address with Dummy Contract  
Alter Type Conversion Operation  
Replace uint[][] with uint256[][]  
Incorrect Byte Mask Application  
Replace Assembly SHA3 with Assembly SHA256  
Signed Integer Zero Extension to Full 256-bit  
StructSub32ByteDirectEncodeDecode  
Alter Event String Literal  
String Payload Emission Adjustment  
Change Encoding Method  
Convert uint8 to uint16 in Array  
Change SHA3 Operation Storage Assignment  
Alter Memory Storage and Load Order  
Use Incorrect Hash Encoding Mechanism  
Incorrect Address to String Encoding  
Insert Type Conversion in Constructor Parameters  
Change Field Type in Struct  
Modify State Variable Type  
Replace Cache Variable Type  
Change Parameter Type in Constructor  
Modify Input Parameters to Allow Large Values  
Alter Immutable Variable Data Type  
Alter Cache Conversion Logic  
Modify Field Width in Struct  
Modify Variable Data Type  
Replace uint256 with int256  
Replace uint with int  
Convert uint256 to uint32  
Inject Substring Method  
Modify Address to Payable Address  
Modify Parameter Type in Method Signature  
Modify Cast from uint256  
Add Explicit Cast from uint256 to int8  
Replace uint128 with uint16  
Convert Address via Assembly  
Inject Array Indexing in Address Comparison  
Add Address Typecast  
Modify Address Type to uint256  
Modify Loop Variable Type  
Insert Bytes32 to uint Conversion  
Replace Address Variable with int Variable  
Insert Explicit Cast from Address to Contract Instance  
Insert Explicit Casting Function  
Introduce Overly Complex Casting Operations for Address Conversion  
Insert Cast to uint8  
Insert Invalid Type Assertion After Boolean to Integer Conversion  
Modify Integer Casting Method  
Modify Byte Extraction Logic  
Change Mapping Value Type  
Insert Type Conversion Function  
Unexpected Hash Algorithm Integration  
Alter Boolean Size Before Casting  
Modify Hash Algorithm Used  
Introduce Complex Expression with Unsupported Operation  
Create Type Cast Between FunctionSelector and ExternalFunction  
Convert Mapping to an Unsupported Type  
Change Integer Casting Method  
Modify Divisor with Random Variable  
Insert Explicit Conversion  
Replace Pointer with uint  
Add Explicit Cast  
Modify Byte Length  
Modify Byte Alignment  
Modify uint256 to bytes32 Casting  
Modify Conversion Logic  
Change Array Subscript to Struct Field Access  
Insert Alignment Requirements  
Add Type-Casting Validation  
Modify Conversion to Handle Sign Overflow  
Convert Byte Array to Fixed-Size  
Modify Literal Type to String  
Convert Number Literal to Undefined  
Modify Struct Definition  
Modify Address to a Non-Standard Size Before Casting  
Change Expected Byte Length  
Modify Allocation Logic  
Modify Pointer Initialization  
Modify Bytes32 to Bytes  
Alter uint128 to bytes16 Conversion  
Change Field Type to BufferPointer  
Replace New Operator with Factory Pattern  
Introduce Type Mismatch in Casting Function  
Insert Explicit Address Conversion Function  
Modify Return Type  
Force Mismatched Length During Conversion  
Replace Boolean Operations with Ternary  
Replace Function Argument Type  
Modify Element Type in Struct  
Insert Conversion Function That Modifies Data Alignment  
Insert Irrational Number Multiplication  
Cast Return Type to bytes32  
Modify Return Type Incorrectly  
Swap Address and uint Conversion  
Insert Invalid Address Length  
Convert to Equality Check  
Replace Bytes with uint8  
Replace Bool with uint8  
Insert Type Mismatch in Casting Function  
Cast Return Type to uint128  
Add Explicit Conversion Function  
Convert String to Bytes  
Change Return Type to FunctionSelector  
Replace Integer Type with Another  
Modify Mapping Key Type  
Use Signed Integers for Operation  
Introduce Unknown Type in Array  
Insert Type Mismatch  
Change Address Variables to Payable Addresses  
Convert Integer to Pointer Using Implicit Casting  
Modify Type Consistency  
Add Unsupported Value Type to Mapping  
Modify Return Type Expected from '__memcmp'  
Use Fixed-Size Integer for Address Casting  
Modify Address to String Conversion  
Convert User-Defined Value Type to Basic Type  
Change Mapping Key Type  
Misinterpret String as Buffer Pointer  
Add Boolean Casting Logic  
Change Byte Order Conversion Function  
Add Default Value to Reference  
Add an Unsupported Function Type Modifier  
Insert Type Coercion Before Comparison  
Modify Underlying Type of Alias to Rational  
Change Type to Rational  
Introduce Computational Type in Mapping  
Add Assertion for Parameter Types  
Change Operand Type Cast  
Insert Explicit Data Casting in Address Conversion  
Modify Comparison Operator  
Allocate Memory for Null Elements in Reference Type  
Insert Invalid Integer Value  
Insert Explicit Type Conversion  
Replace Double Equals with Not Equals  
Change Address Variables to Non-Address Type Before Comparison  
Modify Equality Check to Include Type Cast  
Replace Hex with Decimal  
Modify Variable to Non-Constant  
Overflow Integer Value Beyond u16 Maximum  
Trigger Invalid Type Representation  
Modify Leading Zeros in Binary  
Remove Binary Prefix  
Insert Hashtag Before Number  
Modify Integer to Include Underscore  
Add 'Transient' Data Location to File-Level Variable  
Increase Integer Value  
Modify Leading Digits  
Add Prefix and Suffix That Ensures Empty Parse  
Extend Numerical Type Handling  
Insert Invalid Hexadecimal Character  
Modify Numerical Type  
Introduce Integer Length Validation  
Replace Empty Enum with Populated Version  
Prefix Integer with Multiple Zeros  
Introduce Empty Exponent  
Replace Integer with Exponent Notation  
Replace Integer with Value Starting with Leading Zeros  
Modify Parameter Validation  
Replace Integer with Hex Value  
Modify Number Type Handling  
Insert Prefix '0x' Randomly  
Insert Prefix to Address  
Insert Unknown Prefix to Hex  
Change Base Notation  
Insert Precision Control  
Insert Key Type Change to Invalid Identifier  
Replace Function Signature with Incompatible Type  
Change Base Radix to Unsupported Value  
Modify Initial Value Using Large Exponent Notation  
Insert Invalid Character in Number  
Insert Inline Assembly  
Replace Numerator with Variable  
Modify Number with a Larger Value  
Modify Base Number  
Convert to Hexadecimal Format  
Replace String with Excessive Trailing Zeros  
Modify Function Return Type  
Insert Fraction for Floating Number  
Add Trailing Zeros to Exponent  
Replace Integer with Max uint  
Substitute Value Type with Empty Array  
Modify Value Type to Array  
Replace Rational with Whole Number  
Modify Base to Use Leading Zeros  
Add Prefix to Address  
Add Leading Zeros After Negative Sign  
Add Leading Zeros to Integer  
Modify Parsing Logic to Binary  
Add Unnecessary Leading Zeros  
Convert to Hexadecimal Floating-Point  
Convert Variable to Array  
Replace Rational Part with Empty String  
Replace Integer with Zero Leading  
Change Address to Checksum  
Modify Initial Value  
Add Wildcard Using Directive Globally  
Use Non-Elementary UDVT in Event Parameter  
Add Undefined Datatype Parameter  
Use Global Keyword Incorrectly in Using Directive  
Set Numeric Value to Empty String  
Insert New Variable Declaration with Unsupported Type  
Introduce Non-Elementary Underlying Type  
Modify Variable Declaration with Wrong Type  
Replace Enum Keyword with Contract  
Switch Array to Mapping  
Change Base Radix  
3. Storage and Memory Manipulations
Replace Calldata Array with Memory Array in Encoding
Calldata to Memory Conversion
Modify Storage Slot Using Alternate Identifier
Memory to Storage Pointer Confusion
Alter Data Location in Overridden Function Parameters
Alter Storage Slot Manipulation
Replace calldata with memory
Data Location Alteration in Derived Function Parameter
Alter Memory Storage and Load Order
Change data location of override function call
Change Storage Slot Access
Uninitialized Memory Allocation
Replace Memory with Calldata in Internal Function
Uninitialized Memory Array Mutation to Storage
Insert incorrect default value
Increase data storage cost
Remove struct field on storage deletion
Replace storage operation with direct memory access
Modify journal entry creation on storage deletion
Insert storage pointer manipulation
Insert nested mappings with large data
Replace delete with zero assignment
Append large string to array
Remove struct member
Replace storage mechanism with an incorrect type
Replace array with dynamic bytes
Remove redundant storage access
Modify storage access to use dynamic index
Insert additional storage write
Change storage variable to temporary with assignment tracking
Add zero-check before mulmod
Insert new struct in array
Reverse the order of array initialization
Add conflicting storage write after read
Nested storage writes
Change storage allocation strategy
Modify array copy mechanism
Delay storage load to next logical operation
Increase dynamic array size
Modify string length
Replace array with mapping
Nested dynamic types mutation
Modify address variable type
Add incompatible type element
Remove array element
Insert element at index
Expand array length
Insert zero byte padding
Deconstruct complex type to primitives before casting
Insert storage access with null check
Add function to misuse pointer conversion
Replace direct equality with variable check
Insert function to cast contract to address implicitly
Insert redundant storage update
Add nested dynamic reference type
Introduce partial memory copy
Insert error handling
Insert repeated storage write
Insert condition for zero-length slice
Reduce redundant checks
Skip necessary storage writes after read
Insert unnecessary conditional storage write
Rename struct to UserInfo
Insert array element at index
Modify reference handling
Retrieve length property of array
Convert array to dynamic size
Insert nested struct
Append element to dynamic array
Force pointer dereference before assignment
Insert assertion after conversion
Change function signature
Insert fixed-size array for dynamic bytes
Insert pointer arithmetic operations
Insert padding byte
Insert unsafe cast for address to contract
Insert mapping data type
Append zero byte
Replace array indexing with loop
Zero out uninitialized bytes
Insert conditional conversion logic
Insert unallocated element in dynamic array
Enforce fixed size constraint
Add integer overflow check during conversion
Change function's internal conversion logic
Modify dynamic data type handling
Convert storage read to memory read
Alter memory allocation sizes
Insert explicit length verification for data structures
Change storage layout
Introduce incorrect pointer arithmetic
Insert erroneous bits into address comparison
Modify access pattern
Modify storage from direct variable to a buffer and perform arithmetic operations sequentially
Modify storage slot
Defer pointer allocation
Add function for pointer conversion
Introduce conditional storage bypass
Modify length assignment for mutating dynamic bytes
Insert conflicting storage variable
Modify structure of address conversion
Modify storage access to use cache
Introduce new complex struct type
Change state variable to address type
Duplicate storage write
Modify storage access to cache
Modify struct reference field
Modify array length
Modify mapping value
Duplicating elements beyond bounds
Inject invalid memory access
Resize slice
Modify memory reference state
Attempt to load from an Uninitialized Reference Type
Access out-of-bounds index
Add a double null check before allocation
1Insert dynamic resizing
Alter slice capacity
Convert slice to unsupported type
Insert memory offset
Relocate memory address
Use memory for struct parameter
Create circular dependency in structs
Add struct inside struct
Replace memory with storage
Insert unused public function
Insert inappropriate data location
Remove data location from struct
Insert memory in function parameter
Add struct state variable
Replace storage with memory
Add transient keyword for state variable
Remove full address
Remove storage keyword from state variable
Set array size to zero during declaration
Modify literal handling to allow dynamic padding
Insert modifier call
Insert zero-length static array
Remove entire literal content
Remove placeholder from modifier
Modify literal to be absent
Insert cyclic self-reference in struct
Add new parameter with similar type
Add overloaded function
Replace state variable type
Insert mutable state in non-state variable
Alter base contract inheritance
Introduce user-defined type state variable
Modify function logic
Modify struct parameter
Modify field type in struct
Modify array size in nested struct
Insert key type change to invalid identifier
Introduce dynamic array in nested struct
Insert dynamic array in nested struct
Add parameter in custom function
Add state variable to contract
Remove field from struct
4. Function and Signature Modifications
Add Duplicate Function
ABI Mismatch Inducer
Externalize Internal Function Call
Inline Function with Side-Effect-Free Check
Alter Function Visibility to Introduce Collision
Private Function Shadowing Introduction
Incorrect Selector Evaluation through Variable Overwrite
Zero Selector Function Removal
Add External Function within Limit
Alias Function Shadowing
Remove ABIEncoderV2 Activation
Public Function Exposure of Private Method
Alter Internal Function Logic
Wrap ecrecover in Inline Verification
Modify constructor initialization sequence
Modify state assignment from constructor to function
Modify constructor for initialization
Add constructor initialization
Modify constructor signature
Modify constructor visibility
Make constructor internal
Modify parameter to an unsupported external function type
Modify function argument type
Modify function visibility
Replace signature with bytes4
Modify parameter order
Transform signature into integer
Replace function return type
Modify function parameters to include non-matching types
Modify return type of function
Alter parameter in address to slice conversion method signature
Generate specialized mutation by inserting a function type
Override signature in derived contract
Insert function to cast contract to address implicitly
Modify return type of slice function
Alter internal function signature to use erroneous or incompatible types
Change function signature
Add return value to function
Integrate casting in function modifier
Modify function return value type incorrectly
Remove internal function
Add non-matching signature to function
Modify function to include signature
Remove function visibility keyword
Remove a call to internal function
Replace constructor with function
Insert unsupported Yul code in constructor
Insert conditional statement with unreachable condition
Insert early return
Replace function call with delegatecall
Reduce the returned list length from internal function
Replace modifier with inline code
Alter address variable initialization
Replace shift operator with multiplication
Introduce function argument type using Rational type
Transform function to fallback type
Modify function visibility
Remove prefix from function name
Replace function name with constructor
Modify function parameter types to induce selector collision
Replace function signature
Modify function name
Add function header visibility
Insert parameter in library function
Replace address with variable
Remove parameters from receive function
Replace uint with int
Create modifier without placeholder
Add modifier to interface function
Add parsing function for exponential literals
Insert leading zero in integer
Modify function parameter types to induce selector collision
Remove named return parameters
Add multiple modifiers to interface
Insert a named return parameter
Modify function logic
Insert modifier call
Insert zero literal in expression
Add exponential calculation function
Modify function signature
Add nested structure to function signature
Add overloaded function
Modify initial value using exponent notation
Remove function body
Modify function logic
Modify directive scope
Replace function return type
Insert additional decimal places
Add new parameter with similar type
Add redundant modifier to abstract function
Add parameter in custom function
Add function overloading
Insert octal prefix
Insert unsupported keyword in function
Modify variable declaration with wrong type
Insert New Library Import Statement
5. Control Flow and Execution Changes
Swap Argument Order
Insert Early Return
Conditional Break Continuation Mutation
Add Early Exit with Continue
Negate Conditional Check
Loop Entry State Modification
Insert Assembly Return
Alter Break Condition in Loop
Loop Control Flow Alteration with Variable Side Effects
Swap Argument Evaluation Order
Replace Break with Conditional Continue
Insert invalid state cleanup
Add reentrancy guard
Insert reentrancy guard
Add reentrancy guard modifier
Introduce flag-based reentrancy guard
Insert execution delay
Swap storage deletion order
Insert validation function
Insert conditional logic in constructor to assign immutable state
Add address comparison
Add unreachable code block
Replace direct check with error handling
Change iteration logic in unreachable block check
Replace direct equality with error notification
Modify loop variable type
Modify loop boundary condition
Remove unreachable code block
Force null assignment before pointer dereference
Modify condition to check for valid integer range before casting to address
Generate unreachable condition
Insert false condition to dead-code removal
Insert conditional check for zero-length data
Add boundary check
Add invalid address length check
Insert assertion after conversion
Add unsupported event type
Insert explicit integer validation logic
Simplify conditional check
Insert a storage update in a conditional statement
Insert conditional check before loading
Insert unchecked pointer conversions
Insert nested conditional expression
Set array size to zero
Swap internal with external
Remove event emission
Insert empty return in External Raw Function Call
Insert fallback case handling
Modify default case execution
Insert incorrect index handling
Insert zero-length check
Introduce Unimplemented Logic
Remove null pointer allocation
Replace assembly block with safe casting
Wrap in require statement
Modify switch variable type
Insert break in case
Update reference variable
Add statement to unchecked block
Switch to require assertion
Add conditional check that violates constraints
Modify function logic
Insert bounds check
Remove block braces, leaving variable declaration outside
Insert untyped global using declaration
Insert additional condition for struct validation to assert
Insert placeholder in unchecked block
Modify function logic
Move variable declaration inside a function
Insert bounds check
None
6. Array and Struct Operations
Extreme Value in Memory Struct Attribute
Array Length Overflow Mutation
Change Struct Member Size
Alter Array Access to Fixed Iteration Count
Zero-Length Dynamic Array Initialization
Replace Non-Zero Start Index with Larger Value
Expand Storage Element Size
Alter Struct Member Size
Incomplete Storage Array Clearance
Replace uint[][] with uint256[][]
Convert Fixed-Size Array to Dynamically-Sized Array in Struct
Replace Direct Call with Manual ABI Encoding
Alter Memory Array Dimension
Expand Storage Array
Inline Assembly Removal from Memory Copy
Replace Max Integer with Reduced Value
Incomplete Zeroing After Array Resize
Alter Large Constant Value
Array Return Element Swap
Reduce Elements in Struct
Modify Array Dimensions in Encoding Test
Increase Static Array Size in Struct
Index Out of Bounds Access Mutation
Array Slice Malformation via Start Index Increment
Extend Storage Array Before Push
Return Array and Access Element Outside Function
Struct Field Size Reduction
Insert user-defined value type field in struct
Insert function type field in struct
Insert array type field in struct
Insert struct type field in struct
Insert mapping type field in struct
Change struct visibility
Remove struct field on storage deletion
Add multi-dimensional array to struct
Insert new struct in array
Modify struct member with default value
update struct in loop
Reverse the order of array initialization
Replace array with dynamic bytes
Add incompatible type element
Remove array element
Modify string length
Insert element at index
reorder struct fields
flatten nested struct fields
Expand array length
Modify array copy mechanism
Change state variable type
Insert element in array
Insert error via incorrect index calculation
Reduce array capacity
Modify array element value
Convert dynamic array to static array
Insert invalid type assertion after boolean to integer conversion
Modify slice length
Append element to array
Expand to address array
Convert array index to pointer offset
Double array length
Introduce recursive type
Reorder struct fields
Change struct member order
Insert member to struct
Create nested struct field
Change struct nesting level
Convert struct to array
Insert nested array of structs
Replace bytes with byte array
Empty array declaration
Mutate array dimensions to AnyFixed
Replace array with struct
Change struct field access order
Insert nested array in enum
Expand enum with new value
Replace struct with tuple
Add dynamic field to struct
Add nested array in enum
Add incompatible struct type to array
Use struct in array
Expand enum to integrate pointer type
Alter struct field types with pointers
Modify array to dynamic
Resize array to maximum allowable size
Convert return type to complex array
Add invalid array length dimension
Convert to multi-dimensional array
Remove element from array
Clear entire array
Nested struct within AccountInfo
Modify field type in struct
Insert statement altering user-defined value type without covering in type mapping
Modify storage handling logic
Insert rational number in array element
Extend array with Rational elements
Introduce dynamic array in self-referential struct
Nest a struct inside struct
Add struct inside struct
Replace field in struct with another struct
Flatten nested struct hierarchy
Add nested structure to function signature
Add dynamic array to struct
Modify field type in struct to reference type
Convert struct field to array
Apply calldata keyword to struct parameter
Modify array size
Extend nesting depth in struct
Insert fraction for floating number
Modify array size in nested struct
Generate deeply nested structs
Replace array with dynamic array
Insert fraction for floating number
Substitute array with mapping
Insert additional decimal places
Modify array size in nested struct
Add constraint on array size
Add redundant modifier to abstract function
Introduce dynamic array in nested struct
Prepend using directive
Remove field from struct
Insert New Library Import Statement
7. Mapping and Pointer Manipulations
Modify State Variable Initialization
Omit Function Pointers from Tuple Assignment
Function Pointer Omission in Tuple Assignment
Unexpected State Persistence Mutation
Uninitialized Internal Function Pointer Mutation
Alter Constructor Function Pointer Call
Replace state variable with mapping
Remove cache entry after access
Modify state variable access
Modify cache retrieval function
Modify state variable access to misidentify execution distinction
Insert invalid hash pattern
Nullify Reference
Insert require statement
Duplicate mapping entries
Replace array with mapping
Nested dynamic types mutation
Check pointer before use
Modify storage access to use dynamic index
Insert null pointer check at function entry
Modify pointer validity during integer conversion
Modify length assignment
Change data type for shifting
Modify pointer type
Modify intermediate memory references
Add address arithmetic operation
Alter pointer dereferencing
Insert pointer arithmetic operations
Insert invalid type field in struct
Modify pointer initialization
Replace array of pointers with null pointers
Insert pointer initialization
Insert mapping data type
Insert complex data structure into mapping
Convert integer value to unchecked pointer
Add pointer safety validation
Introduce invalid length during casting
Introduce insufficient bit width casting
Insert invalid pointer arithmetic
Insert explicit address conversion function
Insert bytes-to-slice index
Convert pointer arithmetic to unsafe pointer casts
Insert bytes30 type
Modify address memory layout
Modify array element pointer
Introduce BufferPointer type
Insert BufferPointer type reference
Generate invalid pointer manipulation
Insert invalid ABI encoding pattern before external call
Replace struct field with enum
Replace struct with mapping
Remove all digits leaving only leading zeros in octal
Insert zero at start
Insert leading zero in octal
Insert leading zero
Insert zero at beginning
Duplicate leading zero
Insert zero padding
Modify parameter list
Modify mapping to nested mapping
Replace array with dynamic array
Substitute array with mapping
Substitute array with mapping
Insert key type change to invalid identifier
Modify mapping to nested mapping
Switch array to mapping
8. Contract and Function Invocation Modifications
Swap External Input Dependency
Relay To Different Library Function
Inject Zero Ether Call
Omit Payable Keyword in Constructor
Move Event Emission Outside of Internal Function
Parameterize Derived Without Constructor
Change Library Function to External
Modify state variables update sequence
Alter access level for immutable data retrieval
Introduce dependency cycle in delegate calls
Add external function to modify state
update delegate address dynamically
Swap delegate call target address
Modify transfer sequence
Extend delegate function with an authorization check
Insert explicit null checking
Insert require statement
Swap address with contract instance
Convert address to contract
Insert cast to bytes16
Replace struct with user-defined value type
Add address zero check
Add unsupported operation using user-defined value type
Insert unsupported operation using user-defined value type
Insert unsafe cast for address to contract
Replace array index with variable
Replace expression with function call
Swap address and uint conversion
Insert require statement for valid address
Replace ABI decode with manual parsing
Replace call with delegatecall
Replace address argument with fixed address
Insert address format verification after casting
Replace contract inheritance
Replace constructor logic with static value
Modify constructor to initialize user-defined value type
Alter constructor return type
Append function to modify variable
Add inheritance to library
Insert memory attribute to event parameter
Insert global using directive without specific type
Remove `payable` keyword from receive function state mutability
Add indexed keyword to event parameter
Replace placeholder with function call
Insert library access modifier
Add explicit integer conversion
Add global using for directive inside contract
Insert new library import statement
Append using directive
Prepend using directive to interface
Insert modifier call
Insert binary prefix
Add payable modifier to function
Add nested structure to function signature
Add overloaded function
Alter base contract inheritance
Prepend using directive with global
Modify contract visibility
Move global using to contract scope
Add global using directive inside interface
Replace contract keyword with struct
Insert prefix in address
9. Visibility and State Mutability Adjustments
Modify State Variable Initialization
Replace Address with Dummy Contract
Remove Fallback Function
Inject Fake Calldata Array Content
Modify Payable Function Logic
Replace immutable with constant
Replace immutable variable access with static variable
Modify parameter to an unsupported external function type
Modify function visibility
Modify return variable type
Modify visibility and mutability of function parameters
Modify access logic
Modify mapping key type
Change visibility keyword
Change visibility of state variable
Introduce Internal or Public Access to Free Function
Convert public to external
Alter public to internal
Add Visibility Specifier
Switch private to internal
Modify state variable mutability
Replace implicit visibility with public
Remove Payable Keyword
Prepend using directive with global
Remove explicit visibility indicator
Modify contract visibility
Swap interface inheritance order
Modify field type in struct
Add leading zeros to integer
Modify contract visibility
Alter state variable mutability
None
10. Delegate Calls and External Interactions
Return Type Mismatch in Delegatecall
MisinterpretMemoryAsCallResult
Incorrect Boolean Interpretation in Delegatecall
Introduce invalid delegate dependency
Inject authorization check before delegate call
Introduce reentrancy guard in delegate function
replace parameter types in delegate call
Modify delegate call error handling
Replace logic contract address
generate use unsafe call instead of safe delegate
Insert require statement
Add address memory allocation check
Insert function to misuse pointer conversion
Insert storage access with null check
Insert address type declaration
Add pointer safety validation
Swap internal with external
Replace function call with delegatecall
Remove parameters from receive function
Move variable declaration inside a function
Add Payable modifier to function
None
None
11. Error Handling and Assertions
Add Conditional Variable Reset in Loop
Replace Assembly mload with Safe Wrapper Function
Remove Assembly Result Check
Inject In-loop Reassignment
Insert require statement for hash verification
Enhance error handling
Add require statement to check for immutability
Insert error handling
Modify outcome assignment based on condition
Insert logical AND condition
Replace null check with require statement
Replace direct check with error handling
Insert require statement
Replace direct equality with error notification
Add explicit cast from uint256 to int8
Insert bytes32 to uint conversion
Insert explicit casting function for overflow handling
Insert null pointer check at function entry
Modify cast from uint256
Insert zero byte padding
Add address zero check
Insert error via incorrect index calculation
Insert error handling
Insert zero-length slice condition
Replace comparison with invalid constant
Add boundary check
Insert assert statement
Insert assertion after conversion
Add integer overflow check during conversion
Insert explicit integer validation logic
Insert error checks
Insert require statement for valid address
Add error handling for zero address
Modify error message in assertion
Insert unnecessary calculation in assertion
Insert validation checks
Add safety checks for overflow
Replace require with custom error
Modify error message
Add additional condition for struct validation to assert
Insert bounds check
Replace require with custom error
Modify error message
Add validation mechanism
Remove error type fallback
12. Event Logging and Miscellaneous Adjustments
Add Random Element Before Push
Replace Struct with Basic Data Type in Event Indexed Parameter
Emit Event with Unused Array Parameter
Replace mstore with sstore
Avoid Struct Logging in Events
Add State-Changing Operation in Receive Function
Modify Event Emission Logic
Modify Payable Function Logic
Modify hashing logic
Alter hashing method
Enhance security checks
Replace hash function with a non-existent hashing function
Introduce recursive dependency check
Modify storage charge mechanism
Generate incorrect address mapping
Insert immutable state access in constructor
Modify beneficiary address
Add address comparison
Insert event for address reset
Invalidate address during conversion
Inject array indexing in address comparison
Insert signature comparison
Insert duplicate storage write
Introduce intermediate casting variable
Skip necessary storage writes after read
Add nested dynamic reference type
Add safe null pointer allocation mechanism
Introduce false condition to dead-code removal
Redefine the array dimensions type
Introduce new custom type
Add erroneous cleanup for mappings
Modify NOT to double NOT
Add unsupported event type
Insert function to reset address
Modify address length constant
Remove event emission
Insert conflicting storage variable
Insert empty return in External Raw Function Call
Insert fallback case handling
Insert unexpected enum state
Modify constructor to accept parameters
Replace byte in array
Modify hashing logic
Insert unsupported hash function
Add inheritance to library
Insert library access modifier
Modify leading zero policy
Insert leading zero in integer
Modify parsing logic to handle large numbers
Trim initial characters
Expand supported numeral systems
Nullify integer literal
Insert modifier call
Replace number with blank
Remove all digits from literal
Insert validation checks
Insert unknown prefix to hex
Modify parsing logic to binary
Remove all digits in literal
Insert prefix '0x'
Add unnecessary leading zeros
Modify initial value using exponent notation
Reorder enum values
Add trailing zero after decimal point
Append zero at start
Change enum definition
Delete complete address
Remove placeholder from modifier
Replace enum value with a struct
Add global using directive without specific type inside contract
Remove digits from hexadecimal literal
Insert random non-hex characters in address
Add Duplicate Event Declaration
Insert leading zeros in hex
Insert underscores in binary literals
Strip underscore in literal
Change event parameter data type
Insert leading zeros in binary
Insert zero prefix in address
Pad address with zeroes
Remove underscore from integer value
Insert trailing non-octal digit
