diff --git a/cpp2rust/converter/models/converter_refcount.cpp b/cpp2rust/converter/models/converter_refcount.cpp
index 1b212f4f..9bee3eb9 100644
--- a/cpp2rust/converter/models/converter_refcount.cpp
+++ b/cpp2rust/converter/models/converter_refcount.cpp
@@ -1169,6 +1169,9 @@ bool ConverterRefCount::VisitImplicitCastExpr(clang::ImplicitCastExpr *expr) {
 
   if (expr->getCastKind() == clang::CastKind::CK_BitCast) {
     if (expr->getType()->isVoidPointerType()) {
+      if (sub_expr->getType()->isVoidPointerType()) {
+        return Convert(sub_expr);
+      }
       PushConversionKind push(*this, ConversionKind::Unboxed);
       if (sub_expr->getType()->isPointerType() &&
           sub_expr->getType()->getPointeeType()->isArrayType()) {
diff --git a/rule-preprocessor/src/semantic.rs b/rule-preprocessor/src/semantic.rs
index 77a12f5c..3fc04c3f 100644
--- a/rule-preprocessor/src/semantic.rs
+++ b/rule-preprocessor/src/semantic.rs
@@ -399,10 +399,10 @@ impl<'a, 'tcx> AstVisitor<'a, 'tcx> {
             rustc_hir::ExprKind::Lit(_)
             | rustc_hir::ExprKind::Path(_)
             | rustc_hir::ExprKind::Ret(None)
-            | rustc_hir::ExprKind::Break(_, _)
+            | rustc_hir::ExprKind::Break(_, None)
             | rustc_hir::ExprKind::Continue(_) => {}
 
-            rustc_hir::ExprKind::Ret(Some(e)) => {
+            rustc_hir::ExprKind::Ret(Some(e)) | rustc_hir::ExprKind::Break(_, Some(e)) => {
                 self.visit_expr(e, Access::Read);
             }
 
diff --git a/rules/arpa_inet/tgt_refcount.rs b/rules/arpa_inet/tgt_refcount.rs
new file mode 100644
index 00000000..6f595551
--- /dev/null
+++ b/rules/arpa_inet/tgt_refcount.rs
@@ -0,0 +1,60 @@
+// Copyright (c) 2022-present INESC-ID.
+// Distributed under the MIT license that can be found in the LICENSE file.
+
+use libcc2rs::*;
+
+fn f5(a0: i32, a1: Ptr<u8>, a2: AnyPtr) -> i32 {
+    if a0 == libc::AF_INET {
+        match a1.to_rust_string().parse::<std::net::Ipv4Addr>() {
+            Ok(__ip) => {
+                let __octets = __ip.octets();
+                for __i in 0..4 {
+                    a2.reinterpret_cast::<u8>().offset(__i).write(__octets[__i]);
+                }
+                1
+            }
+            Err(_) => 0,
+        }
+    } else if a0 == libc::AF_INET6 {
+        match a1.to_rust_string().parse::<std::net::Ipv6Addr>() {
+            Ok(__ip) => {
+                let __octets = __ip.octets();
+                for __i in 0..16 {
+                    a2.reinterpret_cast::<u8>().offset(__i).write(__octets[__i]);
+                }
+                1
+            }
+            Err(_) => 0,
+        }
+    } else {
+        -1
+    }
+}
+
+fn f6(a0: i32, a1: AnyPtr, a2: Ptr<u8>, a3: u32) -> Ptr<u8> {
+    let __text = if a0 == libc::AF_INET {
+        let mut __b = [0u8; 4];
+        for __i in 0..4 {
+            __b[__i] = a1.reinterpret_cast::<u8>().offset(__i).read();
+        }
+        Some(std::net::Ipv4Addr::from(__b).to_string())
+    } else if a0 == libc::AF_INET6 {
+        let mut __b = [0u8; 16];
+        for __i in 0..16 {
+            __b[__i] = a1.reinterpret_cast::<u8>().offset(__i).read();
+        }
+        Some(std::net::Ipv6Addr::from(__b).to_string())
+    } else {
+        None
+    };
+    match __text {
+        Some(__s) if (__s.len() as u32) < a3 => {
+            for __i in 0..__s.len() {
+                a2.offset(__i).write(__s.as_bytes()[__i]);
+            }
+            a2.offset(__s.len()).write(0);
+            a2.clone()
+        }
+        _ => Ptr::null(),
+    }
+}
diff --git a/rules/cstring/tgt_refcount.rs b/rules/cstring/tgt_refcount.rs
index 5d2eb6c4..3e09e03f 100644
--- a/rules/cstring/tgt_refcount.rs
+++ b/rules/cstring/tgt_refcount.rs
@@ -18,14 +18,474 @@ fn f3(a0: AnyPtr, a1: AnyPtr, a2: usize) -> i32 {
 }
 
 fn f4(a0: AnyPtr, a1: AnyPtr, a2: usize) -> AnyPtr {
-    a0.memcpy(&a1, a2 as usize);
+    let mut __src = a1.reinterpret_cast::<u8>();
+    let mut __tmp: Vec<u8> = Vec::with_capacity(a2);
+    for _ in 0..a2 {
+        __tmp.push(__src.read());
+        __src += 1;
+    }
+    let mut __dst = a0.reinterpret_cast::<u8>();
+    for __i in 0..a2 {
+        __dst.write(__tmp[__i]);
+        __dst += 1;
+    }
     a0.clone()
 }
 
+fn f5(a0: Ptr<u8>, a1: i32) -> Ptr<u8> {
+    let mut __p = a0.clone();
+    loop {
+        let __c = __p.read();
+        if __c == a1 as u8 {
+            break __p;
+        }
+        if __c == 0 {
+            break Ptr::null();
+        }
+        __p += 1;
+    }
+}
+
 unsafe fn f7(a0: Ptr<u8>) -> usize {
-    a0.to_string_iterator().count()
+    let mut __p = a0.clone();
+    let mut __i: usize = 0;
+    while __p.read() != 0 {
+        __p += 1;
+        __i += 1;
+    }
+    __i
+}
+
+fn f8(a0: Ptr<u8>, a1: Ptr<u8>) -> i32 {
+    let mut __p1 = a0.clone();
+    let mut __p2 = a1.clone();
+    loop {
+        let __c1 = __p1.read();
+        let __c2 = __p2.read();
+        if __c1 != __c2 {
+            break (__c1 as i32) - (__c2 as i32);
+        }
+        if __c1 == 0 {
+            break 0;
+        }
+        __p1 += 1;
+        __p2 += 1;
+    }
+}
+
+fn f9(a0: Ptr<u8>, a1: Ptr<u8>, a2: usize) -> i32 {
+    let mut __p1 = a0.clone();
+    let mut __p2 = a1.clone();
+    let mut __i: usize = 0;
+    loop {
+        if __i == a2 {
+            break 0;
+        }
+        let __c1 = __p1.read();
+        let __c2 = __p2.read();
+        if __c1 != __c2 {
+            break (__c1 as i32) - (__c2 as i32);
+        }
+        if __c1 == 0 {
+            break 0;
+        }
+        __p1 += 1;
+        __p2 += 1;
+        __i += 1;
+    }
+}
+
+fn f10(a0: AnyPtr, a1: i32, a2: usize) -> AnyPtr {
+    let mut __p = a0.reinterpret_cast::<u8>();
+    let mut __i: usize = 0;
+    loop {
+        if __i == a2 {
+            break Ptr::<u8>::null().to_any();
+        }
+        if __p.read() == a1 as u8 {
+            break __p.to_any();
+        }
+        __p += 1;
+        __i += 1;
+    }
+}
+
+fn f11(a0: Ptr<u8>, a1: i32) -> Ptr<u8> {
+    let mut __p = a0.clone();
+    let mut __found = Ptr::null();
+    loop {
+        let __c = __p.read();
+        if __c == a1 as u8 {
+            __found = __p.clone();
+        }
+        if __c == 0 {
+            break __found;
+        }
+        __p += 1;
+    }
 }
 
 fn f15(a0: Ptr<u8>) -> Ptr<u8> {
-    libcc2rs::strdup_refcount(a0)
+    libcc2rs::strdup_refcount(a0.clone())
+}
+
+fn f16(a0: Ptr<u8>, a1: Ptr<u8>) -> usize {
+    let mut __p = a0.clone();
+    let mut __i: usize = 0;
+    loop {
+        let __c = __p.read();
+        if __c == 0 {
+            break __i;
+        }
+        let mut __q = a1.clone();
+        let __hit = loop {
+            let __r = __q.read();
+            if __r == 0 {
+                break false;
+            }
+            if __r == __c {
+                break true;
+            }
+            __q += 1;
+        };
+        if __hit {
+            break __i;
+        }
+        __p += 1;
+        __i += 1;
+    }
+}
+
+fn f17(a0: Ptr<u8>, a1: Ptr<u8>) -> usize {
+    let mut __p = a0.clone();
+    let mut __i: usize = 0;
+    loop {
+        let __c = __p.read();
+        if __c == 0 {
+            break __i;
+        }
+        let mut __q = a1.clone();
+        let __hit = loop {
+            let __r = __q.read();
+            if __r == 0 {
+                break false;
+            }
+            if __r == __c {
+                break true;
+            }
+            __q += 1;
+        };
+        if !__hit {
+            break __i;
+        }
+        __p += 1;
+        __i += 1;
+    }
+}
+
+fn f18(a0: Ptr<u8>, a1: Ptr<u8>) -> Ptr<u8> {
+    let mut __p = a0.clone();
+    loop {
+        let mut __h = __p.clone();
+        let mut __n = a1.clone();
+        let __matched = loop {
+            let __c = __n.read();
+            if __c == 0 {
+                break true;
+            }
+            if __h.read() != __c {
+                break false;
+            }
+            __h += 1;
+            __n += 1;
+        };
+        if __matched {
+            break __p;
+        }
+        if __p.read() == 0 {
+            break Ptr::null();
+        }
+        __p += 1;
+    }
+}
+
+fn f21(a0: Ptr<u8>, a1: Ptr<u8>) -> Ptr<u8> {
+    let mut __p = a0.clone();
+    loop {
+        let __c = __p.read();
+        if __c == 0 {
+            break Ptr::null();
+        }
+        let mut __q = a1.clone();
+        let __hit = loop {
+            let __r = __q.read();
+            if __r == 0 {
+                break false;
+            }
+            if __r == __c {
+                break true;
+            }
+            __q += 1;
+        };
+        if __hit {
+            break __p;
+        }
+        __p += 1;
+    }
+}
+
+#[cfg(target_os = "linux")]
+fn f24(a0: AnyPtr, a1: i32, a2: usize) -> AnyPtr {
+    let mut __p = a0.reinterpret_cast::<u8>().offset(a2);
+    let mut __i: usize = a2;
+    loop {
+        if __i == 0 {
+            break Ptr::<u8>::null().to_any();
+        }
+        __p -= 1;
+        __i -= 1;
+        if __p.read() == a1 as u8 {
+            break __p.to_any();
+        }
+    }
+}
+
+fn f27(a0: Ptr<u8>, a1: Ptr<u8>) -> i32 {
+    let mut __p1 = a0.clone();
+    let mut __p2 = a1.clone();
+    loop {
+        let __c1 = __p1.read().to_ascii_lowercase();
+        let __c2 = __p2.read().to_ascii_lowercase();
+        if __c1 != __c2 {
+            break (__c1 as i32) - (__c2 as i32);
+        }
+        if __c1 == 0 {
+            break 0;
+        }
+        __p1 += 1;
+        __p2 += 1;
+    }
+}
+
+#[cfg(target_os = "linux")]
+fn f28(a0: i32, a1: Ptr<u8>, a2: usize) -> Ptr<u8> {
+    let __msg = std::io::Error::from_raw_os_error(a0).to_string();
+    let __len = __msg.len().min(a2.saturating_sub(1));
+    let mut __p = a1.clone();
+    for __i in 0..__len {
+        __p.write(__msg.as_bytes()[__i]);
+        __p += 1;
+    }
+    if a2 > 0 {
+        a1.offset(__len).write(0);
+    }
+    a1
+}
+
+#[cfg(target_os = "macos")]
+fn f28(a0: i32, a1: Ptr<u8>, a2: usize) -> i32 {
+    let __msg = std::io::Error::from_raw_os_error(a0).to_string();
+    let __len = __msg.len().min(a2.saturating_sub(1));
+    let mut __p = a1.clone();
+    for __i in 0..__len {
+        __p.write(__msg.as_bytes()[__i]);
+        __p += 1;
+    }
+    if a2 > 0 {
+        a1.offset(__len).write(0);
+    }
+    0
+}
+
+fn f6(a0: Ptr<u8>, a1: i32) -> Ptr<u8> {
+    let mut __p = a0.clone();
+    loop {
+        let __c = __p.read();
+        if __c == a1 as u8 {
+            break __p;
+        }
+        if __c == 0 {
+            break Ptr::null();
+        }
+        __p += 1;
+    }
+}
+
+fn f12(a0: AnyPtr, a1: i32, a2: usize) -> AnyPtr {
+    let mut __p = a0.reinterpret_cast::<u8>();
+    let mut __i: usize = 0;
+    loop {
+        if __i == a2 {
+            break Ptr::<u8>::null().to_any();
+        }
+        if __p.read() == a1 as u8 {
+            break __p.to_any();
+        }
+        __p += 1;
+        __i += 1;
+    }
+}
+
+fn f13(a0: Ptr<u8>, a1: i32) -> Ptr<u8> {
+    let mut __p = a0.clone();
+    let mut __found = Ptr::null();
+    loop {
+        let __c = __p.read();
+        if __c == a1 as u8 {
+            __found = __p.clone();
+        }
+        if __c == 0 {
+            break __found;
+        }
+        __p += 1;
+    }
+}
+
+fn f14(a0: Ptr<u8>, a1: i32) -> Ptr<u8> {
+    let mut __p = a0.clone();
+    let mut __found = Ptr::null();
+    loop {
+        let __c = __p.read();
+        if __c == a1 as u8 {
+            __found = __p.clone();
+        }
+        if __c == 0 {
+            break __found;
+        }
+        __p += 1;
+    }
+}
+
+fn f19(a0: Ptr<u8>, a1: Ptr<u8>) -> Ptr<u8> {
+    let mut __p = a0.clone();
+    loop {
+        let mut __h = __p.clone();
+        let mut __n = a1.clone();
+        let __matched = loop {
+            let __c = __n.read();
+            if __c == 0 {
+                break true;
+            }
+            if __h.read() != __c {
+                break false;
+            }
+            __h += 1;
+            __n += 1;
+        };
+        if __matched {
+            break __p;
+        }
+        if __p.read() == 0 {
+            break Ptr::null();
+        }
+        __p += 1;
+    }
+}
+
+fn f20(a0: Ptr<u8>, a1: Ptr<u8>) -> Ptr<u8> {
+    let mut __p = a0.clone();
+    loop {
+        let mut __h = __p.clone();
+        let mut __n = a1.clone();
+        let __matched = loop {
+            let __c = __n.read();
+            if __c == 0 {
+                break true;
+            }
+            if __h.read() != __c {
+                break false;
+            }
+            __h += 1;
+            __n += 1;
+        };
+        if __matched {
+            break __p;
+        }
+        if __p.read() == 0 {
+            break Ptr::null();
+        }
+        __p += 1;
+    }
+}
+
+fn f22(a0: Ptr<u8>, a1: Ptr<u8>) -> Ptr<u8> {
+    let mut __p = a0.clone();
+    loop {
+        let __c = __p.read();
+        if __c == 0 {
+            break Ptr::null();
+        }
+        let mut __q = a1.clone();
+        let __hit = loop {
+            let __r = __q.read();
+            if __r == 0 {
+                break false;
+            }
+            if __r == __c {
+                break true;
+            }
+            __q += 1;
+        };
+        if __hit {
+            break __p;
+        }
+        __p += 1;
+    }
+}
+
+fn f23(a0: Ptr<u8>, a1: Ptr<u8>) -> Ptr<u8> {
+    let mut __p = a0.clone();
+    loop {
+        let __c = __p.read();
+        if __c == 0 {
+            break Ptr::null();
+        }
+        let mut __q = a1.clone();
+        let __hit = loop {
+            let __r = __q.read();
+            if __r == 0 {
+                break false;
+            }
+            if __r == __c {
+                break true;
+            }
+            __q += 1;
+        };
+        if __hit {
+            break __p;
+        }
+        __p += 1;
+    }
+}
+
+#[cfg(target_os = "linux")]
+fn f25(a0: AnyPtr, a1: i32, a2: usize) -> AnyPtr {
+    let mut __p = a0.reinterpret_cast::<u8>().offset(a2);
+    let mut __i: usize = a2;
+    loop {
+        if __i == 0 {
+            break Ptr::<u8>::null().to_any();
+        }
+        __p -= 1;
+        __i -= 1;
+        if __p.read() == a1 as u8 {
+            break __p.to_any();
+        }
+    }
+}
+
+#[cfg(target_os = "linux")]
+fn f26(a0: AnyPtr, a1: i32, a2: usize) -> AnyPtr {
+    let mut __p = a0.reinterpret_cast::<u8>().offset(a2);
+    let mut __i: usize = a2;
+    loop {
+        if __i == 0 {
+            break Ptr::<u8>::null().to_any();
+        }
+        __p -= 1;
+        __i -= 1;
+        if __p.read() == a1 as u8 {
+            break __p.to_any();
+        }
+    }
 }
diff --git a/rules/src/modules.rs b/rules/src/modules.rs
index e873ed19..b60935e3 100644
--- a/rules/src/modules.rs
+++ b/rules/src/modules.rs
@@ -2,6 +2,8 @@
 pub mod algorithm_tgt_refcount;
 #[path = r#"../algorithm/tgt_unsafe.rs"#]
 pub mod algorithm_tgt_unsafe;
+#[path = r#"../arpa_inet/tgt_refcount.rs"#]
+pub mod arpa_inet_tgt_refcount;
 #[path = r#"../arpa_inet/tgt_unsafe.rs"#]
 pub mod arpa_inet_tgt_unsafe;
 #[path = r#"../array/tgt_refcount.rs"#]
diff --git a/tests/unit/cstring.cpp b/tests/unit/cstring.cpp
index e72c26df..a3434272 100644
--- a/tests/unit/cstring.cpp
+++ b/tests/unit/cstring.cpp
@@ -1,4 +1,3 @@
-// no-compile: refcount
 #define _GNU_SOURCE
 #include <cassert>
 #include <cstdlib>
diff --git a/tests/unit/inet_pton_ntop.c b/tests/unit/inet_pton_ntop.c
new file mode 100644
index 00000000..757c65ae
--- /dev/null
+++ b/tests/unit/inet_pton_ntop.c
@@ -0,0 +1,24 @@
+#include <arpa/inet.h>
+#include <assert.h>
+#include <string.h>
+
+int main(void) {
+  unsigned char buf[16];
+  assert(inet_pton(AF_INET, "1.2.3.4", buf) == 1);
+  assert(buf[0] == 1 && buf[1] == 2 && buf[2] == 3 && buf[3] == 4);
+  assert(inet_pton(AF_INET, "999.1.1.1", buf) == 0);
+  assert(inet_pton(AF_INET, "not an ip", buf) == 0);
+  assert(inet_pton(AF_INET6, "::1", buf) == 1);
+  assert(buf[0] == 0 && buf[15] == 1);
+  assert(inet_pton(AF_INET6, "2001:db8::5", buf) == 1);
+  assert(buf[0] == 0x20 && buf[1] == 0x01 && buf[15] == 5);
+
+  char text[64];
+  unsigned char four[4] = {10, 0, 0, 1};
+  assert(strcmp(inet_ntop(AF_INET, four, text, sizeof(text)), "10.0.0.1") == 0);
+  unsigned char sixteen[16] = {0};
+  sixteen[15] = 1;
+  assert(strcmp(inet_ntop(AF_INET6, sixteen, text, sizeof(text)), "::1") == 0);
+  assert(inet_ntop(AF_INET, four, text, 4) == 0);
+  return 0;
+}
diff --git a/tests/unit/out/refcount/cstring.rs b/tests/unit/out/refcount/cstring.rs
new file mode 100644
index 00000000..54061555
--- /dev/null
+++ b/tests/unit/out/refcount/cstring.rs
@@ -0,0 +1,1196 @@
+extern crate libcc2rs;
+use libcc2rs::*;
+use std::cell::RefCell;
+use std::collections::BTreeMap;
+use std::io::prelude::*;
+use std::io::{Read, Seek, Write};
+use std::os::fd::AsFd;
+use std::rc::{Rc, Weak};
+pub fn test_memcpy_0() {
+    let src: Value<Box<[u8]>> = Rc::new(RefCell::new(Box::from(*b"hello\0")));
+    let dst: Value<Box<[u8]>> = Rc::new(RefCell::new(Box::new([
+        0_u8,
+        <u8>::default(),
+        <u8>::default(),
+        <u8>::default(),
+        <u8>::default(),
+        <u8>::default(),
+    ])));
+    let r: Value<AnyPtr> = Rc::new(RefCell::new({
+        ((dst.as_pointer() as Ptr<u8>) as Ptr<u8>).to_any().memcpy(
+            &((src.as_pointer() as Ptr<u8>) as Ptr<u8>).to_any(),
+            6_usize as usize,
+        );
+        ((dst.as_pointer() as Ptr<u8>) as Ptr<u8>).to_any().clone()
+    }));
+    assert!({
+        let _lhs = (*r.borrow()).clone();
+        _lhs == ((dst.as_pointer() as Ptr<u8>) as Ptr<u8>).to_any()
+    });
+    assert!(
+        ((((*dst.borrow())[(0) as usize] as i32) == (('h' as u8) as i32))
+            && (((*dst.borrow())[(1) as usize] as i32) == (('e' as u8) as i32)))
+            && (((*dst.borrow())[(2) as usize] as i32) == (('l' as u8) as i32))
+    );
+    assert!(
+        ((((*dst.borrow())[(3) as usize] as i32) == (('l' as u8) as i32))
+            && (((*dst.borrow())[(4) as usize] as i32) == (('o' as u8) as i32)))
+            && (((*dst.borrow())[(5) as usize] as i32) == (('\0' as u8) as i32))
+    );
+}
+pub fn test_memset_1() {
+    let buf: Value<Box<[u8]>> = Rc::new(RefCell::new(
+        (0..4).map(|_| <u8>::default()).collect::<Box<[u8]>>(),
+    ));
+    let r: Value<AnyPtr> = Rc::new(RefCell::new({
+        ((buf.as_pointer() as Ptr<u8>) as Ptr<u8>)
+            .to_any()
+            .memset((('x' as u8) as i32) as u8, 4_usize as usize);
+        ((buf.as_pointer() as Ptr<u8>) as Ptr<u8>).to_any().clone()
+    }));
+    assert!({
+        let _lhs = (*r.borrow()).clone();
+        _lhs == ((buf.as_pointer() as Ptr<u8>) as Ptr<u8>).to_any()
+    });
+    assert!(
+        (((((*buf.borrow())[(0) as usize] as i32) == (('x' as u8) as i32))
+            && (((*buf.borrow())[(1) as usize] as i32) == (('x' as u8) as i32)))
+            && (((*buf.borrow())[(2) as usize] as i32) == (('x' as u8) as i32)))
+            && (((*buf.borrow())[(3) as usize] as i32) == (('x' as u8) as i32))
+    );
+}
+pub fn test_memcmp_2() {
+    let a: Value<Box<[u8]>> = Rc::new(RefCell::new(Box::new([1_u8, 2_u8, 3_u8, 4_u8])));
+    let b: Value<Box<[u8]>> = Rc::new(RefCell::new(Box::new([1_u8, 2_u8, 3_u8, 4_u8])));
+    let c: Value<Box<[u8]>> = Rc::new(RefCell::new(Box::new([1_u8, 2_u8, 9_u8, 4_u8])));
+    assert!(
+        (((a.as_pointer() as Ptr::<u8>) as Ptr::<u8>)
+            .to_any()
+            .memcmp(
+                &((b.as_pointer() as Ptr::<u8>) as Ptr::<u8>).to_any(),
+                4_usize
+            )
+            == 0)
+    );
+    assert!(
+        (((a.as_pointer() as Ptr::<u8>) as Ptr::<u8>)
+            .to_any()
+            .memcmp(
+                &((c.as_pointer() as Ptr::<u8>) as Ptr::<u8>).to_any(),
+                4_usize
+            )
+            < 0)
+    );
+    assert!(
+        (((c.as_pointer() as Ptr::<u8>) as Ptr::<u8>)
+            .to_any()
+            .memcmp(
+                &((a.as_pointer() as Ptr::<u8>) as Ptr::<u8>).to_any(),
+                4_usize
+            )
+            > 0)
+    );
+}
+pub fn test_memmove_3() {
+    let buf: Value<Box<[u8]>> = Rc::new(RefCell::new(Box::new([
+        ('a' as u8),
+        ('b' as u8),
+        ('c' as u8),
+        ('d' as u8),
+        ('e' as u8),
+        ('\0' as u8),
+    ])));
+    let r: Value<AnyPtr> = Rc::new(RefCell::new({
+        let mut __src = ((buf.as_pointer() as Ptr<u8>) as Ptr<u8>)
+            .to_any()
+            .reinterpret_cast::<u8>();
+        let mut __tmp: Vec<u8> = Vec::with_capacity(4_usize);
+        for _ in 0..4_usize {
+            __tmp.push(__src.read());
+            __src += 1;
+        }
+        let mut __dst = ((buf.as_pointer() as Ptr<u8>).offset((1) as isize) as Ptr<u8>)
+            .to_any()
+            .reinterpret_cast::<u8>();
+        for __i in 0..4_usize {
+            __dst.write(__tmp[__i]);
+            __dst += 1;
+        }
+        ((buf.as_pointer() as Ptr<u8>).offset((1) as isize) as Ptr<u8>)
+            .to_any()
+            .clone()
+    }));
+    assert!({
+        let _lhs = (*r.borrow()).clone();
+        _lhs == ((buf.as_pointer() as Ptr<u8>).offset((1) as isize) as Ptr<u8>).to_any()
+    });
+    assert!(
+        ((((*buf.borrow())[(0) as usize] as i32) == (('a' as u8) as i32))
+            && (((*buf.borrow())[(1) as usize] as i32) == (('a' as u8) as i32)))
+            && (((*buf.borrow())[(2) as usize] as i32) == (('b' as u8) as i32))
+    );
+    assert!(
+        ((((*buf.borrow())[(3) as usize] as i32) == (('c' as u8) as i32))
+            && (((*buf.borrow())[(4) as usize] as i32) == (('d' as u8) as i32)))
+            && (((*buf.borrow())[(5) as usize] as i32) == (('\0' as u8) as i32))
+    );
+}
+pub fn test_strchr_4() {
+    let s: Value<Ptr<u8>> = Rc::new(RefCell::new(Ptr::from_string_literal(b"hello world")));
+    let r: Value<Ptr<u8>> = Rc::new(RefCell::new({
+        let mut __p = (*s.borrow()).clone();
+        loop {
+            let __c = __p.read();
+            if __c == (('w' as u8) as i32) as u8 {
+                break __p;
+            }
+            if __c == 0 {
+                break Ptr::null();
+            }
+            __p += 1;
+        }
+    }));
+    assert!(!((*r.borrow()).is_null()));
+    assert!(((((*r.borrow()).read()) as i32) == (('w' as u8) as i32)));
+    assert!(
+        ({
+            let mut __p = (*s.borrow()).clone();
+            loop {
+                let __c = __p.read();
+                if __c == (('z' as u8) as i32) as u8 {
+                    break __p;
+                }
+                if __c == 0 {
+                    break Ptr::null();
+                }
+                __p += 1;
+            }
+        })
+        .is_null()
+    );
+}
+pub fn test_strlen_5() {
+    assert!(
+        ({
+            let mut __p = Ptr::from_string_literal(b"").clone();
+            let mut __i: usize = 0;
+            while __p.read() != 0 {
+                __p += 1;
+                __i += 1;
+            }
+            __i
+        } == 0_usize)
+    );
+    assert!(
+        ({
+            let mut __p = Ptr::from_string_literal(b"hello").clone();
+            let mut __i: usize = 0;
+            while __p.read() != 0 {
+                __p += 1;
+                __i += 1;
+            }
+            __i
+        } == 5_usize)
+    );
+    assert!(
+        ({
+            let mut __p = Ptr::from_string_literal(b"hello world").clone();
+            let mut __i: usize = 0;
+            while __p.read() != 0 {
+                __p += 1;
+                __i += 1;
+            }
+            __i
+        } == 11_usize)
+    );
+}
+pub fn test_strcmp_6() {
+    assert!(
+        ({
+            let mut __p1 = Ptr::from_string_literal(b"abc").clone();
+            let mut __p2 = Ptr::from_string_literal(b"abc").clone();
+            loop {
+                let __c1 = __p1.read();
+                let __c2 = __p2.read();
+                if __c1 != __c2 {
+                    break (__c1 as i32) - (__c2 as i32);
+                }
+                if __c1 == 0 {
+                    break 0;
+                }
+                __p1 += 1;
+                __p2 += 1;
+            }
+        } == 0)
+    );
+    assert!(
+        ({
+            let mut __p1 = Ptr::from_string_literal(b"abc").clone();
+            let mut __p2 = Ptr::from_string_literal(b"abd").clone();
+            loop {
+                let __c1 = __p1.read();
+                let __c2 = __p2.read();
+                if __c1 != __c2 {
+                    break (__c1 as i32) - (__c2 as i32);
+                }
+                if __c1 == 0 {
+                    break 0;
+                }
+                __p1 += 1;
+                __p2 += 1;
+            }
+        } < 0)
+    );
+    assert!(
+        ({
+            let mut __p1 = Ptr::from_string_literal(b"abd").clone();
+            let mut __p2 = Ptr::from_string_literal(b"abc").clone();
+            loop {
+                let __c1 = __p1.read();
+                let __c2 = __p2.read();
+                if __c1 != __c2 {
+                    break (__c1 as i32) - (__c2 as i32);
+                }
+                if __c1 == 0 {
+                    break 0;
+                }
+                __p1 += 1;
+                __p2 += 1;
+            }
+        } > 0)
+    );
+    let p: Value<Ptr<u8>> = Rc::new(RefCell::new(Ptr::from_string_literal(b"abc")));
+    let q: Value<Ptr<u8>> = Rc::new(RefCell::new(Ptr::from_string_literal(b"abd")));
+    let buf: Value<Box<[u8]>> = Rc::new(RefCell::new(Box::new([
+        ('a' as u8),
+        ('b' as u8),
+        ('c' as u8),
+        ('\0' as u8),
+    ])));
+    assert!(
+        ({
+            let mut __p1 = (*p.borrow()).clone();
+            let mut __p2 = (*p.borrow()).clone();
+            loop {
+                let __c1 = __p1.read();
+                let __c2 = __p2.read();
+                if __c1 != __c2 {
+                    break (__c1 as i32) - (__c2 as i32);
+                }
+                if __c1 == 0 {
+                    break 0;
+                }
+                __p1 += 1;
+                __p2 += 1;
+            }
+        } == 0)
+    );
+    assert!(
+        ({
+            let mut __p1 = (*p.borrow()).clone();
+            let mut __p2 = (*q.borrow()).clone();
+            loop {
+                let __c1 = __p1.read();
+                let __c2 = __p2.read();
+                if __c1 != __c2 {
+                    break (__c1 as i32) - (__c2 as i32);
+                }
+                if __c1 == 0 {
+                    break 0;
+                }
+                __p1 += 1;
+                __p2 += 1;
+            }
+        } < 0)
+    );
+    assert!(
+        ({
+            let mut __p1 = (buf.as_pointer() as Ptr<u8>).clone();
+            let mut __p2 = (*p.borrow()).clone();
+            loop {
+                let __c1 = __p1.read();
+                let __c2 = __p2.read();
+                if __c1 != __c2 {
+                    break (__c1 as i32) - (__c2 as i32);
+                }
+                if __c1 == 0 {
+                    break 0;
+                }
+                __p1 += 1;
+                __p2 += 1;
+            }
+        } == 0)
+    );
+}
+pub fn test_strncmp_7() {
+    assert!(
+        ({
+            let mut __p1 = Ptr::from_string_literal(b"abcdef").clone();
+            let mut __p2 = Ptr::from_string_literal(b"abcxyz").clone();
+            let mut __i: usize = 0;
+            loop {
+                if __i == 3_usize {
+                    break 0;
+                }
+                let __c1 = __p1.read();
+                let __c2 = __p2.read();
+                if __c1 != __c2 {
+                    break (__c1 as i32) - (__c2 as i32);
+                }
+                if __c1 == 0 {
+                    break 0;
+                }
+                __p1 += 1;
+                __p2 += 1;
+                __i += 1;
+            }
+        } == 0)
+    );
+    assert!(
+        ({
+            let mut __p1 = Ptr::from_string_literal(b"abcdef").clone();
+            let mut __p2 = Ptr::from_string_literal(b"abcxyz").clone();
+            let mut __i: usize = 0;
+            loop {
+                if __i == 4_usize {
+                    break 0;
+                }
+                let __c1 = __p1.read();
+                let __c2 = __p2.read();
+                if __c1 != __c2 {
+                    break (__c1 as i32) - (__c2 as i32);
+                }
+                if __c1 == 0 {
+                    break 0;
+                }
+                __p1 += 1;
+                __p2 += 1;
+                __i += 1;
+            }
+        } < 0)
+    );
+    assert!(
+        ({
+            let mut __p1 = Ptr::from_string_literal(b"abcxyz").clone();
+            let mut __p2 = Ptr::from_string_literal(b"abcdef").clone();
+            let mut __i: usize = 0;
+            loop {
+                if __i == 4_usize {
+                    break 0;
+                }
+                let __c1 = __p1.read();
+                let __c2 = __p2.read();
+                if __c1 != __c2 {
+                    break (__c1 as i32) - (__c2 as i32);
+                }
+                if __c1 == 0 {
+                    break 0;
+                }
+                __p1 += 1;
+                __p2 += 1;
+                __i += 1;
+            }
+        } > 0)
+    );
+    let p: Value<Ptr<u8>> = Rc::new(RefCell::new(Ptr::from_string_literal(b"abcdef")));
+    let q: Value<Ptr<u8>> = Rc::new(RefCell::new(Ptr::from_string_literal(b"abcxyz")));
+    let buf: Value<Box<[u8]>> = Rc::new(RefCell::new(Box::new([
+        ('a' as u8),
+        ('b' as u8),
+        ('c' as u8),
+        ('d' as u8),
+        ('e' as u8),
+        ('f' as u8),
+        ('\0' as u8),
+    ])));
+    let n: Value<usize> = Rc::new(RefCell::new(3_usize));
+    assert!(
+        ({
+            let mut __p1 = (*p.borrow()).clone();
+            let mut __p2 = (*q.borrow()).clone();
+            let mut __i: usize = 0;
+            loop {
+                if __i == (*n.borrow()) {
+                    break 0;
+                }
+                let __c1 = __p1.read();
+                let __c2 = __p2.read();
+                if __c1 != __c2 {
+                    break (__c1 as i32) - (__c2 as i32);
+                }
+                if __c1 == 0 {
+                    break 0;
+                }
+                __p1 += 1;
+                __p2 += 1;
+                __i += 1;
+            }
+        } == 0)
+    );
+    assert!(
+        ({
+            let mut __p1 = (*p.borrow()).clone();
+            let mut __p2 = (*q.borrow()).clone();
+            let mut __i: usize = 0;
+            loop {
+                if __i == (*n.borrow()).wrapping_add(1_usize) {
+                    break 0;
+                }
+                let __c1 = __p1.read();
+                let __c2 = __p2.read();
+                if __c1 != __c2 {
+                    break (__c1 as i32) - (__c2 as i32);
+                }
+                if __c1 == 0 {
+                    break 0;
+                }
+                __p1 += 1;
+                __p2 += 1;
+                __i += 1;
+            }
+        } < 0)
+    );
+    assert!(
+        ({
+            let mut __p1 = (buf.as_pointer() as Ptr<u8>).clone();
+            let mut __p2 = (*p.borrow()).clone();
+            let mut __i: usize = 0;
+            loop {
+                if __i == 6_usize {
+                    break 0;
+                }
+                let __c1 = __p1.read();
+                let __c2 = __p2.read();
+                if __c1 != __c2 {
+                    break (__c1 as i32) - (__c2 as i32);
+                }
+                if __c1 == 0 {
+                    break 0;
+                }
+                __p1 += 1;
+                __p2 += 1;
+                __i += 1;
+            }
+        } == 0)
+    );
+}
+pub fn test_memchr_8() {
+    let data: Value<Box<[u8]>> = Rc::new(RefCell::new(Box::new([16_u8, 32_u8, 48_u8, 64_u8])));
+    let r: Value<AnyPtr> = Rc::new(RefCell::new({
+        let mut __p = ((data.as_pointer() as Ptr<u8>) as Ptr<u8>)
+            .to_any()
+            .reinterpret_cast::<u8>();
+        let mut __i: usize = 0;
+        loop {
+            if __i == 4_usize {
+                break Ptr::<u8>::null().to_any();
+            }
+            if __p.read() == 48 as u8 {
+                break __p.to_any();
+            }
+            __p += 1;
+            __i += 1;
+        }
+    }));
+    assert!({
+        let _lhs = (*r.borrow()).clone();
+        _lhs == (((data.as_pointer() as Ptr<u8>).offset(2)) as Ptr<u8>).to_any()
+    });
+    assert!(
+        ({
+            let mut __p = ((data.as_pointer() as Ptr<u8>) as Ptr<u8>)
+                .to_any()
+                .reinterpret_cast::<u8>();
+            let mut __i: usize = 0;
+            loop {
+                if __i == 4_usize {
+                    break Ptr::<u8>::null().to_any();
+                }
+                if __p.read() == 153 as u8 {
+                    break __p.to_any();
+                }
+                __p += 1;
+                __i += 1;
+            }
+        })
+        .is_null()
+    );
+    let p: Value<AnyPtr> = Rc::new(RefCell::new(
+        ((data.as_pointer() as Ptr<u8>) as Ptr<u8>).to_any(),
+    ));
+    let n: Value<usize> = Rc::new(RefCell::new(4_usize));
+    assert!({
+        let _lhs = {
+            let mut __p = (*p.borrow()).reinterpret_cast::<u8>();
+            let mut __i: usize = 0;
+            loop {
+                if __i == (*n.borrow()) {
+                    break Ptr::<u8>::null().to_any();
+                }
+                if __p.read() == 16 as u8 {
+                    break __p.to_any();
+                }
+                __p += 1;
+                __i += 1;
+            }
+        };
+        _lhs == (*p.borrow()).clone()
+    });
+}
+pub fn test_strrchr_9() {
+    let s: Value<Ptr<u8>> = Rc::new(RefCell::new(Ptr::from_string_literal(b"hello world")));
+    let r: Value<Ptr<u8>> = Rc::new(RefCell::new({
+        let mut __p = (*s.borrow()).clone();
+        let mut __found = Ptr::null();
+        loop {
+            let __c = __p.read();
+            if __c == (('l' as u8) as i32) as u8 {
+                __found = __p.clone();
+            }
+            if __c == 0 {
+                break __found;
+            }
+            __p += 1;
+        }
+    }));
+    assert!(!((*r.borrow()).is_null()));
+    assert!(((((*r.borrow()).read()) as i32) == (('l' as u8) as i32)));
+    assert!({
+        let _lhs = (*r.borrow()).clone();
+        _lhs == (*s.borrow()).offset((9) as isize)
+    });
+    assert!(
+        ({
+            let mut __p = (*s.borrow()).clone();
+            let mut __found = Ptr::null();
+            loop {
+                let __c = __p.read();
+                if __c == (('z' as u8) as i32) as u8 {
+                    __found = __p.clone();
+                }
+                if __c == 0 {
+                    break __found;
+                }
+                __p += 1;
+            }
+        })
+        .is_null()
+    );
+    let buf: Value<Box<[u8]>> = Rc::new(RefCell::new(Box::new([
+        ('a' as u8),
+        ('b' as u8),
+        ('a' as u8),
+        ('\0' as u8),
+    ])));
+    assert!(
+        ({
+            let mut __p = (buf.as_pointer() as Ptr<u8>).clone();
+            let mut __found = Ptr::null();
+            loop {
+                let __c = __p.read();
+                if __c == (('a' as u8) as i32) as u8 {
+                    __found = __p.clone();
+                }
+                if __c == 0 {
+                    break __found;
+                }
+                __p += 1;
+            }
+        } == ((buf.as_pointer() as Ptr<u8>).offset(2)))
+    );
+}
+pub fn test_strdup_10() {
+    let d: Value<Ptr<u8>> = Rc::new(RefCell::new(libcc2rs::strdup_refcount(
+        Ptr::from_string_literal(b"hello").clone(),
+    )));
+    assert!(!((*d.borrow()).is_null()));
+    assert!(
+        ({
+            let mut __p1 = (*d.borrow()).clone();
+            let mut __p2 = Ptr::from_string_literal(b"hello").clone();
+            loop {
+                let __c1 = __p1.read();
+                let __c2 = __p2.read();
+                if __c1 != __c2 {
+                    break (__c1 as i32) - (__c2 as i32);
+                }
+                if __c1 == 0 {
+                    break 0;
+                }
+                __p1 += 1;
+                __p2 += 1;
+            }
+        } == 0)
+    );
+    libcc2rs::free_refcount(((*d.borrow()).clone() as Ptr<u8>).to_any());
+    let p: Value<Ptr<u8>> = Rc::new(RefCell::new(Ptr::from_string_literal(b"world")));
+    let buf: Value<Box<[u8]>> = Rc::new(RefCell::new(Box::new([
+        ('a' as u8),
+        ('b' as u8),
+        ('c' as u8),
+        ('\0' as u8),
+    ])));
+    let d2: Value<Ptr<u8>> = Rc::new(RefCell::new(libcc2rs::strdup_refcount(
+        (*p.borrow()).clone(),
+    )));
+    assert!(!((*d2.borrow()).is_null()));
+    assert!(
+        ({
+            let mut __p1 = (*d2.borrow()).clone();
+            let mut __p2 = (*p.borrow()).clone();
+            loop {
+                let __c1 = __p1.read();
+                let __c2 = __p2.read();
+                if __c1 != __c2 {
+                    break (__c1 as i32) - (__c2 as i32);
+                }
+                if __c1 == 0 {
+                    break 0;
+                }
+                __p1 += 1;
+                __p2 += 1;
+            }
+        } == 0)
+    );
+    libcc2rs::free_refcount(((*d2.borrow()).clone() as Ptr<u8>).to_any());
+    let d3: Value<Ptr<u8>> = Rc::new(RefCell::new(libcc2rs::strdup_refcount(
+        (buf.as_pointer() as Ptr<u8>).clone(),
+    )));
+    assert!(!((*d3.borrow()).is_null()));
+    assert!(
+        ({
+            let mut __p1 = (*d3.borrow()).clone();
+            let mut __p2 = (buf.as_pointer() as Ptr<u8>).clone();
+            loop {
+                let __c1 = __p1.read();
+                let __c2 = __p2.read();
+                if __c1 != __c2 {
+                    break (__c1 as i32) - (__c2 as i32);
+                }
+                if __c1 == 0 {
+                    break 0;
+                }
+                __p1 += 1;
+                __p2 += 1;
+            }
+        } == 0)
+    );
+    libcc2rs::free_refcount(((*d3.borrow()).clone() as Ptr<u8>).to_any());
+}
+pub fn test_strcspn_11() {
+    assert!(
+        ({
+            let mut __p = Ptr::from_string_literal(b"hello").clone();
+            let mut __i: usize = 0;
+            loop {
+                let __c = __p.read();
+                if __c == 0 {
+                    break __i;
+                }
+                let mut __q = Ptr::from_string_literal(b"el").clone();
+                let __hit = loop {
+                    let __r = __q.read();
+                    if __r == 0 {
+                        break false;
+                    }
+                    if __r == __c {
+                        break true;
+                    }
+                    __q += 1;
+                };
+                if __hit {
+                    break __i;
+                }
+                __p += 1;
+                __i += 1;
+            }
+        } == 1_usize)
+    );
+    assert!(
+        ({
+            let mut __p = Ptr::from_string_literal(b"abc").clone();
+            let mut __i: usize = 0;
+            loop {
+                let __c = __p.read();
+                if __c == 0 {
+                    break __i;
+                }
+                let mut __q = Ptr::from_string_literal(b"xyz").clone();
+                let __hit = loop {
+                    let __r = __q.read();
+                    if __r == 0 {
+                        break false;
+                    }
+                    if __r == __c {
+                        break true;
+                    }
+                    __q += 1;
+                };
+                if __hit {
+                    break __i;
+                }
+                __p += 1;
+                __i += 1;
+            }
+        } == 3_usize)
+    );
+    assert!(
+        ({
+            let mut __p = Ptr::from_string_literal(b"").clone();
+            let mut __i: usize = 0;
+            loop {
+                let __c = __p.read();
+                if __c == 0 {
+                    break __i;
+                }
+                let mut __q = Ptr::from_string_literal(b"abc").clone();
+                let __hit = loop {
+                    let __r = __q.read();
+                    if __r == 0 {
+                        break false;
+                    }
+                    if __r == __c {
+                        break true;
+                    }
+                    __q += 1;
+                };
+                if __hit {
+                    break __i;
+                }
+                __p += 1;
+                __i += 1;
+            }
+        } == 0_usize)
+    );
+    let s: Value<Ptr<u8>> = Rc::new(RefCell::new(Ptr::from_string_literal(b"hello")));
+    let rej: Value<Ptr<u8>> = Rc::new(RefCell::new(Ptr::from_string_literal(b"el")));
+    assert!(
+        ({
+            let mut __p = (*s.borrow()).clone();
+            let mut __i: usize = 0;
+            loop {
+                let __c = __p.read();
+                if __c == 0 {
+                    break __i;
+                }
+                let mut __q = (*rej.borrow()).clone();
+                let __hit = loop {
+                    let __r = __q.read();
+                    if __r == 0 {
+                        break false;
+                    }
+                    if __r == __c {
+                        break true;
+                    }
+                    __q += 1;
+                };
+                if __hit {
+                    break __i;
+                }
+                __p += 1;
+                __i += 1;
+            }
+        } == 1_usize)
+    );
+}
+pub fn test_strspn_12() {
+    assert!(
+        ({
+            let mut __p = Ptr::from_string_literal(b"hello").clone();
+            let mut __i: usize = 0;
+            loop {
+                let __c = __p.read();
+                if __c == 0 {
+                    break __i;
+                }
+                let mut __q = Ptr::from_string_literal(b"hel").clone();
+                let __hit = loop {
+                    let __r = __q.read();
+                    if __r == 0 {
+                        break false;
+                    }
+                    if __r == __c {
+                        break true;
+                    }
+                    __q += 1;
+                };
+                if !__hit {
+                    break __i;
+                }
+                __p += 1;
+                __i += 1;
+            }
+        } == 4_usize)
+    );
+    assert!(
+        ({
+            let mut __p = Ptr::from_string_literal(b"abc").clone();
+            let mut __i: usize = 0;
+            loop {
+                let __c = __p.read();
+                if __c == 0 {
+                    break __i;
+                }
+                let mut __q = Ptr::from_string_literal(b"xyz").clone();
+                let __hit = loop {
+                    let __r = __q.read();
+                    if __r == 0 {
+                        break false;
+                    }
+                    if __r == __c {
+                        break true;
+                    }
+                    __q += 1;
+                };
+                if !__hit {
+                    break __i;
+                }
+                __p += 1;
+                __i += 1;
+            }
+        } == 0_usize)
+    );
+    assert!(
+        ({
+            let mut __p = Ptr::from_string_literal(b"aaa").clone();
+            let mut __i: usize = 0;
+            loop {
+                let __c = __p.read();
+                if __c == 0 {
+                    break __i;
+                }
+                let mut __q = Ptr::from_string_literal(b"a").clone();
+                let __hit = loop {
+                    let __r = __q.read();
+                    if __r == 0 {
+                        break false;
+                    }
+                    if __r == __c {
+                        break true;
+                    }
+                    __q += 1;
+                };
+                if !__hit {
+                    break __i;
+                }
+                __p += 1;
+                __i += 1;
+            }
+        } == 3_usize)
+    );
+    let s: Value<Ptr<u8>> = Rc::new(RefCell::new(Ptr::from_string_literal(b"hello")));
+    let acc: Value<Ptr<u8>> = Rc::new(RefCell::new(Ptr::from_string_literal(b"hel")));
+    assert!(
+        ({
+            let mut __p = (*s.borrow()).clone();
+            let mut __i: usize = 0;
+            loop {
+                let __c = __p.read();
+                if __c == 0 {
+                    break __i;
+                }
+                let mut __q = (*acc.borrow()).clone();
+                let __hit = loop {
+                    let __r = __q.read();
+                    if __r == 0 {
+                        break false;
+                    }
+                    if __r == __c {
+                        break true;
+                    }
+                    __q += 1;
+                };
+                if !__hit {
+                    break __i;
+                }
+                __p += 1;
+                __i += 1;
+            }
+        } == 4_usize)
+    );
+}
+pub fn test_strstr_13() {
+    let h: Value<Ptr<u8>> = Rc::new(RefCell::new(Ptr::from_string_literal(b"hello world")));
+    let r: Value<Ptr<u8>> = Rc::new(RefCell::new({
+        let mut __p = (*h.borrow()).clone();
+        loop {
+            let mut __h = __p.clone();
+            let mut __n = Ptr::from_string_literal(b"world").clone();
+            let __matched = loop {
+                let __c = __n.read();
+                if __c == 0 {
+                    break true;
+                }
+                if __h.read() != __c {
+                    break false;
+                }
+                __h += 1;
+                __n += 1;
+            };
+            if __matched {
+                break __p;
+            }
+            if __p.read() == 0 {
+                break Ptr::null();
+            }
+            __p += 1;
+        }
+    }));
+    assert!(!((*r.borrow()).is_null()));
+    assert!({
+        let _lhs = (*r.borrow()).clone();
+        _lhs == (*h.borrow()).offset((6) as isize)
+    });
+    assert!(
+        ({
+            let mut __p = (*h.borrow()).clone();
+            loop {
+                let mut __h = __p.clone();
+                let mut __n = Ptr::from_string_literal(b"xyz").clone();
+                let __matched = loop {
+                    let __c = __n.read();
+                    if __c == 0 {
+                        break true;
+                    }
+                    if __h.read() != __c {
+                        break false;
+                    }
+                    __h += 1;
+                    __n += 1;
+                };
+                if __matched {
+                    break __p;
+                }
+                if __p.read() == 0 {
+                    break Ptr::null();
+                }
+                __p += 1;
+            }
+        })
+        .is_null()
+    );
+    let buf: Value<Box<[u8]>> = Rc::new(RefCell::new(Box::new([
+        ('h' as u8),
+        ('e' as u8),
+        ('l' as u8),
+        ('l' as u8),
+        ('o' as u8),
+        ('\0' as u8),
+    ])));
+    assert!(
+        ({
+            let mut __p = (buf.as_pointer() as Ptr<u8>).clone();
+            loop {
+                let mut __h = __p.clone();
+                let mut __n = Ptr::from_string_literal(b"ll").clone();
+                let __matched = loop {
+                    let __c = __n.read();
+                    if __c == 0 {
+                        break true;
+                    }
+                    if __h.read() != __c {
+                        break false;
+                    }
+                    __h += 1;
+                    __n += 1;
+                };
+                if __matched {
+                    break __p;
+                }
+                if __p.read() == 0 {
+                    break Ptr::null();
+                }
+                __p += 1;
+            }
+        } == ((buf.as_pointer() as Ptr<u8>).offset(2)))
+    );
+}
+pub fn test_strpbrk_14() {
+    let s: Value<Ptr<u8>> = Rc::new(RefCell::new(Ptr::from_string_literal(b"hello world")));
+    let r: Value<Ptr<u8>> = Rc::new(RefCell::new({
+        let mut __p = (*s.borrow()).clone();
+        loop {
+            let __c = __p.read();
+            if __c == 0 {
+                break Ptr::null();
+            }
+            let mut __q = Ptr::from_string_literal(b"wo").clone();
+            let __hit = loop {
+                let __r = __q.read();
+                if __r == 0 {
+                    break false;
+                }
+                if __r == __c {
+                    break true;
+                }
+                __q += 1;
+            };
+            if __hit {
+                break __p;
+            }
+            __p += 1;
+        }
+    }));
+    assert!(!((*r.borrow()).is_null()));
+    assert!({
+        let _lhs = (*r.borrow()).clone();
+        _lhs == (*s.borrow()).offset((4) as isize)
+    });
+    assert!(
+        ({
+            let mut __p = (*s.borrow()).clone();
+            loop {
+                let __c = __p.read();
+                if __c == 0 {
+                    break Ptr::null();
+                }
+                let mut __q = Ptr::from_string_literal(b"xyz").clone();
+                let __hit = loop {
+                    let __r = __q.read();
+                    if __r == 0 {
+                        break false;
+                    }
+                    if __r == __c {
+                        break true;
+                    }
+                    __q += 1;
+                };
+                if __hit {
+                    break __p;
+                }
+                __p += 1;
+            }
+        })
+        .is_null()
+    );
+    let buf: Value<Box<[u8]>> = Rc::new(RefCell::new(Box::new([
+        ('a' as u8),
+        ('b' as u8),
+        ('c' as u8),
+        ('\0' as u8),
+    ])));
+    assert!(
+        ({
+            let mut __p = (buf.as_pointer() as Ptr<u8>).clone();
+            loop {
+                let __c = __p.read();
+                if __c == 0 {
+                    break Ptr::null();
+                }
+                let mut __q = Ptr::from_string_literal(b"b").clone();
+                let __hit = loop {
+                    let __r = __q.read();
+                    if __r == 0 {
+                        break false;
+                    }
+                    if __r == __c {
+                        break true;
+                    }
+                    __q += 1;
+                };
+                if __hit {
+                    break __p;
+                }
+                __p += 1;
+            }
+        } == ((buf.as_pointer() as Ptr<u8>).offset(1)))
+    );
+}
+pub fn test_strcasecmp_15() {
+    assert!(
+        ({
+            let mut __p1 = Ptr::from_string_literal(b"HELLO").clone();
+            let mut __p2 = Ptr::from_string_literal(b"hello").clone();
+            loop {
+                let __c1 = __p1.read().to_ascii_lowercase();
+                let __c2 = __p2.read().to_ascii_lowercase();
+                if __c1 != __c2 {
+                    break (__c1 as i32) - (__c2 as i32);
+                }
+                if __c1 == 0 {
+                    break 0;
+                }
+                __p1 += 1;
+                __p2 += 1;
+            }
+        } == 0)
+    );
+    assert!(
+        ({
+            let mut __p1 = Ptr::from_string_literal(b"abc").clone();
+            let mut __p2 = Ptr::from_string_literal(b"abd").clone();
+            loop {
+                let __c1 = __p1.read().to_ascii_lowercase();
+                let __c2 = __p2.read().to_ascii_lowercase();
+                if __c1 != __c2 {
+                    break (__c1 as i32) - (__c2 as i32);
+                }
+                if __c1 == 0 {
+                    break 0;
+                }
+                __p1 += 1;
+                __p2 += 1;
+            }
+        } < 0)
+    );
+    assert!(
+        ({
+            let mut __p1 = Ptr::from_string_literal(b"abd").clone();
+            let mut __p2 = Ptr::from_string_literal(b"abc").clone();
+            loop {
+                let __c1 = __p1.read().to_ascii_lowercase();
+                let __c2 = __p2.read().to_ascii_lowercase();
+                if __c1 != __c2 {
+                    break (__c1 as i32) - (__c2 as i32);
+                }
+                if __c1 == 0 {
+                    break 0;
+                }
+                __p1 += 1;
+                __p2 += 1;
+            }
+        } > 0)
+    );
+    let p: Value<Ptr<u8>> = Rc::new(RefCell::new(Ptr::from_string_literal(b"FOO")));
+    let q: Value<Ptr<u8>> = Rc::new(RefCell::new(Ptr::from_string_literal(b"foo")));
+    assert!(
+        ({
+            let mut __p1 = (*p.borrow()).clone();
+            let mut __p2 = (*q.borrow()).clone();
+            loop {
+                let __c1 = __p1.read().to_ascii_lowercase();
+                let __c2 = __p2.read().to_ascii_lowercase();
+                if __c1 != __c2 {
+                    break (__c1 as i32) - (__c2 as i32);
+                }
+                if __c1 == 0 {
+                    break 0;
+                }
+                __p1 += 1;
+                __p2 += 1;
+            }
+        } == 0)
+    );
+}
+pub fn main() {
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    ({ test_memcpy_0() });
+    ({ test_memset_1() });
+    ({ test_memcmp_2() });
+    ({ test_memmove_3() });
+    ({ test_strchr_4() });
+    ({ test_strlen_5() });
+    ({ test_strcmp_6() });
+    ({ test_strncmp_7() });
+    ({ test_memchr_8() });
+    ({ test_strrchr_9() });
+    ({ test_strdup_10() });
+    ({ test_strcspn_11() });
+    ({ test_strspn_12() });
+    ({ test_strstr_13() });
+    ({ test_strpbrk_14() });
+    ({ test_strcasecmp_15() });
+    return 0;
+}
diff --git a/tests/unit/out/refcount/errno.rs b/tests/unit/out/refcount/errno.rs
index 653f5b96..5960da10 100644
--- a/tests/unit/out/refcount/errno.rs
+++ b/tests/unit/out/refcount/errno.rs
@@ -18,7 +18,7 @@ pub fn test_errno_0() {
 pub fn test_errno_preserved_across_strdup_1() {
     libcc2rs::cpp2rust_errno().write(99);
     let d: Value<Ptr<u8>> = Rc::new(RefCell::new(libcc2rs::strdup_refcount(
-        Ptr::from_string_literal(b"hello"),
+        Ptr::from_string_literal(b"hello").clone(),
     )));
     assert!((((!((*d.borrow()).is_null())) as i32) != 0));
     assert!(((((libcc2rs::cpp2rust_errno().read()) == 99) as i32) != 0));
diff --git a/tests/unit/out/refcount/inet_pton_ntop.rs b/tests/unit/out/refcount/inet_pton_ntop.rs
new file mode 100644
index 00000000..6df25d74
--- /dev/null
+++ b/tests/unit/out/refcount/inet_pton_ntop.rs
@@ -0,0 +1,429 @@
+extern crate libcc2rs;
+use libcc2rs::*;
+use std::cell::RefCell;
+use std::collections::BTreeMap;
+use std::io::prelude::*;
+use std::io::{Read, Seek, Write};
+use std::os::fd::AsFd;
+use std::rc::{Rc, Weak};
+pub fn main() {
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    let buf: Value<Box<[u8]>> = Rc::new(RefCell::new(
+        (0..16).map(|_| <u8>::default()).collect::<Box<[u8]>>(),
+    ));
+    assert!(
+        (((if 2 == libc::AF_INET {
+            match Ptr::from_string_literal(b"1.2.3.4")
+                .to_rust_string()
+                .parse::<std::net::Ipv4Addr>()
+            {
+                Ok(__ip) => {
+                    let __octets = __ip.octets();
+                    for __i in 0..4 {
+                        ((buf.as_pointer() as Ptr<u8>) as Ptr<u8>)
+                            .to_any()
+                            .reinterpret_cast::<u8>()
+                            .offset(__i)
+                            .write(__octets[__i]);
+                    }
+                    1
+                }
+                Err(_) => 0,
+            }
+        } else if 2 == libc::AF_INET6 {
+            match Ptr::from_string_literal(b"1.2.3.4")
+                .to_rust_string()
+                .parse::<std::net::Ipv6Addr>()
+            {
+                Ok(__ip) => {
+                    let __octets = __ip.octets();
+                    for __i in 0..16 {
+                        ((buf.as_pointer() as Ptr<u8>) as Ptr<u8>)
+                            .to_any()
+                            .reinterpret_cast::<u8>()
+                            .offset(__i)
+                            .write(__octets[__i]);
+                    }
+                    1
+                }
+                Err(_) => 0,
+            }
+        } else {
+            -1
+        } == 1) as i32)
+            != 0)
+    );
+    assert!(
+        ((((((((((((((*buf.borrow())[(0) as usize] as i32) == 1) as i32) != 0)
+            && (((((*buf.borrow())[(1) as usize] as i32) == 2) as i32) != 0))
+            as i32)
+            != 0)
+            && (((((*buf.borrow())[(2) as usize] as i32) == 3) as i32) != 0)) as i32)
+            != 0)
+            && (((((*buf.borrow())[(3) as usize] as i32) == 4) as i32) != 0)) as i32)
+            != 0)
+    );
+    assert!(
+        (((if 2 == libc::AF_INET {
+            match Ptr::from_string_literal(b"999.1.1.1")
+                .to_rust_string()
+                .parse::<std::net::Ipv4Addr>()
+            {
+                Ok(__ip) => {
+                    let __octets = __ip.octets();
+                    for __i in 0..4 {
+                        ((buf.as_pointer() as Ptr<u8>) as Ptr<u8>)
+                            .to_any()
+                            .reinterpret_cast::<u8>()
+                            .offset(__i)
+                            .write(__octets[__i]);
+                    }
+                    1
+                }
+                Err(_) => 0,
+            }
+        } else if 2 == libc::AF_INET6 {
+            match Ptr::from_string_literal(b"999.1.1.1")
+                .to_rust_string()
+                .parse::<std::net::Ipv6Addr>()
+            {
+                Ok(__ip) => {
+                    let __octets = __ip.octets();
+                    for __i in 0..16 {
+                        ((buf.as_pointer() as Ptr<u8>) as Ptr<u8>)
+                            .to_any()
+                            .reinterpret_cast::<u8>()
+                            .offset(__i)
+                            .write(__octets[__i]);
+                    }
+                    1
+                }
+                Err(_) => 0,
+            }
+        } else {
+            -1
+        } == 0) as i32)
+            != 0)
+    );
+    assert!(
+        (((if 2 == libc::AF_INET {
+            match Ptr::from_string_literal(b"not an ip")
+                .to_rust_string()
+                .parse::<std::net::Ipv4Addr>()
+            {
+                Ok(__ip) => {
+                    let __octets = __ip.octets();
+                    for __i in 0..4 {
+                        ((buf.as_pointer() as Ptr<u8>) as Ptr<u8>)
+                            .to_any()
+                            .reinterpret_cast::<u8>()
+                            .offset(__i)
+                            .write(__octets[__i]);
+                    }
+                    1
+                }
+                Err(_) => 0,
+            }
+        } else if 2 == libc::AF_INET6 {
+            match Ptr::from_string_literal(b"not an ip")
+                .to_rust_string()
+                .parse::<std::net::Ipv6Addr>()
+            {
+                Ok(__ip) => {
+                    let __octets = __ip.octets();
+                    for __i in 0..16 {
+                        ((buf.as_pointer() as Ptr<u8>) as Ptr<u8>)
+                            .to_any()
+                            .reinterpret_cast::<u8>()
+                            .offset(__i)
+                            .write(__octets[__i]);
+                    }
+                    1
+                }
+                Err(_) => 0,
+            }
+        } else {
+            -1
+        } == 0) as i32)
+            != 0)
+    );
+    assert!(
+        (((if 10 == libc::AF_INET {
+            match Ptr::from_string_literal(b"::1")
+                .to_rust_string()
+                .parse::<std::net::Ipv4Addr>()
+            {
+                Ok(__ip) => {
+                    let __octets = __ip.octets();
+                    for __i in 0..4 {
+                        ((buf.as_pointer() as Ptr<u8>) as Ptr<u8>)
+                            .to_any()
+                            .reinterpret_cast::<u8>()
+                            .offset(__i)
+                            .write(__octets[__i]);
+                    }
+                    1
+                }
+                Err(_) => 0,
+            }
+        } else if 10 == libc::AF_INET6 {
+            match Ptr::from_string_literal(b"::1")
+                .to_rust_string()
+                .parse::<std::net::Ipv6Addr>()
+            {
+                Ok(__ip) => {
+                    let __octets = __ip.octets();
+                    for __i in 0..16 {
+                        ((buf.as_pointer() as Ptr<u8>) as Ptr<u8>)
+                            .to_any()
+                            .reinterpret_cast::<u8>()
+                            .offset(__i)
+                            .write(__octets[__i]);
+                    }
+                    1
+                }
+                Err(_) => 0,
+            }
+        } else {
+            -1
+        } == 1) as i32)
+            != 0)
+    );
+    assert!(
+        ((((((((*buf.borrow())[(0) as usize] as i32) == 0) as i32) != 0)
+            && (((((*buf.borrow())[(15) as usize] as i32) == 1) as i32) != 0)) as i32)
+            != 0)
+    );
+    assert!(
+        (((if 10 == libc::AF_INET {
+            match Ptr::from_string_literal(b"2001:db8::5")
+                .to_rust_string()
+                .parse::<std::net::Ipv4Addr>()
+            {
+                Ok(__ip) => {
+                    let __octets = __ip.octets();
+                    for __i in 0..4 {
+                        ((buf.as_pointer() as Ptr<u8>) as Ptr<u8>)
+                            .to_any()
+                            .reinterpret_cast::<u8>()
+                            .offset(__i)
+                            .write(__octets[__i]);
+                    }
+                    1
+                }
+                Err(_) => 0,
+            }
+        } else if 10 == libc::AF_INET6 {
+            match Ptr::from_string_literal(b"2001:db8::5")
+                .to_rust_string()
+                .parse::<std::net::Ipv6Addr>()
+            {
+                Ok(__ip) => {
+                    let __octets = __ip.octets();
+                    for __i in 0..16 {
+                        ((buf.as_pointer() as Ptr<u8>) as Ptr<u8>)
+                            .to_any()
+                            .reinterpret_cast::<u8>()
+                            .offset(__i)
+                            .write(__octets[__i]);
+                    }
+                    1
+                }
+                Err(_) => 0,
+            }
+        } else {
+            -1
+        } == 1) as i32)
+            != 0)
+    );
+    assert!(
+        (((((((((((*buf.borrow())[(0) as usize] as i32) == 32) as i32) != 0)
+            && (((((*buf.borrow())[(1) as usize] as i32) == 1) as i32) != 0)) as i32)
+            != 0)
+            && (((((*buf.borrow())[(15) as usize] as i32) == 5) as i32) != 0)) as i32)
+            != 0)
+    );
+    let text: Value<Box<[u8]>> = Rc::new(RefCell::new(
+        (0..64).map(|_| <u8>::default()).collect::<Box<[u8]>>(),
+    ));
+    let four: Value<Box<[u8]>> = Rc::new(RefCell::new(Box::new([10_u8, 0_u8, 0_u8, 1_u8])));
+    assert!(
+        ((({
+            let mut __p1 = {
+                let __text = if 2 == libc::AF_INET {
+                    let mut __b = [0u8; 4];
+                    for __i in 0..4 {
+                        __b[__i] = ((four.as_pointer() as Ptr<u8>) as Ptr<u8>)
+                            .to_any()
+                            .reinterpret_cast::<u8>()
+                            .offset(__i)
+                            .read();
+                    }
+                    Some(std::net::Ipv4Addr::from(__b).to_string())
+                } else if 2 == libc::AF_INET6 {
+                    let mut __b = [0u8; 16];
+                    for __i in 0..16 {
+                        __b[__i] = ((four.as_pointer() as Ptr<u8>) as Ptr<u8>)
+                            .to_any()
+                            .reinterpret_cast::<u8>()
+                            .offset(__i)
+                            .read();
+                    }
+                    Some(std::net::Ipv6Addr::from(__b).to_string())
+                } else {
+                    None
+                };
+                match __text {
+                    Some(__s)
+                        if (__s.len() as u32) < (::std::mem::size_of::<[u8; 64]>() as u32) =>
+                    {
+                        for __i in 0..__s.len() {
+                            (text.as_pointer() as Ptr<u8>)
+                                .offset(__i)
+                                .write(__s.as_bytes()[__i]);
+                        }
+                        (text.as_pointer() as Ptr<u8>).offset(__s.len()).write(0);
+                        (text.as_pointer() as Ptr<u8>).clone()
+                    }
+                    _ => Ptr::null(),
+                }
+            }
+            .clone();
+            let mut __p2 = Ptr::from_string_literal(b"10.0.0.1").clone();
+            loop {
+                let __c1 = __p1.read();
+                let __c2 = __p2.read();
+                if __c1 != __c2 {
+                    break (__c1 as i32) - (__c2 as i32);
+                }
+                if __c1 == 0 {
+                    break 0;
+                }
+                __p1 += 1;
+                __p2 += 1;
+            }
+        } == 0) as i32)
+            != 0)
+    );
+    let sixteen: Value<Box<[u8]>> = Rc::new(RefCell::new(Box::new([
+        0_u8,
+        <u8>::default(),
+        <u8>::default(),
+        <u8>::default(),
+        <u8>::default(),
+        <u8>::default(),
+        <u8>::default(),
+        <u8>::default(),
+        <u8>::default(),
+        <u8>::default(),
+        <u8>::default(),
+        <u8>::default(),
+        <u8>::default(),
+        <u8>::default(),
+        <u8>::default(),
+        <u8>::default(),
+    ])));
+    (*sixteen.borrow_mut())[(15) as usize] = 1_u8;
+    assert!(
+        ((({
+            let mut __p1 = {
+                let __text = if 10 == libc::AF_INET {
+                    let mut __b = [0u8; 4];
+                    for __i in 0..4 {
+                        __b[__i] = ((sixteen.as_pointer() as Ptr<u8>) as Ptr<u8>)
+                            .to_any()
+                            .reinterpret_cast::<u8>()
+                            .offset(__i)
+                            .read();
+                    }
+                    Some(std::net::Ipv4Addr::from(__b).to_string())
+                } else if 10 == libc::AF_INET6 {
+                    let mut __b = [0u8; 16];
+                    for __i in 0..16 {
+                        __b[__i] = ((sixteen.as_pointer() as Ptr<u8>) as Ptr<u8>)
+                            .to_any()
+                            .reinterpret_cast::<u8>()
+                            .offset(__i)
+                            .read();
+                    }
+                    Some(std::net::Ipv6Addr::from(__b).to_string())
+                } else {
+                    None
+                };
+                match __text {
+                    Some(__s)
+                        if (__s.len() as u32) < (::std::mem::size_of::<[u8; 64]>() as u32) =>
+                    {
+                        for __i in 0..__s.len() {
+                            (text.as_pointer() as Ptr<u8>)
+                                .offset(__i)
+                                .write(__s.as_bytes()[__i]);
+                        }
+                        (text.as_pointer() as Ptr<u8>).offset(__s.len()).write(0);
+                        (text.as_pointer() as Ptr<u8>).clone()
+                    }
+                    _ => Ptr::null(),
+                }
+            }
+            .clone();
+            let mut __p2 = Ptr::from_string_literal(b"::1").clone();
+            loop {
+                let __c1 = __p1.read();
+                let __c2 = __p2.read();
+                if __c1 != __c2 {
+                    break (__c1 as i32) - (__c2 as i32);
+                }
+                if __c1 == 0 {
+                    break 0;
+                }
+                __p1 += 1;
+                __p2 += 1;
+            }
+        } == 0) as i32)
+            != 0)
+    );
+    assert!(
+        (((({
+            let __text = if 2 == libc::AF_INET {
+                let mut __b = [0u8; 4];
+                for __i in 0..4 {
+                    __b[__i] = ((four.as_pointer() as Ptr<u8>) as Ptr<u8>)
+                        .to_any()
+                        .reinterpret_cast::<u8>()
+                        .offset(__i)
+                        .read();
+                }
+                Some(std::net::Ipv4Addr::from(__b).to_string())
+            } else if 2 == libc::AF_INET6 {
+                let mut __b = [0u8; 16];
+                for __i in 0..16 {
+                    __b[__i] = ((four.as_pointer() as Ptr<u8>) as Ptr<u8>)
+                        .to_any()
+                        .reinterpret_cast::<u8>()
+                        .offset(__i)
+                        .read();
+                }
+                Some(std::net::Ipv6Addr::from(__b).to_string())
+            } else {
+                None
+            };
+            match __text {
+                Some(__s) if (__s.len() as u32) < 4_u32 => {
+                    for __i in 0..__s.len() {
+                        (text.as_pointer() as Ptr<u8>)
+                            .offset(__i)
+                            .write(__s.as_bytes()[__i]);
+                    }
+                    (text.as_pointer() as Ptr<u8>).offset(__s.len()).write(0);
+                    (text.as_pointer() as Ptr<u8>).clone()
+                }
+                _ => Ptr::null(),
+            }
+        })
+        .is_null()) as i32)
+            != 0)
+    );
+    return 0;
+}
diff --git a/tests/unit/out/refcount/offsetof.rs b/tests/unit/out/refcount/offsetof.rs
index ffb50b8b..f183b9c3 100644
--- a/tests/unit/out/refcount/offsetof.rs
+++ b/tests/unit/out/refcount/offsetof.rs
@@ -102,7 +102,16 @@ fn main_0() -> i32 {
     assert!(((*(*v.borrow()).b.borrow()) == 305419896_u32));
     let text: Value<Ptr<u8>> = Rc::new(RefCell::new(Ptr::from_string_literal(b"example-body")));
     let len: Value<usize> = Rc::new(RefCell::new(
-        ((*text.borrow()).to_string_iterator().count()).wrapping_add(1_usize),
+        ({
+            let mut __p = (*text.borrow()).clone();
+            let mut __i: usize = 0;
+            while __p.read() != 0 {
+                __p += 1;
+                __i += 1;
+            }
+            __i
+        })
+        .wrapping_add(1_usize),
     ));
     let total: Value<usize> = Rc::new(RefCell::new(
         ((2_usize as u64).wrapping_add(((*len.borrow()) as u64)) as usize),
diff --git a/tests/unit/out/refcount/strdup.rs b/tests/unit/out/refcount/strdup.rs
new file mode 100644
index 00000000..f75d5a0f
--- /dev/null
+++ b/tests/unit/out/refcount/strdup.rs
@@ -0,0 +1,169 @@
+extern crate libcc2rs;
+use libcc2rs::*;
+use std::cell::RefCell;
+use std::collections::BTreeMap;
+use std::io::prelude::*;
+use std::io::{Read, Seek, Write};
+use std::os::fd::AsFd;
+use std::rc::{Rc, Weak};
+#[derive(Default)]
+pub struct record {
+    pub name: Value<Ptr<u8>>,
+}
+impl Clone for record {
+    fn clone(&self) -> Self {
+        Self {
+            name: Rc::new(RefCell::new((*self.name.borrow()).clone())),
+        }
+    }
+}
+impl ByteRepr for record {
+    fn byte_size() -> usize {
+        8
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.name.borrow()).to_bytes(&mut buf[0..8]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            name: Rc::new(RefCell::new(<Ptr<u8>>::from_bytes(&buf[0..8]))),
+        }
+    }
+}
+pub fn main() {
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    let d: Value<Ptr<u8>> = Rc::new(RefCell::new(libcc2rs::strdup_refcount(
+        Ptr::from_string_literal(b"hello").clone(),
+    )));
+    assert!((((!((*d.borrow()).is_null())) as i32) != 0));
+    assert!(
+        ((({
+            let mut __p1 = (*d.borrow()).clone();
+            let mut __p2 = Ptr::from_string_literal(b"hello").clone();
+            loop {
+                let __c1 = __p1.read();
+                let __c2 = __p2.read();
+                if __c1 != __c2 {
+                    break (__c1 as i32) - (__c2 as i32);
+                }
+                if __c1 == 0 {
+                    break 0;
+                }
+                __p1 += 1;
+                __p2 += 1;
+            }
+        } == 0) as i32)
+            != 0)
+    );
+    libcc2rs::free_refcount(((*d.borrow()).clone() as Ptr<u8>).to_any());
+    let p: Value<Ptr<u8>> = Rc::new(RefCell::new(Ptr::from_string_literal(b"world")));
+    let buf: Value<Box<[u8]>> = Rc::new(RefCell::new(Box::new([
+        (('a' as i32) as u8),
+        (('b' as i32) as u8),
+        (('c' as i32) as u8),
+        (('\0' as i32) as u8),
+    ])));
+    let d2: Value<Ptr<u8>> = Rc::new(RefCell::new(libcc2rs::strdup_refcount(
+        (*p.borrow()).clone(),
+    )));
+    assert!((((!((*d2.borrow()).is_null())) as i32) != 0));
+    assert!(
+        ((({
+            let mut __p1 = (*d2.borrow()).clone();
+            let mut __p2 = (*p.borrow()).clone();
+            loop {
+                let __c1 = __p1.read();
+                let __c2 = __p2.read();
+                if __c1 != __c2 {
+                    break (__c1 as i32) - (__c2 as i32);
+                }
+                if __c1 == 0 {
+                    break 0;
+                }
+                __p1 += 1;
+                __p2 += 1;
+            }
+        } == 0) as i32)
+            != 0)
+    );
+    libcc2rs::free_refcount(((*d2.borrow()).clone() as Ptr<u8>).to_any());
+    let d3: Value<Ptr<u8>> = Rc::new(RefCell::new(libcc2rs::strdup_refcount(
+        (buf.as_pointer() as Ptr<u8>).clone(),
+    )));
+    assert!((((!((*d3.borrow()).is_null())) as i32) != 0));
+    assert!(
+        ((({
+            let mut __p1 = (*d3.borrow()).clone();
+            let mut __p2 = (buf.as_pointer() as Ptr<u8>).clone();
+            loop {
+                let __c1 = __p1.read();
+                let __c2 = __p2.read();
+                if __c1 != __c2 {
+                    break (__c1 as i32) - (__c2 as i32);
+                }
+                if __c1 == 0 {
+                    break 0;
+                }
+                __p1 += 1;
+                __p2 += 1;
+            }
+        } == 0) as i32)
+            != 0)
+    );
+    libcc2rs::free_refcount(((*d3.borrow()).clone() as Ptr<u8>).to_any());
+    let d4: Value<Ptr<u8>> = Rc::new(RefCell::new(Ptr::<u8>::null()));
+    (*d4.borrow_mut()) = libcc2rs::strdup_refcount((*p.borrow()).clone());
+    assert!((((!((*d4.borrow()).is_null())) as i32) != 0));
+    assert!(
+        ((({
+            let mut __p1 = (*d4.borrow()).clone();
+            let mut __p2 = (*p.borrow()).clone();
+            loop {
+                let __c1 = __p1.read();
+                let __c2 = __p2.read();
+                if __c1 != __c2 {
+                    break (__c1 as i32) - (__c2 as i32);
+                }
+                if __c1 == 0 {
+                    break 0;
+                }
+                __p1 += 1;
+                __p2 += 1;
+            }
+        } == 0) as i32)
+            != 0)
+    );
+    libcc2rs::free_refcount(((*d4.borrow()).clone() as Ptr<u8>).to_any());
+    let rec: Value<record> = Rc::new(RefCell::new(record {
+        name: Rc::new(RefCell::new(Ptr::<u8>::null())),
+    }));
+    let r: Value<Ptr<record>> = Rc::new(RefCell::new((rec.as_pointer())));
+    (*(*(*r.borrow()).upgrade().deref()).name.borrow_mut()) =
+        libcc2rs::strdup_refcount((*p.borrow()).clone());
+    assert!((((!((*(*(*r.borrow()).upgrade().deref()).name.borrow()).is_null())) as i32) != 0));
+    assert!(
+        ((({
+            let mut __p1 = (*(*(*r.borrow()).upgrade().deref()).name.borrow()).clone();
+            let mut __p2 = (*p.borrow()).clone();
+            loop {
+                let __c1 = __p1.read();
+                let __c2 = __p2.read();
+                if __c1 != __c2 {
+                    break (__c1 as i32) - (__c2 as i32);
+                }
+                if __c1 == 0 {
+                    break 0;
+                }
+                __p1 += 1;
+                __p2 += 1;
+            }
+        } == 0) as i32)
+            != 0)
+    );
+    libcc2rs::free_refcount(
+        ((*(*(*r.borrow()).upgrade().deref()).name.borrow()).clone() as Ptr<u8>).to_any(),
+    );
+    return 0;
+}
diff --git a/tests/unit/out/refcount/string_h.rs b/tests/unit/out/refcount/string_h.rs
new file mode 100644
index 00000000..8cf22c36
--- /dev/null
+++ b/tests/unit/out/refcount/string_h.rs
@@ -0,0 +1,1263 @@
+extern crate libcc2rs;
+use libcc2rs::*;
+use std::cell::RefCell;
+use std::collections::BTreeMap;
+use std::io::prelude::*;
+use std::io::{Read, Seek, Write};
+use std::os::fd::AsFd;
+use std::rc::{Rc, Weak};
+pub fn test_memcpy_0() {
+    let src: Value<Box<[u8]>> = Rc::new(RefCell::new(Box::from(*b"hello\0")));
+    let dst: Value<Box<[u8]>> = Rc::new(RefCell::new(Box::new([
+        0_u8,
+        <u8>::default(),
+        <u8>::default(),
+        <u8>::default(),
+        <u8>::default(),
+        <u8>::default(),
+    ])));
+    let r: Value<AnyPtr> = Rc::new(RefCell::new({
+        ((dst.as_pointer() as Ptr<u8>) as Ptr<u8>).to_any().memcpy(
+            &((src.as_pointer() as Ptr<u8>) as Ptr<u8>).to_any(),
+            6_usize as usize,
+        );
+        ((dst.as_pointer() as Ptr<u8>) as Ptr<u8>).to_any().clone()
+    }));
+    assert!(
+        ((({
+            let _lhs = (*r.borrow()).clone();
+            _lhs == ((dst.as_pointer() as Ptr<u8>) as Ptr<u8>).to_any()
+        }) as i32)
+            != 0)
+    );
+    assert!(
+        (((((((((((*dst.borrow())[(0) as usize] as i32) == ('h' as i32)) as i32) != 0)
+            && (((((*dst.borrow())[(1) as usize] as i32) == ('e' as i32)) as i32) != 0))
+            as i32)
+            != 0)
+            && (((((*dst.borrow())[(2) as usize] as i32) == ('l' as i32)) as i32) != 0))
+            as i32)
+            != 0)
+    );
+    assert!(
+        (((((((((((*dst.borrow())[(3) as usize] as i32) == ('l' as i32)) as i32) != 0)
+            && (((((*dst.borrow())[(4) as usize] as i32) == ('o' as i32)) as i32) != 0))
+            as i32)
+            != 0)
+            && (((((*dst.borrow())[(5) as usize] as i32) == ('\0' as i32)) as i32) != 0))
+            as i32)
+            != 0)
+    );
+}
+pub fn test_memset_1() {
+    let buf: Value<Box<[u8]>> = Rc::new(RefCell::new(
+        (0..4).map(|_| <u8>::default()).collect::<Box<[u8]>>(),
+    ));
+    let r: Value<AnyPtr> = Rc::new(RefCell::new({
+        ((buf.as_pointer() as Ptr<u8>) as Ptr<u8>)
+            .to_any()
+            .memset(('x' as i32) as u8, 4_usize as usize);
+        ((buf.as_pointer() as Ptr<u8>) as Ptr<u8>).to_any().clone()
+    }));
+    assert!(
+        ((({
+            let _lhs = (*r.borrow()).clone();
+            _lhs == ((buf.as_pointer() as Ptr<u8>) as Ptr<u8>).to_any()
+        }) as i32)
+            != 0)
+    );
+    assert!(
+        ((((((((((((((*buf.borrow())[(0) as usize] as i32) == ('x' as i32)) as i32) != 0)
+            && (((((*buf.borrow())[(1) as usize] as i32) == ('x' as i32)) as i32) != 0))
+            as i32)
+            != 0)
+            && (((((*buf.borrow())[(2) as usize] as i32) == ('x' as i32)) as i32) != 0))
+            as i32)
+            != 0)
+            && (((((*buf.borrow())[(3) as usize] as i32) == ('x' as i32)) as i32) != 0))
+            as i32)
+            != 0)
+    );
+}
+pub fn test_memcmp_2() {
+    let a: Value<Box<[u8]>> = Rc::new(RefCell::new(Box::new([1_u8, 2_u8, 3_u8, 4_u8])));
+    let b: Value<Box<[u8]>> = Rc::new(RefCell::new(Box::new([1_u8, 2_u8, 3_u8, 4_u8])));
+    let c: Value<Box<[u8]>> = Rc::new(RefCell::new(Box::new([1_u8, 2_u8, 9_u8, 4_u8])));
+    assert!(
+        (((((a.as_pointer() as Ptr::<u8>) as Ptr::<u8>)
+            .to_any()
+            .memcmp(
+                &((b.as_pointer() as Ptr::<u8>) as Ptr::<u8>).to_any(),
+                4_usize
+            )
+            == 0) as i32)
+            != 0)
+    );
+    assert!(
+        (((((a.as_pointer() as Ptr::<u8>) as Ptr::<u8>)
+            .to_any()
+            .memcmp(
+                &((c.as_pointer() as Ptr::<u8>) as Ptr::<u8>).to_any(),
+                4_usize
+            )
+            < 0) as i32)
+            != 0)
+    );
+    assert!(
+        (((((c.as_pointer() as Ptr::<u8>) as Ptr::<u8>)
+            .to_any()
+            .memcmp(
+                &((a.as_pointer() as Ptr::<u8>) as Ptr::<u8>).to_any(),
+                4_usize
+            )
+            > 0) as i32)
+            != 0)
+    );
+}
+pub fn test_memmove_3() {
+    let buf: Value<Box<[u8]>> = Rc::new(RefCell::new(Box::new([
+        (('a' as i32) as u8),
+        (('b' as i32) as u8),
+        (('c' as i32) as u8),
+        (('d' as i32) as u8),
+        (('e' as i32) as u8),
+        (('\0' as i32) as u8),
+    ])));
+    let r: Value<AnyPtr> = Rc::new(RefCell::new({
+        let mut __src = ((buf.as_pointer() as Ptr<u8>) as Ptr<u8>)
+            .to_any()
+            .reinterpret_cast::<u8>();
+        let mut __tmp: Vec<u8> = Vec::with_capacity(4_usize);
+        for _ in 0..4_usize {
+            __tmp.push(__src.read());
+            __src += 1;
+        }
+        let mut __dst = ((buf.as_pointer() as Ptr<u8>).offset((1) as isize) as Ptr<u8>)
+            .to_any()
+            .reinterpret_cast::<u8>();
+        for __i in 0..4_usize {
+            __dst.write(__tmp[__i]);
+            __dst += 1;
+        }
+        ((buf.as_pointer() as Ptr<u8>).offset((1) as isize) as Ptr<u8>)
+            .to_any()
+            .clone()
+    }));
+    assert!(
+        ((({
+            let _lhs = (*r.borrow()).clone();
+            _lhs == ((buf.as_pointer() as Ptr<u8>).offset((1) as isize) as Ptr<u8>).to_any()
+        }) as i32)
+            != 0)
+    );
+    assert!(
+        (((((((((((*buf.borrow())[(0) as usize] as i32) == ('a' as i32)) as i32) != 0)
+            && (((((*buf.borrow())[(1) as usize] as i32) == ('a' as i32)) as i32) != 0))
+            as i32)
+            != 0)
+            && (((((*buf.borrow())[(2) as usize] as i32) == ('b' as i32)) as i32) != 0))
+            as i32)
+            != 0)
+    );
+    assert!(
+        (((((((((((*buf.borrow())[(3) as usize] as i32) == ('c' as i32)) as i32) != 0)
+            && (((((*buf.borrow())[(4) as usize] as i32) == ('d' as i32)) as i32) != 0))
+            as i32)
+            != 0)
+            && (((((*buf.borrow())[(5) as usize] as i32) == ('\0' as i32)) as i32) != 0))
+            as i32)
+            != 0)
+    );
+}
+pub fn test_strchr_4() {
+    let s: Value<Ptr<u8>> = Rc::new(RefCell::new(Ptr::from_string_literal(b"hello world")));
+    let r: Value<Ptr<u8>> = Rc::new(RefCell::new({
+        let mut __p = (*s.borrow()).reinterpret_cast::<u8>().clone();
+        loop {
+            let __c = __p.read();
+            if __c == ('w' as i32) as u8 {
+                break __p;
+            }
+            if __c == 0 {
+                break Ptr::null();
+            }
+            __p += 1;
+        }
+    }));
+    assert!((((!((*r.borrow()).is_null())) as i32) != 0));
+    assert!(((((((*r.borrow()).read()) as i32) == ('w' as i32)) as i32) != 0));
+    assert!(
+        (((({
+            let mut __p = (*s.borrow()).reinterpret_cast::<u8>().clone();
+            loop {
+                let __c = __p.read();
+                if __c == ('z' as i32) as u8 {
+                    break __p;
+                }
+                if __c == 0 {
+                    break Ptr::null();
+                }
+                __p += 1;
+            }
+        })
+        .is_null()) as i32)
+            != 0)
+    );
+}
+pub fn test_strlen_5() {
+    assert!(
+        ((({
+            let mut __p = Ptr::from_string_literal(b"").clone();
+            let mut __i: usize = 0;
+            while __p.read() != 0 {
+                __p += 1;
+                __i += 1;
+            }
+            __i
+        } == 0_usize) as i32)
+            != 0)
+    );
+    assert!(
+        ((({
+            let mut __p = Ptr::from_string_literal(b"hello").clone();
+            let mut __i: usize = 0;
+            while __p.read() != 0 {
+                __p += 1;
+                __i += 1;
+            }
+            __i
+        } == 5_usize) as i32)
+            != 0)
+    );
+    assert!(
+        ((({
+            let mut __p = Ptr::from_string_literal(b"hello world").clone();
+            let mut __i: usize = 0;
+            while __p.read() != 0 {
+                __p += 1;
+                __i += 1;
+            }
+            __i
+        } == 11_usize) as i32)
+            != 0)
+    );
+    let buf: Value<Box<[u8]>> = Rc::new(RefCell::new(Box::from(*b"one\0two\0")));
+    let first: Value<Ptr<u8>> = Rc::new(RefCell::new((buf.as_pointer() as Ptr<u8>)));
+    let second: Value<Ptr<u8>> = Rc::new(RefCell::new(
+        ((buf.as_pointer() as Ptr<u8>).offset(
+            ({
+                let mut __p = (*first.borrow()).clone();
+                let mut __i: usize = 0;
+                while __p.read() != 0 {
+                    __p += 1;
+                    __i += 1;
+                }
+                __i
+            })
+            .wrapping_add(1_usize),
+        )),
+    ));
+    assert!(
+        ((({
+            let mut __p1 = (*second.borrow()).clone();
+            let mut __p2 = Ptr::from_string_literal(b"two").clone();
+            loop {
+                let __c1 = __p1.read();
+                let __c2 = __p2.read();
+                if __c1 != __c2 {
+                    break (__c1 as i32) - (__c2 as i32);
+                }
+                if __c1 == 0 {
+                    break 0;
+                }
+                __p1 += 1;
+                __p2 += 1;
+            }
+        } == 0) as i32)
+            != 0)
+    );
+    let  big : Value<Box<[ u8  ]> > = Rc::new(RefCell::new(Box::from(*b"hi\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\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\0\0\0\0") )) ;
+    assert!(
+        ((({
+            let mut __p = (big.as_pointer() as Ptr<u8>).clone();
+            let mut __i: usize = 0;
+            while __p.read() != 0 {
+                __p += 1;
+                __i += 1;
+            }
+            __i
+        } == 2_usize) as i32)
+            != 0)
+    );
+    (*big.borrow_mut())[(2) as usize] = (('x' as i32) as u8);
+    (*big.borrow_mut())[(3) as usize] = (('\0' as i32) as u8);
+    assert!(
+        ((({
+            let mut __p = (big.as_pointer() as Ptr<u8>).clone();
+            let mut __i: usize = 0;
+            while __p.read() != 0 {
+                __p += 1;
+                __i += 1;
+            }
+            __i
+        } == 3_usize) as i32)
+            != 0)
+    );
+}
+pub fn test_strcmp_6() {
+    assert!(
+        ((({
+            let mut __p1 = Ptr::from_string_literal(b"abc").clone();
+            let mut __p2 = Ptr::from_string_literal(b"abc").clone();
+            loop {
+                let __c1 = __p1.read();
+                let __c2 = __p2.read();
+                if __c1 != __c2 {
+                    break (__c1 as i32) - (__c2 as i32);
+                }
+                if __c1 == 0 {
+                    break 0;
+                }
+                __p1 += 1;
+                __p2 += 1;
+            }
+        } == 0) as i32)
+            != 0)
+    );
+    assert!(
+        ((({
+            let mut __p1 = Ptr::from_string_literal(b"abc").clone();
+            let mut __p2 = Ptr::from_string_literal(b"abd").clone();
+            loop {
+                let __c1 = __p1.read();
+                let __c2 = __p2.read();
+                if __c1 != __c2 {
+                    break (__c1 as i32) - (__c2 as i32);
+                }
+                if __c1 == 0 {
+                    break 0;
+                }
+                __p1 += 1;
+                __p2 += 1;
+            }
+        } < 0) as i32)
+            != 0)
+    );
+    assert!(
+        ((({
+            let mut __p1 = Ptr::from_string_literal(b"abd").clone();
+            let mut __p2 = Ptr::from_string_literal(b"abc").clone();
+            loop {
+                let __c1 = __p1.read();
+                let __c2 = __p2.read();
+                if __c1 != __c2 {
+                    break (__c1 as i32) - (__c2 as i32);
+                }
+                if __c1 == 0 {
+                    break 0;
+                }
+                __p1 += 1;
+                __p2 += 1;
+            }
+        } > 0) as i32)
+            != 0)
+    );
+    let p: Value<Ptr<u8>> = Rc::new(RefCell::new(Ptr::from_string_literal(b"abc")));
+    let q: Value<Ptr<u8>> = Rc::new(RefCell::new(Ptr::from_string_literal(b"abd")));
+    let buf: Value<Box<[u8]>> = Rc::new(RefCell::new(Box::new([
+        (('a' as i32) as u8),
+        (('b' as i32) as u8),
+        (('c' as i32) as u8),
+        (('\0' as i32) as u8),
+    ])));
+    assert!(
+        ((({
+            let mut __p1 = (*p.borrow()).clone();
+            let mut __p2 = (*p.borrow()).clone();
+            loop {
+                let __c1 = __p1.read();
+                let __c2 = __p2.read();
+                if __c1 != __c2 {
+                    break (__c1 as i32) - (__c2 as i32);
+                }
+                if __c1 == 0 {
+                    break 0;
+                }
+                __p1 += 1;
+                __p2 += 1;
+            }
+        } == 0) as i32)
+            != 0)
+    );
+    assert!(
+        ((({
+            let mut __p1 = (*p.borrow()).clone();
+            let mut __p2 = (*q.borrow()).clone();
+            loop {
+                let __c1 = __p1.read();
+                let __c2 = __p2.read();
+                if __c1 != __c2 {
+                    break (__c1 as i32) - (__c2 as i32);
+                }
+                if __c1 == 0 {
+                    break 0;
+                }
+                __p1 += 1;
+                __p2 += 1;
+            }
+        } < 0) as i32)
+            != 0)
+    );
+    assert!(
+        ((({
+            let mut __p1 = (buf.as_pointer() as Ptr<u8>).clone();
+            let mut __p2 = (*p.borrow()).clone();
+            loop {
+                let __c1 = __p1.read();
+                let __c2 = __p2.read();
+                if __c1 != __c2 {
+                    break (__c1 as i32) - (__c2 as i32);
+                }
+                if __c1 == 0 {
+                    break 0;
+                }
+                __p1 += 1;
+                __p2 += 1;
+            }
+        } == 0) as i32)
+            != 0)
+    );
+}
+pub fn test_strncmp_7() {
+    assert!(
+        ((({
+            let mut __p1 = Ptr::from_string_literal(b"abcdef").clone();
+            let mut __p2 = Ptr::from_string_literal(b"abcxyz").clone();
+            let mut __i: usize = 0;
+            loop {
+                if __i == 3_usize {
+                    break 0;
+                }
+                let __c1 = __p1.read();
+                let __c2 = __p2.read();
+                if __c1 != __c2 {
+                    break (__c1 as i32) - (__c2 as i32);
+                }
+                if __c1 == 0 {
+                    break 0;
+                }
+                __p1 += 1;
+                __p2 += 1;
+                __i += 1;
+            }
+        } == 0) as i32)
+            != 0)
+    );
+    assert!(
+        ((({
+            let mut __p1 = Ptr::from_string_literal(b"abcdef").clone();
+            let mut __p2 = Ptr::from_string_literal(b"abcxyz").clone();
+            let mut __i: usize = 0;
+            loop {
+                if __i == 4_usize {
+                    break 0;
+                }
+                let __c1 = __p1.read();
+                let __c2 = __p2.read();
+                if __c1 != __c2 {
+                    break (__c1 as i32) - (__c2 as i32);
+                }
+                if __c1 == 0 {
+                    break 0;
+                }
+                __p1 += 1;
+                __p2 += 1;
+                __i += 1;
+            }
+        } < 0) as i32)
+            != 0)
+    );
+    assert!(
+        ((({
+            let mut __p1 = Ptr::from_string_literal(b"abcxyz").clone();
+            let mut __p2 = Ptr::from_string_literal(b"abcdef").clone();
+            let mut __i: usize = 0;
+            loop {
+                if __i == 4_usize {
+                    break 0;
+                }
+                let __c1 = __p1.read();
+                let __c2 = __p2.read();
+                if __c1 != __c2 {
+                    break (__c1 as i32) - (__c2 as i32);
+                }
+                if __c1 == 0 {
+                    break 0;
+                }
+                __p1 += 1;
+                __p2 += 1;
+                __i += 1;
+            }
+        } > 0) as i32)
+            != 0)
+    );
+    let p: Value<Ptr<u8>> = Rc::new(RefCell::new(Ptr::from_string_literal(b"abcdef")));
+    let q: Value<Ptr<u8>> = Rc::new(RefCell::new(Ptr::from_string_literal(b"abcxyz")));
+    let buf: Value<Box<[u8]>> = Rc::new(RefCell::new(Box::new([
+        (('a' as i32) as u8),
+        (('b' as i32) as u8),
+        (('c' as i32) as u8),
+        (('d' as i32) as u8),
+        (('e' as i32) as u8),
+        (('f' as i32) as u8),
+        (('\0' as i32) as u8),
+    ])));
+    let n: Value<usize> = Rc::new(RefCell::new(3_usize));
+    assert!(
+        ((({
+            let mut __p1 = (*p.borrow()).clone();
+            let mut __p2 = (*q.borrow()).clone();
+            let mut __i: usize = 0;
+            loop {
+                if __i == (*n.borrow()) {
+                    break 0;
+                }
+                let __c1 = __p1.read();
+                let __c2 = __p2.read();
+                if __c1 != __c2 {
+                    break (__c1 as i32) - (__c2 as i32);
+                }
+                if __c1 == 0 {
+                    break 0;
+                }
+                __p1 += 1;
+                __p2 += 1;
+                __i += 1;
+            }
+        } == 0) as i32)
+            != 0)
+    );
+    assert!(
+        ((({
+            let mut __p1 = (*p.borrow()).clone();
+            let mut __p2 = (*q.borrow()).clone();
+            let mut __i: usize = 0;
+            loop {
+                if __i == (*n.borrow()).wrapping_add(1_usize) {
+                    break 0;
+                }
+                let __c1 = __p1.read();
+                let __c2 = __p2.read();
+                if __c1 != __c2 {
+                    break (__c1 as i32) - (__c2 as i32);
+                }
+                if __c1 == 0 {
+                    break 0;
+                }
+                __p1 += 1;
+                __p2 += 1;
+                __i += 1;
+            }
+        } < 0) as i32)
+            != 0)
+    );
+    assert!(
+        ((({
+            let mut __p1 = (buf.as_pointer() as Ptr<u8>).clone();
+            let mut __p2 = (*p.borrow()).clone();
+            let mut __i: usize = 0;
+            loop {
+                if __i == 6_usize {
+                    break 0;
+                }
+                let __c1 = __p1.read();
+                let __c2 = __p2.read();
+                if __c1 != __c2 {
+                    break (__c1 as i32) - (__c2 as i32);
+                }
+                if __c1 == 0 {
+                    break 0;
+                }
+                __p1 += 1;
+                __p2 += 1;
+                __i += 1;
+            }
+        } == 0) as i32)
+            != 0)
+    );
+}
+pub fn test_memchr_8() {
+    let data: Value<Box<[u8]>> = Rc::new(RefCell::new(Box::new([16_u8, 32_u8, 48_u8, 64_u8])));
+    let r: Value<AnyPtr> = Rc::new(RefCell::new({
+        let mut __p = ((data.as_pointer() as Ptr<u8>) as Ptr<u8>)
+            .to_any()
+            .reinterpret_cast::<u8>();
+        let mut __i: usize = 0;
+        loop {
+            if __i == 4_usize {
+                break Ptr::<u8>::null().to_any();
+            }
+            if __p.read() == 48 as u8 {
+                break __p.to_any();
+            }
+            __p += 1;
+            __i += 1;
+        }
+    }));
+    assert!(
+        ((({
+            let _lhs = (*r.borrow()).clone();
+            _lhs == (((data.as_pointer() as Ptr<u8>).offset(2)) as Ptr<u8>).to_any()
+        }) as i32)
+            != 0)
+    );
+    assert!(
+        (((({
+            let mut __p = ((data.as_pointer() as Ptr<u8>) as Ptr<u8>)
+                .to_any()
+                .reinterpret_cast::<u8>();
+            let mut __i: usize = 0;
+            loop {
+                if __i == 4_usize {
+                    break Ptr::<u8>::null().to_any();
+                }
+                if __p.read() == 153 as u8 {
+                    break __p.to_any();
+                }
+                __p += 1;
+                __i += 1;
+            }
+        })
+        .is_null()) as i32)
+            != 0)
+    );
+    let p: Value<AnyPtr> = Rc::new(RefCell::new(
+        ((data.as_pointer() as Ptr<u8>) as Ptr<u8>).to_any(),
+    ));
+    let n: Value<usize> = Rc::new(RefCell::new(4_usize));
+    assert!(
+        ((({
+            let _lhs = {
+                let mut __p = (*p.borrow()).reinterpret_cast::<u8>();
+                let mut __i: usize = 0;
+                loop {
+                    if __i == (*n.borrow()) {
+                        break Ptr::<u8>::null().to_any();
+                    }
+                    if __p.read() == 16 as u8 {
+                        break __p.to_any();
+                    }
+                    __p += 1;
+                    __i += 1;
+                }
+            };
+            _lhs == (*p.borrow()).clone()
+        }) as i32)
+            != 0)
+    );
+}
+pub fn test_strrchr_9() {
+    let s: Value<Ptr<u8>> = Rc::new(RefCell::new(Ptr::from_string_literal(b"hello world")));
+    let r: Value<Ptr<u8>> = Rc::new(RefCell::new({
+        let mut __p = (*s.borrow()).reinterpret_cast::<u8>().clone();
+        let mut __found = Ptr::null();
+        loop {
+            let __c = __p.read();
+            if __c == ('l' as i32) as u8 {
+                __found = __p.clone();
+            }
+            if __c == 0 {
+                break __found;
+            }
+            __p += 1;
+        }
+    }));
+    assert!((((!((*r.borrow()).is_null())) as i32) != 0));
+    assert!(((((((*r.borrow()).read()) as i32) == ('l' as i32)) as i32) != 0));
+    assert!(
+        ((({
+            let _lhs = (*r.borrow()).clone();
+            _lhs == (*s.borrow()).offset((9) as isize)
+        }) as i32)
+            != 0)
+    );
+    assert!(
+        (((({
+            let mut __p = (*s.borrow()).reinterpret_cast::<u8>().clone();
+            let mut __found = Ptr::null();
+            loop {
+                let __c = __p.read();
+                if __c == ('z' as i32) as u8 {
+                    __found = __p.clone();
+                }
+                if __c == 0 {
+                    break __found;
+                }
+                __p += 1;
+            }
+        })
+        .is_null()) as i32)
+            != 0)
+    );
+    let buf: Value<Box<[u8]>> = Rc::new(RefCell::new(Box::new([
+        (('a' as i32) as u8),
+        (('b' as i32) as u8),
+        (('a' as i32) as u8),
+        (('\0' as i32) as u8),
+    ])));
+    assert!(
+        ((({
+            let mut __p = (buf.as_pointer() as Ptr<u8>).clone();
+            let mut __found = Ptr::null();
+            loop {
+                let __c = __p.read();
+                if __c == ('a' as i32) as u8 {
+                    __found = __p.clone();
+                }
+                if __c == 0 {
+                    break __found;
+                }
+                __p += 1;
+            }
+        } == ((buf.as_pointer() as Ptr<u8>).offset(2))) as i32)
+            != 0)
+    );
+}
+pub fn test_strcspn_10() {
+    assert!(
+        ((({
+            let mut __p = Ptr::from_string_literal(b"hello").clone();
+            let mut __i: usize = 0;
+            loop {
+                let __c = __p.read();
+                if __c == 0 {
+                    break __i;
+                }
+                let mut __q = Ptr::from_string_literal(b"el").clone();
+                let __hit = loop {
+                    let __r = __q.read();
+                    if __r == 0 {
+                        break false;
+                    }
+                    if __r == __c {
+                        break true;
+                    }
+                    __q += 1;
+                };
+                if __hit {
+                    break __i;
+                }
+                __p += 1;
+                __i += 1;
+            }
+        } == 1_usize) as i32)
+            != 0)
+    );
+    assert!(
+        ((({
+            let mut __p = Ptr::from_string_literal(b"abc").clone();
+            let mut __i: usize = 0;
+            loop {
+                let __c = __p.read();
+                if __c == 0 {
+                    break __i;
+                }
+                let mut __q = Ptr::from_string_literal(b"xyz").clone();
+                let __hit = loop {
+                    let __r = __q.read();
+                    if __r == 0 {
+                        break false;
+                    }
+                    if __r == __c {
+                        break true;
+                    }
+                    __q += 1;
+                };
+                if __hit {
+                    break __i;
+                }
+                __p += 1;
+                __i += 1;
+            }
+        } == 3_usize) as i32)
+            != 0)
+    );
+    assert!(
+        ((({
+            let mut __p = Ptr::from_string_literal(b"").clone();
+            let mut __i: usize = 0;
+            loop {
+                let __c = __p.read();
+                if __c == 0 {
+                    break __i;
+                }
+                let mut __q = Ptr::from_string_literal(b"abc").clone();
+                let __hit = loop {
+                    let __r = __q.read();
+                    if __r == 0 {
+                        break false;
+                    }
+                    if __r == __c {
+                        break true;
+                    }
+                    __q += 1;
+                };
+                if __hit {
+                    break __i;
+                }
+                __p += 1;
+                __i += 1;
+            }
+        } == 0_usize) as i32)
+            != 0)
+    );
+    let s: Value<Ptr<u8>> = Rc::new(RefCell::new(Ptr::from_string_literal(b"hello")));
+    let rej: Value<Ptr<u8>> = Rc::new(RefCell::new(Ptr::from_string_literal(b"el")));
+    assert!(
+        ((({
+            let mut __p = (*s.borrow()).clone();
+            let mut __i: usize = 0;
+            loop {
+                let __c = __p.read();
+                if __c == 0 {
+                    break __i;
+                }
+                let mut __q = (*rej.borrow()).clone();
+                let __hit = loop {
+                    let __r = __q.read();
+                    if __r == 0 {
+                        break false;
+                    }
+                    if __r == __c {
+                        break true;
+                    }
+                    __q += 1;
+                };
+                if __hit {
+                    break __i;
+                }
+                __p += 1;
+                __i += 1;
+            }
+        } == 1_usize) as i32)
+            != 0)
+    );
+}
+pub fn test_strspn_11() {
+    assert!(
+        ((({
+            let mut __p = Ptr::from_string_literal(b"hello").clone();
+            let mut __i: usize = 0;
+            loop {
+                let __c = __p.read();
+                if __c == 0 {
+                    break __i;
+                }
+                let mut __q = Ptr::from_string_literal(b"hel").clone();
+                let __hit = loop {
+                    let __r = __q.read();
+                    if __r == 0 {
+                        break false;
+                    }
+                    if __r == __c {
+                        break true;
+                    }
+                    __q += 1;
+                };
+                if !__hit {
+                    break __i;
+                }
+                __p += 1;
+                __i += 1;
+            }
+        } == 4_usize) as i32)
+            != 0)
+    );
+    assert!(
+        ((({
+            let mut __p = Ptr::from_string_literal(b"abc").clone();
+            let mut __i: usize = 0;
+            loop {
+                let __c = __p.read();
+                if __c == 0 {
+                    break __i;
+                }
+                let mut __q = Ptr::from_string_literal(b"xyz").clone();
+                let __hit = loop {
+                    let __r = __q.read();
+                    if __r == 0 {
+                        break false;
+                    }
+                    if __r == __c {
+                        break true;
+                    }
+                    __q += 1;
+                };
+                if !__hit {
+                    break __i;
+                }
+                __p += 1;
+                __i += 1;
+            }
+        } == 0_usize) as i32)
+            != 0)
+    );
+    assert!(
+        ((({
+            let mut __p = Ptr::from_string_literal(b"aaa").clone();
+            let mut __i: usize = 0;
+            loop {
+                let __c = __p.read();
+                if __c == 0 {
+                    break __i;
+                }
+                let mut __q = Ptr::from_string_literal(b"a").clone();
+                let __hit = loop {
+                    let __r = __q.read();
+                    if __r == 0 {
+                        break false;
+                    }
+                    if __r == __c {
+                        break true;
+                    }
+                    __q += 1;
+                };
+                if !__hit {
+                    break __i;
+                }
+                __p += 1;
+                __i += 1;
+            }
+        } == 3_usize) as i32)
+            != 0)
+    );
+    let s: Value<Ptr<u8>> = Rc::new(RefCell::new(Ptr::from_string_literal(b"hello")));
+    let acc: Value<Ptr<u8>> = Rc::new(RefCell::new(Ptr::from_string_literal(b"hel")));
+    assert!(
+        ((({
+            let mut __p = (*s.borrow()).clone();
+            let mut __i: usize = 0;
+            loop {
+                let __c = __p.read();
+                if __c == 0 {
+                    break __i;
+                }
+                let mut __q = (*acc.borrow()).clone();
+                let __hit = loop {
+                    let __r = __q.read();
+                    if __r == 0 {
+                        break false;
+                    }
+                    if __r == __c {
+                        break true;
+                    }
+                    __q += 1;
+                };
+                if !__hit {
+                    break __i;
+                }
+                __p += 1;
+                __i += 1;
+            }
+        } == 4_usize) as i32)
+            != 0)
+    );
+}
+pub fn test_strstr_12() {
+    let h: Value<Ptr<u8>> = Rc::new(RefCell::new(Ptr::from_string_literal(b"hello world")));
+    let r: Value<Ptr<u8>> = Rc::new(RefCell::new({
+        let mut __p = (*h.borrow()).reinterpret_cast::<u8>().clone();
+        loop {
+            let mut __h = __p.clone();
+            let mut __n = Ptr::from_string_literal(b"world").clone();
+            let __matched = loop {
+                let __c = __n.read();
+                if __c == 0 {
+                    break true;
+                }
+                if __h.read() != __c {
+                    break false;
+                }
+                __h += 1;
+                __n += 1;
+            };
+            if __matched {
+                break __p;
+            }
+            if __p.read() == 0 {
+                break Ptr::null();
+            }
+            __p += 1;
+        }
+    }));
+    assert!((((!((*r.borrow()).is_null())) as i32) != 0));
+    assert!(
+        ((({
+            let _lhs = (*r.borrow()).clone();
+            _lhs == (*h.borrow()).offset((6) as isize)
+        }) as i32)
+            != 0)
+    );
+    assert!(
+        (((({
+            let mut __p = (*h.borrow()).reinterpret_cast::<u8>().clone();
+            loop {
+                let mut __h = __p.clone();
+                let mut __n = Ptr::from_string_literal(b"xyz").clone();
+                let __matched = loop {
+                    let __c = __n.read();
+                    if __c == 0 {
+                        break true;
+                    }
+                    if __h.read() != __c {
+                        break false;
+                    }
+                    __h += 1;
+                    __n += 1;
+                };
+                if __matched {
+                    break __p;
+                }
+                if __p.read() == 0 {
+                    break Ptr::null();
+                }
+                __p += 1;
+            }
+        })
+        .is_null()) as i32)
+            != 0)
+    );
+    let buf: Value<Box<[u8]>> = Rc::new(RefCell::new(Box::new([
+        (('h' as i32) as u8),
+        (('e' as i32) as u8),
+        (('l' as i32) as u8),
+        (('l' as i32) as u8),
+        (('o' as i32) as u8),
+        (('\0' as i32) as u8),
+    ])));
+    assert!(
+        ((({
+            let mut __p = (buf.as_pointer() as Ptr<u8>).clone();
+            loop {
+                let mut __h = __p.clone();
+                let mut __n = Ptr::from_string_literal(b"ll").clone();
+                let __matched = loop {
+                    let __c = __n.read();
+                    if __c == 0 {
+                        break true;
+                    }
+                    if __h.read() != __c {
+                        break false;
+                    }
+                    __h += 1;
+                    __n += 1;
+                };
+                if __matched {
+                    break __p;
+                }
+                if __p.read() == 0 {
+                    break Ptr::null();
+                }
+                __p += 1;
+            }
+        } == ((buf.as_pointer() as Ptr<u8>).offset(2))) as i32)
+            != 0)
+    );
+}
+pub fn test_strpbrk_13() {
+    let s: Value<Ptr<u8>> = Rc::new(RefCell::new(Ptr::from_string_literal(b"hello world")));
+    let r: Value<Ptr<u8>> = Rc::new(RefCell::new({
+        let mut __p = (*s.borrow()).reinterpret_cast::<u8>().clone();
+        loop {
+            let __c = __p.read();
+            if __c == 0 {
+                break Ptr::null();
+            }
+            let mut __q = Ptr::from_string_literal(b"wo").clone();
+            let __hit = loop {
+                let __r = __q.read();
+                if __r == 0 {
+                    break false;
+                }
+                if __r == __c {
+                    break true;
+                }
+                __q += 1;
+            };
+            if __hit {
+                break __p;
+            }
+            __p += 1;
+        }
+    }));
+    assert!((((!((*r.borrow()).is_null())) as i32) != 0));
+    assert!(
+        ((({
+            let _lhs = (*r.borrow()).clone();
+            _lhs == (*s.borrow()).offset((4) as isize)
+        }) as i32)
+            != 0)
+    );
+    assert!(
+        (((({
+            let mut __p = (*s.borrow()).reinterpret_cast::<u8>().clone();
+            loop {
+                let __c = __p.read();
+                if __c == 0 {
+                    break Ptr::null();
+                }
+                let mut __q = Ptr::from_string_literal(b"xyz").clone();
+                let __hit = loop {
+                    let __r = __q.read();
+                    if __r == 0 {
+                        break false;
+                    }
+                    if __r == __c {
+                        break true;
+                    }
+                    __q += 1;
+                };
+                if __hit {
+                    break __p;
+                }
+                __p += 1;
+            }
+        })
+        .is_null()) as i32)
+            != 0)
+    );
+    let buf: Value<Box<[u8]>> = Rc::new(RefCell::new(Box::new([
+        (('a' as i32) as u8),
+        (('b' as i32) as u8),
+        (('c' as i32) as u8),
+        (('\0' as i32) as u8),
+    ])));
+    assert!(
+        ((({
+            let mut __p = (buf.as_pointer() as Ptr<u8>).clone();
+            loop {
+                let __c = __p.read();
+                if __c == 0 {
+                    break Ptr::null();
+                }
+                let mut __q = Ptr::from_string_literal(b"b").clone();
+                let __hit = loop {
+                    let __r = __q.read();
+                    if __r == 0 {
+                        break false;
+                    }
+                    if __r == __c {
+                        break true;
+                    }
+                    __q += 1;
+                };
+                if __hit {
+                    break __p;
+                }
+                __p += 1;
+            }
+        } == ((buf.as_pointer() as Ptr<u8>).offset(1))) as i32)
+            != 0)
+    );
+}
+pub fn test_strcasecmp_14() {
+    assert!(
+        ((({
+            let mut __p1 = Ptr::from_string_literal(b"HELLO").clone();
+            let mut __p2 = Ptr::from_string_literal(b"hello").clone();
+            loop {
+                let __c1 = __p1.read().to_ascii_lowercase();
+                let __c2 = __p2.read().to_ascii_lowercase();
+                if __c1 != __c2 {
+                    break (__c1 as i32) - (__c2 as i32);
+                }
+                if __c1 == 0 {
+                    break 0;
+                }
+                __p1 += 1;
+                __p2 += 1;
+            }
+        } == 0) as i32)
+            != 0)
+    );
+    assert!(
+        ((({
+            let mut __p1 = Ptr::from_string_literal(b"abc").clone();
+            let mut __p2 = Ptr::from_string_literal(b"abd").clone();
+            loop {
+                let __c1 = __p1.read().to_ascii_lowercase();
+                let __c2 = __p2.read().to_ascii_lowercase();
+                if __c1 != __c2 {
+                    break (__c1 as i32) - (__c2 as i32);
+                }
+                if __c1 == 0 {
+                    break 0;
+                }
+                __p1 += 1;
+                __p2 += 1;
+            }
+        } < 0) as i32)
+            != 0)
+    );
+    assert!(
+        ((({
+            let mut __p1 = Ptr::from_string_literal(b"abd").clone();
+            let mut __p2 = Ptr::from_string_literal(b"abc").clone();
+            loop {
+                let __c1 = __p1.read().to_ascii_lowercase();
+                let __c2 = __p2.read().to_ascii_lowercase();
+                if __c1 != __c2 {
+                    break (__c1 as i32) - (__c2 as i32);
+                }
+                if __c1 == 0 {
+                    break 0;
+                }
+                __p1 += 1;
+                __p2 += 1;
+            }
+        } > 0) as i32)
+            != 0)
+    );
+    let p: Value<Ptr<u8>> = Rc::new(RefCell::new(Ptr::from_string_literal(b"FOO")));
+    let q: Value<Ptr<u8>> = Rc::new(RefCell::new(Ptr::from_string_literal(b"foo")));
+    assert!(
+        ((({
+            let mut __p1 = (*p.borrow()).clone();
+            let mut __p2 = (*q.borrow()).clone();
+            loop {
+                let __c1 = __p1.read().to_ascii_lowercase();
+                let __c2 = __p2.read().to_ascii_lowercase();
+                if __c1 != __c2 {
+                    break (__c1 as i32) - (__c2 as i32);
+                }
+                if __c1 == 0 {
+                    break 0;
+                }
+                __p1 += 1;
+                __p2 += 1;
+            }
+        } == 0) as i32)
+            != 0)
+    );
+}
+pub fn main() {
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    ({ test_memcpy_0() });
+    ({ test_memset_1() });
+    ({ test_memcmp_2() });
+    ({ test_memmove_3() });
+    ({ test_strchr_4() });
+    ({ test_strlen_5() });
+    ({ test_strcmp_6() });
+    ({ test_strncmp_7() });
+    ({ test_memchr_8() });
+    ({ test_strrchr_9() });
+    ({ test_strcspn_10() });
+    ({ test_strspn_11() });
+    ({ test_strstr_12() });
+    ({ test_strpbrk_13() });
+    ({ test_strcasecmp_14() });
+    return 0;
+}
diff --git a/tests/unit/out/refcount/va_arg_printf.rs b/tests/unit/out/refcount/va_arg_printf.rs
index cd3d4009..854f3e13 100644
--- a/tests/unit/out/refcount/va_arg_printf.rs
+++ b/tests/unit/out/refcount/va_arg_printf.rs
@@ -30,7 +30,15 @@ pub fn lenf_2(fmt: Ptr<u8>, __args: &[VaArg]) -> i32 {
     (*ap.borrow_mut()) = VaList::new(__args);
     let s: Value<Ptr<u8>> = Rc::new(RefCell::new(((*ap.borrow_mut()).arg::<Ptr<u8>>()).clone()));
     let result: Value<i32> = Rc::new(RefCell::new(
-        ((*s.borrow()).to_string_iterator().count() as i32),
+        ({
+            let mut __p = (*s.borrow()).clone();
+            let mut __i: usize = 0;
+            while __p.read() != 0 {
+                __p += 1;
+                __i += 1;
+            }
+            __i
+        } as i32),
     ));
     return (*result.borrow());
 }
@@ -45,7 +53,16 @@ fn main_0() -> i32 {
                 Ptr::from_string_literal(b"hello %d %d"),
                 &[
                     (10).into(),
-                    ((*dummy.borrow()).to_string_iterator().count()).into(),
+                    ({
+                        let mut __p = (*dummy.borrow()).clone();
+                        let mut __i: usize = 0;
+                        while __p.read() != 0 {
+                            __p += 1;
+                            __i += 1;
+                        }
+                        __i
+                    })
+                    .into(),
                 ],
             )
         }) == 15) as i32)
diff --git a/tests/unit/out/unsafe/inet_pton_ntop.rs b/tests/unit/out/unsafe/inet_pton_ntop.rs
new file mode 100644
index 00000000..45b8908f
--- /dev/null
+++ b/tests/unit/out/unsafe/inet_pton_ntop.rs
@@ -0,0 +1,174 @@
+extern crate libc;
+use libc::*;
+extern crate libcc2rs;
+use libcc2rs::*;
+use std::collections::BTreeMap;
+use std::io::{Read, Seek, Write};
+use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
+use std::rc::Rc;
+pub fn main() {
+    unsafe {
+        std::process::exit(main_0() as i32);
+    }
+}
+unsafe fn main_0() -> i32 {
+    let mut buf: [u8; 16] = [0_u8; 16];
+    assert!(
+        (((({
+            unsafe extern "C" {
+                fn inet_pton(af: i32, src: *const libc::c_char, dst: *mut ::libc::c_void) -> i32;
+            }
+            inet_pton(
+                2,
+                (c"1.2.3.4".as_ptr().cast_mut()).cast_const(),
+                (buf.as_mut_ptr() as *mut u8 as *mut ::libc::c_void),
+            )
+        }) == (1)) as i32)
+            != 0)
+    );
+    assert!(
+        (((((((((((((buf[(0) as usize] as i32) == (1)) as i32) != 0)
+            && ((((buf[(1) as usize] as i32) == (2)) as i32) != 0)) as i32)
+            != 0)
+            && ((((buf[(2) as usize] as i32) == (3)) as i32) != 0)) as i32)
+            != 0)
+            && ((((buf[(3) as usize] as i32) == (4)) as i32) != 0)) as i32)
+            != 0)
+    );
+    assert!(
+        (((({
+            unsafe extern "C" {
+                fn inet_pton(af: i32, src: *const libc::c_char, dst: *mut ::libc::c_void) -> i32;
+            }
+            inet_pton(
+                2,
+                (c"999.1.1.1".as_ptr().cast_mut()).cast_const(),
+                (buf.as_mut_ptr() as *mut u8 as *mut ::libc::c_void),
+            )
+        }) == (0)) as i32)
+            != 0)
+    );
+    assert!(
+        (((({
+            unsafe extern "C" {
+                fn inet_pton(af: i32, src: *const libc::c_char, dst: *mut ::libc::c_void) -> i32;
+            }
+            inet_pton(
+                2,
+                (c"not an ip".as_ptr().cast_mut()).cast_const(),
+                (buf.as_mut_ptr() as *mut u8 as *mut ::libc::c_void),
+            )
+        }) == (0)) as i32)
+            != 0)
+    );
+    assert!(
+        (((({
+            unsafe extern "C" {
+                fn inet_pton(af: i32, src: *const libc::c_char, dst: *mut ::libc::c_void) -> i32;
+            }
+            inet_pton(
+                10,
+                (c"::1".as_ptr().cast_mut()).cast_const(),
+                (buf.as_mut_ptr() as *mut u8 as *mut ::libc::c_void),
+            )
+        }) == (1)) as i32)
+            != 0)
+    );
+    assert!(
+        (((((((buf[(0) as usize] as i32) == (0)) as i32) != 0)
+            && ((((buf[(15) as usize] as i32) == (1)) as i32) != 0)) as i32)
+            != 0)
+    );
+    assert!(
+        (((({
+            unsafe extern "C" {
+                fn inet_pton(af: i32, src: *const libc::c_char, dst: *mut ::libc::c_void) -> i32;
+            }
+            inet_pton(
+                10,
+                (c"2001:db8::5".as_ptr().cast_mut()).cast_const(),
+                (buf.as_mut_ptr() as *mut u8 as *mut ::libc::c_void),
+            )
+        }) == (1)) as i32)
+            != 0)
+    );
+    assert!(
+        ((((((((((buf[(0) as usize] as i32) == (32)) as i32) != 0)
+            && ((((buf[(1) as usize] as i32) == (1)) as i32) != 0)) as i32)
+            != 0)
+            && ((((buf[(15) as usize] as i32) == (5)) as i32) != 0)) as i32)
+            != 0)
+    );
+    let mut text: [libc::c_char; 64] = [(0 as libc::c_char); 64];
+    let mut four: [u8; 4] = [10_u8, 0_u8, 0_u8, 1_u8];
+    assert!(
+        ((((libc::strcmp(
+            {
+                unsafe extern "C" {
+                    fn inet_ntop(
+                        af: i32,
+                        src: *const ::libc::c_void,
+                        dst: *mut libc::c_char,
+                        size: u32,
+                    ) -> *const libc::c_char;
+                }
+                inet_ntop(
+                    2,
+                    (four.as_mut_ptr() as *const u8 as *const ::libc::c_void),
+                    text.as_mut_ptr(),
+                    (::std::mem::size_of::<[libc::c_char; 64]>() as u32),
+                )
+            },
+            (c"10.0.0.1".as_ptr().cast_mut()).cast_const()
+        )) == (0)) as i32)
+            != 0)
+    );
+    let mut sixteen: [u8; 16] = [
+        0_u8, 0_u8, 0_u8, 0_u8, 0_u8, 0_u8, 0_u8, 0_u8, 0_u8, 0_u8, 0_u8, 0_u8, 0_u8, 0_u8, 0_u8,
+        0_u8,
+    ];
+    sixteen[(15) as usize] = 1_u8;
+    assert!(
+        ((((libc::strcmp(
+            {
+                unsafe extern "C" {
+                    fn inet_ntop(
+                        af: i32,
+                        src: *const ::libc::c_void,
+                        dst: *mut libc::c_char,
+                        size: u32,
+                    ) -> *const libc::c_char;
+                }
+                inet_ntop(
+                    10,
+                    (sixteen.as_mut_ptr() as *const u8 as *const ::libc::c_void),
+                    text.as_mut_ptr(),
+                    (::std::mem::size_of::<[libc::c_char; 64]>() as u32),
+                )
+            },
+            (c"::1".as_ptr().cast_mut()).cast_const()
+        )) == (0)) as i32)
+            != 0)
+    );
+    assert!(
+        (((({
+            unsafe extern "C" {
+                fn inet_ntop(
+                    af: i32,
+                    src: *const ::libc::c_void,
+                    dst: *mut libc::c_char,
+                    size: u32,
+                ) -> *const libc::c_char;
+            }
+            inet_ntop(
+                2,
+                (four.as_mut_ptr() as *const u8 as *const ::libc::c_void),
+                text.as_mut_ptr(),
+                4_u32,
+            )
+        })
+        .is_null()) as i32)
+            != 0)
+    );
+    return 0;
+}
diff --git a/tests/unit/out/unsafe/strdup.rs b/tests/unit/out/unsafe/strdup.rs
new file mode 100644
index 00000000..b60b8a55
--- /dev/null
+++ b/tests/unit/out/unsafe/strdup.rs
@@ -0,0 +1,62 @@
+extern crate libc;
+use libc::*;
+extern crate libcc2rs;
+use libcc2rs::*;
+use std::collections::BTreeMap;
+use std::io::{Read, Seek, Write};
+use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
+use std::rc::Rc;
+#[repr(C)]
+#[derive(Copy, Clone, Default)]
+pub struct record {
+    pub name: *mut libc::c_char,
+}
+pub fn main() {
+    unsafe {
+        std::process::exit(main_0() as i32);
+    }
+}
+unsafe fn main_0() -> i32 {
+    let mut d: *mut libc::c_char =
+        libcc2rs::strdup_unsafe((c"hello".as_ptr().cast_mut()).cast_const());
+    assert!((((!((d).is_null())) as i32) != 0));
+    assert!(
+        ((((libc::strcmp(
+            (d).cast_const(),
+            (c"hello".as_ptr().cast_mut()).cast_const()
+        )) == (0)) as i32)
+            != 0)
+    );
+    libcc2rs::free_unsafe((d as *mut libc::c_char as *mut ::libc::c_void));
+    let mut p: *const libc::c_char = (c"world".as_ptr().cast_mut()).cast_const();
+    let mut buf: [libc::c_char; 4] = [
+        (('a' as i32) as libc::c_char),
+        (('b' as i32) as libc::c_char),
+        (('c' as i32) as libc::c_char),
+        (('\0' as i32) as libc::c_char),
+    ];
+    let mut d2: *mut libc::c_char = libcc2rs::strdup_unsafe(p);
+    assert!((((!((d2).is_null())) as i32) != 0));
+    assert!(((((libc::strcmp((d2).cast_const(), p)) == (0)) as i32) != 0));
+    libcc2rs::free_unsafe((d2 as *mut libc::c_char as *mut ::libc::c_void));
+    let mut d3: *mut libc::c_char = libcc2rs::strdup_unsafe((buf.as_mut_ptr()).cast_const());
+    assert!((((!((d3).is_null())) as i32) != 0));
+    assert!(
+        ((((libc::strcmp((d3).cast_const(), (buf.as_mut_ptr()).cast_const())) == (0)) as i32) != 0)
+    );
+    libcc2rs::free_unsafe((d3 as *mut libc::c_char as *mut ::libc::c_void));
+    let mut d4: *mut libc::c_char = std::ptr::null_mut();
+    d4 = libcc2rs::strdup_unsafe(p);
+    assert!((((!((d4).is_null())) as i32) != 0));
+    assert!(((((libc::strcmp((d4).cast_const(), p)) == (0)) as i32) != 0));
+    libcc2rs::free_unsafe((d4 as *mut libc::c_char as *mut ::libc::c_void));
+    let mut rec: record = record {
+        name: std::ptr::null_mut(),
+    };
+    let mut r: *mut record = (&mut rec as *mut record);
+    (*r).name = libcc2rs::strdup_unsafe(p);
+    assert!((((!(((*r).name).is_null())) as i32) != 0));
+    assert!(((((libc::strcmp(((*r).name).cast_const(), p)) == (0)) as i32) != 0));
+    libcc2rs::free_unsafe(((*r).name as *mut libc::c_char as *mut ::libc::c_void));
+    return 0;
+}
diff --git a/tests/unit/out/unsafe/string_h.rs b/tests/unit/out/unsafe/string_h.rs
index 9c5faac7..fbe4f580 100644
--- a/tests/unit/out/unsafe/string_h.rs
+++ b/tests/unit/out/unsafe/string_h.rs
@@ -218,6 +218,11 @@ pub unsafe fn test_strlen_5() {
     assert!(
         ((((libc::strcmp(second, (c"two".as_ptr().cast_mut()).cast_const())) == (0)) as i32) != 0)
     );
+    let mut big : [ libc::c_char ; 64] = std::mem::transmute(*b"hi\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\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\0\0\0\0") ;
+    assert!(((((libc::strlen((big.as_mut_ptr()).cast_const())) == (2_usize)) as i32) != 0));
+    big[(2) as usize] = (('x' as i32) as libc::c_char);
+    big[(3) as usize] = (('\0' as i32) as libc::c_char);
+    assert!(((((libc::strlen((big.as_mut_ptr()).cast_const())) == (3_usize)) as i32) != 0));
 }
 pub unsafe fn test_strcmp_6() {
     assert!(
@@ -357,37 +362,7 @@ pub unsafe fn test_strrchr_9() {
             != 0)
     );
 }
-pub unsafe fn test_strdup_10() {
-    let mut d: *mut libc::c_char =
-        libcc2rs::strdup_unsafe((c"hello".as_ptr().cast_mut()).cast_const());
-    assert!((((!((d).is_null())) as i32) != 0));
-    assert!(
-        ((((libc::strcmp(
-            (d).cast_const(),
-            (c"hello".as_ptr().cast_mut()).cast_const()
-        )) == (0)) as i32)
-            != 0)
-    );
-    libcc2rs::free_unsafe((d as *mut libc::c_char as *mut ::libc::c_void));
-    let mut p: *const libc::c_char = (c"world".as_ptr().cast_mut()).cast_const();
-    let mut buf: [libc::c_char; 4] = [
-        (('a' as i32) as libc::c_char),
-        (('b' as i32) as libc::c_char),
-        (('c' as i32) as libc::c_char),
-        (('\0' as i32) as libc::c_char),
-    ];
-    let mut d2: *mut libc::c_char = libcc2rs::strdup_unsafe(p);
-    assert!((((!((d2).is_null())) as i32) != 0));
-    assert!(((((libc::strcmp((d2).cast_const(), p)) == (0)) as i32) != 0));
-    libcc2rs::free_unsafe((d2 as *mut libc::c_char as *mut ::libc::c_void));
-    let mut d3: *mut libc::c_char = libcc2rs::strdup_unsafe((buf.as_mut_ptr()).cast_const());
-    assert!((((!((d3).is_null())) as i32) != 0));
-    assert!(
-        ((((libc::strcmp((d3).cast_const(), (buf.as_mut_ptr()).cast_const())) == (0)) as i32) != 0)
-    );
-    libcc2rs::free_unsafe((d3 as *mut libc::c_char as *mut ::libc::c_void));
-}
-pub unsafe fn test_strcspn_11() {
+pub unsafe fn test_strcspn_10() {
     assert!(
         ((((libc::strcspn(
             (c"hello".as_ptr().cast_mut()).cast_const(),
@@ -413,7 +388,7 @@ pub unsafe fn test_strcspn_11() {
     let mut rej: *const libc::c_char = (c"el".as_ptr().cast_mut()).cast_const();
     assert!(((((libc::strcspn(s, rej)) == (1_usize)) as i32) != 0));
 }
-pub unsafe fn test_strspn_12() {
+pub unsafe fn test_strspn_11() {
     assert!(
         ((((libc::strspn(
             (c"hello".as_ptr().cast_mut()).cast_const(),
@@ -439,7 +414,7 @@ pub unsafe fn test_strspn_12() {
     let mut acc: *const libc::c_char = (c"hel".as_ptr().cast_mut()).cast_const();
     assert!(((((libc::strspn(s, acc)) == (4_usize)) as i32) != 0));
 }
-pub unsafe fn test_strstr_13() {
+pub unsafe fn test_strstr_12() {
     let mut h: *const libc::c_char = (c"hello world".as_ptr().cast_mut()).cast_const();
     let mut r: *mut libc::c_char = libc::strstr(
         (h as *mut libc::c_char).cast_const(),
@@ -471,7 +446,7 @@ pub unsafe fn test_strstr_13() {
             != 0)
     );
 }
-pub unsafe fn test_strpbrk_14() {
+pub unsafe fn test_strpbrk_13() {
     let mut s: *const libc::c_char = (c"hello world".as_ptr().cast_mut()).cast_const();
     let mut r: *mut libc::c_char = libc::strpbrk(
         (s as *mut libc::c_char).cast_const(),
@@ -501,7 +476,7 @@ pub unsafe fn test_strpbrk_14() {
             != 0)
     );
 }
-pub unsafe fn test_strcasecmp_15() {
+pub unsafe fn test_strcasecmp_14() {
     assert!(
         ((((libc::strcasecmp(
             (c"HELLO".as_ptr().cast_mut()).cast_const(),
@@ -543,11 +518,10 @@ unsafe fn main_0() -> i32 {
     (unsafe { test_strncmp_7() });
     (unsafe { test_memchr_8() });
     (unsafe { test_strrchr_9() });
-    (unsafe { test_strdup_10() });
-    (unsafe { test_strcspn_11() });
-    (unsafe { test_strspn_12() });
-    (unsafe { test_strstr_13() });
-    (unsafe { test_strpbrk_14() });
-    (unsafe { test_strcasecmp_15() });
+    (unsafe { test_strcspn_10() });
+    (unsafe { test_strspn_11() });
+    (unsafe { test_strstr_12() });
+    (unsafe { test_strpbrk_13() });
+    (unsafe { test_strcasecmp_14() });
     return 0;
 }
diff --git a/tests/unit/strdup.c b/tests/unit/strdup.c
new file mode 100644
index 00000000..49fa29cc
--- /dev/null
+++ b/tests/unit/strdup.c
@@ -0,0 +1,36 @@
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+
+struct record {
+  char *name;
+};
+
+int main(void) {
+  char *d = strdup("hello");
+  assert(d != NULL);
+  assert(strcmp(d, "hello") == 0);
+  free(d);
+  const char *p = "world";
+  char buf[] = {'a', 'b', 'c', '\0'};
+  char *d2 = strdup(p);
+  assert(d2 != NULL);
+  assert(strcmp(d2, p) == 0);
+  free(d2);
+  char *d3 = strdup(buf);
+  assert(d3 != NULL);
+  assert(strcmp(d3, buf) == 0);
+  free(d3);
+  char *d4 = 0;
+  d4 = strdup(p);
+  assert(d4 != NULL);
+  assert(strcmp(d4, p) == 0);
+  free(d4);
+  struct record rec = {0};
+  struct record *r = &rec;
+  r->name = strdup(p);
+  assert(r->name != NULL);
+  assert(strcmp(r->name, p) == 0);
+  free(r->name);
+  return 0;
+}
diff --git a/tests/unit/string_h.c b/tests/unit/string_h.c
index 3d47628b..c123fd26 100644
--- a/tests/unit/string_h.c
+++ b/tests/unit/string_h.c
@@ -1,7 +1,5 @@
-// no-compile: refcount
 #define _GNU_SOURCE
 #include <assert.h>
-#include <stdlib.h>
 #include <string.h>
 #include <strings.h>
 
@@ -54,6 +52,11 @@ static void test_strlen(void) {
   const char *first = buf;
   const char *second = &buf[strlen(first) + 1];
   assert(strcmp(second, "two") == 0);
+  char big[64] = "hi";
+  assert(strlen(big) == 2);
+  big[2] = 'x';
+  big[3] = '\0';
+  assert(strlen(big) == 3);
 }
 
 static void test_strcmp(void) {
@@ -102,23 +105,6 @@ static void test_strrchr(void) {
   assert(strrchr(buf, 'a') == &buf[2]);
 }
 
-static void test_strdup(void) {
-  char *d = strdup("hello");
-  assert(d != NULL);
-  assert(strcmp(d, "hello") == 0);
-  free(d);
-  const char *p = "world";
-  char buf[] = {'a', 'b', 'c', '\0'};
-  char *d2 = strdup(p);
-  assert(d2 != NULL);
-  assert(strcmp(d2, p) == 0);
-  free(d2);
-  char *d3 = strdup(buf);
-  assert(d3 != NULL);
-  assert(strcmp(d3, buf) == 0);
-  free(d3);
-}
-
 static void test_strcspn(void) {
   assert(strcspn("hello", "el") == 1);
   assert(strcspn("abc", "xyz") == 3);
@@ -177,7 +163,6 @@ int main(void) {
   test_strncmp();
   test_memchr();
   test_strrchr();
-  test_strdup();
   test_strcspn();
   test_strspn();
   test_strstr();