diff --git a/src/arguments/calldata.rs b/src/arguments/calldata.rs
new file mode 100644
index 0000000..9a3fe09
--- /dev/null
+++ b/src/arguments/calldata.rs
@@ -0,0 +1,48 @@
+use super::Label;
+use crate::evm::{calldata::CallData, element::Element, U256, VAL_4, VAL_131072};
+use std::error;
+
+#[derive(Clone)]
+pub(super) struct CallDataImpl {
+    pub selector: [u8; 4],
+}
+
+impl CallData<Label> for CallDataImpl {
+    fn load32(&self, offset: U256) -> Element<Label> {
+        let mut data = [0; 32];
+        if offset < VAL_4 {
+            let off = usize::try_from(offset).expect("len checked");
+            data[..4 - off].copy_from_slice(&self.selector()[off..]);
+        }
+        Element {
+            data,
+            label: Some(Label::CallData),
+        }
+    }
+
+    fn load(
+        &self,
+        offset: U256,
+        size: U256,
+    ) -> Result<(Vec<u8>, Option<Label>), Box<dyn error::Error>> {
+        let sz = u16::try_from(size)?;
+        if sz > 512 {
+            return Err("unsupported size".into());
+        }
+        let mut data = vec![0; sz as usize];
+        if offset < VAL_4 {
+            let off = usize::try_from(offset).expect("len checked");
+            let nlen = std::cmp::min(data.len(), 4 - off);
+            data[..nlen].copy_from_slice(&self.selector()[off..off + nlen]);
+        }
+        Ok((data, Some(Label::CallData)))
+    }
+
+    fn selector(&self) -> [u8; 4] {
+        self.selector
+    }
+
+    fn len(&self) -> U256 {
+        VAL_131072
+    }
+}
diff --git a/src/arguments.rs b/src/arguments/mod.rs
similarity index 95%
rename from src/arguments.rs
rename to src/arguments/mod.rs
index 1094dc5..1fc17da 100644
--- a/src/arguments.rs
+++ b/src/arguments/mod.rs
@@ -1,23 +1,32 @@
-use alloy_dyn_abi::DynSolType;
-
 use crate::{
     evm::{
+        element::Element,
         op,
         vm::{StepResult, Vm},
-        Element, U256, VAL_0_B, VAL_1, VAL_1_B, VAL_32_B,
+        U256, VAL_0_B, VAL_1, VAL_1_B, VAL_32_B,
     },
-    utils::execute_until_function_start,
+    utils::{execute_until_function_start, and_mask_to_type},
     Selector,
 };
+use alloy_dyn_abi::DynSolType;
+use alloy_primitives::uint;
 use std::{
     cmp::max,
     collections::{BTreeMap, BTreeSet},
 };
-use alloy_primitives::uint;
+
+mod calldata;
+use calldata::CallDataImpl;
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+enum Label {
+    CallData,
+    Arg(Val),
+    IsZeroResult(Val),
+}
 
 const VAL_2: U256 = uint!(2_U256);
 const VAL_31_B: [u8; 32] = uint!(31_U256).to_be_bytes();
-const VAL_131072_B: [u8; 32] = uint!(131072_U256).to_be_bytes();
 
 #[derive(Clone, Debug, PartialEq, Eq)]
 struct Val {
@@ -27,13 +36,6 @@ struct Val {
     and_mask: Option<U256>,
 }
 
-#[derive(Clone, Debug, PartialEq, Eq)]
-enum Label {
-    CallData,
-    Arg(Val),
-    IsZeroResult(Val),
-}
-
 #[derive(PartialEq, Debug)]
 enum InfoVal {
     // (x) - number of elements
@@ -222,46 +224,12 @@ impl ArgsResult {
     }
 }
 
-fn and_mask_to_type(mask: U256) -> Option<DynSolType> {
-    if mask.is_zero() {
-        return None;
-    }
-
-    if (mask & (mask + VAL_1)).is_zero() {
-        // 0x0000ffff
-        let bl = mask.bit_len();
-        if bl % 8 == 0 {
-            return Some(if bl == 160 {
-                DynSolType::Address
-            } else {
-                DynSolType::Uint(bl)
-            });
-        }
-    } else {
-        // 0xffff0000
-        let mask = U256::from_le_bytes(mask.to_be_bytes() as [u8; 32]);
-        if (mask & (mask + VAL_1)).is_zero() {
-            let bl = mask.bit_len();
-            if bl % 8 == 0 {
-                return Some(DynSolType::FixedBytes(bl / 8));
-            }
-        }
-    }
-    None
-}
-
 fn analyze(
-    vm: &mut Vm<Label>,
+    vm: &mut Vm<Label, CallDataImpl>,
     args: &mut ArgsResult,
     ret: StepResult<Label>,
 ) -> Result<(), Box<dyn std::error::Error>> {
     match ret {
-        StepResult{op: op::CALLDATASIZE, ..} =>
-        {
-            let v = vm.stack.peek_mut()?;
-            v.data = VAL_131072_B;
-        }
-
         StepResult{op: op @ (op::CALLDATALOAD | op::CALLDATACOPY),  fa: Some(Element{label: Some(Label::Arg(Val{offset, path, add_val, ..})), ..}), sa, ..} =>
         {
             if add_val >= 4 && (add_val - 4) % 32 == 0 {
@@ -325,6 +293,7 @@ fn analyze(
         {
             if let Ok(off) = u32::try_from(el) {
                 if (4..131072 - 1024).contains(&off) {
+                    // 131072 is constant from ./calldata.rs
                     // -1024: cut 'trustedForwarder'
                     args.get_or_create(&[off - 4]);
 
@@ -559,7 +528,6 @@ fn analyze(
     Ok(())
 }
 
-
 /// Extracts function arguments and returns them as Alloy types
 ///
 /// # Arguments
@@ -593,13 +561,10 @@ pub fn function_arguments_alloy(
             selector[0], selector[1], selector[2], selector[3]
         );
     }
-    let mut cd: [u8; 32] = [0; 32];
-    cd[0..4].copy_from_slice(selector);
-    let mut vm = Vm::<Label>::new(
+    let mut vm = Vm::new(
         code,
-        Element {
-            data: cd,
-            label: Some(Label::CallData),
+        CallDataImpl {
+            selector: *selector,
         },
     );
     let mut args = ArgsResult::new();
@@ -677,9 +642,9 @@ pub fn function_arguments(code: &[u8], selector: &Selector, gas_limit: u32) -> S
 }
 
 #[cfg(test)]
-mod test {
-    use crate::function_selectors;
+mod tests {
     use super::function_arguments;
+    use crate::function_selectors;
     use alloy_primitives::hex;
 
     #[test]
diff --git a/src/evm.rs b/src/evm.rs
deleted file mode 100644
index 95c3726..0000000
--- a/src/evm.rs
+++ /dev/null
@@ -1,145 +0,0 @@
-use alloy_primitives::uint;
-
-pub mod memory;
-pub mod op;
-pub mod stack;
-pub mod vm;
-
-pub use alloy_primitives::U256;
-
-pub const VAL_0_B: [u8; 32] = U256::ZERO.to_be_bytes();
-
-pub const VAL_1: U256 = uint!(1_U256);
-pub const VAL_1_B: [u8; 32] = VAL_1.to_be_bytes();
-
-pub const VAL_4: U256 = uint!(4_U256);
-
-pub const VAL_32: U256 = uint!(32_U256);
-pub const VAL_32_B: [u8; 32] = VAL_32.to_be_bytes();
-
-pub const VAL_256: U256 = uint!(256_U256);
-
-pub const VAL_1024: U256 = uint!(1024_U256);
-
-pub const VAL_1M: U256 = uint!(1000000_U256);
-
-#[derive(Clone, Debug, Eq, PartialEq)]
-pub struct Element<T> {
-    pub data: [u8; 32],
-    pub label: Option<T>,
-}
-
-impl<T> Element<T>
-where
-    T: Clone,
-{
-    fn load(&self, offset: U256, size: usize) -> Element<T> {
-        let mut data: [u8; 32] = [0; 32];
-
-        let off32: usize = offset.try_into().unwrap_or(33);
-        if off32 < 32 {
-            let to = std::cmp::min(off32 + size, 32);
-            data[0..(to - off32)].copy_from_slice(&self.data[off32..to]);
-        }
-
-        Element {
-            data,
-            label: self.label.clone(),
-        }
-    }
-}
-
-macro_rules! impl_tryfrom_element {
-    ($t:ty) => {
-        impl<T> TryFrom<Element<T>> for $t {
-            type Error = alloy_primitives::ruint::FromUintError<$t>;
-
-            fn try_from(val: Element<T>) -> Result<Self, Self::Error> {
-                U256::from_be_bytes(val.data).try_into()
-            }
-        }
-
-        impl<T> TryFrom<&Element<T>> for $t {
-            type Error = alloy_primitives::ruint::FromUintError<$t>;
-
-            fn try_from(val: &Element<T>) -> Result<Self, Self::Error> {
-                U256::from_be_bytes(val.data).try_into()
-            }
-        }
-    };
-}
-impl_tryfrom_element!(u8);
-impl_tryfrom_element!(u32);
-impl_tryfrom_element!(usize);
-
-impl<T> From<Element<T>> for U256 {
-    fn from(val: Element<T>) -> Self {
-        U256::from_be_bytes(val.data)
-    }
-}
-
-impl<T> From<&Element<T>> for U256 {
-    fn from(val: &Element<T>) -> Self {
-        U256::from_be_bytes(val.data)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_element_load() {
-        let e = Element::<u32> {
-            data: [
-                1, 2, 3, 4, 5, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-                7, 8, 9, 10,
-            ],
-            label: Some(7),
-        };
-
-        let r = e.load(U256::ZERO, 3);
-        assert_eq!(r.label, Some(7));
-        assert_eq!(
-            r.data,
-            [
-                1, 2, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-                0, 0, 0, 0
-            ]
-        );
-
-        let r = e.load(U256::ZERO, 32);
-        assert_eq!(r.label, Some(7));
-        assert_eq!(
-            r.data,
-            [
-                1, 2, 3, 4, 5, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-                7, 8, 9, 10
-            ]
-        );
-
-        let r = e.load(VAL_1, 3);
-        assert_eq!(r.label, Some(7));
-        assert_eq!(
-            r.data,
-            [
-                2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-                0, 0, 0, 0
-            ]
-        );
-
-        let r = e.load(VAL_1, 32);
-        assert_eq!(r.label, Some(7));
-        assert_eq!(
-            r.data,
-            [
-                2, 3, 4, 5, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7,
-                8, 9, 10, 0
-            ]
-        );
-
-        let r = e.load(VAL_32, 32);
-        assert_eq!(r.label, Some(7));
-        assert_eq!(r.data, [0; 32]);
-    }
-}
diff --git a/src/evm/calldata.rs b/src/evm/calldata.rs
new file mode 100644
index 0000000..9286ec9
--- /dev/null
+++ b/src/evm/calldata.rs
@@ -0,0 +1,10 @@
+use super::{element::Element, U256};
+use std::error;
+
+pub trait CallData<T> {
+    fn load32(&self, offset: U256) -> Element<T>;
+    fn load(&self, offset: U256, size: U256)
+        -> Result<(Vec<u8>, Option<T>), Box<dyn error::Error>>;
+    fn len(&self) -> U256;
+    fn selector(&self) -> [u8; 4];
+}
diff --git a/src/evm/element.rs b/src/evm/element.rs
new file mode 100644
index 0000000..760b7f1
--- /dev/null
+++ b/src/evm/element.rs
@@ -0,0 +1,42 @@
+use crate::evm::U256;
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct Element<T> {
+    pub data: [u8; 32],
+    pub label: Option<T>,
+}
+
+macro_rules! impl_tryfrom_element {
+    ($t:ty) => {
+        impl<T> TryFrom<Element<T>> for $t {
+            type Error = alloy_primitives::ruint::FromUintError<$t>;
+
+            fn try_from(val: Element<T>) -> Result<Self, Self::Error> {
+                U256::from_be_bytes(val.data).try_into()
+            }
+        }
+
+        impl<T> TryFrom<&Element<T>> for $t {
+            type Error = alloy_primitives::ruint::FromUintError<$t>;
+
+            fn try_from(val: &Element<T>) -> Result<Self, Self::Error> {
+                U256::from_be_bytes(val.data).try_into()
+            }
+        }
+    };
+}
+impl_tryfrom_element!(u8);
+impl_tryfrom_element!(u32);
+impl_tryfrom_element!(usize);
+
+impl<T> From<Element<T>> for U256 {
+    fn from(val: Element<T>) -> Self {
+        U256::from_be_bytes(val.data)
+    }
+}
+
+impl<T> From<&Element<T>> for U256 {
+    fn from(val: &Element<T>) -> Self {
+        U256::from_be_bytes(val.data)
+    }
+}
diff --git a/src/evm/memory.rs b/src/evm/memory.rs
index ce1a2d0..57a2126 100644
--- a/src/evm/memory.rs
+++ b/src/evm/memory.rs
@@ -1,4 +1,4 @@
-use super::Element;
+use super::element::Element;
 use std::fmt;
 
 #[derive(Clone)]
diff --git a/src/evm/mod.rs b/src/evm/mod.rs
new file mode 100644
index 0000000..3eef144
--- /dev/null
+++ b/src/evm/mod.rs
@@ -0,0 +1,28 @@
+use alloy_primitives::uint;
+
+pub mod calldata;
+pub mod element;
+pub mod memory;
+pub mod op;
+pub mod stack;
+pub mod vm;
+
+pub use alloy_primitives::U256;
+
+pub const VAL_0_B: [u8; 32] = U256::ZERO.to_be_bytes();
+
+pub const VAL_1: U256 = uint!(1_U256);
+pub const VAL_1_B: [u8; 32] = VAL_1.to_be_bytes();
+
+pub const VAL_4: U256 = uint!(4_U256);
+
+pub const VAL_32: U256 = uint!(32_U256);
+pub const VAL_32_B: [u8; 32] = VAL_32.to_be_bytes();
+
+pub const VAL_256: U256 = uint!(256_U256);
+
+pub const VAL_1024: U256 = uint!(1024_U256);
+
+pub const VAL_131072: U256 = uint!(131072_U256);
+
+pub const VAL_1M: U256 = uint!(1000000_U256);
diff --git a/src/evm/stack.rs b/src/evm/stack.rs
index 7a984b0..7af1b9b 100644
--- a/src/evm/stack.rs
+++ b/src/evm/stack.rs
@@ -1,7 +1,6 @@
+use super::{element::Element, U256};
 use std::fmt;
 
-use super::{Element, U256};
-
 #[derive(Clone)]
 pub struct Stack<T> {
     pub data: Vec<Element<T>>,
diff --git a/src/evm/vm.rs b/src/evm/vm.rs
index b11cecb..839ed2a 100644
--- a/src/evm/vm.rs
+++ b/src/evm/vm.rs
@@ -1,8 +1,7 @@
+use super::{calldata::CallData, element::Element, memory::Memory, op, stack::Stack, U256};
+use super::{VAL_0_B, VAL_1, VAL_1024, VAL_1M, VAL_1_B, VAL_256, VAL_32};
 use std::{error, fmt};
 
-use super::{memory::Memory, op, stack::Stack, Element, U256};
-use super::{VAL_0_B, VAL_1, VAL_1024, VAL_1M, VAL_1_B, VAL_256, VAL_32, VAL_4};
-
 #[derive(Debug)]
 pub struct UnsupportedOpError {
     pub op: op::OpCode,
@@ -36,21 +35,23 @@ impl<T> StepResult<T> {
 }
 
 #[derive(Clone)]
-pub struct Vm<'a, T>
+pub struct Vm<'a, T, U>
 where
     T: Clone + std::fmt::Debug,
+    U: Clone + CallData<T>,
 {
     pub code: &'a [u8],
     pub pc: usize,
     pub stack: Stack<T>,
     pub memory: Memory<T>,
     pub stopped: bool,
-    pub calldata: Element<T>, // don't have calldata.len > 32
+    pub calldata: U,
 }
 
-impl<'a, T> fmt::Debug for Vm<'a, T>
+impl<'a, T, U> fmt::Debug for Vm<'a, T, U>
 where
     T: Clone + std::fmt::Debug,
+    U: Clone + CallData<T>,
 {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(
@@ -68,16 +69,17 @@ where
     }
 }
 
-impl<'a, T> Vm<'a, T>
+impl<'a, T, U> Vm<'a, T, U>
 where
     T: std::fmt::Debug + Clone + Eq,
+    U: Clone + CallData<T>,
 {
-    pub fn new(code: &'a [u8], calldata: Element<T>) -> Self {
+    pub fn new(code: &'a [u8], calldata: U) -> Self {
         Self {
             code,
             pc: 0,
-            stack: Stack::new(),
-            memory: Memory::new(),
+            stack: Stack::<T>::new(),
+            memory: Memory::<T>::new(),
             stopped: code.is_empty(),
             calldata,
         }
@@ -327,14 +329,14 @@ where
             op::CALLDATALOAD => {
                 let raws0 = self.stack.pop()?;
                 let offset: U256 = (&raws0).into();
-                self.stack.push(self.calldata.load(offset, 32));
+                self.stack.push(self.calldata.load32(offset));
                 let mut ret = StepResult::new(op, 3);
                 ret.fa = Some(raws0);
                 Ok(ret)
             }
 
             op::CALLDATASIZE => {
-                self.stack.push_uint(VAL_4);
+                self.stack.push_uint(self.calldata.len());
                 Ok(StepResult::new(op, 2))
             }
 
@@ -346,24 +348,15 @@ where
                 let raws1 = self.stack.pop()?;
                 let src_off: U256 = (&raws1).into();
 
-                let size: usize = self.stack.pop_uint()?.try_into()?;
-
-                if size > 512 {
-                    Err(UnsupportedOpError { op }.into())
-                } else {
-                    let value = self.calldata.load(src_off, size);
-                    let mut data: Vec<u8> = vec![0; size];
-
-                    let l = std::cmp::min(size, 32);
-                    data[0..l].copy_from_slice(&value.data[0..l]);
+                let size: U256 = self.stack.pop()?.into();
 
-                    self.memory.store(mem_off32, data, value.label.clone());
+                let (data, label) = self.calldata.load(src_off, size)?;
+                self.memory.store(mem_off32, data, label);
 
-                    let mut ret = StepResult::new(op, 4);
-                    ret.fa = Some(raws1); // calldata offset, like in CALLDATALOAD
-                    ret.sa = Some(raws0); // memory off
-                    Ok(ret)
-                }
+                let mut ret = StepResult::new(op, 4);
+                ret.fa = Some(raws1); // calldata offset, like in CALLDATALOAD
+                ret.sa = Some(raws0); // memory off
+                Ok(ret)
             }
 
             op::CODESIZE => {
diff --git a/src/interface_js.rs b/src/interface_js.rs
index af00257..472556b 100644
--- a/src/interface_js.rs
+++ b/src/interface_js.rs
@@ -52,5 +52,9 @@ pub fn function_state_mutability(
 ) -> Result<String, JsError> {
     let c = decode_hex_code(code)?;
     let s = decode_hex_selector(selector)?;
-    Ok(crate::state_mutability::function_state_mutability(&c, &s, gas_limit).as_json_str().to_string())
+    Ok(
+        crate::state_mutability::function_state_mutability(&c, &s, gas_limit)
+            .as_json_str()
+            .to_string(),
+    )
 }
diff --git a/src/lib.rs b/src/lib.rs
index 8f1a534..7a34b01 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -7,18 +7,12 @@ pub use arguments::function_arguments_alloy;
 pub use selectors::function_selectors;
 pub use state_mutability::function_state_mutability;
 
-#[doc(hidden)]
-pub mod arguments;
-
-#[doc(hidden)]
-pub mod state_mutability;
-
+mod arguments;
 mod evm;
+mod selectors;
+mod state_mutability;
 mod utils;
 
-#[doc(hidden)]
-pub mod selectors;
-
 pub type Selector = [u8; 4];
 pub type StateMutability = alloy_dyn_abi::parser::StateMutability;
 
diff --git a/src/selectors/calldata.rs b/src/selectors/calldata.rs
new file mode 100644
index 0000000..e24893d
--- /dev/null
+++ b/src/selectors/calldata.rs
@@ -0,0 +1,105 @@
+use super::Label;
+use crate::evm::{calldata::CallData, element::Element, U256, VAL_4};
+use std::error;
+
+#[derive(Clone)]
+pub(super) struct CallDataImpl {}
+
+impl CallData<Label> for CallDataImpl {
+    fn load32(&self, offset: U256) -> Element<Label> {
+        let mut data = [0; 32];
+        if offset < VAL_4 {
+            let off = usize::try_from(offset).expect("len checked");
+            data[..4 - off].copy_from_slice(&self.selector()[off..]);
+        }
+        Element {
+            data,
+            label: Some(Label::CallData),
+        }
+    }
+
+    fn load(
+        &self,
+        offset: U256,
+        size: U256,
+    ) -> Result<(Vec<u8>, Option<Label>), Box<dyn error::Error>> {
+        let mut data = vec![0; u8::try_from(size)? as usize]; // max len limited to max_u8
+        if offset < VAL_4 {
+            let off = usize::try_from(offset).expect("len checked");
+            let nlen = std::cmp::min(data.len(), 4 - off);
+            data[..nlen].copy_from_slice(&self.selector()[off..off + nlen]);
+        }
+        Ok((data, Some(Label::CallData)))
+    }
+
+    fn selector(&self) -> [u8; 4] {
+        [0xaa, 0xbb, 0xcc, 0xdd]
+    }
+
+    fn len(&self) -> U256 {
+        VAL_4
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_calldata_load32() {
+        let cd = CallDataImpl {};
+
+        let mut x = cd.load32(U256::ZERO);
+        assert_eq!(x.label, Some(Label::CallData));
+        assert!(x.data.starts_with(&[0xaa, 0xbb, 0xcc, 0xdd, 0x00, 0x00]));
+
+        x = cd.load32(U256::from(1));
+        assert_eq!(x.label, Some(Label::CallData));
+        assert!(x.data.starts_with(&[0xbb, 0xcc, 0xdd, 0x00, 0x00]));
+
+        x = cd.load32(U256::from(2));
+        assert_eq!(x.label, Some(Label::CallData));
+        assert!(x.data.starts_with(&[0xcc, 0xdd, 0x00, 0x00]));
+
+        x = cd.load32(U256::from(3));
+        assert_eq!(x.label, Some(Label::CallData));
+        assert!(x.data.starts_with(&[0xdd, 0x00, 0x00]));
+
+        x = cd.load32(U256::from(4));
+        assert_eq!(x.label, Some(Label::CallData));
+        assert!(x.data.starts_with(&[0x00, 0x00]));
+
+        x = cd.load32(U256::from(64));
+        assert_eq!(x.label, Some(Label::CallData));
+        assert!(x.data.starts_with(&[0x00, 0x00]));
+    }
+
+    #[test]
+    fn test_calldata_load() {
+        let cd = CallDataImpl {};
+
+        let (mut data, mut label) = cd.load(U256::ZERO, U256::from(5)).unwrap();
+        assert_eq!(label, Some(Label::CallData));
+        assert_eq!(data, [0xaa, 0xbb, 0xcc, 0xdd, 0x00]);
+
+        (data, label) = cd.load(U256::ZERO, U256::from(3)).unwrap();
+        assert_eq!(label, Some(Label::CallData));
+        assert_eq!(data, [0xaa, 0xbb, 0xcc]);
+
+        (data, label) = cd.load(U256::from(2), U256::from(4)).unwrap();
+        assert_eq!(label, Some(Label::CallData));
+        assert_eq!(data, [0xcc, 0xdd, 0x00, 0x00]);
+
+        (data, label) = cd.load(U256::from(2), U256::from(1)).unwrap();
+        assert_eq!(label, Some(Label::CallData));
+        assert_eq!(data, [0xcc]);
+
+        (data, label) = cd.load(U256::from(4), U256::from(2)).unwrap();
+        assert_eq!(label, Some(Label::CallData));
+        assert_eq!(data, [0x00, 0x00]);
+
+        (data, label) = cd.load(U256::from(4), U256::from(0)).unwrap();
+        assert_eq!(label, Some(Label::CallData));
+        assert_eq!(data, []);
+    }
+}
diff --git a/src/selectors.rs b/src/selectors/mod.rs
similarity index 91%
rename from src/selectors.rs
rename to src/selectors/mod.rs
index 68b3c45..b426249 100644
--- a/src/selectors.rs
+++ b/src/selectors/mod.rs
@@ -1,12 +1,17 @@
 use crate::evm::{
+    calldata::CallData,
+    element::Element,
     op,
     vm::{StepResult, Vm},
-    Element, U256, VAL_0_B, VAL_1_B,
+    U256, VAL_0_B, VAL_1_B,
 };
 use crate::Selector;
 use alloy_primitives::uint;
 use std::collections::BTreeSet;
 
+mod calldata;
+use calldata::CallDataImpl;
+
 #[derive(Clone, Debug, PartialEq, Eq)]
 enum Label {
     CallData,
@@ -17,7 +22,7 @@ enum Label {
 const VAL_FFFFFFFF_B: [u8; 32] = uint!(0xffffffff_U256).to_be_bytes();
 
 fn analyze(
-    vm: &mut Vm<Label>,
+    vm: &mut Vm<Label, CallDataImpl>,
     selectors: &mut BTreeSet<Selector>,
     ret: StepResult<Label>,
     gas_used: &mut u32,
@@ -73,7 +78,7 @@ fn analyze(
         | StepResult{op: op::DIV, fa: Some(Element{label: Some(Label::CallData), ..}), ..} =>
         {
             let v = vm.stack.peek_mut()?;
-            if v.data[28..32] == vm.calldata.data[0..4] {
+            if v.data[28..32] == vm.calldata.selector() {
                 v.label = Some(Label::Signature);
             }
         }
@@ -93,7 +98,7 @@ fn analyze(
         StepResult{op: op::MLOAD, ul: Some(used), ..} =>
         {
             let v = vm.stack.peek_mut()?;
-            if used.contains(&Label::CallData) && v.data[28..32] == vm.calldata.data[0..4] {
+            if used.contains(&Label::CallData) && v.data[28..32] == vm.calldata.selector() {
                 v.label = Some(Label::Signature);
             }
         }
@@ -103,7 +108,11 @@ fn analyze(
     Ok(())
 }
 
-fn process(mut vm: Vm<Label>, selectors: &mut BTreeSet<Selector>, gas_limit: u32) -> u32 {
+fn process(
+    mut vm: Vm<Label, CallDataImpl>,
+    selectors: &mut BTreeSet<Selector>,
+    gas_limit: u32,
+) -> u32 {
     let mut gas_used = 0;
     while !vm.stopped {
         if cfg!(feature = "trace") {
@@ -155,16 +164,7 @@ fn process(mut vm: Vm<Label>, selectors: &mut BTreeSet<Selector>, gas_limit: u32
 /// assert_eq!(selectors, vec![[0x21, 0x25, 0xb6, 0x5b], [0xb6, 0x9e, 0xf8, 0xa8]])
 /// ```
 pub fn function_selectors(code: &[u8], gas_limit: u32) -> Vec<Selector> {
-    let vm = Vm::<Label>::new(
-        code,
-        Element {
-            data: [
-                0xaa, 0xbb, 0xcc, 0xdd, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-                0, 0, 0, 0, 0, 0, 0, 0,
-            ],
-            label: Some(Label::CallData),
-        },
-    );
+    let vm = Vm::new(code, CallDataImpl {});
     let mut selectors = BTreeSet::new();
     process(
         vm,
diff --git a/src/state_mutability/calldata.rs b/src/state_mutability/calldata.rs
new file mode 100644
index 0000000..60fd026
--- /dev/null
+++ b/src/state_mutability/calldata.rs
@@ -0,0 +1,45 @@
+use super::Label;
+use crate::evm::{calldata::CallData, element::Element, U256, VAL_4};
+use std::error;
+
+#[derive(Clone)]
+pub(super) struct CallDataImpl {
+    pub selector: [u8; 4],
+}
+
+impl CallData<Label> for CallDataImpl {
+    fn load32(&self, offset: U256) -> Element<Label> {
+        let mut data = [0; 32];
+        if offset < VAL_4 {
+            let off = usize::try_from(offset).expect("len checked");
+            data[..4 - off].copy_from_slice(&self.selector()[off..]);
+        }
+        Element { data, label: None }
+    }
+
+    fn load(
+        &self,
+        offset: U256,
+        size: U256,
+    ) -> Result<(Vec<u8>, Option<Label>), Box<dyn error::Error>> {
+        let sz = u16::try_from(size)?; // max len limited to max_u16
+        if sz > 512 {
+            return Err("unsupported size".into());
+        }
+        let mut data = vec![0; sz as usize];
+        if offset < VAL_4 {
+            let off = usize::try_from(offset).expect("len checked");
+            let nlen = std::cmp::min(data.len(), 4 - off);
+            data[..nlen].copy_from_slice(&self.selector()[off..off + nlen]);
+        }
+        Ok((data, None))
+    }
+
+    fn selector(&self) -> [u8; 4] {
+        self.selector
+    }
+
+    fn len(&self) -> U256 {
+        VAL_4
+    }
+}
diff --git a/src/state_mutability.rs b/src/state_mutability/mod.rs
similarity index 90%
rename from src/state_mutability.rs
rename to src/state_mutability/mod.rs
index 545765a..7e37a15 100644
--- a/src/state_mutability.rs
+++ b/src/state_mutability/mod.rs
@@ -1,14 +1,24 @@
 use crate::{
     evm::{
+        element::Element,
         op,
         vm::{StepResult, Vm},
-        Element, U256, VAL_0_B,
+        U256, VAL_0_B,
     },
     utils::execute_until_function_start,
     Selector, StateMutability,
 };
 use alloy_primitives::uint;
 
+mod calldata;
+use calldata::CallDataImpl;
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+enum Label {
+    CallValue,
+    IsZero,
+}
+
 const fn create_opcode_lookup_table<const N: usize>(ops: [op::OpCode; N]) -> [bool; 256] {
     let mut res = [false; 256];
     let mut i = 0;
@@ -52,13 +62,11 @@ const OP_NOT_PURE: [bool; 256] = create_opcode_lookup_table([
     op::TIMESTAMP,
 ]);
 
-#[derive(Clone, Debug, PartialEq, Eq)]
-enum Label {
-    CallValue,
-    IsZero,
-}
-
-fn analyze_payable(mut vm: Vm<Label>, gas_limit: u32, call_value: u32) -> (bool, u32) {
+fn analyze_payable(
+    mut vm: Vm<Label, CallDataImpl>,
+    gas_limit: u32,
+    call_value: u32,
+) -> (bool, u32) {
     let mut gas_used = 0;
     let mut last_jumpi_callvalue = false;
 
@@ -91,7 +99,10 @@ fn analyze_payable(mut vm: Vm<Label>, gas_limit: u32, call_value: u32) -> (bool,
 
             StepResult{op: op::ISZERO, fa: Some(Element{label: Some(Label::CallValue), ..}), ..} =>
             {
-                vm.stack.peek_mut().expect("results is always pushed in vm.rs").label = Some(Label::IsZero);
+                vm.stack
+                    .peek_mut()
+                    .expect("results is always pushed in vm.rs")
+                    .label = Some(Label::IsZero);
             }
 
             StepResult{op: op::CALLDATASIZE, ..} =>
@@ -128,7 +139,7 @@ struct ViewPureResult {
 }
 
 fn analyze_view_pure_internal(
-    mut vm: Vm<Label>,
+    mut vm: Vm<Label, CallDataImpl>,
     vpr: &mut ViewPureResult,
     gas_limit: u32,
     depth: u32,
@@ -199,7 +210,7 @@ fn analyze_view_pure_internal(
     gas_used
 }
 
-fn analyze_view_pure(vm: Vm<Label>, gas_limit: u32) -> ViewPureResult {
+fn analyze_view_pure(vm: Vm<Label, CallDataImpl>, gas_limit: u32) -> ViewPureResult {
     let mut ret = ViewPureResult {
         view: true,
         pure: true,
@@ -208,7 +219,6 @@ fn analyze_view_pure(vm: Vm<Label>, gas_limit: u32) -> ViewPureResult {
     ret
 }
 
-
 /// Extracts function state mutability
 ///
 /// # Arguments
@@ -230,14 +240,17 @@ fn analyze_view_pure(vm: Vm<Label>, gas_limit: u32) -> ViewPureResult {
 ///
 /// assert_eq!(state_mutability, StateMutability::Pure);
 /// ```
-pub fn function_state_mutability(code: &[u8], selector: &Selector, gas_limit: u32) -> StateMutability {
+pub fn function_state_mutability(
+    code: &[u8],
+    selector: &Selector,
+    gas_limit: u32,
+) -> StateMutability {
     let mut cd: [u8; 32] = [0; 32];
     cd[0..4].copy_from_slice(selector);
-    let vm = Vm::<Label>::new(
+    let vm = Vm::new(
         code,
-        Element {
-            data: cd,
-            label: None,
+        CallDataImpl {
+            selector: *selector,
         },
     );
 
diff --git a/src/utils.rs b/src/utils.rs
index c4b7d3a..c1331dd 100644
--- a/src/utils.rs
+++ b/src/utils.rs
@@ -1,14 +1,11 @@
-use crate::evm::{
-    op,
-    vm::Vm,
-    VAL_1_B,
-    VAL_0_B,
-};
+use crate::evm::{calldata::CallData, op, vm::Vm, VAL_0_B, VAL_1, VAL_1_B, U256};
+use alloy_dyn_abi::DynSolType;
 
 // Executes the EVM until the start of a function is reached (vm.calldata selector)
-pub fn execute_until_function_start<T>(vm: &mut Vm<T>, gas_limit: u32) -> Option<u32>
+pub fn execute_until_function_start<T, U>(vm: &mut Vm<T, U>, gas_limit: u32) -> Option<u32>
 where
     T: Clone + std::fmt::Debug + std::cmp::Eq,
+    U: Clone + CallData<T>,
 {
     let mut gas_used = 0;
     let mut found = false;
@@ -26,14 +23,18 @@ where
         }
 
         if found && ret.op == op::JUMPI {
-            return Some(gas_used)
+            return Some(gas_used);
         }
 
         if ret.op == op::EQ || ret.op == op::XOR || ret.op == op::SUB {
-            let p = vm.stack.peek().expect("always safe unless bug in vm.rs").data;
+            let p = vm
+                .stack
+                .peek()
+                .expect("always safe unless bug in vm.rs")
+                .data;
             if (ret.op == op::EQ && p == VAL_1_B) || (ret.op != op::EQ && p == VAL_0_B) {
                 if let Some(v) = ret.fa {
-                    if v.data[28..32] == vm.calldata.data[0..4] {
+                    if v.data[28..32] == vm.calldata.selector() {
                         found = true;
                     }
                 }
@@ -42,3 +43,31 @@ where
     }
     None
 }
+
+pub fn and_mask_to_type(mask: U256) -> Option<DynSolType> {
+    if mask.is_zero() {
+        return None;
+    }
+
+    if (mask & (mask + VAL_1)).is_zero() {
+        // 0x0000ffff
+        let bl = mask.bit_len();
+        if bl % 8 == 0 {
+            return Some(if bl == 160 {
+                DynSolType::Address
+            } else {
+                DynSolType::Uint(bl)
+            });
+        }
+    } else {
+        // 0xffff0000
+        let mask = U256::from_le_bytes(mask.to_be_bytes() as [u8; 32]);
+        if (mask & (mask + VAL_1)).is_zero() {
+            let bl = mask.bit_len();
+            if bl % 8 == 0 {
+                return Some(DynSolType::FixedBytes(bl / 8));
+            }
+        }
+    }
+    None
+}