This is page 23 of 94. Use http://codebase.md/cyfrin/aderyn?lines=false&page={x} to view the full context.
# Directory Structure
```
├── .cargo
│ └── config.toml
├── .git-blame-ignore-revs
├── .gitattributes
├── .github
│ ├── images
│ │ ├── aderyn_logo.png
│ │ ├── poweredbycyfrinblack.png
│ │ └── poweredbycyfrinblue.png
│ ├── ISSUE_TEMPLATE
│ │ ├── bug_report.md
│ │ ├── false_positive_issue.md
│ │ └── feature_request.md
│ └── workflows
│ ├── cargo.yml
│ ├── dependencies.yml
│ ├── release.yml
│ ├── reports.yml
│ └── toml.yml
├── .gitignore
├── .gitmodules
├── .vscode
│ └── settings.json
├── aderyn
│ ├── Cargo.toml
│ ├── oranda.json
│ ├── README.md
│ ├── src
│ │ ├── birdsong.rs
│ │ ├── completions.rs
│ │ ├── lib.rs
│ │ ├── lsp.rs
│ │ ├── main.rs
│ │ ├── mcp.rs
│ │ └── panic.rs
│ └── templates
│ └── aderyn.toml
├── aderyn_core
│ ├── .gitignore
│ ├── Cargo.toml
│ ├── README.md
│ ├── src
│ │ ├── ast
│ │ │ ├── ast_nodes.rs
│ │ │ ├── ast.rs
│ │ │ ├── impls
│ │ │ │ ├── ctx
│ │ │ │ │ ├── utils.rs
│ │ │ │ │ └── workspace.rs
│ │ │ │ ├── ctx.rs
│ │ │ │ ├── disp
│ │ │ │ │ ├── blocks.rs
│ │ │ │ │ ├── contracts.rs
│ │ │ │ │ ├── enumerations.rs
│ │ │ │ │ ├── errors.rs
│ │ │ │ │ ├── events.rs
│ │ │ │ │ ├── expressions.rs
│ │ │ │ │ ├── functions.rs
│ │ │ │ │ ├── identifiers.rs
│ │ │ │ │ ├── literals.rs
│ │ │ │ │ ├── modifiers.rs
│ │ │ │ │ ├── statements.rs
│ │ │ │ │ ├── structures.rs
│ │ │ │ │ ├── types.rs
│ │ │ │ │ ├── user_defined_value_types.rs
│ │ │ │ │ ├── using_for_directives.rs
│ │ │ │ │ └── variables.rs
│ │ │ │ ├── disp.rs
│ │ │ │ ├── node
│ │ │ │ │ ├── blocks.rs
│ │ │ │ │ ├── contracts.rs
│ │ │ │ │ ├── documentation.rs
│ │ │ │ │ ├── enumerations.rs
│ │ │ │ │ ├── errors.rs
│ │ │ │ │ ├── events.rs
│ │ │ │ │ ├── expressions.rs
│ │ │ │ │ ├── functions.rs
│ │ │ │ │ ├── identifiers.rs
│ │ │ │ │ ├── import_directives.rs
│ │ │ │ │ ├── literals.rs
│ │ │ │ │ ├── modifiers.rs
│ │ │ │ │ ├── pragma_directives.rs
│ │ │ │ │ ├── source_units.rs
│ │ │ │ │ ├── statements.rs
│ │ │ │ │ ├── structures.rs
│ │ │ │ │ ├── types.rs
│ │ │ │ │ ├── user_defined_value_types.rs
│ │ │ │ │ ├── using_for_directives.rs
│ │ │ │ │ └── variables.rs
│ │ │ │ ├── node.rs
│ │ │ │ ├── own
│ │ │ │ │ ├── hashing.rs
│ │ │ │ │ ├── node_id.rs
│ │ │ │ │ ├── source_units.rs
│ │ │ │ │ └── utils.rs
│ │ │ │ └── own.rs
│ │ │ ├── impls.rs
│ │ │ ├── macros.rs
│ │ │ ├── magic.rs
│ │ │ ├── node_type.rs
│ │ │ └── yul.rs
│ │ ├── ast.rs
│ │ ├── audit
│ │ │ ├── attack_surface.rs
│ │ │ ├── auditor.rs
│ │ │ ├── entrypoint.rs
│ │ │ └── public_functions_no_sender.rs
│ │ ├── audit.rs
│ │ ├── context
│ │ │ ├── browser
│ │ │ │ ├── ancestral_line.rs
│ │ │ │ ├── closest_ancestor.rs
│ │ │ │ ├── external_calls.rs
│ │ │ │ ├── extractor.rs
│ │ │ │ ├── immediate_children.rs
│ │ │ │ ├── location.rs
│ │ │ │ ├── macros.rs
│ │ │ │ ├── parent.rs
│ │ │ │ ├── peek_over.rs
│ │ │ │ ├── peek_under.rs
│ │ │ │ ├── peek.rs
│ │ │ │ ├── siblings.rs
│ │ │ │ ├── sort_nodes.rs
│ │ │ │ └── storage_vars.rs
│ │ │ ├── browser.rs
│ │ │ ├── capturable.rs
│ │ │ ├── flow
│ │ │ │ ├── display.rs
│ │ │ │ ├── error.rs
│ │ │ │ ├── kind.rs
│ │ │ │ ├── primitives.rs
│ │ │ │ ├── reducibles.rs
│ │ │ │ ├── tests.rs
│ │ │ │ ├── utils.rs
│ │ │ │ ├── visualizer.rs
│ │ │ │ └── voids.rs
│ │ │ ├── flow.rs
│ │ │ ├── graph
│ │ │ │ ├── callgraph
│ │ │ │ │ ├── legacy.rs
│ │ │ │ │ ├── new.rs
│ │ │ │ │ ├── tests.rs
│ │ │ │ │ ├── utils.rs
│ │ │ │ │ └── visit.rs
│ │ │ │ ├── callgraph.rs
│ │ │ │ ├── preprocess
│ │ │ │ │ ├── legacy.rs
│ │ │ │ │ └── new.rs
│ │ │ │ ├── preprocess.rs
│ │ │ │ ├── traits.rs
│ │ │ │ └── utils.rs
│ │ │ ├── graph.rs
│ │ │ ├── macros.rs
│ │ │ ├── mcp
│ │ │ │ ├── callgraph
│ │ │ │ │ ├── render.rs
│ │ │ │ │ ├── tool.rs
│ │ │ │ │ └── utils.rs
│ │ │ │ ├── callgraph.rs
│ │ │ │ ├── contract_surface
│ │ │ │ │ ├── render.rs
│ │ │ │ │ ├── tool.rs
│ │ │ │ │ └── util.rs
│ │ │ │ ├── contract_surface.rs
│ │ │ │ ├── list_contracts
│ │ │ │ │ ├── render.rs
│ │ │ │ │ └── tool.rs
│ │ │ │ ├── list_contracts.rs
│ │ │ │ ├── node_finder
│ │ │ │ │ ├── render.rs
│ │ │ │ │ ├── tool.rs
│ │ │ │ │ └── utils.rs
│ │ │ │ ├── node_finder.rs
│ │ │ │ ├── node_summarizer
│ │ │ │ │ ├── render.rs
│ │ │ │ │ ├── tool.rs
│ │ │ │ │ └── utils.rs
│ │ │ │ ├── node_summarizer.rs
│ │ │ │ ├── project_overview
│ │ │ │ │ ├── render.rs
│ │ │ │ │ └── tool.rs
│ │ │ │ ├── project_overview.rs
│ │ │ │ ├── tool_guide
│ │ │ │ │ └── tool.rs
│ │ │ │ └── tool_guide.rs
│ │ │ ├── mcp.rs
│ │ │ ├── router
│ │ │ │ ├── external_calls.rs
│ │ │ │ ├── internal_calls.rs
│ │ │ │ ├── modifier_calls.rs
│ │ │ │ └── tests.rs
│ │ │ ├── router.rs
│ │ │ └── workspace.rs
│ │ ├── context.rs
│ │ ├── detect
│ │ │ ├── detector.rs
│ │ │ ├── entrypoint.rs
│ │ │ ├── helpers.rs
│ │ │ ├── high
│ │ │ │ ├── _template.rs
│ │ │ │ ├── abi_encode_packed_hash_collision.rs
│ │ │ │ ├── arbitrary_transfer_from.rs
│ │ │ │ ├── const_func_changes_state.rs
│ │ │ │ ├── contract_locks_ether.rs
│ │ │ │ ├── dangerous_unary_operator.rs
│ │ │ │ ├── delegate_call_unchecked_address.rs
│ │ │ │ ├── delete_nested_mapping.rs
│ │ │ │ ├── dynamic_array_length_assignment.rs
│ │ │ │ ├── enumerable_loop_removal.rs
│ │ │ │ ├── eth_send_unchecked_address.rs
│ │ │ │ ├── experimental_encoder.rs
│ │ │ │ ├── function_selector_collision.rs
│ │ │ │ ├── incorrect_caret_operator.rs
│ │ │ │ ├── incorrect_erc20_interface.rs
│ │ │ │ ├── incorrect_erc721_interface.rs
│ │ │ │ ├── incorrect_shift_order.rs
│ │ │ │ ├── misused_boolean.rs
│ │ │ │ ├── msg_value_in_loops.rs
│ │ │ │ ├── multiple_constructors.rs
│ │ │ │ ├── nested_struct_in_mapping.rs
│ │ │ │ ├── out_of_order_retryable.rs
│ │ │ │ ├── pre_declared_variable_usage.rs
│ │ │ │ ├── reentrancy_state_change.rs
│ │ │ │ ├── reused_contract_name.rs
│ │ │ │ ├── rtlo.rs
│ │ │ │ ├── selfdestruct.rs
│ │ │ │ ├── signed_integer_storage_array.rs
│ │ │ │ ├── state_variable_shadowing.rs
│ │ │ │ ├── storage_array_memory_edit.rs
│ │ │ │ ├── strict_equality_contract_balance.rs
│ │ │ │ ├── tautological_compare.rs
│ │ │ │ ├── tautology_or_contradiction.rs
│ │ │ │ ├── tx_origin_used_for_auth.rs
│ │ │ │ ├── unchecked_low_level_call.rs
│ │ │ │ ├── unchecked_send.rs
│ │ │ │ ├── unprotected_initializer.rs
│ │ │ │ ├── unsafe_casting.rs
│ │ │ │ ├── weak_randomness.rs
│ │ │ │ └── yul_return.rs
│ │ │ ├── high.rs
│ │ │ ├── low
│ │ │ │ ├── _template.rs
│ │ │ │ ├── assert_state_change.rs
│ │ │ │ ├── block_timestamp_deadline.rs
│ │ │ │ ├── boolean_equality.rs
│ │ │ │ ├── builtin_symbol_shadowing.rs
│ │ │ │ ├── centralization_risk.rs
│ │ │ │ ├── constant_function_contains_assembly.rs
│ │ │ │ ├── costly_loop.rs
│ │ │ │ ├── dead_code.rs
│ │ │ │ ├── delegatecall_in_loop.rs
│ │ │ │ ├── deprecated_oz_function.rs
│ │ │ │ ├── division_before_multiplication.rs
│ │ │ │ ├── ecrecover.rs
│ │ │ │ ├── empty_block.rs
│ │ │ │ ├── empty_require_revert.rs
│ │ │ │ ├── function_initializing_state.rs
│ │ │ │ ├── function_pointer_in_constructor.rs
│ │ │ │ ├── inconsistent_type_names.rs
│ │ │ │ ├── incorrect_modifier.rs
│ │ │ │ ├── internal_function_used_once.rs
│ │ │ │ ├── large_numeric_literal.rs
│ │ │ │ ├── literal_instead_of_constant.rs
│ │ │ │ ├── local_variable_shadowing.rs
│ │ │ │ ├── missing_inheritance.rs
│ │ │ │ ├── modifier_used_only_once.rs
│ │ │ │ ├── multiple_placeholders.rs
│ │ │ │ ├── non_reentrant_not_first.rs
│ │ │ │ ├── push_0_opcode.rs
│ │ │ │ ├── redundant_statement.rs
│ │ │ │ ├── require_revert_in_loop.rs
│ │ │ │ ├── return_bomb.rs
│ │ │ │ ├── solmate_safe_transfer_lib.rs
│ │ │ │ ├── state_change_without_event.rs
│ │ │ │ ├── state_no_address_check.rs
│ │ │ │ ├── state_variable_could_be_constant.rs
│ │ │ │ ├── state_variable_could_be_immutable.rs
│ │ │ │ ├── state_variable_read_external.rs
│ │ │ │ ├── storage_array_length_not_cached.rs
│ │ │ │ ├── todo.rs
│ │ │ │ ├── unchecked_return.rs
│ │ │ │ ├── uninitialized_local_variable.rs
│ │ │ │ ├── unsafe_erc20_operation.rs
│ │ │ │ ├── unsafe_oz_erc721_mint.rs
│ │ │ │ ├── unspecific_solidity_pragma.rs
│ │ │ │ ├── unused_error.rs
│ │ │ │ ├── unused_import.rs
│ │ │ │ ├── unused_public_function.rs
│ │ │ │ ├── unused_state_variable.rs
│ │ │ │ └── void_constructor.rs
│ │ │ ├── low.rs
│ │ │ └── test_utils.rs
│ │ ├── detect.rs
│ │ ├── lib.rs
│ │ ├── stats
│ │ │ ├── cloc.rs
│ │ │ ├── dbg_tips.txt
│ │ │ ├── ignore.rs
│ │ │ ├── token.rs
│ │ │ └── util.rs
│ │ ├── stats.rs
│ │ ├── test_utils
│ │ │ └── load_source_unit.rs
│ │ ├── test_utils.rs
│ │ ├── visitor
│ │ │ ├── ast_visitor.rs
│ │ │ ├── macros.rs
│ │ │ └── workspace_visitor.rs
│ │ └── visitor.rs
│ ├── templates
│ │ └── mcp-tool-response
│ │ ├── callgraph.md
│ │ ├── contract_surface.md
│ │ ├── list_contracts.md
│ │ ├── node_finder_get_all.md
│ │ ├── node_finder_grep.md
│ │ ├── node_finder_search.md
│ │ ├── node_summarizer.md
│ │ ├── project_overview.md
│ │ └── tool_guide.md
│ └── tests
│ ├── common
│ │ ├── ancestral_line.rs
│ │ ├── closest_ancestor.rs
│ │ ├── immediate_children.rs
│ │ ├── immediate_parent.rs
│ │ ├── mod.rs
│ │ ├── new_ast_nodes.rs
│ │ ├── peek_over.rs
│ │ └── sibling.rs
│ └── traversal.rs
├── aderyn_driver
│ ├── .gitignore
│ ├── benches
│ │ └── detectors.rs
│ ├── Cargo.toml
│ ├── README.md
│ ├── src
│ │ ├── compile.rs
│ │ ├── config.rs
│ │ ├── display.rs
│ │ ├── driver.rs
│ │ ├── interface
│ │ │ ├── json.rs
│ │ │ ├── lsp.rs
│ │ │ ├── markdown.rs
│ │ │ ├── mod.rs
│ │ │ ├── sarif.rs
│ │ │ ├── tables.rs
│ │ │ └── util.rs
│ │ ├── lib.rs
│ │ ├── mcp.rs
│ │ ├── process.rs
│ │ └── runner.rs
│ └── tests
│ └── astgen.rs
├── bacon.toml
├── benchmarks
│ ├── aderyn
│ │ ├── base
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ ├── change
│ │ │ └── estimates.json
│ │ ├── new
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ └── report
│ │ ├── both
│ │ │ ├── iteration_times.svg
│ │ │ └── pdf.svg
│ │ ├── change
│ │ │ ├── mean.svg
│ │ │ ├── median.svg
│ │ │ └── t-test.svg
│ │ ├── index.html
│ │ ├── iteration_times_small.svg
│ │ ├── iteration_times.svg
│ │ ├── MAD.svg
│ │ ├── mean.svg
│ │ ├── median.svg
│ │ ├── pdf_small.svg
│ │ ├── pdf.svg
│ │ ├── relative_iteration_times_small.svg
│ │ ├── relative_pdf_small.svg
│ │ ├── SD.svg
│ │ └── typical.svg
│ ├── arbitrary-transfer-from
│ │ ├── base
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ ├── change
│ │ │ └── estimates.json
│ │ ├── new
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ └── report
│ │ ├── both
│ │ │ ├── pdf.svg
│ │ │ └── regression.svg
│ │ ├── change
│ │ │ ├── mean.svg
│ │ │ ├── median.svg
│ │ │ └── t-test.svg
│ │ ├── index.html
│ │ ├── MAD.svg
│ │ ├── mean.svg
│ │ ├── median.svg
│ │ ├── pdf_small.svg
│ │ ├── pdf.svg
│ │ ├── regression_small.svg
│ │ ├── regression.svg
│ │ ├── relative_pdf_small.svg
│ │ ├── relative_regression_small.svg
│ │ ├── SD.svg
│ │ ├── slope.svg
│ │ └── typical.svg
│ ├── avoid-abi-encode-packed
│ │ ├── base
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ ├── change
│ │ │ └── estimates.json
│ │ ├── new
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ └── report
│ │ ├── both
│ │ │ ├── pdf.svg
│ │ │ └── regression.svg
│ │ ├── change
│ │ │ ├── mean.svg
│ │ │ ├── median.svg
│ │ │ └── t-test.svg
│ │ ├── index.html
│ │ ├── MAD.svg
│ │ ├── mean.svg
│ │ ├── median.svg
│ │ ├── pdf_small.svg
│ │ ├── pdf.svg
│ │ ├── regression_small.svg
│ │ ├── regression.svg
│ │ ├── relative_pdf_small.svg
│ │ ├── relative_regression_small.svg
│ │ ├── SD.svg
│ │ ├── slope.svg
│ │ └── typical.svg
│ ├── block-timestamp-deadline
│ │ ├── base
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ ├── change
│ │ │ └── estimates.json
│ │ ├── new
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ └── report
│ │ ├── both
│ │ │ ├── pdf.svg
│ │ │ └── regression.svg
│ │ ├── change
│ │ │ ├── mean.svg
│ │ │ ├── median.svg
│ │ │ └── t-test.svg
│ │ ├── index.html
│ │ ├── MAD.svg
│ │ ├── mean.svg
│ │ ├── median.svg
│ │ ├── pdf_small.svg
│ │ ├── pdf.svg
│ │ ├── regression_small.svg
│ │ ├── regression.svg
│ │ ├── relative_pdf_small.svg
│ │ ├── relative_regression_small.svg
│ │ ├── SD.svg
│ │ ├── slope.svg
│ │ └── typical.svg
│ ├── centralization-risk
│ │ ├── base
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ ├── change
│ │ │ └── estimates.json
│ │ ├── new
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ └── report
│ │ ├── both
│ │ │ ├── pdf.svg
│ │ │ └── regression.svg
│ │ ├── change
│ │ │ ├── mean.svg
│ │ │ ├── median.svg
│ │ │ └── t-test.svg
│ │ ├── index.html
│ │ ├── MAD.svg
│ │ ├── mean.svg
│ │ ├── median.svg
│ │ ├── pdf_small.svg
│ │ ├── pdf.svg
│ │ ├── regression_small.svg
│ │ ├── regression.svg
│ │ ├── relative_pdf_small.svg
│ │ ├── relative_regression_small.svg
│ │ ├── SD.svg
│ │ ├── slope.svg
│ │ └── typical.svg
│ ├── constants-instead-of-literals
│ │ ├── base
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ ├── change
│ │ │ └── estimates.json
│ │ ├── new
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ └── report
│ │ ├── both
│ │ │ ├── pdf.svg
│ │ │ └── regression.svg
│ │ ├── change
│ │ │ ├── mean.svg
│ │ │ ├── median.svg
│ │ │ └── t-test.svg
│ │ ├── index.html
│ │ ├── MAD.svg
│ │ ├── mean.svg
│ │ ├── median.svg
│ │ ├── pdf_small.svg
│ │ ├── pdf.svg
│ │ ├── regression_small.svg
│ │ ├── regression.svg
│ │ ├── relative_pdf_small.svg
│ │ ├── relative_regression_small.svg
│ │ ├── SD.svg
│ │ ├── slope.svg
│ │ └── typical.svg
│ ├── delegate-call-in-loop
│ │ ├── base
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ ├── change
│ │ │ └── estimates.json
│ │ ├── new
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ └── report
│ │ ├── both
│ │ │ ├── pdf.svg
│ │ │ └── regression.svg
│ │ ├── change
│ │ │ ├── mean.svg
│ │ │ ├── median.svg
│ │ │ └── t-test.svg
│ │ ├── index.html
│ │ ├── MAD.svg
│ │ ├── mean.svg
│ │ ├── median.svg
│ │ ├── pdf_small.svg
│ │ ├── pdf.svg
│ │ ├── regression_small.svg
│ │ ├── regression.svg
│ │ ├── relative_pdf_small.svg
│ │ ├── relative_regression_small.svg
│ │ ├── SD.svg
│ │ ├── slope.svg
│ │ └── typical.svg
│ ├── deprecated-oz-functions
│ │ ├── base
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ ├── change
│ │ │ └── estimates.json
│ │ ├── new
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ └── report
│ │ ├── both
│ │ │ ├── pdf.svg
│ │ │ └── regression.svg
│ │ ├── change
│ │ │ ├── mean.svg
│ │ │ ├── median.svg
│ │ │ └── t-test.svg
│ │ ├── index.html
│ │ ├── MAD.svg
│ │ ├── mean.svg
│ │ ├── median.svg
│ │ ├── pdf_small.svg
│ │ ├── pdf.svg
│ │ ├── regression_small.svg
│ │ ├── regression.svg
│ │ ├── relative_pdf_small.svg
│ │ ├── relative_regression_small.svg
│ │ ├── SD.svg
│ │ ├── slope.svg
│ │ └── typical.svg
│ ├── ecrecover
│ │ ├── base
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ ├── change
│ │ │ └── estimates.json
│ │ ├── new
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ └── report
│ │ ├── both
│ │ │ ├── pdf.svg
│ │ │ └── regression.svg
│ │ ├── change
│ │ │ ├── mean.svg
│ │ │ ├── median.svg
│ │ │ └── t-test.svg
│ │ ├── index.html
│ │ ├── MAD.svg
│ │ ├── mean.svg
│ │ ├── median.svg
│ │ ├── pdf_small.svg
│ │ ├── pdf.svg
│ │ ├── regression_small.svg
│ │ ├── regression.svg
│ │ ├── relative_pdf_small.svg
│ │ ├── relative_regression_small.svg
│ │ ├── SD.svg
│ │ ├── slope.svg
│ │ └── typical.svg
│ ├── empty-block
│ │ ├── base
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ ├── change
│ │ │ └── estimates.json
│ │ ├── new
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ └── report
│ │ ├── both
│ │ │ ├── pdf.svg
│ │ │ └── regression.svg
│ │ ├── change
│ │ │ ├── mean.svg
│ │ │ ├── median.svg
│ │ │ └── t-test.svg
│ │ ├── index.html
│ │ ├── MAD.svg
│ │ ├── mean.svg
│ │ ├── median.svg
│ │ ├── pdf_small.svg
│ │ ├── pdf.svg
│ │ ├── regression_small.svg
│ │ ├── regression.svg
│ │ ├── relative_pdf_small.svg
│ │ ├── relative_regression_small.svg
│ │ ├── SD.svg
│ │ ├── slope.svg
│ │ └── typical.svg
│ ├── hello_world
│ │ ├── base
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ ├── new
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ └── report
│ │ ├── index.html
│ │ ├── MAD.svg
│ │ ├── mean.svg
│ │ ├── median.svg
│ │ ├── pdf_small.svg
│ │ ├── pdf.svg
│ │ ├── regression_small.svg
│ │ ├── regression.svg
│ │ ├── SD.svg
│ │ ├── slope.svg
│ │ └── typical.svg
│ ├── inconsistent-type-names
│ │ ├── base
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ ├── change
│ │ │ └── estimates.json
│ │ ├── new
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ └── report
│ │ ├── both
│ │ │ ├── pdf.svg
│ │ │ └── regression.svg
│ │ ├── change
│ │ │ ├── mean.svg
│ │ │ ├── median.svg
│ │ │ └── t-test.svg
│ │ ├── index.html
│ │ ├── MAD.svg
│ │ ├── mean.svg
│ │ ├── median.svg
│ │ ├── pdf_small.svg
│ │ ├── pdf.svg
│ │ ├── regression_small.svg
│ │ ├── regression.svg
│ │ ├── relative_pdf_small.svg
│ │ ├── relative_regression_small.svg
│ │ ├── SD.svg
│ │ ├── slope.svg
│ │ └── typical.svg
│ ├── large-numeric-literal
│ │ ├── base
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ ├── change
│ │ │ └── estimates.json
│ │ ├── new
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ └── report
│ │ ├── both
│ │ │ ├── pdf.svg
│ │ │ └── regression.svg
│ │ ├── change
│ │ │ ├── mean.svg
│ │ │ ├── median.svg
│ │ │ └── t-test.svg
│ │ ├── index.html
│ │ ├── MAD.svg
│ │ ├── mean.svg
│ │ ├── median.svg
│ │ ├── pdf_small.svg
│ │ ├── pdf.svg
│ │ ├── regression_small.svg
│ │ ├── regression.svg
│ │ ├── relative_pdf_small.svg
│ │ ├── relative_regression_small.svg
│ │ ├── SD.svg
│ │ ├── slope.svg
│ │ └── typical.svg
│ ├── non-reentrant-before-others
│ │ ├── base
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ ├── change
│ │ │ └── estimates.json
│ │ ├── new
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ └── report
│ │ ├── both
│ │ │ ├── pdf.svg
│ │ │ └── regression.svg
│ │ ├── change
│ │ │ ├── mean.svg
│ │ │ ├── median.svg
│ │ │ └── t-test.svg
│ │ ├── index.html
│ │ ├── MAD.svg
│ │ ├── mean.svg
│ │ ├── median.svg
│ │ ├── pdf_small.svg
│ │ ├── pdf.svg
│ │ ├── regression_small.svg
│ │ ├── regression.svg
│ │ ├── relative_pdf_small.svg
│ │ ├── relative_regression_small.svg
│ │ ├── SD.svg
│ │ ├── slope.svg
│ │ └── typical.svg
│ ├── push-zero-opcode
│ │ ├── base
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ ├── change
│ │ │ └── estimates.json
│ │ ├── new
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ └── report
│ │ ├── both
│ │ │ ├── pdf.svg
│ │ │ └── regression.svg
│ │ ├── change
│ │ │ ├── mean.svg
│ │ │ ├── median.svg
│ │ │ └── t-test.svg
│ │ ├── index.html
│ │ ├── MAD.svg
│ │ ├── mean.svg
│ │ ├── median.svg
│ │ ├── pdf_small.svg
│ │ ├── pdf.svg
│ │ ├── regression_small.svg
│ │ ├── regression.svg
│ │ ├── relative_pdf_small.svg
│ │ ├── relative_regression_small.svg
│ │ ├── SD.svg
│ │ ├── slope.svg
│ │ └── typical.svg
│ ├── report
│ │ └── index.html
│ ├── require-with-string
│ │ ├── base
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ ├── change
│ │ │ └── estimates.json
│ │ ├── new
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ └── report
│ │ ├── both
│ │ │ ├── pdf.svg
│ │ │ └── regression.svg
│ │ ├── change
│ │ │ ├── mean.svg
│ │ │ ├── median.svg
│ │ │ └── t-test.svg
│ │ ├── index.html
│ │ ├── MAD.svg
│ │ ├── mean.svg
│ │ ├── median.svg
│ │ ├── pdf_small.svg
│ │ ├── pdf.svg
│ │ ├── regression_small.svg
│ │ ├── regression.svg
│ │ ├── relative_pdf_small.svg
│ │ ├── relative_regression_small.svg
│ │ ├── SD.svg
│ │ ├── slope.svg
│ │ └── typical.svg
│ ├── solmate-safe-transfer-lib
│ │ ├── base
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ ├── change
│ │ │ └── estimates.json
│ │ ├── new
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ └── report
│ │ ├── both
│ │ │ ├── pdf.svg
│ │ │ └── regression.svg
│ │ ├── change
│ │ │ ├── mean.svg
│ │ │ ├── median.svg
│ │ │ └── t-test.svg
│ │ ├── index.html
│ │ ├── MAD.svg
│ │ ├── mean.svg
│ │ ├── median.svg
│ │ ├── pdf_small.svg
│ │ ├── pdf.svg
│ │ ├── regression_small.svg
│ │ ├── regression.svg
│ │ ├── relative_pdf_small.svg
│ │ ├── relative_regression_small.svg
│ │ ├── SD.svg
│ │ ├── slope.svg
│ │ └── typical.svg
│ ├── unindexed-events
│ │ ├── base
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ ├── change
│ │ │ └── estimates.json
│ │ ├── new
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ └── report
│ │ ├── both
│ │ │ ├── pdf.svg
│ │ │ └── regression.svg
│ │ ├── change
│ │ │ ├── mean.svg
│ │ │ ├── median.svg
│ │ │ └── t-test.svg
│ │ ├── index.html
│ │ ├── MAD.svg
│ │ ├── mean.svg
│ │ ├── median.svg
│ │ ├── pdf_small.svg
│ │ ├── pdf.svg
│ │ ├── regression_small.svg
│ │ ├── regression.svg
│ │ ├── relative_pdf_small.svg
│ │ ├── relative_regression_small.svg
│ │ ├── SD.svg
│ │ ├── slope.svg
│ │ └── typical.svg
│ ├── unprotected-initializer
│ │ ├── base
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ ├── change
│ │ │ └── estimates.json
│ │ ├── new
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ └── report
│ │ ├── both
│ │ │ ├── pdf.svg
│ │ │ └── regression.svg
│ │ ├── change
│ │ │ ├── mean.svg
│ │ │ ├── median.svg
│ │ │ └── t-test.svg
│ │ ├── index.html
│ │ ├── MAD.svg
│ │ ├── mean.svg
│ │ ├── median.svg
│ │ ├── pdf_small.svg
│ │ ├── pdf.svg
│ │ ├── regression_small.svg
│ │ ├── regression.svg
│ │ ├── relative_pdf_small.svg
│ │ ├── relative_regression_small.svg
│ │ ├── SD.svg
│ │ ├── slope.svg
│ │ └── typical.svg
│ ├── unsafe-erc20-functions
│ │ ├── base
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ ├── change
│ │ │ └── estimates.json
│ │ ├── new
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ └── report
│ │ ├── both
│ │ │ ├── pdf.svg
│ │ │ └── regression.svg
│ │ ├── change
│ │ │ ├── mean.svg
│ │ │ ├── median.svg
│ │ │ └── t-test.svg
│ │ ├── index.html
│ │ ├── MAD.svg
│ │ ├── mean.svg
│ │ ├── median.svg
│ │ ├── pdf_small.svg
│ │ ├── pdf.svg
│ │ ├── regression_small.svg
│ │ ├── regression.svg
│ │ ├── relative_pdf_small.svg
│ │ ├── relative_regression_small.svg
│ │ ├── SD.svg
│ │ ├── slope.svg
│ │ └── typical.svg
│ ├── unsafe-oz-erc721-mint
│ │ ├── base
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ ├── change
│ │ │ └── estimates.json
│ │ ├── new
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ └── report
│ │ ├── both
│ │ │ ├── pdf.svg
│ │ │ └── regression.svg
│ │ ├── change
│ │ │ ├── mean.svg
│ │ │ ├── median.svg
│ │ │ └── t-test.svg
│ │ ├── index.html
│ │ ├── MAD.svg
│ │ ├── mean.svg
│ │ ├── median.svg
│ │ ├── pdf_small.svg
│ │ ├── pdf.svg
│ │ ├── regression_small.svg
│ │ ├── regression.svg
│ │ ├── relative_pdf_small.svg
│ │ ├── relative_regression_small.svg
│ │ ├── SD.svg
│ │ ├── slope.svg
│ │ └── typical.svg
│ ├── unspecific-solidity-pragma
│ │ ├── base
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ ├── change
│ │ │ └── estimates.json
│ │ ├── new
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ └── report
│ │ ├── both
│ │ │ ├── pdf.svg
│ │ │ └── regression.svg
│ │ ├── change
│ │ │ ├── mean.svg
│ │ │ ├── median.svg
│ │ │ └── t-test.svg
│ │ ├── index.html
│ │ ├── MAD.svg
│ │ ├── mean.svg
│ │ ├── median.svg
│ │ ├── pdf_small.svg
│ │ ├── pdf.svg
│ │ ├── regression_small.svg
│ │ ├── regression.svg
│ │ ├── relative_pdf_small.svg
│ │ ├── relative_regression_small.svg
│ │ ├── SD.svg
│ │ ├── slope.svg
│ │ └── typical.svg
│ ├── useless-internal-function
│ │ ├── base
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ ├── change
│ │ │ └── estimates.json
│ │ ├── new
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ └── report
│ │ ├── both
│ │ │ ├── pdf.svg
│ │ │ └── regression.svg
│ │ ├── change
│ │ │ ├── mean.svg
│ │ │ ├── median.svg
│ │ │ └── t-test.svg
│ │ ├── index.html
│ │ ├── MAD.svg
│ │ ├── mean.svg
│ │ ├── median.svg
│ │ ├── pdf_small.svg
│ │ ├── pdf.svg
│ │ ├── regression_small.svg
│ │ ├── regression.svg
│ │ ├── relative_pdf_small.svg
│ │ ├── relative_regression_small.svg
│ │ ├── SD.svg
│ │ ├── slope.svg
│ │ └── typical.svg
│ ├── useless-modifier
│ │ ├── base
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ ├── change
│ │ │ └── estimates.json
│ │ ├── new
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ └── report
│ │ ├── both
│ │ │ ├── pdf.svg
│ │ │ └── regression.svg
│ │ ├── change
│ │ │ ├── mean.svg
│ │ │ ├── median.svg
│ │ │ └── t-test.svg
│ │ ├── index.html
│ │ ├── MAD.svg
│ │ ├── mean.svg
│ │ ├── median.svg
│ │ ├── pdf_small.svg
│ │ ├── pdf.svg
│ │ ├── regression_small.svg
│ │ ├── regression.svg
│ │ ├── relative_pdf_small.svg
│ │ ├── relative_regression_small.svg
│ │ ├── SD.svg
│ │ ├── slope.svg
│ │ └── typical.svg
│ ├── useless-public-function
│ │ ├── base
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ ├── change
│ │ │ └── estimates.json
│ │ ├── new
│ │ │ ├── benchmark.json
│ │ │ ├── estimates.json
│ │ │ ├── sample.json
│ │ │ └── tukey.json
│ │ └── report
│ │ ├── both
│ │ │ ├── pdf.svg
│ │ │ └── regression.svg
│ │ ├── change
│ │ │ ├── mean.svg
│ │ │ ├── median.svg
│ │ │ └── t-test.svg
│ │ ├── index.html
│ │ ├── MAD.svg
│ │ ├── mean.svg
│ │ ├── median.svg
│ │ ├── pdf_small.svg
│ │ ├── pdf.svg
│ │ ├── regression_small.svg
│ │ ├── regression.svg
│ │ ├── relative_pdf_small.svg
│ │ ├── relative_regression_small.svg
│ │ ├── SD.svg
│ │ ├── slope.svg
│ │ └── typical.svg
│ └── zero-address-check
│ ├── base
│ │ ├── benchmark.json
│ │ ├── estimates.json
│ │ ├── sample.json
│ │ └── tukey.json
│ ├── change
│ │ └── estimates.json
│ ├── new
│ │ ├── benchmark.json
│ │ ├── estimates.json
│ │ ├── sample.json
│ │ └── tukey.json
│ └── report
│ ├── both
│ │ ├── pdf.svg
│ │ └── regression.svg
│ ├── change
│ │ ├── mean.svg
│ │ ├── median.svg
│ │ └── t-test.svg
│ ├── index.html
│ ├── MAD.svg
│ ├── mean.svg
│ ├── median.svg
│ ├── pdf_small.svg
│ ├── pdf.svg
│ ├── regression_small.svg
│ ├── regression.svg
│ ├── relative_pdf_small.svg
│ ├── relative_regression_small.svg
│ ├── SD.svg
│ ├── slope.svg
│ └── typical.svg
├── Cargo.lock
├── Cargo.toml
├── cli
│ ├── benchmarks.sh
│ └── reportgen.sh
├── CODEOWNERS
├── CONTRIBUTING.md
├── cyfrinup
│ ├── dynamic_script
│ └── why.md
├── deny.toml
├── dist-workspace.toml
├── funding.json
├── LICENSE
├── Makefile
├── package-lock.json
├── package.json
├── README.md
├── RELEASE_CHECKLIST.md
├── reports
│ ├── adhoc-sol-files-highs-only-report.json
│ ├── adhoc-sol-files-report.md
│ ├── ccip-functions-report.md
│ ├── empty_report.md
│ ├── hardhat-playground-report.md
│ ├── nft-report-icm.md
│ ├── nft-report.md
│ ├── prb-math-report.md
│ ├── report.json
│ ├── report.md
│ ├── report.sarif
│ ├── sablier-aderyn-toml-nested-root.md
│ ├── templegold-report.md
│ └── uniswap_profile.md
├── rust-toolchain.toml
├── rustfmt.toml
├── tests
│ ├── adhoc-sol-files
│ │ ├── aderyn.toml
│ │ ├── Counter.sol
│ │ ├── DemoASTNodes.sol
│ │ ├── Helper.sol
│ │ ├── InconsistentUints.sol
│ │ ├── inheritance
│ │ │ ├── ExtendedInheritance.sol
│ │ │ ├── IContractInheritance.sol
│ │ │ └── InheritanceBase.sol
│ │ ├── InternalFunctions.sol
│ │ ├── lib
│ │ │ └── ThisShouldBeExcluded.sol
│ │ ├── multiple-versions
│ │ │ ├── 0.4
│ │ │ │ ├── A.sol
│ │ │ │ └── B.sol
│ │ │ ├── 0.5
│ │ │ │ ├── A.sol
│ │ │ │ └── B.sol
│ │ │ ├── 0.6
│ │ │ │ ├── A.sol
│ │ │ │ └── B.sol
│ │ │ ├── 0.7
│ │ │ │ ├── A.sol
│ │ │ │ └── B.sol
│ │ │ └── 0.8
│ │ │ ├── A.sol
│ │ │ └── B.sol
│ │ ├── OnceModifierExample.sol
│ │ └── StateVariables.sol
│ ├── ast
│ │ ├── abstract_contract.json
│ │ ├── address_payable.json
│ │ ├── array_type_name.json
│ │ ├── ast-erc4626.json
│ │ ├── base_constructor_call.json
│ │ ├── bit_not.json
│ │ ├── call.json
│ │ ├── constructor.json
│ │ ├── contract_dep_order.json
│ │ ├── do_while.json
│ │ ├── documentation_1.json
│ │ ├── documentation_2.json
│ │ ├── documentation_3.json
│ │ ├── documentation_local_variable.json
│ │ ├── documentation_on_statements.json
│ │ ├── documentation_triple.json
│ │ ├── empty_block.json
│ │ ├── enum_value_declaration.json
│ │ ├── enum_value.json
│ │ ├── event_definition.json
│ │ ├── experimental_encoder_pragma.json
│ │ ├── fallback_and_reveice_ether.json
│ │ ├── fallback_payable.json
│ │ ├── fallback.json
│ │ ├── function_type.json
│ │ ├── function.json
│ │ ├── global_enum.json
│ │ ├── global_struct.json
│ │ ├── inheritance_specifier.json
│ │ ├── leave.json
│ │ ├── license.json
│ │ ├── long_type_name_binary_operation.json
│ │ ├── long_type_name_identifier.json
│ │ ├── loop.json
│ │ ├── mappings.json
│ │ ├── modifier_definition.json
│ │ ├── modifier_invocation.json
│ │ ├── mutability.json
│ │ ├── nested_functions.json
│ │ ├── non_utf8.json
│ │ ├── override.json
│ │ ├── placeholder_statement.json
│ │ ├── receive_ether.json
│ │ ├── short_type_name_ref.json
│ │ ├── short_type_name.json
│ │ ├── slot_offset.json
│ │ ├── smoke.json
│ │ ├── source_location.json
│ │ ├── string.json
│ │ ├── stringlit.json
│ │ ├── switch_default.json
│ │ ├── switch.json
│ │ ├── try_catch.json
│ │ ├── two_base_functions.json
│ │ ├── unicode.json
│ │ ├── used_errors.json
│ │ ├── userDefinedValueType.json
│ │ ├── using_for_directive.json
│ │ ├── var_access.json
│ │ └── yul_hex_literal.json
│ ├── contract-playground
│ │ ├── .github
│ │ │ └── workflows
│ │ │ └── test.yml
│ │ ├── .gitignore
│ │ ├── dot
│ │ │ └── .gitkeep
│ │ ├── foundry.toml
│ │ ├── README.md
│ │ ├── script
│ │ │ └── Counter.s.sol
│ │ ├── src
│ │ │ ├── AbstractContract.sol
│ │ │ ├── AderynIgnoreCustomDetectors.sol
│ │ │ ├── AdminContract.sol
│ │ │ ├── ArbitraryTransferFrom.sol
│ │ │ ├── AssemblyExample.sol
│ │ │ ├── AssertStateChange.sol
│ │ │ ├── auditor_mode
│ │ │ │ ├── ExternalCalls.sol
│ │ │ │ └── PublicFunctionsWithoutSenderCheck.sol
│ │ │ ├── BooleanEquality.sol
│ │ │ ├── BuiltinSymbolShadow.sol
│ │ │ ├── CacheArrayLength.sol
│ │ │ ├── CallGraphTests.sol
│ │ │ ├── Casting.sol
│ │ │ ├── cloc
│ │ │ │ ├── AnotherHeavilyCommentedContract.sol
│ │ │ │ ├── EmptyContractFile.sol
│ │ │ │ └── HeavilyCommentedContract.sol
│ │ │ ├── CompilerBugStorageSignedIntegerArray.sol
│ │ │ ├── ConstantFuncsAssembly.sol
│ │ │ ├── ConstantsLiterals.sol
│ │ │ ├── ConstFuncChangeState.sol
│ │ │ ├── ContractLocksEther.sol
│ │ │ ├── ContractWithTodo.sol
│ │ │ ├── control_flow
│ │ │ │ └── SimpleProgram.sol
│ │ │ ├── CostlyOperationsInsideLoops.sol
│ │ │ ├── Counter.sol
│ │ │ ├── CrazyPragma.sol
│ │ │ ├── DangerousStrictEquality1.sol
│ │ │ ├── DangerousStrictEquality2.sol
│ │ │ ├── DangerousUnaryOperator.sol
│ │ │ ├── DeadCode.sol
│ │ │ ├── DelegateCallWithoutAddressCheck.sol
│ │ │ ├── DeletionNestedMappingStructureContract.sol
│ │ │ ├── DeprecatedOZFunctions.sol
│ │ │ ├── DivisionBeforeMultiplication.sol
│ │ │ ├── DynamicArrayLengthAssignment.sol
│ │ │ ├── EmitAfterExternalCall.sol
│ │ │ ├── EmptyBlocks.sol
│ │ │ ├── EnumerableSetIteration.sol
│ │ │ ├── eth2
│ │ │ │ └── DepositContract.sol
│ │ │ ├── ExperimentalEncoder.sol
│ │ │ ├── ExternalCalls.sol
│ │ │ ├── FunctionInitializingState.sol
│ │ │ ├── FunctionPointers.sol
│ │ │ ├── FunctionSignatureCollision.sol
│ │ │ ├── HugeConstants.sol
│ │ │ ├── IgnoreEverything.sol
│ │ │ ├── InconsistentUints.sol
│ │ │ ├── IncorrectCaretOperator.sol
│ │ │ ├── IncorrectERC20.sol
│ │ │ ├── IncorrectERC721.sol
│ │ │ ├── IncorrectModifier.sol
│ │ │ ├── IncorrectShift.sol
│ │ │ ├── inheritance
│ │ │ │ ├── ExtendedInheritance.sol
│ │ │ │ ├── IContractInheritance.sol
│ │ │ │ └── InheritanceBase.sol
│ │ │ ├── InternalFunctions.sol
│ │ │ ├── KeccakContract.sol
│ │ │ ├── LocalVariableShadow.sol
│ │ │ ├── MissingInheritance.sol
│ │ │ ├── MisusedBoolean.sol
│ │ │ ├── MsgValueInLoop.sol
│ │ │ ├── MultipleConstructorSchemes.sol
│ │ │ ├── MultiplePlaceholders.sol
│ │ │ ├── nested
│ │ │ │ ├── 1
│ │ │ │ │ └── Nested.sol
│ │ │ │ └── 2
│ │ │ │ └── Nested.sol
│ │ │ ├── nested_mappings
│ │ │ │ ├── LaterVersion.sol
│ │ │ │ └── NestedMappings.sol
│ │ │ ├── OnceModifierExample.sol
│ │ │ ├── OnlyLibrary.sol
│ │ │ ├── OutOfOrderRetryable.sol
│ │ │ ├── parent_chain
│ │ │ │ └── ParentChainContract.sol
│ │ │ ├── PragmaRange.sol
│ │ │ ├── PreDeclaredVarUsage.sol
│ │ │ ├── PublicFunction.sol
│ │ │ ├── PublicVariableReadInExternalContext.sol
│ │ │ ├── RedundantStatements.sol
│ │ │ ├── ReturnBomb.sol
│ │ │ ├── reused_contract_name
│ │ │ │ ├── ContractA.sol
│ │ │ │ └── ContractB.sol
│ │ │ ├── RevertsAndRequriesInLoops.sol
│ │ │ ├── router
│ │ │ │ ├── ExternalCalls.sol
│ │ │ │ ├── FallbackAndReceiveOverrides.sol
│ │ │ │ ├── InternalCalls.sol
│ │ │ │ ├── ModifierCalls.sol
│ │ │ │ └── VarOverridesFunction.sol
│ │ │ ├── RTLO.sol
│ │ │ ├── SendEtherNoChecks.sol
│ │ │ ├── SendEtherNoChecksLibImport.sol
│ │ │ ├── StateChangeAfterExternalCall.sol
│ │ │ ├── StateShadowing.sol
│ │ │ ├── StateVariableCouldBeDeclaredConstant.sol
│ │ │ ├── StateVariableCouldBeDeclaredImmutable.sol
│ │ │ ├── StateVariables.sol
│ │ │ ├── StateVariablesChangesWithoutEvents.sol
│ │ │ ├── StateVariablesManipulation.sol
│ │ │ ├── StorageConditionals.sol
│ │ │ ├── StorageParameters.sol
│ │ │ ├── T11sTranferer.sol
│ │ │ ├── TautologicalCompare.sol
│ │ │ ├── TautologyOrContradiction.sol
│ │ │ ├── TestERC20.sol
│ │ │ ├── TransientKeyword.sol
│ │ │ ├── Trump.sol
│ │ │ ├── TxOriginUsedForAuth.sol
│ │ │ ├── U2.sol
│ │ │ ├── U3.sol
│ │ │ ├── U4.sol
│ │ │ ├── U5.sol
│ │ │ ├── UncheckedCalls.sol
│ │ │ ├── UncheckedReturn.sol
│ │ │ ├── UncheckedSend.sol
│ │ │ ├── UninitializedLocalVariables.sol
│ │ │ ├── UninitializedStateVariable.sol
│ │ │ ├── uniswap
│ │ │ │ ├── UniswapV2Swapper.sol
│ │ │ │ └── UniswapV3Swapper.sol
│ │ │ ├── UnprotectedInitialize.sol
│ │ │ ├── UnsafeERC721Mint.sol
│ │ │ ├── UnusedError.sol
│ │ │ ├── UnusedImport.sol
│ │ │ ├── UnusedStateVariables.sol
│ │ │ ├── UsingSelfdestruct.sol
│ │ │ ├── VoidConstructor.sol
│ │ │ ├── WeakRandomness.sol
│ │ │ ├── WrongOrderOfLayout.sol
│ │ │ ├── YulReturn.sol
│ │ │ └── ZeroAddressCheck.sol
│ │ └── test
│ │ └── Counter.t.sol
│ ├── foundry-nft-f23
│ │ ├── .github
│ │ │ └── workflows
│ │ │ └── test.yml
│ │ ├── .gitignore
│ │ ├── foundry.lock
│ │ ├── foundry.toml
│ │ ├── README.md
│ │ ├── remappings.txt
│ │ └── src
│ │ ├── BasicNft.sol
│ │ ├── F1.sol
│ │ ├── F2.sol
│ │ ├── Initializer.sol
│ │ └── inner-core-modules
│ │ └── ICM.sol
│ ├── foundry-nft-f23-icm
│ │ ├── .github
│ │ │ └── workflows
│ │ │ └── test.yml
│ │ ├── .gitignore
│ │ ├── aderyn.toml
│ │ ├── foundry.toml
│ │ ├── README.md
│ │ ├── remappings.txt
│ │ └── src
│ │ ├── BasicNft.sol
│ │ ├── F1.sol
│ │ ├── F2.sol
│ │ ├── Initializer.sol
│ │ └── inner-core-modules
│ │ └── ICM.sol
│ ├── hardhat-js-playground
│ │ ├── .gitignore
│ │ ├── artifacts
│ │ │ ├── build-info
│ │ │ │ └── cee6fe9a9a2f03f7ff10a27ab2746af6.json
│ │ │ └── contracts
│ │ │ ├── Counter.sol
│ │ │ │ ├── Counter.dbg.json
│ │ │ │ └── Counter.json
│ │ │ ├── ExtendedInheritance.sol
│ │ │ │ ├── ExtendedInheritance.dbg.json
│ │ │ │ └── ExtendedInheritance.json
│ │ │ ├── IContractInheritance.sol
│ │ │ │ ├── IContractInheritance.dbg.json
│ │ │ │ └── IContractInheritance.json
│ │ │ ├── InheritanceBase.sol
│ │ │ │ ├── InheritanceBase.dbg.json
│ │ │ │ └── InheritanceBase.json
│ │ │ ├── KeccakContract.sol
│ │ │ │ ├── KeccakContract.dbg.json
│ │ │ │ └── KeccakContract.json
│ │ │ ├── Lock.sol
│ │ │ │ ├── Lock.dbg.json
│ │ │ │ └── Lock.json
│ │ │ └── StateVariables.sol
│ │ │ ├── StateVariables.dbg.json
│ │ │ └── StateVariables.json
│ │ ├── contracts
│ │ │ ├── Counter.sol
│ │ │ ├── ExtendedInheritance.sol
│ │ │ ├── IContractInheritance.sol
│ │ │ ├── InheritanceBase.sol
│ │ │ ├── KeccakContract.sol
│ │ │ ├── Lock.sol
│ │ │ └── StateVariables.sol
│ │ ├── hardhat.config.js
│ │ ├── package.json
│ │ ├── README.md
│ │ ├── scripts
│ │ │ └── deploy.js
│ │ ├── test
│ │ │ └── Lock.js
│ │ └── yarn.lock
│ ├── no-sol-files
│ │ ├── extra
│ │ │ └── HelloAgain.md
│ │ ├── Hello.txt
│ │ └── Hello.yul
│ └── toml
│ ├── nested_project1
│ │ ├── aderyn.toml
│ │ ├── folder1
│ │ │ └── hardhat.config.ts
│ │ ├── folder2
│ │ │ └── hardhat.config.ts
│ │ └── folder3
│ │ └── file.txt
│ └── nested_project2
│ ├── aderyn.toml
│ ├── folder1
│ │ └── foundry.toml
│ └── folder2
│ └── file1.txt
├── tools
│ └── xtask
│ ├── Cargo.toml
│ └── src
│ ├── blesspr.rs
│ ├── cut_release.rs
│ ├── flags.rs
│ ├── main.rs
│ ├── reportgen.rs
│ └── tomlgen.rs
└── typos.toml
```
# Files
--------------------------------------------------------------------------------
/benchmarks/useless-internal-function/report/index.html:
--------------------------------------------------------------------------------
```html
<!DOCTYPE html>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>useless-internal-function - Criterion.rs</title>
<style type="text/css">
body {
font: 14px Helvetica Neue;
text-rendering: optimizelegibility;
}
.body {
width: 960px;
margin: auto;
}
th {
font-weight: 200
}
th,
td {
padding-right: 3px;
padding-bottom: 3px;
}
a:link {
color: #1F78B4;
text-decoration: none;
}
th.ci-bound {
opacity: 0.6
}
td.ci-bound {
opacity: 0.5
}
.stats {
width: 80%;
margin: auto;
display: flex;
}
.additional_stats {
flex: 0 0 60%
}
.additional_plots {
flex: 1
}
h2 {
font-size: 36px;
font-weight: 300;
}
h3 {
font-size: 24px;
font-weight: 300;
}
#footer {
height: 40px;
background: #888;
color: white;
font-size: larger;
font-weight: 300;
}
#footer a {
color: white;
text-decoration: underline;
}
#footer p {
text-align: center
}
</style>
</head>
<body>
<div class="body">
<h2>useless-internal-function</h2>
<div class="absolute">
<section class="plots">
<table width="100%">
<tbody>
<tr>
<td>
<a href="pdf.svg">
<img src="pdf_small.svg" alt="PDF of Slope" width="450" height="300" />
</a>
</td>
<td>
<a href="regression.svg">
<img src="regression_small.svg" alt="Regression" width="450" height="300" />
</a>
</td>
</tr>
</tbody>
</table>
</section>
<section class="stats">
<div class="additional_stats">
<h4>Additional Statistics:</h4>
<table>
<thead>
<tr>
<th></th>
<th title="0.95 confidence level" class="ci-bound">Lower bound</th>
<th>Estimate</th>
<th title="0.95 confidence level" class="ci-bound">Upper bound</th>
</tr>
</thead>
<tbody>
<tr>
<td>Slope</td>
<td class="ci-bound">15.839 µs</td>
<td>16.070 µs</td>
<td class="ci-bound">16.357 µs</td>
</tr>
<tr>
<td>R²</td>
<td class="ci-bound">0.4261988</td>
<td>0.4320976</td>
<td class="ci-bound">0.4230508</td>
</tr>
<tr>
<td>Mean</td>
<td class="ci-bound">16.323 µs</td>
<td>16.765 µs</td>
<td class="ci-bound">17.297 µs</td>
</tr>
<tr>
<td title="Standard Deviation">Std. Dev.</td>
<td class="ci-bound">1.3830 µs</td>
<td>2.5163 µs</td>
<td class="ci-bound">3.5335 µs</td>
</tr>
<tr>
<td>Median</td>
<td class="ci-bound">15.886 µs</td>
<td>16.001 µs</td>
<td class="ci-bound">16.172 µs</td>
</tr>
<tr>
<td title="Median Absolute Deviation">MAD</td>
<td class="ci-bound">413.45 ns</td>
<td>621.21 ns</td>
<td class="ci-bound">851.57 ns</td>
</tr>
</tbody>
</table>
</div>
<div class="additional_plots">
<h4>Additional Plots:</h4>
<ul>
<li>
<a href="typical.svg">Typical</a>
</li>
<li>
<a href="mean.svg">Mean</a>
</li>
<li>
<a href="SD.svg">Std. Dev.</a>
</li>
<li>
<a href="median.svg">Median</a>
</li>
<li>
<a href="MAD.svg">MAD</a>
</li>
<li>
<a href="slope.svg">Slope</a>
</li>
</ul>
</div>
</section>
<section class="explanation">
<h4>Understanding this report:</h4>
<p>The plot on the left displays the average time per iteration for this benchmark. The shaded region
shows the estimated probability of an iteration taking a certain amount of time, while the line
shows the mean. Click on the plot for a larger view showing the outliers.</p>
<p>The plot on the right shows the linear regression calculated from the measurements. Each point
represents a sample, though here it shows the total time for the sample rather than time per
iteration. The line is the line of best fit for these measurements.</p>
<p>See <a href="https://bheisler.github.io/criterion.rs/book/user_guide/command_line_output.html#additional-statistics">the
documentation</a> for more details on the additional statistics.</p>
</section>
</div>
<section class="plots">
<h3>Change Since Previous Benchmark</h3>
<div class="relative">
<table width="100%">
<tbody>
<tr>
<td>
<a href="both/pdf.svg">
<img src="relative_pdf_small.svg" alt="PDF Comparison" width="450"
height="300" />
</a>
</td>
<td>
<a href="both/regression.svg">
<img src="relative_regression_small.svg" alt="Regression Comparison" width="450"
height="300" />
</a>
</td>
</tr>
</tbody>
</table>
</div>
</section>
<section class="stats">
<div class="additional_stats">
<h4>Additional Statistics:</h4>
<table>
<thead>
<tr>
<th></th>
<th title="0.95 confidence level" class="ci-bound">Lower bound</th>
<th>Estimate</th>
<th title="0.95 confidence level" class="ci-bound">Upper bound</th>
<th></th>
</tr>
</thead>
<tbody>
<tr>
<td>Change in time</td>
<td class="ci-bound">-3.6256%</td>
<td>+1.1376%</td>
<td class="ci-bound">+6.2274%</td>
<td>(p = 0.65 >
0.05)</td>
</tr>
</tbody>
</table>
No change in performance detected.
</div>
<div class="additional_plots">
<h4>Additional Plots:</h4>
<ul>
<li>
<a href="change/mean.svg">Change in mean</a>
</li>
<li>
<a href="change/median.svg">Change in median</a>
</li>
<li>
<a href="change/t-test.svg">T-Test</a>
</li>
</ul>
</div>
</section>
<section class="explanation">
<h4>Understanding this report:</h4>
<p>The plot on the left shows the probability of the function taking a certain amount of time. The red
curve represents the saved measurements from the last time this benchmark was run, while the blue curve
shows the measurements from this run. The lines represent the mean time per iteration. Click on the
plot for a larger view.</p>
<p>The plot on the right shows the two regressions. Again, the red line represents the previous measurement
while the blue line shows the current measurement.</p>
<p>See <a href="https://bheisler.github.io/criterion.rs/book/user_guide/command_line_output.html#change">the
documentation</a> for more details on the additional statistics.</p>
</section>
</div>
<div id="footer">
<p>This report was generated by
<a href="https://github.com/bheisler/criterion.rs">Criterion.rs</a>, a statistics-driven benchmarking
library in Rust.</p>
</div>
</body>
</html>
```
--------------------------------------------------------------------------------
/aderyn_core/src/context/flow/display.rs:
--------------------------------------------------------------------------------
```rust
use crate::context::{browser::Peek, workspace::WorkspaceContext};
use super::{CfgBreakStatement, CfgNodeDescriptor, primitives::*, voids::*};
impl CfgNodeDescriptor {
pub fn display(&self, context: &WorkspaceContext) -> String {
match self {
// Voids
CfgNodeDescriptor::Start(n) => n.peek(),
CfgNodeDescriptor::End(n) => n.peek(),
// Primitives
CfgNodeDescriptor::VariableDeclarationStatement(n) => n.peek(context),
CfgNodeDescriptor::ExpressionStatement(n) => n.peek(context),
CfgNodeDescriptor::PlaceholderStatement(n) => n.peek(),
CfgNodeDescriptor::Break(n) => n.peek(),
CfgNodeDescriptor::Continue(n) => n.peek(),
CfgNodeDescriptor::Return(n) => n.peek(context),
CfgNodeDescriptor::EmitStatement(n) => n.peek(context),
CfgNodeDescriptor::RevertStatement(n) => n.peek(context),
CfgNodeDescriptor::InlineAssembly(n) => n.peek(context),
CfgNodeDescriptor::TryStatement(n) => n.peek(context),
CfgNodeDescriptor::IfStatementCondition(n) => n.peek(context),
CfgNodeDescriptor::WhileStatementCondition(n) => n.peek(context),
CfgNodeDescriptor::ForStatementCondition(n) => n.peek(context),
CfgNodeDescriptor::DoWhileStatementCondition(n) => n.peek(context),
// Reducibles
CfgNodeDescriptor::IfStatement(_) => String::from("REDUCIBLE IF-STATEMENT"),
CfgNodeDescriptor::WhileStatement(_) => String::from("REDUCIBLE WHILE-STATEMENT"),
CfgNodeDescriptor::DoWhileStatement(_) => String::from("REDUCIBLE DO-WHILE-STATEMENT"),
CfgNodeDescriptor::ForStatement(_) => String::from("REDUCIBLE FOR-STATEMENT"),
CfgNodeDescriptor::Block(_) => String::from("REDUCIBLE BLOCK"),
CfgNodeDescriptor::UncheckedBlock(_) => String::from("REDUCIBLE UNCHECKED BLOCK"),
}
}
}
impl CfgStartNode {
pub fn peek(&self) -> String {
match self {
CfgStartNode::Start => String::from("START"),
CfgStartNode::StartBlock(ast_id) => format!("START BLOCK ({})", ast_id),
CfgStartNode::StartUncheckedBlock(ast_id) => {
format!("START UNCHECKED BLOCK ({})", ast_id)
}
CfgStartNode::StartModifierBody(ast_id) => {
format!("START MODIFIER BODY {}", ast_id)
}
CfgStartNode::StartFunctionBody(ast_id) => {
format!("START FUNCTION BODY {}", ast_id)
}
CfgStartNode::StartIf(ast_id) => format!("START IF ({})", ast_id),
CfgStartNode::StartIfCond => String::from("START IF COND"),
CfgStartNode::StartIfTrue => String::from("START IF TRUE BRANCH"),
CfgStartNode::StartIfFalse => String::from("START IF FALSE BRANCH"),
CfgStartNode::StartWhile(ast_id) => format!("START WHILE ({})", ast_id),
CfgStartNode::StartWhileCond => String::from("START WHILE COND"),
CfgStartNode::StartWhileBody => String::from("START WHILE BODY"),
CfgStartNode::StartFor(ast_id) => format!("START FOR ({})", ast_id),
CfgStartNode::StartForInitExp => String::from("START FOR INIT_EXP"),
CfgStartNode::StartForCond => String::from("START FOR COND"),
CfgStartNode::StartForLoopExp => String::from("START FOR LOOP_EXP"),
CfgStartNode::StartForBody => String::from("START FOR BODY"),
CfgStartNode::StartDoWhile(ast_id) => format!("START DO WHILE ({})", ast_id),
CfgStartNode::StartDoWhileCond => String::from("START DO WHILE COND"),
CfgStartNode::StartDoWhileBody => String::from("START DO WHILE BODY"),
}
}
}
impl CfgEndNode {
pub fn peek(&self) -> String {
match self {
CfgEndNode::End => String::from("END"),
CfgEndNode::EndBlock(ast_id) => format!("END BLOCK ({})", ast_id),
CfgEndNode::EndUncheckedBlock(ast_id) => format!("END UNCHECKED BLOCK ({})", ast_id),
CfgEndNode::EndModifierBody(ast_id) => format!("END MODIFIER BODY ({})", ast_id),
CfgEndNode::EndFunctionBody(ast_id) => format!("END FUNCTION BODY ({})", ast_id),
CfgEndNode::EndIf(ast_id) => format!("END IF ({})", ast_id),
CfgEndNode::EndIfCond => String::from("END IF COND"),
CfgEndNode::EndIfTrue => String::from("END IF TRUE BRANCH"),
CfgEndNode::EndIfFalse => String::from("END IF FALSE BRANCH"),
CfgEndNode::EndWhile(ast_id) => format!("END WHILE ({})", ast_id),
CfgEndNode::EndWhileCond => String::from("END WHILE COND"),
CfgEndNode::EndWhileBody => String::from("END WHILE BODY"),
CfgEndNode::EndFor(ast_id) => format!("END FOR ({})", ast_id),
CfgEndNode::EndForInitExp => String::from("END FOR INIT_EXP"),
CfgEndNode::EndForCond => String::from("END FOR COND"),
CfgEndNode::EndForLoopExp => String::from("END FOR LOOP_EXP"),
CfgEndNode::EndForBody => String::from("END FOR BODY"),
CfgEndNode::EndDoWhile(ast_id) => format!("END DO WHILE ({})", ast_id),
CfgEndNode::EndDoWhileCond => String::from("END DO WHILE COND"),
CfgEndNode::EndDoWhileBody => String::from("END DO WHILE BODY"),
}
}
}
impl CfgVariableDeclarationStatement {
pub fn peek(&self, context: &WorkspaceContext) -> String {
let mut content = format!("Variable Decl. Stmt ({})", self.variable_declaration_statement);
if let Some(node) = context.nodes.get(&self.variable_declaration_statement)
&& let Some(inside) = node.peek(context)
{
content.push_str(&format!(": \n{}", inside));
}
content
}
}
impl CfgExpressionStatement {
pub fn peek(&self, context: &WorkspaceContext) -> String {
let mut content = format!("Expression Stmt ({})", self.expression_statement);
if let Some(node) = context.nodes.get(&self.expression_statement)
&& let Some(inside) = node.peek(context)
{
content.push_str(&format!(": \n{}", inside));
}
content
}
}
impl CfgBreakStatement {
pub fn peek(&self) -> String {
format!("BREAK ({})", &self.break_statement)
}
}
impl CfgContinueStatement {
pub fn peek(&self) -> String {
format!("CONTINUE ({})", &self.continue_statement)
}
}
impl CfgReturnStatement {
pub fn peek(&self, context: &WorkspaceContext) -> String {
let mut content = format!("Return Stmt ({})", self.return_statement);
if let Some(node) = context.nodes.get(&self.return_statement)
&& let Some(inside) = node.peek(context)
{
content.push_str(&format!(": \n{}", inside));
}
content
}
}
impl CfgEmitStatement {
pub fn peek(&self, context: &WorkspaceContext) -> String {
let mut content = format!("Emit Stmt ({})", self.emit_statement);
if let Some(node) = context.nodes.get(&self.emit_statement)
&& let Some(inside) = node.peek(context)
{
content.push_str(&format!(": \n{}", inside));
}
content
}
}
impl CfgRevertStatement {
pub fn peek(&self, context: &WorkspaceContext) -> String {
let mut content = format!("Revert Stmt ({})", self.revert_statement);
if let Some(node) = context.nodes.get(&self.revert_statement)
&& let Some(inside) = node.peek(context)
{
content.push_str(&format!(": \n{}", inside));
}
content
}
}
impl CfgInlineAssemblyStatement {
pub fn peek(&self, context: &WorkspaceContext) -> String {
let mut content = format!("Inline Assembly Stmt ({})", self.inline_assembly_statement);
if let Some(node) = context.nodes.get(&self.inline_assembly_statement)
&& let Some(inside) = node.peek(context)
{
content.push_str(&format!(": \n{}", inside));
}
content
}
}
impl CfgPlaceholderStatement {
pub fn peek(&self) -> String {
let mut content = format!("Placeholder statement ({})", self.placeholder_statement);
content.push_str(": \n_");
content
}
}
impl CfgIfStatementCondition {
pub fn peek(&self, context: &WorkspaceContext) -> String {
let Some(if_cond) = self.if_stmt_condition else {
return String::from("If Cond");
};
let mut content = format!("If Cond ({})", if_cond);
if let Some(node) = context.nodes.get(&if_cond)
&& let Some(inside) = node.peek(context)
{
content.push_str(&format!(": \n{}", inside));
}
content
}
}
impl CfgWhileStatementCondition {
pub fn peek(&self, context: &WorkspaceContext) -> String {
let Some(while_cond) = self.while_stmt_condition else {
return String::from("While Cond");
};
let mut content = format!("While Cond ({})", while_cond);
if let Some(node) = context.nodes.get(&while_cond)
&& let Some(inside) = node.peek(context)
{
content.push_str(&format!(": \n{}", inside));
}
content
}
}
impl CfgForStatementCondition {
pub fn peek(&self, context: &WorkspaceContext) -> String {
let Some(for_stmt) = self.for_stmt_condition else {
return String::from("For Cond");
};
let mut content = format!("For Cond ({})", for_stmt);
if let Some(node) = context.nodes.get(&for_stmt)
&& let Some(inside) = node.peek(context)
{
content.push_str(&format!(": \n{}", inside));
}
content
}
}
impl CfgDoWhileStatementCondition {
pub fn peek(&self, context: &WorkspaceContext) -> String {
let Some(for_stmt) = self.do_while_stmt_condition else {
return String::from("Do While Cond");
};
let mut content = format!("Do While Cond ({})", for_stmt);
if let Some(node) = context.nodes.get(&for_stmt)
&& let Some(inside) = node.peek(context)
{
content.push_str(&format!(": \n{}", inside));
}
content
}
}
impl CfgTryStatement {
pub fn peek(&self, context: &WorkspaceContext) -> String {
let mut content = format!("Try Stmt ({})", self.try_statement);
if let Some(node) = context.nodes.get(&self.try_statement)
&& let Some(inside) = node.peek(context)
{
content.push_str(&format!(": \n{}", inside));
}
content
}
}
```
--------------------------------------------------------------------------------
/benchmarks/non-reentrant-before-others/report/relative_pdf_small.svg:
--------------------------------------------------------------------------------
```
<svg width="450" height="300" viewBox="0 0 450 300" xmlns="http://www.w3.org/2000/svg">
<text x="15" y="130" dy="0.76em" text-anchor="middle" font-family="sans-serif" font-size="9.67741935483871" opacity="1" fill="#000000" transform="rotate(270, 15, 130)">
Density (a.u.)
</text>
<text x="255" y="285" dy="-0.5ex" text-anchor="middle" font-family="sans-serif" font-size="9.67741935483871" opacity="1" fill="#000000">
Average Time (µs)
</text>
<polyline fill="none" opacity="1" stroke="#000000" stroke-width="1" points="74,15 74,244 "/>
<text x="65" y="198" dy="0.5ex" text-anchor="end" font-family="sans-serif" font-size="9.67741935483871" opacity="1" fill="#000000">
0.5
</text>
<polyline fill="none" opacity="1" stroke="#000000" stroke-width="1" points="69,198 74,198 "/>
<text x="65" y="151" dy="0.5ex" text-anchor="end" font-family="sans-serif" font-size="9.67741935483871" opacity="1" fill="#000000">
1
</text>
<polyline fill="none" opacity="1" stroke="#000000" stroke-width="1" points="69,151 74,151 "/>
<text x="65" y="105" dy="0.5ex" text-anchor="end" font-family="sans-serif" font-size="9.67741935483871" opacity="1" fill="#000000">
1.5
</text>
<polyline fill="none" opacity="1" stroke="#000000" stroke-width="1" points="69,105 74,105 "/>
<text x="65" y="58" dy="0.5ex" text-anchor="end" font-family="sans-serif" font-size="9.67741935483871" opacity="1" fill="#000000">
2
</text>
<polyline fill="none" opacity="1" stroke="#000000" stroke-width="1" points="69,58 74,58 "/>
<polyline fill="none" opacity="1" stroke="#000000" stroke-width="1" points="75,245 434,245 "/>
<text x="78" y="255" dy="0.76em" text-anchor="middle" font-family="sans-serif" font-size="9.67741935483871" opacity="1" fill="#000000">
3
</text>
<polyline fill="none" opacity="1" stroke="#000000" stroke-width="1" points="78,245 78,250 "/>
<text x="164" y="255" dy="0.76em" text-anchor="middle" font-family="sans-serif" font-size="9.67741935483871" opacity="1" fill="#000000">
4
</text>
<polyline fill="none" opacity="1" stroke="#000000" stroke-width="1" points="164,245 164,250 "/>
<text x="250" y="255" dy="0.76em" text-anchor="middle" font-family="sans-serif" font-size="9.67741935483871" opacity="1" fill="#000000">
5
</text>
<polyline fill="none" opacity="1" stroke="#000000" stroke-width="1" points="250,245 250,250 "/>
<text x="336" y="255" dy="0.76em" text-anchor="middle" font-family="sans-serif" font-size="9.67741935483871" opacity="1" fill="#000000">
6
</text>
<polyline fill="none" opacity="1" stroke="#000000" stroke-width="1" points="336,245 336,250 "/>
<text x="422" y="255" dy="0.76em" text-anchor="middle" font-family="sans-serif" font-size="9.67741935483871" opacity="1" fill="#000000">
7
</text>
<polyline fill="none" opacity="1" stroke="#000000" stroke-width="1" points="422,245 422,250 "/>
<polygon opacity="0.5" fill="#E31A1C" points="87,244 88,244 88,244 89,244 90,244 91,244 91,244 92,244 93,244 93,244 94,244 95,243 95,243 96,243 97,243 97,243 98,243 99,242 100,242 100,242 101,242 102,241 102,241 103,241 104,240 104,240 105,239 106,239 106,238 107,237 108,237 109,236 109,235 110,234 111,233 111,232 112,231 113,230 113,229 114,228 115,226 116,225 116,224 117,222 118,220 118,219 119,217 120,215 120,213 121,211 122,209 122,207 123,205 124,202 125,200 125,198 126,195 127,193 127,190 128,188 129,185 129,182 130,180 131,177 131,174 132,172 133,169 134,166 134,163 135,161 136,158 136,156 137,153 138,150 138,148 139,146 140,143 141,141 141,139 142,137 143,135 143,133 144,131 145,129 145,128 146,126 147,125 147,124 148,123 149,122 150,121 150,120 151,120 152,119 152,119 153,119 154,119 154,119 155,119 156,119 156,120 157,120 158,121 159,122 159,123 160,124 161,125 161,126 162,127 163,128 163,130 164,131 165,133 165,134 166,136 167,137 168,139 168,141 169,143 170,144 170,146 171,148 172,150 172,152 173,154 174,156 175,158 175,160 176,162 177,164 177,166 178,167 179,169 179,171 180,173 181,175 181,177 182,179 183,180 184,182 184,184 185,185 186,187 186,189 187,190 188,192 188,193 189,195 190,196 190,198 191,199 192,201 193,202 193,203 194,204 195,206 195,207 196,208 197,209 197,210 198,211 199,212 200,213 200,214 201,215 202,216 202,217 203,218 204,218 204,219 205,220 206,221 206,221 207,222 208,223 209,223 209,224 210,224 211,225 211,225 212,226 213,226 213,227 214,227 215,228 215,228 216,228 217,229 218,229 218,229 219,230 220,230 220,230 221,231 222,231 222,231 223,231 224,231 225,232 225,232 226,232 227,232 227,232 228,233 229,233 229,233 230,233 231,233 231,233 232,233 233,234 234,234 234,234 235,234 236,234 236,234 237,234 238,234 238,234 239,235 240,235 240,235 241,235 242,235 243,235 243,235 244,235 245,235 245,236 246,236 247,236 247,236 248,236 249,236 250,236 250,236 251,237 252,237 252,237 253,237 254,237 254,237 255,237 256,238 256,238 257,238 258,238 259,238 259,238 260,238 261,239 261,239 262,239 263,239 263,239 264,239 265,239 265,239 266,240 267,240 268,240 268,240 269,240 270,240 270,240 271,240 272,240 272,240 273,240 274,241 275,241 275,241 276,241 277,241 277,241 278,241 279,241 279,241 280,241 281,241 281,241 282,241 283,241 284,241 284,241 285,241 286,241 286,241 287,241 288,241 288,241 289,241 290,241 290,241 291,241 292,241 293,241 293,241 294,241 295,241 295,241 296,241 297,241 297,241 298,241 299,242 299,242 300,242 301,242 302,242 302,242 303,242 304,242 304,242 305,242 306,242 306,242 307,242 308,242 309,242 309,242 310,242 311,242 311,242 312,242 313,242 313,242 314,242 315,243 315,243 316,243 317,243 318,243 318,243 319,243 320,243 320,243 321,243 322,243 322,243 323,243 324,243 324,243 325,243 326,244 327,244 327,244 328,244 329,244 329,244 330,244 331,244 331,244 332,244 333,244 334,244 334,244 335,244 336,244 336,244 337,244 338,244 338,244 339,244 340,244 340,244 341,244 342,244 343,244 343,244 344,244 345,244 345,244 346,244 347,244 347,244 348,244 349,244 349,244 350,244 351,244 352,244 352,244 353,244 354,244 354,244 355,244 356,244 356,244 357,244 358,244 359,244 359,244 360,244 361,244 361,244 362,244 363,244 363,244 364,244 365,244 365,244 366,244 367,243 368,243 368,243 369,243 370,243 370,243 371,243 372,243 372,243 373,243 374,243 374,243 375,243 376,243 377,243 377,243 378,243 379,243 379,243 380,243 381,243 381,243 382,243 383,243 384,243 384,243 385,243 386,243 386,243 387,243 388,243 388,243 389,243 390,243 390,243 391,243 392,243 393,243 393,243 394,243 395,243 395,243 396,243 397,243 397,243 398,243 399,243 399,243 400,243 401,243 402,243 402,243 403,243 404,243 404,244 405,244 406,244 406,244 407,244 408,244 409,244 409,244 410,244 411,244 411,244 412,244 413,244 413,244 414,244 415,244 415,244 416,244 417,244 418,244 418,244 419,244 420,244 420,244 421,244 422,244 422,244 423,244 424,244 424,244 425,244 426,244 427,244 427,244 428,244 429,244 429,244 430,244 431,244 431,244 432,244 433,244 434,244 434,244 87,244 "/>
<polygon opacity="0.5" fill="#1F78B4" points="75,244 75,244 75,244 75,244 75,244 76,243 76,243 76,243 76,243 77,243 77,243 77,242 77,242 78,242 78,241 78,241 78,241 79,240 79,240 79,239 79,239 79,238 80,237 80,237 80,236 80,235 81,234 81,233 81,232 81,231 82,230 82,228 82,227 82,225 83,224 83,222 83,220 83,218 83,216 84,214 84,212 84,209 84,207 85,204 85,201 85,198 85,195 86,192 86,189 86,186 86,182 87,179 87,175 87,172 87,168 87,164 88,160 88,156 88,152 88,148 89,144 89,140 89,136 89,132 90,128 90,123 90,119 90,115 91,111 91,107 91,103 91,99 92,96 92,92 92,88 92,85 92,81 93,78 93,75 93,72 93,69 94,66 94,63 94,61 94,58 95,56 95,54 95,52 95,50 96,48 96,46 96,45 96,43 96,42 97,41 97,39 97,38 97,37 98,36 98,36 98,35 98,34 99,33 99,33 99,32 99,32 100,31 100,31 100,30 100,30 100,29 101,28 101,28 101,27 101,27 102,26 102,26 102,25 102,25 103,24 103,23 103,23 103,22 104,22 104,21 104,20 104,20 105,19 105,19 105,18 105,18 105,17 106,17 106,16 106,16 106,16 107,16 107,16 107,15 107,16 108,16 108,16 108,16 108,16 109,17 109,17 109,18 109,19 109,20 110,21 110,22 110,23 110,24 111,25 111,26 111,28 111,29 112,31 112,33 112,34 112,36 113,38 113,40 113,42 113,44 113,46 114,48 114,51 114,53 114,55 115,57 115,60 115,62 115,64 116,67 116,69 116,72 116,74 117,76 117,79 117,81 117,83 117,86 118,88 118,90 118,92 118,94 119,97 119,99 119,101 119,103 120,105 120,107 120,109 120,110 121,112 121,114 121,116 121,117 122,119 122,121 122,122 122,124 122,125 123,127 123,128 123,130 123,131 124,132 124,134 124,135 124,137 125,138 125,139 125,141 125,142 126,144 126,145 126,146 126,148 126,149 127,151 127,152 127,154 127,156 128,157 128,159 128,160 128,162 129,163 129,165 129,167 129,168 130,170 130,172 130,173 130,175 130,177 131,178 131,180 131,182 131,183 132,185 132,187 132,188 132,190 133,192 133,193 133,195 133,196 134,198 134,199 134,201 134,202 135,204 135,205 135,207 135,208 135,209 136,211 136,212 136,213 136,214 137,215 137,217 137,218 137,219 138,220 138,221 138,222 138,223 139,224 139,225 139,226 139,227 139,228 140,229 140,229 140,230 140,231 141,232 141,232 141,233 141,234 142,234 142,235 142,235 142,236 143,237 143,237 143,238 143,238 143,238 144,239 144,239 144,240 144,240 145,240 145,241 145,241 145,241 146,241 146,242 146,242 146,242 147,242 147,242 147,243 147,243 148,243 148,243 148,243 148,243 148,243 149,244 149,244 149,244 149,244 150,244 150,244 150,244 150,244 151,244 151,244 151,244 151,244 152,244 152,244 152,244 152,244 152,244 153,244 153,244 153,244 153,244 154,244 154,244 154,244 154,244 155,244 155,244 155,244 155,244 156,244 156,244 156,244 156,244 156,244 157,244 157,244 157,244 157,244 158,244 158,244 158,244 158,244 159,244 159,244 159,244 159,244 160,244 160,244 160,244 160,244 160,244 161,244 161,244 161,244 161,244 162,244 162,244 162,244 162,244 163,244 163,244 163,244 163,244 164,244 164,244 164,244 164,244 165,244 165,244 165,244 165,243 165,243 166,243 166,243 166,243 166,243 167,243 167,243 167,243 167,243 168,242 168,242 168,242 168,242 169,242 169,242 169,242 169,241 169,241 170,241 170,241 170,241 170,241 171,241 171,240 171,240 171,240 172,240 172,240 172,240 172,240 173,240 173,239 173,239 173,239 173,239 174,239 174,239 174,239 174,239 175,239 175,239 175,239 175,239 176,239 176,239 176,239 176,239 177,239 177,239 177,239 177,239 178,239 178,239 178,239 178,239 178,240 179,240 179,240 179,240 179,240 180,240 180,240 180,240 180,241 181,241 181,241 181,241 181,241 182,241 182,241 182,242 182,242 182,242 183,242 183,242 183,242 183,242 184,243 184,243 184,243 184,243 185,243 185,243 185,243 185,243 186,243 186,243 186,244 186,244 186,244 187,244 187,244 187,244 187,244 188,244 188,244 188,244 188,244 189,244 189,244 189,244 189,244 190,244 190,244 190,244 190,244 190,244 191,244 191,244 191,244 191,244 192,244 192,244 192,244 192,244 192,244 75,244 "/>
<polyline fill="none" opacity="1" stroke="#E31A1C" stroke-width="2" points="169,245 169,142 "/>
<polyline fill="none" opacity="1" stroke="#1F78B4" stroke-width="2" points="109,245 109,17 "/>
</svg>
```
--------------------------------------------------------------------------------
/aderyn_core/src/detect/helpers.rs:
--------------------------------------------------------------------------------
```rust
use semver::{Error, VersionReq};
use crate::{
ast::{
ASTNode, Expression, FunctionDefinition, Identifier, LiteralKind, MemberAccess, NodeID,
PragmaDirective, Visibility,
},
context::{
browser::{
ExtractBinaryOperations, ExtractFunctionCallOptions, ExtractFunctionCalls,
ExtractMemberAccesses,
},
workspace::WorkspaceContext,
},
};
/// Count the number of identifiers that reference a given ID in the context.
pub fn count_identifiers_that_reference_an_id(
context: &WorkspaceContext,
function_id: NodeID,
) -> i32 {
let mut count = 0;
context.identifiers().iter().for_each(|&identifier| {
if let Some(reference_id) = identifier.referenced_declaration
&& reference_id == function_id
{
count += 1;
}
});
count
}
pub fn get_calls_and_delegate_calls(context: &WorkspaceContext) -> Vec<&MemberAccess> {
context
.member_accesses()
.into_iter()
.filter(|member_access| {
member_access.member_name == "call" || member_access.member_name == "delegatecall"
})
.collect()
}
// Get all implemented external and public functions in the context.
pub fn get_implemented_external_and_public_functions(
context: &WorkspaceContext,
) -> impl Iterator<Item = &FunctionDefinition> {
context.function_definitions().into_iter().filter(|function| {
(function.visibility == Visibility::Public || function.visibility == Visibility::External)
&& function.implemented
})
}
pub fn pragma_directive_to_semver(pragma_directive: &PragmaDirective) -> Result<VersionReq, Error> {
let mut version_string = String::new();
for literal in &pragma_directive.literals {
if literal == "solidity" {
continue;
}
if version_string.is_empty() && literal.contains("0.") {
version_string.push('=');
}
if version_string.len() > 5 && (literal == "<" || literal == "=") {
version_string.push(',');
}
version_string.push_str(literal);
}
VersionReq::parse(&version_string)
}
// Check if an ast_node has a `msg.sender` binary operation.
// Examples:
// ```
// function foo() public {
// require(msg.sender == owner);
// }
// ```
pub fn has_msg_sender_binary_operation(ast_node: &ASTNode) -> bool {
// Directly return the evaluation of the condition
ExtractBinaryOperations::from(ast_node).extracted.iter().any(|binary_operation| {
ExtractMemberAccesses::from(binary_operation).extracted.iter().any(|member_access| {
member_access.member_name == "sender"
&& if let Expression::Identifier(identifier) = member_access.expression.as_ref() {
identifier.name == "msg"
} else {
false
}
})
})
}
// Check if an ast_node sends native eth
// Examples:
// ```
// function foo() public {
// address(0x1).call{value: 10}("...")
// }
// ```
pub fn has_calls_that_sends_native_eth(ast_node: &ASTNode) -> bool {
// Check for address(..).call{value: 10}("...") pattern
let function_call_ops = ExtractFunctionCallOptions::from(ast_node).extracted;
for function_call in &function_call_ops {
let call_carries_value = function_call.names.contains(&String::from("value"));
if !call_carries_value {
continue;
}
if let Expression::MemberAccess(member_access) = function_call.expression.as_ref() {
let is_call = member_access.member_name == "call";
if !is_call {
continue;
}
}
return true;
}
// Now, check for :-
// payable(address(..)).transfer(100)
// payable(address(..)).send(100)
// address.sendValue(..) (from openzeppelin)
let function_calls = ExtractFunctionCalls::from(ast_node).extracted;
for function_call in function_calls {
if let Expression::MemberAccess(member_access) = function_call.expression.as_ref()
&& (member_access.member_name == "transfer"
|| member_access.member_name == "send"
|| member_access.member_name == "sendValue")
&& let Some(type_description) = member_access.expression.type_descriptions()
&& type_description
.type_string
.as_ref()
.is_some_and(|type_string| type_string.starts_with("address"))
{
return true;
}
}
false
}
/// Detects for the pattern
/// x.delegatecall("...") where x is not a state variable
/// That means, it can be
/// a) An Identifier that references a variable declaration which is not `state_variable`
/// b) A literal address
pub fn has_delegate_calls_on_non_state_variables(
ast_node: &ASTNode,
context: &WorkspaceContext,
) -> bool {
let member_accesses = ExtractMemberAccesses::from(ast_node).extracted;
member_accesses.into_iter().any(|member| {
let is_delegate_call = member.member_name == "delegatecall";
let mut is_on_non_state_variable = false;
if let Expression::Identifier(identifier) = member.expression.as_ref() {
if let Some(referenced_id) = identifier.referenced_declaration
&& let Some(ASTNode::VariableDeclaration(v)) = context.nodes.get(&referenced_id)
&& !v.state_variable
{
is_on_non_state_variable = true;
}
} else if let Expression::Literal(_) = member.expression.as_ref() {
is_on_non_state_variable = true;
}
is_delegate_call && is_on_non_state_variable
})
}
/// Detects for the pattern
/// x.call("...") where x is not a state variable
/// That means, it can be
/// a) An Identifier that references a variable declaration which is not `state_variable`
/// b) A literal address
pub fn get_low_level_calls_on_non_state_variable_addresses(
ast_node: &ASTNode,
context: &WorkspaceContext,
) -> Vec<MemberAccess> {
ExtractMemberAccesses::from(ast_node)
.extracted
.into_iter()
.filter_map(|member| {
if member.member_name != "call" {
return None;
}
if let Expression::Identifier(identifier) = member.expression.as_ref() {
if let Some(referenced_id) = identifier.referenced_declaration
&& let Some(ASTNode::VariableDeclaration(v)) = context.nodes.get(&referenced_id)
&& !v.state_variable
{
return Some(member);
}
} else if let Expression::Literal(_) = member.expression.as_ref() {
return Some(member);
}
None
})
.collect::<_>()
}
pub fn has_binary_checks_on_some_address(ast_node: &ASTNode) -> bool {
let binary_operations = ExtractBinaryOperations::from(ast_node).extracted;
binary_operations.into_iter().any(|op| {
[op.left_expression, op.right_expression].iter().any(|op| {
op.as_ref().type_descriptions().is_some_and(|desc| {
desc.type_string.as_ref().is_some_and(|type_string| {
type_string == "address" || type_string == "address payable"
})
})
})
})
}
pub fn get_literal_value_or_constant_variable_value(
node_id: NodeID,
context: &WorkspaceContext,
) -> Option<String> {
match context.nodes.get(&node_id)? {
ASTNode::Literal(literal) => return literal.value.to_owned(),
ASTNode::VariableDeclaration(variable) => {
if variable.mutability() == Some(&crate::ast::Mutability::Constant)
&& let Some(Expression::Literal(literal)) = variable.value.as_ref()
{
return literal.value.to_owned();
}
}
_ => (),
}
None
}
pub fn get_node_offset(node: &ASTNode) -> Option<usize> {
let src_location = node.src()?;
let chopped_location = match src_location.rfind(':') {
Some(index) => &src_location[..index],
None => src_location, // No colon found, return the original string
}
.to_string();
let (offset, _) = chopped_location.split_once(':').unwrap();
offset.parse::<usize>().ok()
}
/*
Check if expression in constant
Expression::Literal whose value is false/true
Expression::Identifier that refers to a constant boolean variable declaration
Expression::UnaryOperation with ! operator followed by a sub expression that could be either of the above
*/
pub fn is_constant_boolean(context: &WorkspaceContext, ast_node: &Expression) -> bool {
if let Expression::Literal(literal) = ast_node
&& literal.kind == LiteralKind::Bool
&& literal.value.as_ref().is_some_and(|value| value == "false" || value == "true")
{
return true;
}
if let Expression::Identifier(Identifier { referenced_declaration: Some(id), .. }) = ast_node
&& let Some(ASTNode::VariableDeclaration(variable_declaration)) = context.nodes.get(id)
&& variable_declaration
.type_descriptions
.type_string
.as_ref()
.is_some_and(|value| value == "bool")
&& variable_declaration.mutability() == Some(&crate::ast::Mutability::Constant)
{
return true;
}
if let Expression::UnaryOperation(operation) = ast_node
&& operation.operator == "!"
{
return is_constant_boolean(context, operation.sub_expression.as_ref());
}
false
}
/// List of [`ASTNode`]s that are in some kind of a loop
/// Typically used as starting points to explore inward from callgraph
pub fn get_explore_centers_of_loops(context: &WorkspaceContext) -> Vec<&ASTNode> {
let mut explore_node_ids: Vec<Option<NodeID>> = vec![];
for for_loop in context.for_statements() {
if let Some(loop_expression) = for_loop.loop_expression.as_ref() {
explore_node_ids.push(loop_expression.expression.get_node_id());
}
if let Some(condition) = &for_loop.condition {
explore_node_ids.push(condition.get_node_id());
}
explore_node_ids.push(for_loop.body.get_node_id());
}
for while_loop in context.while_statements() {
explore_node_ids.push(while_loop.condition.get_node_id());
explore_node_ids.push(while_loop.body.get_node_id());
}
for do_while_loop in context.do_while_statements() {
explore_node_ids.push(do_while_loop.condition.get_node_id());
explore_node_ids.push(Some(do_while_loop.body.id));
}
let mut explore_nodes = Vec::with_capacity(explore_node_ids.len());
for id in explore_node_ids.iter().flatten() {
if let Some(ast_node) = context.nodes.get(id) {
explore_nodes.push(ast_node);
}
}
explore_nodes
}
```
--------------------------------------------------------------------------------
/aderyn_core/src/ast/impls/node/expressions.rs:
--------------------------------------------------------------------------------
```rust
use crate::{ast::*, visitor::ast_visitor::*};
use eyre::Result;
impl Node for Expression {
fn accept(&self, visitor: &mut impl ASTConstVisitor) -> Result<()> {
match self {
Expression::Literal(literal) => literal.accept(visitor),
Expression::Identifier(identifier) => identifier.accept(visitor),
Expression::UnaryOperation(unary_operation) => unary_operation.accept(visitor),
Expression::BinaryOperation(binary_operation) => binary_operation.accept(visitor),
Expression::Conditional(conditional) => conditional.accept(visitor),
Expression::Assignment(assignment) => assignment.accept(visitor),
Expression::FunctionCall(function_call) => function_call.accept(visitor),
Expression::FunctionCallOptions(function_call_options) => {
function_call_options.accept(visitor)
}
Expression::IndexAccess(index_access) => index_access.accept(visitor),
Expression::IndexRangeAccess(index_range_access) => index_range_access.accept(visitor),
Expression::MemberAccess(member_access) => member_access.accept(visitor),
Expression::ElementaryTypeNameExpression(elementary_type_name_expression) => {
elementary_type_name_expression.accept(visitor)
}
Expression::TupleExpression(tuple_expression) => tuple_expression.accept(visitor),
Expression::NewExpression(new_expression) => new_expression.accept(visitor),
}
}
fn accept_id(&self, visitor: &mut impl ASTConstVisitor) -> Result<()> {
visitor.visit_node_id(self.get_node_id())?;
Ok(())
}
}
impl Node for UnaryOperation {
fn accept(&self, visitor: &mut impl ASTConstVisitor) -> Result<()> {
if visitor.visit_unary_operation(self)? {
self.sub_expression.accept(visitor)?
}
self.accept_metadata(visitor)?;
visitor.end_visit_unary_operation(self)
}
fn accept_metadata(&self, visitor: &mut impl ASTConstVisitor) -> Result<()> {
if let Some(child_id) = self.sub_expression.get_node_id() {
visitor.visit_immediate_children(self.id, vec![child_id])?;
}
Ok(())
}
macros::accept_id!();
}
impl Node for BinaryOperation {
fn accept(&self, visitor: &mut impl ASTConstVisitor) -> Result<()> {
if visitor.visit_binary_operation(self)? {
self.left_expression.accept(visitor)?;
self.right_expression.accept(visitor)?;
}
self.accept_metadata(visitor)?;
visitor.end_visit_binary_operation(self)
}
fn accept_metadata(&self, visitor: &mut impl ASTConstVisitor) -> Result<()> {
if let Some(left_node_id) = self.left_expression.get_node_id() {
visitor.visit_immediate_children(self.id, vec![left_node_id])?;
}
if let Some(right_node) = self.right_expression.get_node_id() {
visitor.visit_immediate_children(self.id, vec![right_node])?;
}
Ok(())
}
macros::accept_id!();
}
impl Node for Conditional {
fn accept(&self, visitor: &mut impl ASTConstVisitor) -> Result<()> {
if visitor.visit_conditional(self)? {
self.condition.accept(visitor)?;
self.true_expression.accept(visitor)?;
self.false_expression.accept(visitor)?;
}
self.accept_metadata(visitor)?;
visitor.end_visit_conditional(self)
}
fn accept_metadata(&self, visitor: &mut impl ASTConstVisitor) -> Result<()> {
if let Some(condition_id) = self.condition.get_node_id() {
visitor.visit_immediate_children(self.id, vec![condition_id])?;
}
if let Some(true_expression_id) = self.true_expression.get_node_id() {
visitor.visit_immediate_children(self.id, vec![true_expression_id])?;
}
if let Some(false_expression_id) = self.false_expression.get_node_id() {
visitor.visit_immediate_children(self.id, vec![false_expression_id])?;
}
Ok(())
}
macros::accept_id!();
}
impl Node for Assignment {
fn accept(&self, visitor: &mut impl ASTConstVisitor) -> Result<()> {
if visitor.visit_assignment(self)? {
self.left_hand_side.accept(visitor)?;
self.right_hand_side.accept(visitor)?;
}
self.accept_metadata(visitor)?;
visitor.end_visit_assignment(self)
}
fn accept_metadata(&self, visitor: &mut impl ASTConstVisitor) -> Result<()> {
if let Some(left_hand_id) = self.left_hand_side.get_node_id() {
visitor.visit_immediate_children(self.id, vec![left_hand_id])?;
}
if let Some(right_hand_id) = self.right_hand_side.get_node_id() {
visitor.visit_immediate_children(self.id, vec![right_hand_id])?;
}
Ok(())
}
macros::accept_id!();
}
impl Node for FunctionCall {
fn accept(&self, visitor: &mut impl ASTConstVisitor) -> Result<()> {
if visitor.visit_function_call(self)? {
self.expression.accept(visitor)?;
list_accept(&self.arguments, visitor)?;
}
self.accept_metadata(visitor)?;
visitor.end_visit_function_call(self)
}
fn accept_metadata(&self, visitor: &mut impl ASTConstVisitor) -> Result<()> {
if let Some(expr_id) = self.expression.get_node_id() {
visitor.visit_immediate_children(self.id, vec![expr_id])?;
}
let mut argument_ids = vec![];
for arg in &self.arguments {
if let Some(arg_id) = arg.get_node_id() {
argument_ids.push(arg_id);
}
}
visitor.visit_immediate_children(self.id, argument_ids)?;
Ok(())
}
macros::accept_id!();
}
impl Node for FunctionCallOptions {
fn accept(&self, visitor: &mut impl ASTConstVisitor) -> Result<()> {
if visitor.visit_function_call_options(self)? {
self.expression.accept(visitor)?;
if self.arguments.is_some() {
list_accept(self.arguments.as_ref().unwrap(), visitor)?;
}
}
self.accept_metadata(visitor)?;
visitor.end_visit_function_call_options(self)
}
fn accept_metadata(&self, visitor: &mut impl ASTConstVisitor) -> Result<()> {
if let Some(expr_id) = self.expression.get_node_id() {
visitor.visit_immediate_children(self.id, vec![expr_id])?;
}
let mut argument_ids = vec![];
if let Some(arguments) = &self.arguments {
for arg in arguments {
if let Some(arg_id) = arg.get_node_id() {
argument_ids.push(arg_id);
}
}
visitor.visit_immediate_children(self.id, argument_ids)?;
}
Ok(())
}
macros::accept_id!();
}
impl Node for IndexAccess {
fn accept(&self, visitor: &mut impl ASTConstVisitor) -> Result<()> {
if visitor.visit_index_access(self)? {
self.base_expression.accept(visitor)?;
if let Some(index_expression) = &self.index_expression {
index_expression.accept(visitor)?;
}
}
self.accept_metadata(visitor)?;
visitor.end_visit_index_access(self)
}
fn accept_metadata(&self, visitor: &mut impl ASTConstVisitor) -> Result<()> {
if let Some(base_expr_id) = self.base_expression.get_node_id() {
visitor.visit_immediate_children(self.id, vec![base_expr_id])?;
}
if let Some(index_expression) = &self.index_expression
&& let Some(index_expr_id) = index_expression.get_node_id()
{
visitor.visit_immediate_children(self.id, vec![index_expr_id])?;
}
Ok(())
}
macros::accept_id!();
}
impl Node for IndexRangeAccess {
fn accept(&self, visitor: &mut impl ASTConstVisitor) -> Result<()> {
if visitor.visit_index_range_access(self)? {
self.base_expression.accept(visitor)?;
if self.start_expression.is_some() {
self.start_expression.as_ref().unwrap().accept(visitor)?;
}
if self.end_expression.is_some() {
self.end_expression.as_ref().unwrap().accept(visitor)?;
}
}
self.accept_metadata(visitor)?;
visitor.end_visit_index_range_access(self)
}
fn accept_metadata(&self, visitor: &mut impl ASTConstVisitor) -> Result<()> {
if let Some(start_expression) = &self.start_expression
&& let Some(start_expr_id) = start_expression.get_node_id()
{
visitor.visit_immediate_children(self.id, vec![start_expr_id])?;
}
if let Some(end_expression) = &self.end_expression
&& let Some(end_expr_id) = end_expression.get_node_id()
{
visitor.visit_immediate_children(self.id, vec![end_expr_id])?;
}
Ok(())
}
macros::accept_id!();
}
impl Node for MemberAccess {
fn accept(&self, visitor: &mut impl ASTConstVisitor) -> Result<()> {
if visitor.visit_member_access(self)? {
self.expression.accept(visitor)?;
}
self.accept_metadata(visitor)?;
visitor.end_visit_member_access(self)
}
fn accept_metadata(&self, visitor: &mut impl ASTConstVisitor) -> Result<()> {
if let Some(expr_id) = self.expression.get_node_id() {
visitor.visit_immediate_children(self.id, vec![expr_id])?;
}
Ok(())
}
macros::accept_id!();
}
impl Node for ElementaryTypeNameExpression {
fn accept(&self, visitor: &mut impl ASTConstVisitor) -> Result<()> {
visitor.visit_elementary_type_name_expression(self)?;
visitor.end_visit_elementary_type_name_expression(self)
}
macros::accept_id!();
}
impl Node for TupleExpression {
fn accept(&self, visitor: &mut impl ASTConstVisitor) -> Result<()> {
if visitor.visit_tuple_expression(self)? {
for elem in &self.components {
if elem.is_some() {
elem.as_ref().unwrap().accept(visitor)?;
}
}
}
self.accept_metadata(visitor)?;
visitor.end_visit_tuple_expression(self)
}
fn accept_metadata(&self, visitor: &mut impl ASTConstVisitor) -> Result<()> {
let mut comp_ids = vec![];
for expr in self.components.iter().flatten() {
if let Some(id) = expr.get_node_id() {
comp_ids.push(id)
}
}
visitor.visit_immediate_children(self.id, comp_ids)?;
Ok(())
}
macros::accept_id!();
}
impl Node for NewExpression {
fn accept(&self, visitor: &mut impl ASTConstVisitor) -> Result<()> {
if visitor.visit_new_expression(self)? {
self.type_name.accept(visitor)?;
}
visitor.end_visit_new_expression(self)
}
macros::accept_id!();
}
```
--------------------------------------------------------------------------------
/aderyn_core/src/ast/yul.rs:
--------------------------------------------------------------------------------
```rust
// Original source: https://github.com/camden-smallwood/solidity-rs
use crate::visitor::ast_visitor::{ASTConstVisitor, Node, list_accept};
use eyre::Result;
use serde::{Deserialize, Serialize};
use std::{
collections::HashMap,
hash::{Hash, Hasher},
};
use super::*;
#[derive(Clone, Debug, Deserialize, Eq, Serialize, PartialEq)]
#[serde(untagged)]
pub enum ExternalReference {
Untagged(ExternalReferenceData),
Tagged(HashMap<String, ExternalReferenceData>),
}
impl Hash for ExternalReference {
fn hash<H: Hasher>(&self, state: &mut H) {
match self {
ExternalReference::Untagged(data) => {
0.hash(state); // A unique value to denote the Untagged variant
data.hash(state);
}
ExternalReference::Tagged(map) => {
1.hash(state); // A unique value to denote the Tagged variant
// Create a vector of references to the map's key-value pairs
let mut pairs: Vec<_> = map.iter().collect();
// Sort the vector by keys
pairs.sort_by(|a, b| a.0.cmp(b.0));
// Hash each pair in the sorted order
for (key, value) in pairs {
key.hash(state);
value.hash(state);
}
}
}
}
}
#[derive(Clone, Debug, Deserialize, Eq, Serialize, PartialEq, Hash)]
#[serde(rename_all = "camelCase")]
pub struct ExternalReferenceData {
declaration: NodeID,
is_offset: bool,
is_slot: bool,
src: String,
value_size: NodeID,
}
#[derive(Clone, Debug, Eq, Serialize, Deserialize, PartialEq, Hash)]
#[serde(tag = "nodeType")]
pub enum YulExpression {
YulLiteral(YulLiteral),
YulIdentifier(YulIdentifier),
YulFunctionCall(YulFunctionCall),
}
impl Node for YulExpression {
fn accept(&self, visitor: &mut impl ASTConstVisitor) -> Result<()> {
match self {
YulExpression::YulLiteral(node) => node.accept(visitor),
YulExpression::YulIdentifier(node) => node.accept(visitor),
YulExpression::YulFunctionCall(node) => node.accept(visitor),
}
}
}
#[derive(Clone, Debug, Deserialize, Eq, Serialize, PartialEq, Hash)]
#[serde(rename_all = "camelCase")]
pub struct YulLiteral {
pub src: String,
pub kind: YulLiteralKind,
pub value: Option<String>,
pub hex_value: Option<String>,
}
impl Node for YulLiteral {
fn accept(&self, visitor: &mut impl ASTConstVisitor) -> Result<()> {
visitor.visit_yul_literal(self)?;
visitor.end_visit_yul_literal(self)
}
}
#[derive(Clone, Debug, Deserialize, Eq, Serialize, PartialEq, Hash)]
#[serde(rename_all = "camelCase")]
pub enum YulLiteralKind {
Bool,
Number,
String,
HexString,
Address,
}
#[derive(Clone, Debug, Deserialize, Eq, Serialize, PartialEq, Hash)]
#[serde(rename_all = "camelCase")]
pub struct YulIdentifier {
pub name: String,
pub src: String,
}
impl Node for YulIdentifier {
fn accept(&self, visitor: &mut impl ASTConstVisitor) -> Result<()> {
visitor.visit_yul_identifier(self)?;
visitor.end_visit_yul_identifier(self)
}
}
#[derive(Clone, Debug, Deserialize, Eq, Serialize, PartialEq, Hash)]
#[serde(rename_all = "camelCase")]
pub struct YulFunctionCall {
pub src: String,
pub function_name: YulIdentifier,
pub arguments: Vec<YulExpression>,
}
impl Node for YulFunctionCall {
fn accept(&self, visitor: &mut impl ASTConstVisitor) -> Result<()> {
if visitor.visit_yul_function_call(self)? {
self.function_name.accept(visitor)?;
list_accept(&self.arguments, visitor)?;
}
visitor.end_visit_yul_function_call(self)
}
}
#[derive(Clone, Debug, Deserialize, Eq, Serialize, PartialEq, Hash)]
#[serde(rename_all = "camelCase")]
pub struct YulBlock {
pub statements: Vec<YulStatement>,
}
impl Node for YulBlock {
fn accept(&self, visitor: &mut impl ASTConstVisitor) -> Result<()> {
if visitor.visit_yul_block(self)? {
list_accept(&self.statements, visitor)?;
}
visitor.end_visit_yul_block(self)
}
}
#[derive(Clone, Debug, Eq, Serialize, Deserialize, PartialEq, Hash)]
#[serde(tag = "nodeType")]
pub enum YulStatement {
YulIf(YulIf),
YulSwitch(YulSwitch),
YulForLoop(YulForLoop),
YulAssignment(YulAssignment),
YulVariableDeclaration(YulVariableDeclaration),
YulExpressionStatement(YulExpressionStatement),
YulFunctionDefinition(YulFunctionDefinition),
YulBlock(YulBlock),
YulLeave,
YulBreak,
YulContinue,
}
impl Node for YulStatement {
fn accept(&self, visitor: &mut impl ASTConstVisitor) -> Result<()> {
match self {
YulStatement::YulIf(node) => node.accept(visitor),
YulStatement::YulSwitch(node) => node.accept(visitor),
YulStatement::YulForLoop(node) => node.accept(visitor),
YulStatement::YulAssignment(node) => node.accept(visitor),
YulStatement::YulVariableDeclaration(node) => node.accept(visitor),
YulStatement::YulExpressionStatement(node) => node.accept(visitor),
YulStatement::YulFunctionDefinition(node) => node.accept(visitor),
YulStatement::YulBlock(node) => node.accept(visitor),
YulStatement::YulLeave => Ok(()),
YulStatement::YulBreak => Ok(()),
YulStatement::YulContinue => Ok(()),
}
}
}
#[derive(Clone, Debug, Deserialize, Eq, Serialize, PartialEq, Hash)]
#[serde(rename_all = "camelCase")]
pub struct YulIf {
pub condition: YulExpression,
pub body: YulBlock,
}
impl Node for YulIf {
fn accept(&self, visitor: &mut impl ASTConstVisitor) -> Result<()> {
if visitor.visit_yul_if(self)? {
self.condition.accept(visitor)?;
self.body.accept(visitor)?;
}
visitor.end_visit_yul_if(self)
}
}
#[derive(Clone, Debug, Deserialize, Eq, Serialize, PartialEq, Hash)]
#[serde(rename_all = "camelCase")]
pub struct YulSwitch {
pub cases: Vec<YulCase>,
pub expression: YulExpression,
}
impl Node for YulSwitch {
fn accept(&self, visitor: &mut impl ASTConstVisitor) -> Result<()> {
if visitor.visit_yul_switch(self)? {
self.expression.accept(visitor)?;
list_accept(&self.cases, visitor)?;
}
visitor.end_visit_yul_switch(self)
}
}
#[derive(Clone, Debug, Eq, Serialize, PartialEq, Hash)]
#[serde(rename_all = "camelCase")]
pub struct YulCase {
pub body: YulBlock,
pub value: Option<YulExpression>,
}
impl Node for YulCase {
fn accept(&self, visitor: &mut impl ASTConstVisitor) -> Result<()> {
if visitor.visit_yul_case(self)? {
self.body.accept(visitor)?;
if let Some(value) = &self.value {
value.accept(visitor)?;
}
}
visitor.end_visit_yul_case(self)
}
}
impl<'de> Deserialize<'de> for YulCase {
fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
let json = serde_json::Value::deserialize(deserializer)?;
let body = json.get("body").unwrap();
let value = json.get("value").unwrap();
Ok(YulCase {
body: serde_json::from_value(body.clone()).unwrap(),
value: if matches!(value.as_str(), Some("default")) {
None
} else {
Some(serde_json::from_value(value.clone()).unwrap())
},
})
}
}
#[derive(Clone, Debug, Deserialize, Eq, Serialize, PartialEq, Hash)]
#[serde(rename_all = "camelCase")]
pub struct YulForLoop {
pub pre: YulBlock,
pub condition: YulExpression,
pub post: YulBlock,
pub body: YulBlock,
}
impl Node for YulForLoop {
fn accept(&self, visitor: &mut impl ASTConstVisitor) -> Result<()> {
if visitor.visit_yul_for_loop(self)? {
self.pre.accept(visitor)?;
self.condition.accept(visitor)?;
self.post.accept(visitor)?;
self.body.accept(visitor)?;
}
visitor.end_visit_yul_for_loop(self)
}
}
#[derive(Clone, Debug, Deserialize, Eq, Serialize, PartialEq, Hash)]
#[serde(rename_all = "camelCase")]
pub struct YulAssignment {
pub value: YulExpression,
pub variable_names: Vec<YulIdentifier>,
}
impl Node for YulAssignment {
fn accept(&self, visitor: &mut impl ASTConstVisitor) -> Result<()> {
if visitor.visit_yul_assignment(self)? {
self.value.accept(visitor)?;
list_accept(&self.variable_names, visitor)?;
}
visitor.end_visit_yul_assignment(self)
}
}
#[derive(Clone, Debug, Deserialize, Eq, Serialize, PartialEq, Hash)]
#[serde(rename_all = "camelCase")]
pub struct YulVariableDeclaration {
pub value: Option<YulExpression>,
pub variables: Vec<YulTypedName>,
}
impl Node for YulVariableDeclaration {
fn accept(&self, visitor: &mut impl ASTConstVisitor) -> Result<()> {
if visitor.visit_yul_variable_declaration(self)? {
if let Some(value) = &self.value {
value.accept(visitor)?;
}
list_accept(&self.variables, visitor)?;
}
visitor.end_visit_yul_variable_declaration(self)
}
}
#[derive(Clone, Debug, Deserialize, Eq, Serialize, PartialEq, Hash)]
#[serde(rename_all = "camelCase")]
pub struct YulTypedName {
pub r#type: String,
pub name: String,
}
impl Node for YulTypedName {
fn accept(&self, visitor: &mut impl ASTConstVisitor) -> Result<()> {
visitor.visit_yul_typed_name(self)?;
visitor.end_visit_yul_typed_name(self)
}
}
#[derive(Clone, Debug, Deserialize, Eq, Serialize, PartialEq, Hash)]
#[serde(rename_all = "camelCase")]
pub struct YulExpressionStatement {
pub expression: YulExpression,
}
impl Node for YulExpressionStatement {
fn accept(&self, visitor: &mut impl ASTConstVisitor) -> Result<()> {
if visitor.visit_yul_expression_statement(self)? {
self.expression.accept(visitor)?;
}
visitor.end_visit_yul_expression_statement(self)
}
}
#[derive(Clone, Debug, Deserialize, Eq, Serialize, PartialEq, Hash)]
#[serde(rename_all = "camelCase")]
pub struct YulFunctionDefinition {
pub name: String,
pub parameters: Option<Vec<YulTypedName>>,
pub return_parameters: Option<Vec<YulTypedName>>,
pub body: YulBlock,
}
impl Node for YulFunctionDefinition {
fn accept(&self, visitor: &mut impl ASTConstVisitor) -> Result<()> {
if visitor.visit_yul_function_definition(self)? {
if let Some(parameters) = &self.parameters {
list_accept(parameters, visitor)?;
}
if let Some(return_parameters) = &self.return_parameters {
list_accept(return_parameters, visitor)?;
}
self.body.accept(visitor)?;
}
visitor.end_visit_yul_function_definition(self)
}
}
```
--------------------------------------------------------------------------------
/benchmarks/unsafe-oz-erc721-mint/report/relative_pdf_small.svg:
--------------------------------------------------------------------------------
```
<svg width="450" height="300" viewBox="0 0 450 300" xmlns="http://www.w3.org/2000/svg">
<text x="15" y="130" dy="0.76em" text-anchor="middle" font-family="sans-serif" font-size="9.67741935483871" opacity="1" fill="#000000" transform="rotate(270, 15, 130)">
Density (a.u.)
</text>
<text x="255" y="285" dy="-0.5ex" text-anchor="middle" font-family="sans-serif" font-size="9.67741935483871" opacity="1" fill="#000000">
Average Time (µs)
</text>
<polyline fill="none" opacity="1" stroke="#000000" stroke-width="1" points="74,15 74,244 "/>
<text x="65" y="214" dy="0.5ex" text-anchor="end" font-family="sans-serif" font-size="9.67741935483871" opacity="1" fill="#000000">
0.005
</text>
<polyline fill="none" opacity="1" stroke="#000000" stroke-width="1" points="69,214 74,214 "/>
<text x="65" y="183" dy="0.5ex" text-anchor="end" font-family="sans-serif" font-size="9.67741935483871" opacity="1" fill="#000000">
0.01
</text>
<polyline fill="none" opacity="1" stroke="#000000" stroke-width="1" points="69,183 74,183 "/>
<text x="65" y="153" dy="0.5ex" text-anchor="end" font-family="sans-serif" font-size="9.67741935483871" opacity="1" fill="#000000">
0.015
</text>
<polyline fill="none" opacity="1" stroke="#000000" stroke-width="1" points="69,153 74,153 "/>
<text x="65" y="122" dy="0.5ex" text-anchor="end" font-family="sans-serif" font-size="9.67741935483871" opacity="1" fill="#000000">
0.02
</text>
<polyline fill="none" opacity="1" stroke="#000000" stroke-width="1" points="69,122 74,122 "/>
<text x="65" y="92" dy="0.5ex" text-anchor="end" font-family="sans-serif" font-size="9.67741935483871" opacity="1" fill="#000000">
0.025
</text>
<polyline fill="none" opacity="1" stroke="#000000" stroke-width="1" points="69,92 74,92 "/>
<text x="65" y="61" dy="0.5ex" text-anchor="end" font-family="sans-serif" font-size="9.67741935483871" opacity="1" fill="#000000">
0.03
</text>
<polyline fill="none" opacity="1" stroke="#000000" stroke-width="1" points="69,61 74,61 "/>
<text x="65" y="31" dy="0.5ex" text-anchor="end" font-family="sans-serif" font-size="9.67741935483871" opacity="1" fill="#000000">
0.035
</text>
<polyline fill="none" opacity="1" stroke="#000000" stroke-width="1" points="69,31 74,31 "/>
<polyline fill="none" opacity="1" stroke="#000000" stroke-width="1" points="75,245 434,245 "/>
<text x="159" y="255" dy="0.76em" text-anchor="middle" font-family="sans-serif" font-size="9.67741935483871" opacity="1" fill="#000000">
250
</text>
<polyline fill="none" opacity="1" stroke="#000000" stroke-width="1" points="159,245 159,250 "/>
<text x="268" y="255" dy="0.76em" text-anchor="middle" font-family="sans-serif" font-size="9.67741935483871" opacity="1" fill="#000000">
300
</text>
<polyline fill="none" opacity="1" stroke="#000000" stroke-width="1" points="268,245 268,250 "/>
<text x="377" y="255" dy="0.76em" text-anchor="middle" font-family="sans-serif" font-size="9.67741935483871" opacity="1" fill="#000000">
350
</text>
<polyline fill="none" opacity="1" stroke="#000000" stroke-width="1" points="377,245 377,250 "/>
<polygon opacity="0.5" fill="#E31A1C" points="75,244 75,244 76,244 76,244 77,244 78,244 78,244 79,244 80,244 80,244 81,244 81,244 82,244 83,244 83,244 84,243 85,243 85,243 86,243 87,243 87,242 88,242 88,242 89,241 90,241 90,241 91,240 92,240 92,239 93,238 93,238 94,237 95,236 95,235 96,234 97,233 97,232 98,231 99,230 99,228 100,227 100,225 101,224 102,222 102,220 103,218 104,217 104,214 105,212 105,210 106,208 107,205 107,203 108,200 109,197 109,195 110,192 111,189 111,186 112,183 112,180 113,176 114,173 114,170 115,167 116,163 116,160 117,156 117,153 118,150 119,146 119,143 120,139 121,136 121,132 122,129 123,125 123,121 124,118 124,114 125,111 126,107 126,104 127,100 128,97 128,93 129,90 129,86 130,83 131,79 131,76 132,72 133,69 133,65 134,62 135,59 135,56 136,52 136,49 137,46 138,43 138,41 139,38 140,35 140,33 141,30 141,28 142,26 143,24 143,22 144,21 145,19 145,18 146,17 147,17 147,16 148,16 148,15 149,16 150,16 150,16 151,17 152,18 152,19 153,20 153,22 154,23 155,25 155,27 156,29 157,31 157,33 158,35 159,38 159,40 160,43 160,46 161,48 162,51 162,54 163,57 164,60 164,63 165,66 165,69 166,72 167,76 167,79 168,82 169,86 169,89 170,92 171,96 171,99 172,103 172,106 173,110 174,113 174,117 175,121 176,124 176,128 177,131 177,135 178,139 179,142 179,146 180,149 181,153 181,156 182,160 183,163 183,167 184,170 184,173 185,176 186,179 186,182 187,185 188,187 188,190 189,192 189,195 190,197 191,199 191,201 192,203 193,205 193,207 194,209 195,210 195,212 196,213 196,215 197,216 198,217 198,218 199,219 200,220 200,221 201,222 202,223 202,224 203,225 203,226 204,226 205,227 205,228 206,228 207,229 207,229 208,230 208,231 209,231 210,232 210,232 211,233 212,233 212,234 213,234 214,235 214,235 215,236 215,236 216,236 217,237 217,237 218,238 219,238 219,238 220,239 220,239 221,239 222,240 222,240 223,240 224,241 224,241 225,241 226,241 226,242 227,242 227,242 228,242 229,242 229,243 230,243 231,243 231,243 232,243 232,243 233,243 234,244 234,244 235,244 236,244 236,244 237,244 238,244 238,244 239,244 239,244 240,244 241,244 241,244 242,244 243,244 243,244 244,244 244,244 245,244 246,244 246,244 247,244 248,244 248,244 249,244 250,244 250,244 251,244 251,244 252,244 253,244 253,244 254,244 255,244 255,244 256,244 256,244 257,244 258,244 258,244 259,244 260,244 260,244 261,244 262,244 262,244 263,244 263,244 264,244 265,244 265,244 266,244 267,244 267,244 268,244 268,244 269,244 270,244 270,244 271,244 272,244 272,244 273,244 274,244 274,244 275,244 275,244 276,244 277,244 277,244 278,244 279,244 279,244 280,244 280,244 281,244 282,244 282,244 283,244 284,244 284,244 285,244 286,244 286,244 287,244 287,244 288,244 289,244 289,244 290,244 291,244 291,244 292,244 292,244 293,244 294,244 294,244 295,244 296,244 296,244 297,244 298,244 298,244 299,244 299,244 300,244 301,244 301,244 302,244 303,244 303,244 304,244 304,244 305,244 306,244 306,244 307,244 308,244 308,244 309,244 310,244 310,244 311,244 311,244 312,244 313,244 313,244 314,244 315,244 315,244 316,244 316,244 317,244 318,244 318,244 319,244 320,244 320,244 321,244 322,244 322,244 323,244 323,244 324,244 325,244 325,244 326,244 327,244 327,244 328,244 328,244 329,244 330,244 330,244 331,244 332,244 332,244 333,244 334,243 334,243 335,243 335,243 336,243 337,243 337,243 338,243 339,243 339,242 340,242 341,242 341,242 342,242 342,242 343,242 344,241 344,241 345,241 346,241 346,241 347,241 347,241 348,241 349,240 349,240 350,240 351,240 351,240 352,240 353,240 353,240 354,240 354,240 355,240 356,240 356,240 357,240 358,240 358,240 359,240 359,241 360,241 361,241 361,241 362,241 363,241 363,241 364,241 365,242 365,242 366,242 366,242 367,242 368,242 368,242 369,243 370,243 370,243 371,243 371,243 372,243 373,243 373,243 374,243 375,244 375,244 376,244 377,244 377,244 378,244 378,244 379,244 380,244 380,244 381,244 382,244 382,244 383,244 383,244 384,244 385,244 385,244 386,244 387,244 387,244 388,244 389,244 389,244 390,244 390,244 75,244 "/>
<polygon opacity="0.5" fill="#1F78B4" points="78,244 78,244 79,244 80,244 81,244 81,244 82,244 83,244 83,244 84,244 85,244 86,244 86,244 87,244 88,244 88,244 89,244 90,244 91,244 91,244 92,244 93,244 93,244 94,244 95,244 96,243 96,243 97,243 98,243 98,243 99,243 100,243 101,243 101,243 102,243 103,243 103,242 104,242 105,242 106,242 106,242 107,242 108,241 108,241 109,241 110,241 111,241 111,240 112,240 113,240 113,240 114,239 115,239 116,239 116,239 117,238 118,238 118,238 119,237 120,237 120,237 121,237 122,236 123,236 123,235 124,235 125,235 125,234 126,234 127,234 128,233 128,233 129,232 130,232 130,232 131,231 132,231 133,230 133,230 134,229 135,229 135,229 136,228 137,228 138,227 138,227 139,226 140,226 140,225 141,225 142,225 143,224 143,224 144,223 145,223 145,223 146,222 147,222 148,221 148,221 149,221 150,220 150,220 151,220 152,219 153,219 153,219 154,218 155,218 155,218 156,217 157,217 158,217 158,217 159,216 160,216 160,216 161,216 162,215 163,215 163,215 164,215 165,214 165,214 166,214 167,214 168,214 168,213 169,213 170,213 170,213 171,213 172,213 173,212 173,212 174,212 175,212 175,212 176,212 177,211 178,211 178,211 179,211 180,211 180,211 181,210 182,210 183,210 183,210 184,210 185,210 185,210 186,209 187,209 188,209 188,209 189,209 190,209 190,209 191,208 192,208 193,208 193,208 194,208 195,208 195,208 196,208 197,207 197,207 198,207 199,207 200,207 200,207 201,207 202,207 202,207 203,207 204,206 205,206 205,206 206,206 207,206 207,206 208,206 209,206 210,206 210,206 211,206 212,206 212,206 213,205 214,205 215,205 215,205 216,205 217,205 217,205 218,205 219,205 220,205 220,205 221,204 222,204 222,204 223,204 224,204 225,204 225,204 226,203 227,203 227,203 228,203 229,203 230,202 230,202 231,202 232,202 232,201 233,201 234,201 235,201 235,200 236,200 237,199 237,199 238,199 239,198 240,198 240,197 241,197 242,197 242,196 243,196 244,195 245,194 245,194 246,193 247,193 247,192 248,192 249,191 250,190 250,190 251,189 252,188 252,187 253,187 254,186 255,185 255,184 256,183 257,183 257,182 258,181 259,180 260,179 260,178 261,177 262,176 262,175 263,174 264,173 265,172 265,171 266,170 267,169 267,168 268,167 269,166 270,164 270,163 271,162 272,161 272,160 273,159 274,157 275,156 275,155 276,154 277,153 277,151 278,150 279,149 279,148 280,147 281,145 282,144 282,143 283,142 284,141 284,140 285,139 286,138 287,137 287,136 288,135 289,134 289,133 290,132 291,131 292,130 292,130 293,129 294,128 294,128 295,127 296,127 297,126 297,126 298,126 299,125 299,125 300,125 301,125 302,125 302,125 303,125 304,125 304,126 305,126 306,127 307,127 307,128 308,128 309,129 309,130 310,131 311,132 312,133 312,134 313,135 314,136 314,137 315,139 316,140 317,141 317,143 318,144 319,146 319,147 320,149 321,151 322,152 322,154 323,156 324,158 324,159 325,161 326,163 327,165 327,167 328,169 329,170 329,172 330,174 331,176 332,178 332,179 333,181 334,183 334,185 335,187 336,188 337,190 337,192 338,193 339,195 339,196 340,198 341,199 342,201 342,202 343,204 344,205 344,206 345,208 346,209 347,210 347,211 348,212 349,214 349,215 350,216 351,217 352,218 352,219 353,219 354,220 354,221 355,222 356,223 356,223 357,224 358,225 359,226 359,226 360,227 361,227 361,228 362,228 363,229 364,230 364,230 365,231 366,231 366,231 367,232 368,232 369,233 369,233 370,233 371,234 371,234 372,234 373,235 374,235 374,235 375,236 376,236 376,236 377,237 378,237 379,237 379,237 380,238 381,238 381,238 382,238 383,239 384,239 384,239 385,239 386,239 386,240 387,240 388,240 389,240 389,240 390,241 391,241 391,241 392,241 393,241 394,241 394,242 395,242 396,242 396,242 397,242 398,242 399,242 399,242 400,243 401,243 401,243 402,243 403,243 404,243 404,243 405,243 406,243 406,243 407,243 408,243 409,244 409,244 410,244 411,244 411,244 412,244 413,244 414,244 414,244 415,244 416,244 416,244 417,244 418,244 419,244 419,244 420,244 421,244 421,244 422,244 423,244 424,244 424,244 425,244 426,244 426,244 427,244 428,244 429,244 429,244 430,244 431,244 431,244 432,244 433,244 434,244 434,244 78,244 "/>
<polyline fill="none" opacity="1" stroke="#E31A1C" stroke-width="2" points="152,244 152,19 "/>
<polyline fill="none" opacity="1" stroke="#1F78B4" stroke-width="2" points="268,244 268,167 "/>
</svg>
```
--------------------------------------------------------------------------------
/benchmarks/useless-modifier/report/relative_pdf_small.svg:
--------------------------------------------------------------------------------
```
<svg width="450" height="300" viewBox="0 0 450 300" xmlns="http://www.w3.org/2000/svg">
<text x="15" y="130" dy="0.76em" text-anchor="middle" font-family="sans-serif" font-size="9.67741935483871" opacity="1" fill="#000000" transform="rotate(270, 15, 130)">
Density (a.u.)
</text>
<text x="255" y="285" dy="-0.5ex" text-anchor="middle" font-family="sans-serif" font-size="9.67741935483871" opacity="1" fill="#000000">
Average Time (µs)
</text>
<polyline fill="none" opacity="1" stroke="#000000" stroke-width="1" points="74,15 74,244 "/>
<text x="65" y="212" dy="0.5ex" text-anchor="end" font-family="sans-serif" font-size="9.67741935483871" opacity="1" fill="#000000">
0.05
</text>
<polyline fill="none" opacity="1" stroke="#000000" stroke-width="1" points="69,212 74,212 "/>
<text x="65" y="180" dy="0.5ex" text-anchor="end" font-family="sans-serif" font-size="9.67741935483871" opacity="1" fill="#000000">
0.1
</text>
<polyline fill="none" opacity="1" stroke="#000000" stroke-width="1" points="69,180 74,180 "/>
<text x="65" y="148" dy="0.5ex" text-anchor="end" font-family="sans-serif" font-size="9.67741935483871" opacity="1" fill="#000000">
0.15
</text>
<polyline fill="none" opacity="1" stroke="#000000" stroke-width="1" points="69,148 74,148 "/>
<text x="65" y="116" dy="0.5ex" text-anchor="end" font-family="sans-serif" font-size="9.67741935483871" opacity="1" fill="#000000">
0.2
</text>
<polyline fill="none" opacity="1" stroke="#000000" stroke-width="1" points="69,116 74,116 "/>
<text x="65" y="83" dy="0.5ex" text-anchor="end" font-family="sans-serif" font-size="9.67741935483871" opacity="1" fill="#000000">
0.25
</text>
<polyline fill="none" opacity="1" stroke="#000000" stroke-width="1" points="69,83 74,83 "/>
<text x="65" y="51" dy="0.5ex" text-anchor="end" font-family="sans-serif" font-size="9.67741935483871" opacity="1" fill="#000000">
0.3
</text>
<polyline fill="none" opacity="1" stroke="#000000" stroke-width="1" points="69,51 74,51 "/>
<text x="65" y="19" dy="0.5ex" text-anchor="end" font-family="sans-serif" font-size="9.67741935483871" opacity="1" fill="#000000">
0.35
</text>
<polyline fill="none" opacity="1" stroke="#000000" stroke-width="1" points="69,19 74,19 "/>
<polyline fill="none" opacity="1" stroke="#000000" stroke-width="1" points="75,245 434,245 "/>
<text x="92" y="255" dy="0.76em" text-anchor="middle" font-family="sans-serif" font-size="9.67741935483871" opacity="1" fill="#000000">
20
</text>
<polyline fill="none" opacity="1" stroke="#000000" stroke-width="1" points="92,245 92,250 "/>
<text x="219" y="255" dy="0.76em" text-anchor="middle" font-family="sans-serif" font-size="9.67741935483871" opacity="1" fill="#000000">
40
</text>
<polyline fill="none" opacity="1" stroke="#000000" stroke-width="1" points="219,245 219,250 "/>
<text x="346" y="255" dy="0.76em" text-anchor="middle" font-family="sans-serif" font-size="9.67741935483871" opacity="1" fill="#000000">
60
</text>
<polyline fill="none" opacity="1" stroke="#000000" stroke-width="1" points="346,245 346,250 "/>
<polygon opacity="0.5" fill="#E31A1C" points="75,244 75,244 76,244 77,244 77,244 78,244 79,244 80,244 80,244 81,244 82,244 82,244 83,244 84,244 85,244 85,244 86,243 87,243 87,243 88,243 89,243 90,243 90,243 91,242 92,242 92,242 93,242 94,242 95,241 95,241 96,241 97,240 98,240 98,240 99,239 100,239 100,239 101,238 102,238 103,237 103,237 104,236 105,235 105,235 106,234 107,234 108,233 108,232 109,231 110,231 110,230 111,229 112,228 113,227 113,226 114,225 115,224 116,223 116,222 117,221 118,220 118,219 119,218 120,217 121,215 121,214 122,213 123,212 123,211 124,209 125,208 126,207 126,206 127,205 128,203 128,202 129,201 130,200 131,199 131,198 132,196 133,195 133,194 134,193 135,192 136,192 136,191 137,190 138,189 139,188 139,188 140,187 141,186 141,186 142,185 143,185 144,185 144,184 145,184 146,184 146,184 147,184 148,184 149,184 149,184 150,184 151,185 151,185 152,185 153,186 154,186 154,187 155,187 156,188 157,189 157,189 158,190 159,191 159,192 160,193 161,194 162,195 162,195 163,196 164,197 164,198 165,199 166,200 167,201 167,202 168,203 169,205 169,206 170,207 171,208 172,209 172,210 173,211 174,212 175,213 175,214 176,215 177,215 177,216 178,217 179,218 180,219 180,220 181,221 182,221 182,222 183,223 184,224 185,224 185,225 186,226 187,226 187,227 188,228 189,228 190,229 190,229 191,230 192,230 192,231 193,231 194,232 195,232 195,233 196,233 197,233 198,234 198,234 199,234 200,235 200,235 201,235 202,235 203,236 203,236 204,236 205,236 205,237 206,237 207,237 208,237 208,237 209,237 210,238 210,238 211,238 212,238 213,238 213,238 214,238 215,239 216,239 216,239 217,239 218,239 218,239 219,239 220,239 221,239 221,239 222,239 223,239 223,240 224,240 225,240 226,240 226,240 227,240 228,240 228,240 229,240 230,240 231,240 231,240 232,240 233,240 233,240 234,240 235,241 236,241 236,241 237,241 238,241 239,241 239,241 240,241 241,241 241,241 242,241 243,241 244,241 244,241 245,241 246,241 246,241 247,241 248,241 249,242 249,242 250,242 251,242 251,242 252,242 253,242 254,242 254,242 255,242 256,242 257,242 257,242 258,242 259,242 259,242 260,242 261,242 262,242 262,242 263,242 264,242 264,242 265,242 266,242 267,242 267,242 268,242 269,242 269,242 270,242 271,242 272,242 272,242 273,242 274,242 275,242 275,242 276,242 277,242 277,242 278,242 279,242 280,242 280,242 281,242 282,242 282,242 283,242 284,242 285,242 285,242 286,242 287,242 287,242 288,242 289,242 290,242 290,241 291,241 292,241 292,241 293,241 294,241 295,241 295,241 296,241 297,241 298,241 298,241 299,241 300,241 300,241 301,241 302,241 303,241 303,241 304,241 305,241 305,241 306,241 307,241 308,241 308,241 309,241 310,241 310,241 311,241 312,241 313,241 313,241 314,241 315,241 316,241 316,241 317,241 318,241 318,241 319,241 320,241 321,241 321,241 322,241 323,241 323,241 324,241 325,241 326,241 326,241 327,241 328,241 328,241 329,241 330,241 331,242 331,242 332,242 333,242 333,242 334,242 335,242 336,242 336,242 337,242 338,242 339,242 339,242 340,242 341,242 341,242 342,242 343,242 344,242 344,242 345,242 346,242 346,242 347,242 348,243 349,243 349,243 350,243 351,243 351,243 352,243 353,243 354,243 354,243 355,243 356,243 357,243 357,243 358,243 359,243 359,243 360,243 361,243 362,243 362,243 363,243 364,243 364,243 365,243 366,243 367,243 367,243 368,243 369,243 369,243 370,243 371,243 372,243 372,243 373,243 374,243 375,244 375,244 376,244 377,244 377,244 378,244 379,244 380,244 380,244 381,244 382,244 382,244 383,244 384,244 385,244 385,244 386,244 387,244 387,244 388,244 389,244 390,244 390,244 391,244 392,244 392,244 393,244 394,244 395,244 395,244 396,244 397,244 398,244 398,244 399,244 400,244 400,244 401,244 402,244 403,244 403,244 404,244 405,244 405,244 406,244 407,244 408,244 408,244 409,244 410,244 410,244 411,244 412,244 413,244 413,244 414,244 415,244 416,244 416,244 417,244 418,244 418,244 419,244 420,244 421,244 421,244 422,244 423,244 423,244 424,244 425,244 426,244 426,244 427,244 428,244 428,244 429,244 430,244 431,244 431,244 432,244 433,244 434,244 434,244 75,244 "/>
<polygon opacity="0.5" fill="#1F78B4" points="104,244 104,244 104,244 104,244 104,244 105,244 105,244 105,244 105,244 105,244 105,243 106,243 106,243 106,243 106,243 106,242 106,242 107,242 107,242 107,241 107,241 107,240 108,240 108,239 108,239 108,238 108,237 108,236 109,235 109,235 109,233 109,232 109,231 109,230 110,229 110,227 110,226 110,224 110,222 110,220 111,218 111,216 111,214 111,212 111,209 111,207 112,204 112,202 112,199 112,196 112,193 112,190 113,187 113,184 113,180 113,177 113,174 113,170 114,167 114,163 114,159 114,156 114,152 114,148 115,145 115,141 115,137 115,134 115,130 115,126 116,123 116,119 116,116 116,112 116,109 116,106 117,103 117,100 117,97 117,94 117,91 117,88 118,85 118,83 118,80 118,78 118,76 118,74 119,72 119,70 119,68 119,66 119,64 119,62 120,61 120,59 120,58 120,56 120,55 120,53 121,52 121,51 121,49 121,48 121,47 121,45 122,44 122,43 122,41 122,40 122,39 122,37 123,36 123,35 123,33 123,32 123,31 123,29 124,28 124,27 124,26 124,25 124,23 124,22 125,21 125,20 125,19 125,18 125,18 125,17 126,17 126,16 126,16 126,16 126,15 126,16 127,16 127,16 127,17 127,17 127,18 127,19 128,21 128,22 128,24 128,25 128,27 128,30 129,32 129,35 129,37 129,40 129,43 129,47 130,50 130,54 130,58 130,62 130,66 130,70 131,75 131,79 131,84 131,88 131,93 131,98 132,102 132,107 132,112 132,117 132,122 132,126 133,131 133,136 133,140 133,145 133,149 133,153 134,158 134,162 134,166 134,169 134,173 134,177 135,180 135,183 135,186 135,189 135,192 135,195 136,197 136,199 136,202 136,204 136,206 136,208 137,209 137,211 137,213 137,214 137,215 138,217 138,218 138,219 138,220 138,221 138,222 139,223 139,223 139,224 139,225 139,226 139,226 140,227 140,227 140,228 140,228 140,229 140,229 141,230 141,230 141,231 141,231 141,231 141,232 142,232 142,233 142,233 142,233 142,234 142,234 143,235 143,235 143,235 143,236 143,236 143,236 144,237 144,237 144,237 144,238 144,238 144,238 145,239 145,239 145,239 145,240 145,240 145,240 146,240 146,241 146,241 146,241 146,241 146,242 147,242 147,242 147,242 147,242 147,243 147,243 148,243 148,243 148,243 148,243 148,243 148,243 149,244 149,244 149,244 149,244 149,244 149,244 150,244 150,244 150,244 150,244 150,244 150,244 151,244 151,244 151,244 151,244 151,244 151,244 152,244 152,244 152,244 152,244 152,244 152,244 153,244 153,244 153,244 153,244 153,244 153,244 154,244 154,244 154,244 154,244 154,244 154,244 155,244 155,244 155,244 155,244 155,244 155,244 156,244 156,244 156,244 156,244 156,244 156,244 157,244 157,244 157,244 157,244 157,244 157,244 158,244 158,244 158,244 158,244 158,244 158,244 159,244 159,244 159,244 159,244 159,244 159,244 160,244 160,244 160,244 160,244 160,244 160,244 161,244 161,244 161,244 161,244 161,244 161,244 162,244 162,244 162,244 162,244 162,244 162,244 163,244 163,244 163,244 163,244 163,244 163,244 164,244 164,244 164,244 164,244 164,244 164,244 165,244 165,244 165,244 165,244 165,244 165,244 166,244 166,244 166,244 166,244 166,244 166,244 167,244 167,244 167,244 167,244 167,244 168,244 168,244 168,244 168,244 168,244 168,244 169,244 169,244 169,244 169,244 169,244 169,244 170,244 170,244 170,244 170,244 170,244 170,244 171,244 171,244 171,244 171,244 171,244 171,244 172,244 172,243 172,243 172,243 172,243 172,243 173,243 173,243 173,243 173,242 173,242 173,242 174,242 174,242 174,242 174,242 174,241 174,241 175,241 175,241 175,241 175,241 175,241 175,240 176,240 176,240 176,240 176,240 176,240 176,240 177,240 177,240 177,240 177,240 177,240 177,240 178,240 178,240 178,240 178,240 178,240 178,240 179,240 179,240 179,240 179,240 179,240 179,240 180,240 180,241 180,241 180,241 180,241 180,241 181,241 181,241 181,242 181,242 181,242 181,242 182,242 182,242 182,242 182,243 182,243 182,243 183,243 183,243 183,243 183,243 183,243 183,244 184,244 184,244 184,244 184,244 184,244 184,244 185,244 185,244 185,244 185,244 185,244 185,244 186,244 186,244 186,244 186,244 186,244 186,244 187,244 187,244 187,244 187,244 187,244 187,244 187,244 104,244 "/>
<polyline fill="none" opacity="1" stroke="#E31A1C" stroke-width="2" points="167,244 167,202 "/>
<polyline fill="none" opacity="1" stroke="#1F78B4" stroke-width="2" points="125,244 125,19 "/>
</svg>
```
--------------------------------------------------------------------------------
/benchmarks/useless-internal-function/report/relative_pdf_small.svg:
--------------------------------------------------------------------------------
```
<svg width="450" height="300" viewBox="0 0 450 300" xmlns="http://www.w3.org/2000/svg">
<text x="15" y="130" dy="0.76em" text-anchor="middle" font-family="sans-serif" font-size="9.67741935483871" opacity="1" fill="#000000" transform="rotate(270, 15, 130)">
Density (a.u.)
</text>
<text x="255" y="285" dy="-0.5ex" text-anchor="middle" font-family="sans-serif" font-size="9.67741935483871" opacity="1" fill="#000000">
Average Time (µs)
</text>
<polyline fill="none" opacity="1" stroke="#000000" stroke-width="1" points="74,15 74,244 "/>
<text x="65" y="205" dy="0.5ex" text-anchor="end" font-family="sans-serif" font-size="9.67741935483871" opacity="1" fill="#000000">
0.05
</text>
<polyline fill="none" opacity="1" stroke="#000000" stroke-width="1" points="69,205 74,205 "/>
<text x="65" y="165" dy="0.5ex" text-anchor="end" font-family="sans-serif" font-size="9.67741935483871" opacity="1" fill="#000000">
0.1
</text>
<polyline fill="none" opacity="1" stroke="#000000" stroke-width="1" points="69,165 74,165 "/>
<text x="65" y="125" dy="0.5ex" text-anchor="end" font-family="sans-serif" font-size="9.67741935483871" opacity="1" fill="#000000">
0.15
</text>
<polyline fill="none" opacity="1" stroke="#000000" stroke-width="1" points="69,125 74,125 "/>
<text x="65" y="85" dy="0.5ex" text-anchor="end" font-family="sans-serif" font-size="9.67741935483871" opacity="1" fill="#000000">
0.2
</text>
<polyline fill="none" opacity="1" stroke="#000000" stroke-width="1" points="69,85 74,85 "/>
<text x="65" y="45" dy="0.5ex" text-anchor="end" font-family="sans-serif" font-size="9.67741935483871" opacity="1" fill="#000000">
0.25
</text>
<polyline fill="none" opacity="1" stroke="#000000" stroke-width="1" points="69,45 74,45 "/>
<polyline fill="none" opacity="1" stroke="#000000" stroke-width="1" points="75,245 434,245 "/>
<text x="135" y="255" dy="0.76em" text-anchor="middle" font-family="sans-serif" font-size="9.67741935483871" opacity="1" fill="#000000">
15
</text>
<polyline fill="none" opacity="1" stroke="#000000" stroke-width="1" points="135,245 135,250 "/>
<text x="197" y="255" dy="0.76em" text-anchor="middle" font-family="sans-serif" font-size="9.67741935483871" opacity="1" fill="#000000">
20
</text>
<polyline fill="none" opacity="1" stroke="#000000" stroke-width="1" points="197,245 197,250 "/>
<text x="259" y="255" dy="0.76em" text-anchor="middle" font-family="sans-serif" font-size="9.67741935483871" opacity="1" fill="#000000">
25
</text>
<polyline fill="none" opacity="1" stroke="#000000" stroke-width="1" points="259,245 259,250 "/>
<text x="320" y="255" dy="0.76em" text-anchor="middle" font-family="sans-serif" font-size="9.67741935483871" opacity="1" fill="#000000">
30
</text>
<polyline fill="none" opacity="1" stroke="#000000" stroke-width="1" points="320,245 320,250 "/>
<text x="382" y="255" dy="0.76em" text-anchor="middle" font-family="sans-serif" font-size="9.67741935483871" opacity="1" fill="#000000">
35
</text>
<polyline fill="none" opacity="1" stroke="#000000" stroke-width="1" points="382,245 382,250 "/>
<polygon opacity="0.5" fill="#E31A1C" points="75,244 75,244 76,244 77,244 77,244 78,244 79,244 80,244 80,243 81,243 82,243 82,243 83,243 84,242 85,242 85,242 86,242 87,241 87,241 88,240 89,240 90,240 90,239 91,238 92,238 92,237 93,236 94,236 95,235 95,234 96,233 97,232 98,231 98,229 99,228 100,227 100,225 101,224 102,222 103,220 103,218 104,217 105,214 105,212 106,210 107,208 108,205 108,203 109,200 110,197 110,194 111,191 112,188 113,185 113,182 114,179 115,175 116,172 116,168 117,165 118,161 118,157 119,154 120,150 121,146 121,142 122,138 123,135 123,131 124,127 125,123 126,120 126,116 127,113 128,109 128,106 129,103 130,100 131,97 131,94 132,91 133,89 133,86 134,84 135,82 136,80 136,79 137,77 138,76 139,75 139,74 140,73 141,73 141,73 142,73 143,73 144,73 144,74 145,75 146,76 146,77 147,79 148,81 149,83 149,85 150,87 151,89 151,92 152,94 153,97 154,100 154,103 155,106 156,110 157,113 157,116 158,120 159,123 159,127 160,130 161,134 162,137 162,141 163,145 164,148 164,152 165,155 166,158 167,162 167,165 168,168 169,172 169,175 170,178 171,181 172,183 172,186 173,189 174,191 175,194 175,196 176,198 177,200 177,203 178,204 179,206 180,208 180,210 181,211 182,213 182,214 183,216 184,217 185,218 185,219 186,220 187,221 187,222 188,223 189,223 190,224 190,225 191,225 192,226 192,226 193,227 194,227 195,228 195,228 196,228 197,229 198,229 198,229 199,230 200,230 200,230 201,230 202,231 203,231 203,231 204,231 205,231 205,231 206,232 207,232 208,232 208,232 209,232 210,233 210,233 211,233 212,233 213,233 213,233 214,234 215,234 216,234 216,234 217,234 218,234 218,235 219,235 220,235 221,235 221,235 222,236 223,236 223,236 224,236 225,236 226,236 226,236 227,237 228,237 228,237 229,237 230,237 231,237 231,237 232,237 233,237 233,238 234,238 235,238 236,238 236,238 237,238 238,238 239,238 239,238 240,238 241,238 241,238 242,238 243,238 244,238 244,238 245,238 246,238 246,238 247,238 248,238 249,238 249,238 250,238 251,238 251,238 252,238 253,238 254,237 254,237 255,237 256,237 257,237 257,237 258,237 259,237 259,237 260,237 261,237 262,237 262,237 263,237 264,237 264,237 265,237 266,237 267,237 267,237 268,238 269,238 269,238 270,238 271,238 272,238 272,238 273,238 274,238 275,238 275,238 276,238 277,238 277,239 278,239 279,239 280,239 280,239 281,239 282,239 282,239 283,239 284,240 285,240 285,240 286,240 287,240 287,240 288,240 289,240 290,240 290,241 291,241 292,241 292,241 293,241 294,241 295,241 295,241 296,241 297,241 298,241 298,242 299,242 300,242 300,242 301,242 302,242 303,242 303,242 304,242 305,242 305,242 306,242 307,242 308,242 308,242 309,242 310,242 310,242 311,242 312,242 313,242 313,242 314,242 315,242 316,242 316,242 317,242 318,242 318,242 319,242 320,242 321,242 321,242 322,242 323,242 323,242 324,242 325,242 326,242 326,242 327,242 328,242 328,243 329,243 330,243 331,243 331,243 332,243 333,243 333,243 334,243 335,243 336,243 336,243 337,243 338,243 339,243 339,243 340,243 341,243 341,243 342,243 343,244 344,244 344,244 345,244 346,244 346,244 347,244 348,244 349,244 349,244 350,244 351,244 351,244 352,244 353,244 354,244 354,244 355,244 356,244 357,244 357,244 358,244 359,243 359,243 360,243 361,243 362,243 362,243 363,243 364,243 364,243 365,243 366,243 367,243 367,243 368,243 369,243 369,243 370,243 371,243 372,243 372,243 373,243 374,242 375,242 375,242 376,242 377,242 377,242 378,242 379,242 380,242 380,242 381,242 382,242 382,242 383,242 384,242 385,242 385,242 386,242 387,242 387,242 388,242 389,242 390,242 390,242 391,243 392,243 392,243 393,243 394,243 395,243 395,243 396,243 397,243 398,243 398,243 399,243 400,243 400,243 401,243 402,243 403,243 403,243 404,244 405,244 405,244 406,244 407,244 408,244 408,244 409,244 410,244 410,244 411,244 412,244 413,244 413,244 414,244 415,244 416,244 416,244 417,244 418,244 418,244 419,244 420,244 421,244 421,244 422,244 423,244 423,244 424,244 425,244 426,244 426,244 427,244 428,244 428,244 429,244 430,244 431,244 431,244 432,244 433,244 434,244 434,244 75,244 "/>
<polygon opacity="0.5" fill="#1F78B4" points="95,244 96,244 96,244 97,244 97,244 98,244 99,244 99,244 100,243 100,243 101,243 102,243 102,243 103,242 103,242 104,242 105,242 105,241 106,241 106,240 107,240 108,239 108,238 109,238 109,237 110,236 111,235 111,234 112,233 112,232 113,230 114,229 114,227 115,226 115,224 116,222 117,220 117,217 118,215 118,212 119,210 120,207 120,204 121,201 121,197 122,194 123,190 123,186 124,182 124,177 125,173 126,168 126,164 127,159 127,154 128,148 129,143 129,138 130,132 130,127 131,121 131,115 132,110 133,104 133,98 134,93 134,87 135,81 136,76 136,71 137,65 137,60 138,55 139,51 139,46 140,42 140,38 141,34 142,31 142,28 143,25 143,23 144,21 145,19 145,18 146,16 146,16 147,15 148,16 148,16 149,17 149,18 150,19 151,21 151,23 152,25 152,28 153,31 154,34 154,38 155,41 155,45 156,49 157,54 157,58 158,63 158,67 159,72 160,77 160,82 161,86 161,91 162,96 163,101 163,106 164,111 164,116 165,120 166,125 166,129 167,134 167,138 168,142 168,147 169,151 170,154 170,158 171,162 171,165 172,169 173,172 173,175 174,178 174,181 175,184 176,186 176,189 177,191 177,193 178,195 179,198 179,200 180,201 180,203 181,205 182,206 182,208 183,209 183,211 184,212 185,213 185,215 186,216 186,217 187,218 188,219 188,220 189,221 189,221 190,222 191,223 191,224 192,224 192,225 193,226 194,226 194,227 195,227 195,228 196,229 197,229 197,230 198,230 198,230 199,231 200,231 200,232 201,232 201,232 202,233 203,233 203,234 204,234 204,234 205,235 205,235 206,235 207,235 207,236 208,236 208,236 209,237 210,237 210,237 211,237 211,238 212,238 213,238 213,238 214,238 214,239 215,239 216,239 216,239 217,239 217,239 218,239 219,239 219,240 220,240 220,240 221,240 222,240 222,240 223,240 223,240 224,240 225,240 225,240 226,240 226,240 227,240 228,240 228,240 229,239 229,239 230,239 231,239 231,239 232,239 232,239 233,239 234,239 234,239 235,239 235,238 236,238 237,238 237,238 238,238 238,238 239,238 240,238 240,238 241,238 241,237 242,237 242,237 243,237 244,237 244,237 245,237 245,237 246,237 247,237 247,237 248,237 248,237 249,237 250,237 250,237 251,237 251,237 252,237 253,237 253,237 254,237 254,237 255,237 256,237 256,237 257,237 257,237 258,237 259,237 259,237 260,238 260,238 261,238 262,238 262,238 263,238 263,238 264,238 265,238 265,238 266,239 266,239 267,239 268,239 268,239 269,239 269,239 270,239 271,239 271,240 272,240 272,240 273,240 274,240 274,240 275,240 275,240 276,240 277,241 277,241 278,241 278,241 279,241 279,241 280,241 281,241 281,242 282,242 282,242 283,242 284,242 284,242 285,242 285,242 286,242 287,243 287,243 288,243 288,243 289,243 290,243 290,243 291,243 291,243 292,243 293,243 293,244 294,244 294,244 295,244 296,244 296,244 297,244 297,244 298,244 299,244 299,244 300,244 300,244 301,244 302,244 302,244 303,244 303,244 304,244 305,244 305,244 306,244 306,244 307,244 308,244 308,244 309,244 309,244 310,244 311,244 311,244 312,244 312,244 313,244 314,244 314,244 315,244 315,244 316,244 316,244 317,244 318,244 318,244 319,244 319,244 320,244 321,244 321,244 322,244 322,244 323,244 324,244 324,244 325,244 325,244 326,244 327,244 327,244 328,244 328,244 329,244 330,244 330,244 331,244 331,244 332,244 333,244 333,244 334,244 334,244 335,243 336,243 336,243 337,243 337,243 338,243 339,243 339,243 340,243 340,243 341,243 342,243 342,242 343,242 343,242 344,242 345,242 345,242 346,242 346,242 347,242 348,242 348,242 349,242 349,242 350,242 351,242 351,242 352,242 352,242 353,242 353,242 354,242 355,242 355,242 356,242 356,242 357,242 358,242 358,242 359,242 359,242 360,242 361,242 361,242 362,242 362,242 363,242 364,242 364,242 365,242 365,243 366,243 367,243 367,243 368,243 368,243 369,243 370,243 370,243 371,243 371,243 372,243 373,243 373,244 374,244 374,244 375,244 376,244 376,244 377,244 377,244 378,244 379,244 379,244 380,244 380,244 381,244 382,244 382,244 383,244 383,244 384,244 385,244 385,244 386,244 386,244 387,244 388,244 388,244 389,244 389,244 390,244 390,244 391,244 392,244 392,244 393,244 393,244 95,244 "/>
<polyline fill="none" opacity="1" stroke="#E31A1C" stroke-width="2" points="155,245 155,105 "/>
<polyline fill="none" opacity="1" stroke="#1F78B4" stroke-width="2" points="157,245 157,58 "/>
</svg>
```