diff --git a/cpp2rust/converter/converter.cpp b/cpp2rust/converter/converter.cpp
index aae2337f..81a94fda 100644
--- a/cpp2rust/converter/converter.cpp
+++ b/cpp2rust/converter/converter.cpp
@@ -4003,10 +4003,6 @@ void Converter::ConvertVarInit(clang::QualType qual_type, clang::Expr *expr) {
     PushInitType init_type(*this, qual_type);
     Convert(expr, qual_type);
   }
-  if (qual_type->isReferenceType() && !IsReferenceType(expr)) {
-    StrCat(keyword::kAs);
-    Convert(qual_type);
-  }
 }
 
 void Converter::ConvertUnsignedArithOperand(clang::Expr *expr,
diff --git a/tests/ub/out/unsafe/dangling-prvalue-as-lvalue.rs b/tests/ub/out/unsafe/dangling-prvalue-as-lvalue.rs
index dbe39a02..32337b39 100644
--- a/tests/ub/out/unsafe/dangling-prvalue-as-lvalue.rs
+++ b/tests/ub/out/unsafe/dangling-prvalue-as-lvalue.rs
@@ -16,7 +16,7 @@ pub fn main() {
 }
 unsafe fn main_0() -> i32 {
     let mut v: Vec<i32> = vec![1, 2];
-    let b: *const i32 = (unsafe { foo_0(&(*v.as_mut_ptr()) as *const i32) });
+    let b: *const i32 = (unsafe { foo_0(&(*v.as_mut_ptr())) });
     v.clear();
     return (*b);
 }
diff --git a/tests/ub/out/unsafe/ub1.rs b/tests/ub/out/unsafe/ub1.rs
index 5ad662e9..71faa394 100644
--- a/tests/ub/out/unsafe/ub1.rs
+++ b/tests/ub/out/unsafe/ub1.rs
@@ -9,7 +9,7 @@ use std::rc::Rc;
 pub unsafe fn dangling_0() -> *mut i32 {
     let mut x: i32 = 1;
     let mut p: *mut i32 = (&mut x as *mut i32);
-    return &mut (*p) as *mut i32;
+    return &mut (*p);
 }
 pub fn main() {
     unsafe {
diff --git a/tests/ub/out/unsafe/ub4.rs b/tests/ub/out/unsafe/ub4.rs
index df61ee19..22d7d6cb 100644
--- a/tests/ub/out/unsafe/ub4.rs
+++ b/tests/ub/out/unsafe/ub4.rs
@@ -19,7 +19,7 @@ unsafe fn main_0() -> i32 {
     let mut x1: i32 = 1;
     if (x1 != 0) {
         let mut x2: i32 = -1_i32;
-        out = (unsafe { smaller_0(&mut x1 as *mut i32, &mut x2 as *mut i32) });
+        out = (unsafe { smaller_0(&mut x1, &mut x2) });
     }
     return (*out);
 }
diff --git a/tests/ub/out/unsafe/ub5.rs b/tests/ub/out/unsafe/ub5.rs
index c148459a..b3c322cf 100644
--- a/tests/ub/out/unsafe/ub5.rs
+++ b/tests/ub/out/unsafe/ub5.rs
@@ -18,6 +18,6 @@ unsafe fn main_0() -> i32 {
     let mut x: i32 = 1;
     let mut p: *mut i32 = (&mut x as *mut i32);
     (unsafe { null_0((&mut p as *mut *mut i32)) });
-    let r: *mut i32 = &mut (*p) as *mut i32;
+    let r: *mut i32 = &mut (*p);
     return (*r);
 }
diff --git a/tests/ub/out/unsafe/ub6.rs b/tests/ub/out/unsafe/ub6.rs
index e1c32351..9bb09de2 100644
--- a/tests/ub/out/unsafe/ub6.rs
+++ b/tests/ub/out/unsafe/ub6.rs
@@ -19,7 +19,7 @@ pub unsafe fn fill_1(arr: *mut Option<Box<[*mut i32]>>, n1: *mut i32) {
     let mut n2: i32 = (*n1);
     let mut pair: Pair = (unsafe {
         let _x1: *mut i32 = n1;
-        let _x2: *mut i32 = &mut n2 as *mut i32;
+        let _x2: *mut i32 = &mut n2;
         mkPair_0(_x1, _x2)
     });
     (*arr).as_mut().unwrap()[(0_usize)] = (pair.x1);
@@ -46,7 +46,6 @@ unsafe fn main_0() -> i32 {
             .map(|_| <*mut i32>::default())
             .collect::<Box<[_]>>(),
     );
-    (unsafe { fill_1(&mut arr as *mut Option<Box<[*mut i32]>>, &mut n as *mut i32) });
-    return ((unsafe { any_2(&mut arr as *mut Option<Box<[*mut i32]>>, &mut n as *mut i32) })
-        as i32);
+    (unsafe { fill_1(&mut arr, &mut n) });
+    return ((unsafe { any_2(&mut arr, &mut n) }) as i32);
 }
diff --git a/tests/unit/out/unsafe/04_address_taken_array.rs b/tests/unit/out/unsafe/04_address_taken_array.rs
index 73dd1ef6..04105f2d 100644
--- a/tests/unit/out/unsafe/04_address_taken_array.rs
+++ b/tests/unit/out/unsafe/04_address_taken_array.rs
@@ -18,7 +18,7 @@ unsafe fn main_0() -> i32 {
     let mut arr2_ptr: *mut i32 = arr2.as_mut_ptr();
     (*arr2_ptr.offset((0) as isize)) = 5;
     (*arr2_ptr.offset((1) as isize)) = 6;
-    let arr2_ref1: *mut i32 = &mut arr2[(1) as usize] as *mut i32;
+    let arr2_ref1: *mut i32 = &mut arr2[(1) as usize];
     (*arr2_ref1) = 7;
     assert!((((arr2[(0) as usize]) + (arr2[(1) as usize])) == (12)));
     return 0;
diff --git a/tests/unit/out/unsafe/09_references.rs b/tests/unit/out/unsafe/09_references.rs
index 73b50b7e..7abb3895 100644
--- a/tests/unit/out/unsafe/09_references.rs
+++ b/tests/unit/out/unsafe/09_references.rs
@@ -13,10 +13,10 @@ pub fn main() {
 }
 unsafe fn main_0() -> i32 {
     let mut h: i32 = 15;
-    let h_ref1: *mut i32 = &mut h as *mut i32;
+    let h_ref1: *mut i32 = &mut h;
     (*h_ref1) = 16;
     let mut h_ptr: *mut i32 = (h_ref1);
-    let h_ref2: *mut i32 = &mut (*h_ptr) as *mut i32;
+    let h_ref2: *mut i32 = &mut (*h_ptr);
     (*h_ref2) = 17;
     assert!((((*h_ref1) + (*h_ref2)) == (34)));
     return 0;
diff --git a/tests/unit/out/unsafe/11_move.rs b/tests/unit/out/unsafe/11_move.rs
index e6a6359e..22fa8c85 100644
--- a/tests/unit/out/unsafe/11_move.rs
+++ b/tests/unit/out/unsafe/11_move.rs
@@ -22,7 +22,7 @@ pub fn main() {
 }
 unsafe fn main_0() -> i32 {
     let mut n: Option<Box<i32>> = Some(Box::new(10));
-    (unsafe { change_0(&mut n as *mut Option<Box<i32>>) });
+    (unsafe { change_0(&mut n) });
     assert!(((*n.as_deref_mut().unwrap()) == (20)));
     return 0;
 }
diff --git a/tests/unit/out/unsafe/13_testing.rs b/tests/unit/out/unsafe/13_testing.rs
index 4825b256..ed7d44c3 100644
--- a/tests/unit/out/unsafe/13_testing.rs
+++ b/tests/unit/out/unsafe/13_testing.rs
@@ -13,7 +13,7 @@ pub fn main() {
 }
 unsafe fn main_0() -> i32 {
     let mut a: i32 = 1;
-    let r: *mut i32 = &mut a as *mut i32;
+    let r: *mut i32 = &mut a;
     let mut p: *mut i32 = (&mut a as *mut i32);
     (*r) = 2;
     (*p) = 3;
diff --git a/tests/unit/out/unsafe/alloc_array.rs b/tests/unit/out/unsafe/alloc_array.rs
index d7b4467c..be1d513d 100644
--- a/tests/unit/out/unsafe/alloc_array.rs
+++ b/tests/unit/out/unsafe/alloc_array.rs
@@ -39,7 +39,7 @@ unsafe fn main_0() -> i32 {
             .map(|_| <i32>::default())
             .collect::<Box<[_]>>(),
     );
-    (unsafe { All_0(&mut arr as *mut Option<Box<[i32]>>, N, 1) });
+    (unsafe { All_0(&mut arr, N, 1) });
     assert!(((unsafe { Consume_1(arr.take(), N,) }) == (10)));
     return 0;
 }
diff --git a/tests/unit/out/unsafe/array_reference.rs b/tests/unit/out/unsafe/array_reference.rs
index bdf9acd1..1a39c841 100644
--- a/tests/unit/out/unsafe/array_reference.rs
+++ b/tests/unit/out/unsafe/array_reference.rs
@@ -68,36 +68,32 @@ pub fn main() {
     }
 }
 unsafe fn main_0() -> i32 {
-    assert!(
-        ((unsafe { len_0(&std::mem::transmute(*b"beta\0") as *const [libc::c_char; 5],) }) == (4))
-    );
+    assert!(((unsafe { len_0(&std::mem::transmute(*b"beta\0"),) }) == (4)));
     let mut buf: [libc::c_char; 5] = std::mem::transmute(*b"abcd\0");
-    assert!(((unsafe { len_0(&buf as *const [libc::c_char; 5],) }) == (4)));
+    assert!(((unsafe { len_0(&buf,) }) == (4)));
     let mut arr: [i32; 3] = [1, 2, 3];
-    assert!(((unsafe { sum_2(&arr as *const [i32; 3],) }) == (6)));
-    (unsafe { fill_3(&mut arr as *mut [i32; 3], 7) });
-    assert!(((unsafe { sum_2(&arr as *const [i32; 3],) }) == (21)));
-    assert!(((unsafe { sum_twice_4(&arr as *const [i32; 3],) }) == (42)));
+    assert!(((unsafe { sum_2(&arr,) }) == (6)));
+    (unsafe { fill_3(&mut arr, 7) });
+    assert!(((unsafe { sum_2(&arr,) }) == (21)));
+    assert!(((unsafe { sum_twice_4(&arr,) }) == (42)));
     let mut out: i32 = 0;
-    (unsafe { fill_and_sum_5(&mut arr as *mut [i32; 3], 2, &mut out as *mut i32) });
+    (unsafe { fill_and_sum_5(&mut arr, 2, &mut out) });
     assert!(((out) == (12)));
     assert!(((arr[(0) as usize]) == (2)));
-    let lit: *const [libc::c_char; 5] =
-        &std::mem::transmute(*b"beta\0") as *const [libc::c_char; 5];
+    let lit: *const [libc::c_char; 5] = &std::mem::transmute(*b"beta\0");
     assert!(((unsafe { len_0(lit,) }) == (4)));
     assert!(
-        (((*(unsafe { pick_6(&std::mem::transmute(*b"beta\0") as *const [libc::c_char; 5],) }))
-            [(0) as usize] as i32)
+        (((*(unsafe { pick_6(&std::mem::transmute(*b"beta\0"),) }))[(0) as usize] as i32)
             == (('b' as libc::c_char) as i32))
     );
-    assert!(((unsafe { len_0((unsafe { pick_6(&buf as *const [libc::c_char; 5],) }),) }) == (4)));
+    assert!(((unsafe { len_0((unsafe { pick_6(&buf,) }),) }) == (4)));
     let mut pts: [Point; 2] = [Point { x: 1, y: 2 }, Point { x: 3, y: 4 }];
-    assert!(((unsafe { sum_points_7(&pts as *const [Point; 2],) }) == (10)));
-    (unsafe { shift_points_8(&mut pts as *mut [Point; 2], 10) });
+    assert!(((unsafe { sum_points_7(&pts,) }) == (10)));
+    (unsafe { shift_points_8(&mut pts, 10) });
     assert!(((pts[(0) as usize].x) == (11)));
     assert!(((pts[(1) as usize].y) == (14)));
-    assert!(((unsafe { sum_points_7(&pts as *const [Point; 2],) }) == (30)));
+    assert!(((unsafe { sum_points_7(&pts,) }) == (30)));
     let mut names: [*const libc::c_char; 2] = [c"ab".as_ptr(), c"cde".as_ptr()];
-    assert!(((unsafe { total_len_9(&mut names as *mut [*const libc::c_char; 2],) }) == (5)));
+    assert!(((unsafe { total_len_9(&mut names,) }) == (5)));
     return 0;
 }
diff --git a/tests/unit/out/unsafe/borrow_mut_opt.rs b/tests/unit/out/unsafe/borrow_mut_opt.rs
index 1aa8e5ae..7ebeca1e 100644
--- a/tests/unit/out/unsafe/borrow_mut_opt.rs
+++ b/tests/unit/out/unsafe/borrow_mut_opt.rs
@@ -32,7 +32,7 @@ pub unsafe fn convert_without_rhs_0() {
     c = arr2[(*p1) as usize];
     let mut p2: *mut i32 = (&mut x as *mut i32);
     (*p2) = 1;
-    let r: *mut i32 = &mut x as *mut i32;
+    let r: *mut i32 = &mut x;
     (*r) = 1;
 }
 pub unsafe fn convert_with_rhs_1() {
@@ -44,7 +44,7 @@ pub unsafe fn convert_with_rhs_1() {
     arr[(y) as usize] = ((y) + (1));
     arr[(x) as usize] = ((x) + (1));
     arr[(x) as usize] = ((arr[(y) as usize]) + (1));
-    let z: *mut i32 = &mut x as *mut i32;
+    let z: *mut i32 = &mut x;
     x += (*z);
     y += (*z);
     let mut p: *mut i32 = (&mut x as *mut i32);
diff --git a/tests/unit/out/unsafe/class.rs b/tests/unit/out/unsafe/class.rs
index a2517775..2ac686ff 100644
--- a/tests/unit/out/unsafe/class.rs
+++ b/tests/unit/out/unsafe/class.rs
@@ -29,14 +29,14 @@ impl Pair {
     pub unsafe fn SetFirst(&mut self, mut new_first: i32) -> i32 {
         return ((unsafe { Pair::GetFirst(self) })
             + (unsafe {
-                let _field: *mut i32 = &mut self.first as *mut i32;
+                let _field: *mut i32 = &mut self.first;
                 Pair::Set(self, _field, new_first)
             }));
     }
     pub unsafe fn SetSecond(&mut self, mut new_second: i32) -> i32 {
         return ((unsafe { Pair::GetSecond(self) })
             + (unsafe {
-                let _field: *mut i32 = &mut self.second as *mut i32;
+                let _field: *mut i32 = &mut self.second;
                 Pair::Set(self, _field, new_second)
             }));
     }
@@ -95,8 +95,8 @@ unsafe fn main_0() -> i32 {
         )
     });
     assert!(
-        (((((unsafe { RandomRoute_0(&mut route1 as *mut Route,) })
-            + (unsafe { RandomRoute_0(&mut route2 as *mut Route,) })) as f64)
+        (((((unsafe { RandomRoute_0(&mut route1,) }) + (unsafe { RandomRoute_0(&mut route2,) }))
+            as f64)
             + (old_cost))
             == (9_f64))
     );
diff --git a/tests/unit/out/unsafe/clone_vs_move.rs b/tests/unit/out/unsafe/clone_vs_move.rs
index 61340742..4d2f0030 100644
--- a/tests/unit/out/unsafe/clone_vs_move.rs
+++ b/tests/unit/out/unsafe/clone_vs_move.rs
@@ -47,7 +47,7 @@ unsafe fn main_0() -> i32 {
     x4.prefix_inc();
     assert!(((x3) == (3.0E+0)));
     assert!(((x4) == (4.0E+0)));
-    let reference: *mut i32 = &mut x1 as *mut i32;
+    let reference: *mut i32 = &mut x1;
     let mut x5: i32 = (*reference);
     x5.prefix_inc();
     assert!(((*reference) == (1)));
@@ -63,7 +63,7 @@ unsafe fn main_0() -> i32 {
     assert!(((*other_pointer) == (*pointer)));
     let mut f1: Foo = Foo {
         x: 1,
-        y: &mut x1 as *mut i32,
+        y: &mut x1,
         z: (&mut x1 as *mut i32),
         a: [0, 1, 2],
         bar: Bar { w: 10 },
diff --git a/tests/unit/out/unsafe/complex_function.rs b/tests/unit/out/unsafe/complex_function.rs
index ad8fc5c3..20fd319d 100644
--- a/tests/unit/out/unsafe/complex_function.rs
+++ b/tests/unit/out/unsafe/complex_function.rs
@@ -47,7 +47,7 @@ pub struct X4 {
 }
 impl X4 {
     pub unsafe fn get(&mut self) -> *mut X3 {
-        return &mut self.v as *mut X3;
+        return &mut self.v;
     }
 }
 pub fn main() {
@@ -66,17 +66,15 @@ unsafe fn main_0() -> i32 {
     let mut p2: *mut i32 = (unsafe { ptr_1(p1) });
     p1 = p2;
     p2 = (unsafe { ptr_1(p1) });
-    let r1: *mut i32 = &mut x1 as *mut i32;
-    let r2: *mut i32 = (unsafe { bar_2(&mut x1 as *mut i32) });
+    let r1: *mut i32 = &mut x1;
+    let r2: *mut i32 = (unsafe { bar_2(&mut x1) });
     let r3: *mut i32 = (unsafe { bar_2(r1) });
     (*r2) += x1;
     (*r3) += (*r1);
     let mut x4: i32 = (((unsafe { foo_0(x3) }) + (*(unsafe { ptr_1((&mut x3 as *mut i32)) })))
-        + (*(unsafe { bar_2(&mut x2 as *mut i32) })));
+        + (*(unsafe { bar_2(&mut x2) })));
     let mut a: X1 = X1 { v: 0 };
-    let mut b: X2 = X2 {
-        v: &mut a as *mut X1,
-    };
+    let mut b: X2 = X2 { v: &mut a };
     let mut c: X3 = X3 {
         v: (&mut b as *mut X2),
     };
@@ -88,36 +86,35 @@ unsafe fn main_0() -> i32 {
     let r4: *const i32 = &(*(unsafe {
         X2::get(&mut (*(unsafe { X3::get(&mut (*(unsafe { X4::get(&mut d) }))) })))
     }))
-    .v as *const i32;
+    .v;
     let r5: *mut X1 =
         (unsafe { X2::get(&mut (*(unsafe { X3::get(&mut (*(unsafe { X4::get(&mut d) }))) }))) });
     let mut p: *mut X2 = (unsafe { X3::get(&mut (*(unsafe { X4::get(&mut d) }))) });
     let r6: *mut X3 = (unsafe { X4::get(&mut d) });
-    let r7: *mut X3 = &mut d.v as *mut X3;
-    let r8: *mut i32 =
-        &mut (*(unsafe { X2::get(&mut (*(unsafe { X3::get(&mut d.v) }))) })).v as *mut i32;
+    let r7: *mut X3 = &mut d.v;
+    let r8: *mut i32 = &mut (*(unsafe { X2::get(&mut (*(unsafe { X3::get(&mut d.v) }))) })).v;
     let mut x5: i32 =
         (*(unsafe { X2::get(&mut (*(unsafe { X3::get(&mut (*(unsafe { X4::get(&mut d) }))) }))) }))
             .v;
-    (*(unsafe { bar_2(&mut x1 as *mut i32) })) += 10;
-    (*(unsafe { bar_2(&mut x1 as *mut i32) })).postfix_inc();
+    (*(unsafe { bar_2(&mut x1) })) += 10;
+    (*(unsafe { bar_2(&mut x1) })).postfix_inc();
     let mut bar_out: i32 = (*(unsafe {
         bar_2(
             &mut (*(unsafe {
                 X2::get(&mut (*(unsafe { X3::get(&mut (*(unsafe { X4::get(&mut d) }))) })))
             }))
-            .v as *mut i32,
+            .v,
         )
     }));
-    let mut bar_inc: i32 = (*(unsafe { bar_2(&mut x1 as *mut i32) })).prefix_inc();
-    bar_inc = (*(unsafe { bar_2(&mut x1 as *mut i32) })).postfix_inc();
-    bar_inc = (((*(unsafe { bar_2(&mut x1 as *mut i32) })) + (unsafe { foo_0(x4) })) + (1));
+    let mut bar_inc: i32 = (*(unsafe { bar_2(&mut x1) })).prefix_inc();
+    bar_inc = (*(unsafe { bar_2(&mut x1) })).postfix_inc();
+    bar_inc = (((*(unsafe { bar_2(&mut x1) })) + (unsafe { foo_0(x4) })) + (1));
     (*(unsafe {
         bar_2(
             &mut (*(unsafe {
                 X2::get(&mut (*(unsafe { X3::get(&mut (*(unsafe { X4::get(&mut d) }))) })))
             }))
-            .v as *mut i32,
+            .v,
         )
     })) += 10;
     (*(unsafe {
@@ -125,7 +122,7 @@ unsafe fn main_0() -> i32 {
             &mut (*(unsafe {
                 X2::get(&mut (*(unsafe { X3::get(&mut (*(unsafe { X4::get(&mut d) }))) })))
             }))
-            .v as *mut i32,
+            .v,
         )
     }))
     .postfix_inc();
@@ -134,7 +131,7 @@ unsafe fn main_0() -> i32 {
             &mut (*(unsafe {
                 X2::get(&mut (*(unsafe { X3::get(&mut (*(unsafe { X4::get(&mut d) }))) })))
             }))
-            .v as *mut i32,
+            .v,
         )
     }))
     .prefix_inc();
@@ -143,7 +140,7 @@ unsafe fn main_0() -> i32 {
             &mut (*(unsafe {
                 X2::get(&mut (*(unsafe { X3::get(&mut (*(unsafe { X4::get(&mut d) }))) })))
             }))
-            .v as *mut i32,
+            .v,
         )
     }))
     .postfix_inc();
@@ -190,7 +187,7 @@ unsafe fn main_0() -> i32 {
             }))
             .v as *mut i32),
         )
-    })) as *mut i32;
+    }));
     let mut ptr3: *mut i32 = (&mut (*(unsafe {
         ptr_1(
             (&mut (*(unsafe {
@@ -212,7 +209,7 @@ unsafe fn main_0() -> i32 {
             &mut (*(unsafe {
                 X2::get(&mut (*(unsafe { X3::get(&mut (*(unsafe { X4::get(&mut d) }))) })))
             }))
-            .v as *mut i32,
+            .v,
         )
     });
     (*(unsafe {
@@ -220,7 +217,7 @@ unsafe fn main_0() -> i32 {
             &mut (*(unsafe {
                 X2::get(&mut (*(unsafe { X3::get(&mut (*(unsafe { X4::get(&mut d) }))) })))
             }))
-            .v as *mut i32,
+            .v,
         )
     }))
     .postfix_inc();
@@ -237,7 +234,7 @@ unsafe fn main_0() -> i32 {
                 &mut (*(unsafe {
                     X2::get(&mut (*(unsafe { X3::get(&mut (*(unsafe { X4::get(&mut d) }))) })))
                 }))
-                .v as *mut i32,
+                .v,
             )
         }))) + (unsafe {
             foo_0(
diff --git a/tests/unit/out/unsafe/copy_assign.rs b/tests/unit/out/unsafe/copy_assign.rs
index c16d17a5..d1b7469f 100644
--- a/tests/unit/out/unsafe/copy_assign.rs
+++ b/tests/unit/out/unsafe/copy_assign.rs
@@ -27,11 +27,11 @@ impl Partial {
     }
     pub unsafe fn operator_assign(&mut self, o: *const Partial) -> *mut Partial {
         if (((self as *mut Partial).cast_const()) == (o)) {
-            return &mut (*(self as *mut Partial)) as *mut Partial;
+            return &mut (*(self as *mut Partial));
         }
         self.v = (*o).v;
         assigns_0.prefix_inc();
-        return &mut (*(self as *mut Partial)) as *mut Partial;
+        return &mut (*(self as *mut Partial));
     }
 }
 impl Clone for Partial {
@@ -54,14 +54,14 @@ impl NonConstAssign {
         o: *mut NonConstAssign,
     ) -> *mut NonConstAssign {
         self.mark = (((*o).mark) + (1));
-        return &mut (*(self as *mut NonConstAssign)) as *mut NonConstAssign;
+        return &mut (*(self as *mut NonConstAssign));
     }
     pub unsafe fn operator_assign_pconstNonConstAssign(
         &mut self,
         o: *const NonConstAssign,
     ) -> *mut NonConstAssign {
         self.mark = (((*o).mark) + (10));
-        return &mut (*(self as *mut NonConstAssign)) as *mut NonConstAssign;
+        return &mut (*(self as *mut NonConstAssign));
     }
 }
 impl Default for NonConstAssign {
@@ -81,7 +81,7 @@ impl RefQualified {
     }
     pub unsafe fn operator_assign(&mut self, o: *const RefQualified) -> *mut RefQualified {
         self.mark = (((*o).mark) + (1));
-        return &mut (*(self as *mut RefQualified)) as *mut RefQualified;
+        return &mut (*(self as *mut RefQualified));
     }
 }
 impl Default for RefQualified {
@@ -112,20 +112,19 @@ unsafe fn main_0() -> i32 {
     let mut a: Partial = Partial::Partial({ 1 }, { 100 });
     let mut b: Partial = Partial::Partial({ 2 }, { 200 });
     let mut c: Partial = Partial::Partial({ 3 }, { 300 });
-    (unsafe { Partial::operator_assign(&mut a, &b as *const Partial) });
+    (unsafe { Partial::operator_assign(&mut a, &b) });
     assert!(((a.v) == (2)) && ((a.keep) == (100)));
     assert!(((assigns_0) == (1)));
     (unsafe {
         Partial::operator_assign(
             &mut c,
-            &(*(unsafe { Partial::operator_assign(&mut a, &b as *const Partial) }))
-                as *const Partial,
+            &(*(unsafe { Partial::operator_assign(&mut a, &b) })),
         )
     });
     assert!(((c.v) == (2)) && ((c.keep) == (300)));
     assert!(((assigns_0) == (3)));
     (unsafe {
-        let _o: *const Partial = &a as *const Partial;
+        let _o: *const Partial = &a;
         Partial::operator_assign(&mut a, _o)
     });
     assert!(((assigns_0) == (3)));
@@ -135,15 +134,15 @@ unsafe fn main_0() -> i32 {
     });
     assert!(((a.v) == (9)) && ((a.keep) == (100)));
     assert!(((assigns_0) == (4)));
-    let ra: *mut Partial = &mut a as *mut Partial;
+    let ra: *mut Partial = &mut a;
     (unsafe {
-        let _o: *const Partial = &c as *const Partial;
+        let _o: *const Partial = &c;
         Partial::operator_assign(&mut (*ra), _o)
     });
     assert!(((a.v) == (2)));
     let mut pa: *mut Partial = (&mut a as *mut Partial);
     (unsafe {
-        let _o: *const Partial = &b as *const Partial;
+        let _o: *const Partial = &b;
         Partial::operator_assign(&mut (*pa), _o)
     });
     assert!(((a.v) == (2)));
@@ -155,8 +154,8 @@ unsafe fn main_0() -> i32 {
             Partial::Partial({ 6 }, { 60 }),
         ],
     };
-    (unsafe { Partial::operator_assign(&mut h.p, &b as *const Partial) });
-    (unsafe { Partial::operator_assign(&mut h.arr[(1) as usize], &c as *const Partial) });
+    (unsafe { Partial::operator_assign(&mut h.p, &b) });
+    (unsafe { Partial::operator_assign(&mut h.arr[(1) as usize], &c) });
     assert!(((h.p.v) == (2)) && ((h.p.keep) == (40)));
     assert!(((h.arr[(1) as usize].v) == (2)) && ((h.arr[(1) as usize].keep) == (60)));
     assert!(((assigns_0) == (8)));
@@ -164,17 +163,13 @@ unsafe fn main_0() -> i32 {
     let mut n1: NonConstAssign = NonConstAssign::NonConstAssign();
     let mut n2: NonConstAssign = NonConstAssign::NonConstAssign();
     let cn: NonConstAssign = NonConstAssign::NonConstAssign();
-    (unsafe {
-        NonConstAssign::operator_assign_pmutNonConstAssign(&mut n1, &mut n as *mut NonConstAssign)
-    });
-    (unsafe {
-        NonConstAssign::operator_assign_pconstNonConstAssign(&mut n2, &cn as *const NonConstAssign)
-    });
+    (unsafe { NonConstAssign::operator_assign_pmutNonConstAssign(&mut n1, &mut n) });
+    (unsafe { NonConstAssign::operator_assign_pconstNonConstAssign(&mut n2, &cn) });
     assert!(((n1.mark) == (1)));
     assert!(((n2.mark) == (10)));
     let mut r: RefQualified = RefQualified::RefQualified();
     let mut r1: RefQualified = RefQualified::RefQualified();
-    (unsafe { RefQualified::operator_assign(&mut r1, &r as *const RefQualified) });
+    (unsafe { RefQualified::operator_assign(&mut r1, &r) });
     assert!(((r1.mark) == (1)));
     return 0;
 }
diff --git a/tests/unit/out/unsafe/copy_ctor.rs b/tests/unit/out/unsafe/copy_ctor.rs
index 5bbe7906..56bd4a35 100644
--- a/tests/unit/out/unsafe/copy_ctor.rs
+++ b/tests/unit/out/unsafe/copy_ctor.rs
@@ -89,15 +89,12 @@ pub fn main() {
 }
 unsafe fn main_0() -> i32 {
     let mut a: Counted = Counted::Counted({ 1 });
-    let mut b: Counted = Counted::Counted_pconstCounted({ &a as *const Counted });
-    let mut c: Counted = Counted::Counted_pconstCounted({ &a as *const Counted });
-    let mut d: Counted = Counted::Counted_pconstCounted({ &a as *const Counted });
+    let mut b: Counted = Counted::Counted_pconstCounted({ &a });
+    let mut c: Counted = Counted::Counted_pconstCounted({ &a });
+    let mut d: Counted = Counted::Counted_pconstCounted({ &a });
     assert!(((copies_0) == (3)));
     assert!((((b.v) == (1)) && ((c.v) == (1))) && ((d.v) == (1)));
-    assert!(
-        ((unsafe { by_value_1(Counted::Counted_pconstCounted({ &a as *const Counted },),) })
-            == (1))
-    );
+    assert!(((unsafe { by_value_1(Counted::Counted_pconstCounted({ &a },),) }) == (1)));
     assert!(((copies_0) == (4)));
     let mut e: Counted = (unsafe { make_2(5) });
     assert!(((e.v) == (5)));
@@ -106,7 +103,7 @@ unsafe fn main_0() -> i32 {
     assert!(((f.v) == (6)));
     assert!(((copies_0) == (5)));
     let g: Counted = Counted::Counted({ 7 });
-    let mut h: Counted = Counted::Counted_pconstCounted({ &g as *const Counted });
+    let mut h: Counted = Counted::Counted_pconstCounted({ &g });
     assert!(((h.v) == (7)));
     assert!(((copies_0) == (6)));
     let mut hold: Holder = Holder {
@@ -127,9 +124,9 @@ unsafe fn main_0() -> i32 {
     assert!(((vec_[(0_usize)].v) == (1)));
     assert!(((copies_0) == (10)));
     let mut n: NonConst = NonConst::NonConst();
-    let mut n1: NonConst = NonConst::NonConst_pmutNonConst({ &mut n as *mut NonConst });
+    let mut n1: NonConst = NonConst::NonConst_pmutNonConst({ &mut n });
     let cn: NonConst = NonConst::NonConst();
-    let mut n2: NonConst = NonConst::NonConst_pconstNonConst({ &cn as *const NonConst });
+    let mut n2: NonConst = NonConst::NonConst_pconstNonConst({ &cn });
     assert!(((n1.mark) == (1)));
     assert!(((n2.mark) == (10)));
     return 0;
diff --git a/tests/unit/out/unsafe/cout_alias.rs b/tests/unit/out/unsafe/cout_alias.rs
index 35d1841c..3b4f5011 100644
--- a/tests/unit/out/unsafe/cout_alias.rs
+++ b/tests/unit/out/unsafe/cout_alias.rs
@@ -35,7 +35,7 @@ unsafe fn main_0() -> i32 {
                 .unwrap()
                 .into_raw_fd(),
         )
-    } as *mut std::fs::File;
+    };
     write!((*os2), "hello\n",);
     return 0;
 }
diff --git a/tests/unit/out/unsafe/doubly_linked_list.rs b/tests/unit/out/unsafe/doubly_linked_list.rs
index f11bcec2..0d414e79 100644
--- a/tests/unit/out/unsafe/doubly_linked_list.rs
+++ b/tests/unit/out/unsafe/doubly_linked_list.rs
@@ -127,38 +127,38 @@ unsafe fn main_0() -> i32 {
         prev: std::ptr::null_mut(),
     };
     (unsafe {
-        let _head: *mut Node = &mut (*head) as *mut Node;
-        let _new_node: *mut Node = &mut n1 as *mut Node;
+        let _head: *mut Node = &mut (*head);
+        let _new_node: *mut Node = &mut n1;
         Append_2(_head, _new_node)
     });
     (unsafe {
-        let _head: *mut Node = &mut (*head) as *mut Node;
-        let _new_node: *mut Node = &mut n2 as *mut Node;
+        let _head: *mut Node = &mut (*head);
+        let _new_node: *mut Node = &mut n2;
         Append_2(_head, _new_node)
     });
     (unsafe {
-        let _head: *mut Node = &mut (*head) as *mut Node;
-        let _new_node: *mut Node = &mut n3 as *mut Node;
+        let _head: *mut Node = &mut (*head);
+        let _new_node: *mut Node = &mut n3;
         Append_2(_head, _new_node)
     });
     (unsafe {
-        let _head: *mut Node = &mut (*head) as *mut Node;
-        let _new_node: *mut Node = &mut n4 as *mut Node;
+        let _head: *mut Node = &mut (*head);
+        let _new_node: *mut Node = &mut n4;
         Append_2(_head, _new_node)
     });
     (unsafe {
-        let _head: *mut Node = &mut (*head) as *mut Node;
-        let _new_node: *mut Node = &mut n5 as *mut Node;
+        let _head: *mut Node = &mut (*head);
+        let _new_node: *mut Node = &mut n5;
         Append_2(_head, _new_node)
     });
     (unsafe {
-        let _head: *mut Node = &mut (*head) as *mut Node;
-        let _new_node: *mut Node = &mut n6 as *mut Node;
+        let _head: *mut Node = &mut (*head);
+        let _new_node: *mut Node = &mut n6;
         Append_2(_head, _new_node)
     });
     (unsafe {
-        let _head: *mut Node = &mut (*head) as *mut Node;
-        let _new_node: *mut Node = &mut n7 as *mut Node;
+        let _head: *mut Node = &mut (*head);
+        let _new_node: *mut Node = &mut n7;
         Append_2(_head, _new_node)
     });
     head = (unsafe { Delete_3(head, 5) });
diff --git a/tests/unit/out/unsafe/exprs.rs b/tests/unit/out/unsafe/exprs.rs
index 69405697..150824d4 100644
--- a/tests/unit/out/unsafe/exprs.rs
+++ b/tests/unit/out/unsafe/exprs.rs
@@ -19,7 +19,7 @@ pub struct Y {
 }
 impl Y {
     pub unsafe fn foo(&mut self) -> *mut X {
-        return &mut self.x as *mut X;
+        return &mut self.x;
     }
     pub unsafe fn ptr(&mut self) -> *mut X {
         return (&mut self.x as *mut X);
@@ -45,7 +45,7 @@ unsafe fn main_0() -> i32 {
     (*p1) = (((x1) + (x4)) + (1));
     let mut x5: i32 = (*p1);
     let mut x6: i32 = (((*p1) + (x3)) + (5));
-    let r: *mut i32 = &mut x1 as *mut i32;
+    let r: *mut i32 = &mut x1;
     (*r) = 5;
     (*r) = ((*p1) + (5));
     let mut x7: i32 = (*r);
diff --git a/tests/unit/out/unsafe/fatorial.rs b/tests/unit/out/unsafe/fatorial.rs
index 84ce95d8..ad00e181 100644
--- a/tests/unit/out/unsafe/fatorial.rs
+++ b/tests/unit/out/unsafe/fatorial.rs
@@ -18,7 +18,7 @@ pub unsafe fn fatorial_by_ref_1(n: *mut i32) {
         return;
     }
     let mut n_1: i32 = ((*n) - (1));
-    (unsafe { fatorial_by_ref_1(&mut n_1 as *mut i32) });
+    (unsafe { fatorial_by_ref_1(&mut n_1) });
     (*n) *= n_1;
 }
 pub unsafe fn fatorial_by_ptr_2(mut n: *mut i32) {
@@ -39,7 +39,7 @@ unsafe fn main_0() -> i32 {
     let mut n1: i32 = 2;
     (unsafe { fatorial_by_ptr_2((&mut n1 as *mut i32)) });
     let mut n: i32 = ((n1) + (1));
-    (unsafe { fatorial_by_ref_1(&mut n as *mut i32) });
+    (unsafe { fatorial_by_ref_1(&mut n) });
     assert!(((unsafe { fatorial_0(n,) }) == (720)));
     return 0;
 }
diff --git a/tests/unit/out/unsafe/fft.rs b/tests/unit/out/unsafe/fft.rs
index 19ed836f..88a02fea 100644
--- a/tests/unit/out/unsafe/fft.rs
+++ b/tests/unit/out/unsafe/fft.rs
@@ -82,10 +82,8 @@ pub unsafe fn fft_3(a: *mut Option<Box<[Complex]>>, mut N: i32) -> Option<Box<[C
         };
         i.postfix_inc();
     }
-    let mut y0: Option<Box<[Complex]>> =
-        (unsafe { fft_3(&mut A0 as *mut Option<Box<[Complex]>>, ((N) / (2))) });
-    let mut y1: Option<Box<[Complex]>> =
-        (unsafe { fft_3(&mut A1 as *mut Option<Box<[Complex]>>, ((N) / (2))) });
+    let mut y0: Option<Box<[Complex]>> = (unsafe { fft_3(&mut A0, ((N) / (2))) });
+    let mut y1: Option<Box<[Complex]>> = (unsafe { fft_3(&mut A1, ((N) / (2))) });
     let mut k: i32 = 0;
     'loop_: while ((k) < ((N) / (2))) {
         let mut yk: Complex = (unsafe {
@@ -142,8 +140,7 @@ unsafe fn main_0() -> i32 {
         };
         i.postfix_inc();
     }
-    let mut b: Option<Box<[Complex]>> =
-        (unsafe { fft_3(&mut a as *mut Option<Box<[Complex]>>, N) });
+    let mut b: Option<Box<[Complex]>> = (unsafe { fft_3(&mut a, N) });
     let mut reals: Option<Box<[i32]>> = Some(
         (0..(N as usize))
             .map(|_| <i32>::default())
diff --git a/tests/unit/out/unsafe/friend.rs b/tests/unit/out/unsafe/friend.rs
index 0b9d58f7..0838e6ce 100644
--- a/tests/unit/out/unsafe/friend.rs
+++ b/tests/unit/out/unsafe/friend.rs
@@ -62,26 +62,26 @@ unsafe fn main_0() -> i32 {
     let mut a: V = V { x: 3 };
     let mut b: V = V { x: 3 };
     let mut c: V = V { x: 4 };
-    assert!(((unsafe { get_0(&a as *const V,) }) == (3)));
+    assert!(((unsafe { get_0(&a,) }) == (3)));
     assert!(
         (unsafe {
-            let _a: *const V = &a as *const V;
-            operator_eq_1(_a, &b as *const V)
+            let _a: *const V = &a;
+            operator_eq_1(_a, &b)
         })
     );
     assert!(
         !(unsafe {
-            let _a: *const V = &a as *const V;
-            operator_eq_1(_a, &c as *const V)
+            let _a: *const V = &a;
+            operator_eq_1(_a, &c)
         })
     );
-    assert!(((unsafe { scaled_2(&c as *const V, 2,) }) == (8)));
-    assert!(((unsafe { scaled_3(&c as *const V, 1.5E+0,) }) == (6.0E+0)));
+    assert!(((unsafe { scaled_2(&c, 2,) }) == (8)));
+    assert!(((unsafe { scaled_3(&c, 1.5E+0,) }) == (6.0E+0)));
     let mut wi: W_int_ = W_int_ { x: 5 };
     let mut wl: W_long_ = W_long_ { x: 6_i64 };
-    assert!(((unsafe { get_4(&wi as *const W_int_,) }) == (5)));
-    assert!(((unsafe { get_5(&wl as *const W_long_,) }) == (6_i64)));
+    assert!(((unsafe { get_4(&wi,) }) == (5)));
+    assert!(((unsafe { get_5(&wl,) }) == (6_i64)));
     let mut d: D = D { x: 7 };
-    assert!(((unsafe { declared_then_defined_6(&d as *const D,) }) == (8)));
+    assert!(((unsafe { declared_then_defined_6(&d,) }) == (8)));
     return 0;
 }
diff --git a/tests/unit/out/unsafe/function_overloading.rs b/tests/unit/out/unsafe/function_overloading.rs
index 19cfa331..a1ea21e6 100644
--- a/tests/unit/out/unsafe/function_overloading.rs
+++ b/tests/unit/out/unsafe/function_overloading.rs
@@ -48,11 +48,11 @@ unsafe fn main_0() -> i32 {
     let mut out: i32 = 0;
     out += (unsafe { foo_0(0) });
     out += (unsafe { foo_1((&mut x as *mut i32)) });
-    out += (unsafe { bar_4(&mut x as *mut i32) });
+    out += (unsafe { bar_4(&mut x) });
     out += (unsafe {
         let _x: *mut i32 = (&mut x as *mut i32);
         let _y: *mut i32 = (&mut x as *mut i32);
-        let _z: *mut i32 = &mut x as *mut i32;
+        let _z: *mut i32 = &mut x;
         foo_3(_x, _y, _z)
     });
     out += (unsafe {
diff --git a/tests/unit/out/unsafe/huffman.rs b/tests/unit/out/unsafe/huffman.rs
index ea15aba8..75a246d4 100644
--- a/tests/unit/out/unsafe/huffman.rs
+++ b/tests/unit/out/unsafe/huffman.rs
@@ -79,10 +79,8 @@ impl MinHeap {
         }
         if ((smallest) != (idx)) {
             (unsafe {
-                let _a: *mut MinHeapNode =
-                    &mut (*self.arr.as_mut().unwrap()[(smallest as usize)]) as *mut MinHeapNode;
-                let _b: *mut MinHeapNode =
-                    &mut (*self.arr.as_mut().unwrap()[(idx as usize)]) as *mut MinHeapNode;
+                let _a: *mut MinHeapNode = &mut (*self.arr.as_mut().unwrap()[(smallest as usize)]);
+                let _b: *mut MinHeapNode = &mut (*self.arr.as_mut().unwrap()[(idx as usize)]);
                 Swap_0(_a, _b)
             });
             (unsafe { MinHeap::Heapify(self, smallest) });
@@ -260,15 +258,7 @@ pub unsafe fn HuffmanCodes_5(
     );
     let mut top: i32 = 0;
     let mut next: i32 = 0;
-    (unsafe {
-        CollectCodes_4(
-            root,
-            &mut arr as *mut Option<Box<[i32]>>,
-            top,
-            &mut out as *mut Option<Box<[i32]>>,
-            &mut next as *mut i32,
-        )
-    });
+    (unsafe { CollectCodes_4(root, &mut arr, top, &mut out, &mut next) });
     return out.take();
 }
 pub fn main() {
@@ -303,13 +293,7 @@ unsafe fn main_0() -> i32 {
         freq.as_mut().unwrap()[(i as usize)] = arr2[(i) as usize];
         i.prefix_inc();
     }
-    let mut out: Option<Box<[i32]>> = (unsafe {
-        HuffmanCodes_5(
-            &mut data as *mut Option<Box<[libc::c_char]>>,
-            &mut freq as *mut Option<Box<[i32]>>,
-            size,
-        )
-    });
+    let mut out: Option<Box<[i32]>> = (unsafe { HuffmanCodes_5(&mut data, &mut freq, size) });
     assert!(
         ((((((out.as_mut().unwrap()[(0_usize)]) == (0))
             && ((out.as_mut().unwrap()[(1_usize)]) == (100)))
diff --git a/tests/unit/out/unsafe/init.rs b/tests/unit/out/unsafe/init.rs
index 5590090d..c4b49a67 100644
--- a/tests/unit/out/unsafe/init.rs
+++ b/tests/unit/out/unsafe/init.rs
@@ -22,7 +22,7 @@ pub fn main() {
 unsafe fn main_0() -> i32 {
     let mut x: i32 = 0_i32;
     let mut p: *mut i32 = std::ptr::null_mut();
-    let g: *mut i32 = &mut x as *mut i32;
+    let g: *mut i32 = &mut x;
     let mut q: *mut i32 = (&mut x as *mut i32);
     let mut z: *mut i32 = p;
     let mut xx: X = <X>::default();
diff --git a/tests/unit/out/unsafe/kruskal.rs b/tests/unit/out/unsafe/kruskal.rs
index cb364530..cb48b4dc 100644
--- a/tests/unit/out/unsafe/kruskal.rs
+++ b/tests/unit/out/unsafe/kruskal.rs
@@ -14,7 +14,7 @@ pub struct Edge {
     pub weight: f64,
 }
 pub unsafe fn partition_0(arr: *mut Option<Box<[Edge]>>, mut start: i32, mut end: i32) -> i32 {
-    let pivot: *mut Edge = &mut (*arr).as_mut().unwrap()[(start as usize)] as *mut Edge;
+    let pivot: *mut Edge = &mut (*arr).as_mut().unwrap()[(start as usize)];
     let mut count: i32 = 0;
     let mut i: i32 = ((start) + (1));
     'loop_: while ((i) <= (end)) {
@@ -148,7 +148,7 @@ pub struct Graph {
 }
 pub unsafe fn MSTKruskal_2(graph: *mut Graph) -> f64 {
     (unsafe {
-        let _arr: *mut Option<Box<[Edge]>> = &mut (*graph).edges as *mut Option<Box<[Edge]>>;
+        let _arr: *mut Option<Box<[Edge]>> = &mut (*graph).edges;
         let _end: i32 = (((*graph).E) - (1));
         quicksort_1(_arr, 0, _end)
     });
@@ -224,7 +224,7 @@ unsafe fn main_0() -> i32 {
         v: 3,
         weight: 5_f64,
     };
-    let mut total_weight: f64 = (unsafe { MSTKruskal_2(&mut graph as *mut Graph) });
+    let mut total_weight: f64 = (unsafe { MSTKruskal_2(&mut graph) });
     assert!(((total_weight) == (19_f64)));
     return 0;
 }
diff --git a/tests/unit/out/unsafe/linked_list.rs b/tests/unit/out/unsafe/linked_list.rs
index aaf26744..8fadd385 100644
--- a/tests/unit/out/unsafe/linked_list.rs
+++ b/tests/unit/out/unsafe/linked_list.rs
@@ -90,38 +90,38 @@ unsafe fn main_0() -> i32 {
         next: std::ptr::null_mut(),
     };
     (unsafe {
-        let _head: *mut Node = &mut (*head) as *mut Node;
-        let _new_node: *mut Node = &mut n1 as *mut Node;
+        let _head: *mut Node = &mut (*head);
+        let _new_node: *mut Node = &mut n1;
         Append_1(_head, _new_node)
     });
     (unsafe {
-        let _head: *mut Node = &mut (*head) as *mut Node;
-        let _new_node: *mut Node = &mut n2 as *mut Node;
+        let _head: *mut Node = &mut (*head);
+        let _new_node: *mut Node = &mut n2;
         Append_1(_head, _new_node)
     });
     (unsafe {
-        let _head: *mut Node = &mut (*head) as *mut Node;
-        let _new_node: *mut Node = &mut n3 as *mut Node;
+        let _head: *mut Node = &mut (*head);
+        let _new_node: *mut Node = &mut n3;
         Append_1(_head, _new_node)
     });
     (unsafe {
-        let _head: *mut Node = &mut (*head) as *mut Node;
-        let _new_node: *mut Node = &mut n4 as *mut Node;
+        let _head: *mut Node = &mut (*head);
+        let _new_node: *mut Node = &mut n4;
         Append_1(_head, _new_node)
     });
     (unsafe {
-        let _head: *mut Node = &mut (*head) as *mut Node;
-        let _new_node: *mut Node = &mut n5 as *mut Node;
+        let _head: *mut Node = &mut (*head);
+        let _new_node: *mut Node = &mut n5;
         Append_1(_head, _new_node)
     });
     (unsafe {
-        let _head: *mut Node = &mut (*head) as *mut Node;
-        let _new_node: *mut Node = &mut n6 as *mut Node;
+        let _head: *mut Node = &mut (*head);
+        let _new_node: *mut Node = &mut n6;
         Append_1(_head, _new_node)
     });
     (unsafe {
-        let _head: *mut Node = &mut (*head) as *mut Node;
-        let _new_node: *mut Node = &mut n7 as *mut Node;
+        let _head: *mut Node = &mut (*head);
+        let _new_node: *mut Node = &mut n7;
         Append_1(_head, _new_node)
     });
     head = (unsafe { Delete_2(head, 5) });
diff --git a/tests/unit/out/unsafe/map.rs b/tests/unit/out/unsafe/map.rs
index f2cdfb24..36fdf0f0 100644
--- a/tests/unit/out/unsafe/map.rs
+++ b/tests/unit/out/unsafe/map.rs
@@ -34,7 +34,7 @@ unsafe fn main_0() -> i32 {
     assert!(((*m.entry(2_i16).or_default().as_mut()) == (3_u32)));
     (unsafe { foo_0((*m.entry(0_i16).or_default().as_mut())) });
     assert!(((*m.entry(0_i16).or_default().as_mut()) == (1_u32)));
-    (unsafe { bar_1(&mut (*m.entry(2_i16).or_default().as_mut()) as *mut u32) });
+    (unsafe { bar_1(&mut (*m.entry(2_i16).or_default().as_mut())) });
     assert!(((*m.entry(2_i16).or_default().as_mut()) == (4_u32)));
     (*m.entry(0_i16).or_default().as_mut()) = (*m.entry(0_i16).or_default().as_mut())
         .wrapping_add((*m.entry(2_i16).or_default().as_mut()));
@@ -80,7 +80,7 @@ unsafe fn main_0() -> i32 {
     assert!(((*it4.second()) == (6_u32)));
     assert!(((*p) == (6_u32)));
     assert!(((x5) == (5_u32)));
-    let r: *mut BTreeMap<i16, Box<u32>> = &mut m as *mut BTreeMap<i16, Box<u32>>;
+    let r: *mut BTreeMap<i16, Box<u32>> = &mut m;
     assert!((((*r).len()) == (4_usize)));
     assert!(
         UnsafeMapIterator::find_key(&m as *const BTreeMap<i16, Box<u32>>, &4_i16)
diff --git a/tests/unit/out/unsafe/move_assign.rs b/tests/unit/out/unsafe/move_assign.rs
index 81caf114..5c9f54c9 100644
--- a/tests/unit/out/unsafe/move_assign.rs
+++ b/tests/unit/out/unsafe/move_assign.rs
@@ -23,11 +23,11 @@ impl MoveOnly {
     }
     pub unsafe fn operator_assign_pmutMoveOnly(&mut self, o: *mut MoveOnly) -> *mut MoveOnly {
         if ((self as *mut MoveOnly) == (o)) {
-            return &mut (*(self as *mut MoveOnly)) as *mut MoveOnly;
+            return &mut (*(self as *mut MoveOnly));
         }
         self.v = (*o).v;
         (*o).v = 0;
-        return &mut (*(self as *mut MoveOnly)) as *mut MoveOnly;
+        return &mut (*(self as *mut MoveOnly));
     }
 }
 #[repr(C)]
@@ -45,14 +45,14 @@ impl ConstMoveAssign {
         o: *mut ConstMoveAssign,
     ) -> *mut ConstMoveAssign {
         self.mark = (((*o).mark) + (1));
-        return &mut (*(self as *mut ConstMoveAssign)) as *mut ConstMoveAssign;
+        return &mut (*(self as *mut ConstMoveAssign));
     }
     pub unsafe fn operator_assign_pconstConstMoveAssign(
         &mut self,
         o: *const ConstMoveAssign,
     ) -> *mut ConstMoveAssign {
         self.mark = (((*o).mark) + (10));
-        return &mut (*(self as *mut ConstMoveAssign)) as *mut ConstMoveAssign;
+        return &mut (*(self as *mut ConstMoveAssign));
     }
 }
 impl Default for ConstMoveAssign {
diff --git a/tests/unit/out/unsafe/move_this.rs b/tests/unit/out/unsafe/move_this.rs
index a06da153..75b912f1 100644
--- a/tests/unit/out/unsafe/move_this.rs
+++ b/tests/unit/out/unsafe/move_this.rs
@@ -31,7 +31,7 @@ impl Chain {
     }
     pub unsafe fn add_i32_lref(&mut self, mut n: i32) -> *mut Chain {
         self.v += n;
-        return &mut (*(self as *mut Chain)) as *mut Chain;
+        return &mut (*(self as *mut Chain));
     }
     pub unsafe fn add_i32_rref(&mut self, mut n: i32) -> *mut Chain {
         self.v += n;
@@ -41,7 +41,7 @@ impl Chain {
         return Chain::Chain_pmutChain({ (self as *mut Chain) });
     }
     pub unsafe fn copy(&self) -> Chain {
-        return Chain::Chain_pconstChain({ &(*(self as *const Chain)) as *const Chain });
+        return Chain::Chain_pconstChain({ &(*(self as *const Chain)) });
     }
     pub unsafe fn self_(&mut self) -> *mut Chain {
         return (self as *mut Chain);
diff --git a/tests/unit/out/unsafe/new_array_var_size.rs b/tests/unit/out/unsafe/new_array_var_size.rs
index 323b005f..e9e34ea5 100644
--- a/tests/unit/out/unsafe/new_array_var_size.rs
+++ b/tests/unit/out/unsafe/new_array_var_size.rs
@@ -20,7 +20,7 @@ unsafe fn main_0() -> i32 {
         A,
         libcc2rs::malloc_usable_size(A as *mut ::libc::c_void) / ::std::mem::size_of::<i32>(),
     )));
-    let N2: *mut i32 = &mut N as *mut i32;
+    let N2: *mut i32 = &mut N;
     let mut A2: *mut i32 =
         Box::leak((0..((*N2) as usize)).map(|_| 0_i32).collect::<Box<[i32]>>()).as_mut_ptr();
 
diff --git a/tests/unit/out/unsafe/operator_arithmetic_free.rs b/tests/unit/out/unsafe/operator_arithmetic_free.rs
index 28a79422..07abe9a0 100644
--- a/tests/unit/out/unsafe/operator_arithmetic_free.rs
+++ b/tests/unit/out/unsafe/operator_arithmetic_free.rs
@@ -80,63 +80,63 @@ unsafe fn main_0() -> i32 {
     let mut b: S = S { v: 2 };
     assert!(
         (((unsafe {
-            let _a: *const S = &a as *const S;
-            operator_add_0(_a, &b as *const S)
+            let _a: *const S = &a;
+            operator_add_0(_a, &b)
         })
         .v) == (9))
     );
     assert!(
         (((unsafe {
-            let _a: *const S = &a as *const S;
-            operator_sub_1(_a, &b as *const S)
+            let _a: *const S = &a;
+            operator_sub_1(_a, &b)
         })
         .v) == (5))
     );
     assert!(
         (((unsafe {
-            let _a: *const S = &a as *const S;
-            operator_mul_2(_a, &b as *const S)
+            let _a: *const S = &a;
+            operator_mul_2(_a, &b)
         })
         .v) == (14))
     );
     assert!(
         (((unsafe {
-            let _a: *const S = &a as *const S;
-            operator_div_3(_a, &b as *const S)
+            let _a: *const S = &a;
+            operator_div_3(_a, &b)
         })
         .v) == (3))
     );
     assert!(
         (((unsafe {
-            let _a: *const S = &a as *const S;
-            operator_rem_4(_a, &b as *const S)
+            let _a: *const S = &a;
+            operator_rem_4(_a, &b)
         })
         .v) == (1))
     );
     assert!(
         (((unsafe {
-            let _a: *const S = &a as *const S;
+            let _a: *const S = &a;
             operator_pos_5(_a)
         })
         .v) == (7))
     );
     assert!(
         (((unsafe {
-            let _a: *const S = &a as *const S;
+            let _a: *const S = &a;
             operator_neg_6(_a)
         })
         .v) == (-7_i32))
     );
     assert!(
         (((*(unsafe {
-            let _a: *mut S = &mut a as *mut S;
+            let _a: *mut S = &mut a;
             operator_inc_7(_a)
         }))
         .v) == (8))
     );
     assert!(
         (((unsafe {
-            let _a: *mut S = &mut a as *mut S;
+            let _a: *mut S = &mut a;
             operator_post_inc_8(_a, 0)
         })
         .v) == (8))
@@ -144,14 +144,14 @@ unsafe fn main_0() -> i32 {
     assert!(((a.v) == (9)));
     assert!(
         (((*(unsafe {
-            let _a: *mut S = &mut a as *mut S;
+            let _a: *mut S = &mut a;
             operator_dec_9(_a)
         }))
         .v) == (8))
     );
     assert!(
         (((unsafe {
-            let _a: *mut S = &mut a as *mut S;
+            let _a: *mut S = &mut a;
             operator_post_dec_10(_a, 0)
         })
         .v) == (8))
@@ -159,11 +159,11 @@ unsafe fn main_0() -> i32 {
     assert!(((a.v) == (7)));
     assert!(
         (((unsafe {
-            let _a: *const S = &a as *const S;
+            let _a: *const S = &a;
             operator_add_11(_a, 1)
         })
         .v) == (8))
     );
-    assert!((((unsafe { operator_add_12(1, &a as *const S,) }).v) == (8)));
+    assert!((((unsafe { operator_add_12(1, &a,) }).v) == (8)));
     return 0;
 }
diff --git a/tests/unit/out/unsafe/operator_arithmetic_member.rs b/tests/unit/out/unsafe/operator_arithmetic_member.rs
index c3166ce2..268866bc 100644
--- a/tests/unit/out/unsafe/operator_arithmetic_member.rs
+++ b/tests/unit/out/unsafe/operator_arithmetic_member.rs
@@ -45,7 +45,7 @@ impl S {
     }
     pub unsafe fn operator_inc(&mut self) -> *mut S {
         self.v.prefix_inc();
-        return &mut (*(self as *mut S)) as *mut S;
+        return &mut (*(self as *mut S));
     }
     pub unsafe fn operator_post_inc_i32(&mut self, mut _a0: i32) -> S {
         let mut old: S = (*(self as *mut S));
@@ -54,7 +54,7 @@ impl S {
     }
     pub unsafe fn operator_dec(&mut self) -> *mut S {
         self.v.prefix_dec();
-        return &mut (*(self as *mut S)) as *mut S;
+        return &mut (*(self as *mut S));
     }
     pub unsafe fn operator_post_dec_i32(&mut self, mut _a0: i32) -> S {
         let mut old: S = (*(self as *mut S));
@@ -70,11 +70,11 @@ pub fn main() {
 unsafe fn main_0() -> i32 {
     let mut a: S = S { v: 7 };
     let mut b: S = S { v: 2 };
-    assert!((((unsafe { S::operator_add_pconstS_const(&a, &b as *const S,) }).v) == (9)));
-    assert!((((unsafe { S::operator_sub_pconstS_const(&a, &b as *const S,) }).v) == (5)));
-    assert!((((unsafe { S::operator_mul(&a, &b as *const S,) }).v) == (14)));
-    assert!((((unsafe { S::operator_div(&a, &b as *const S,) }).v) == (3)));
-    assert!((((unsafe { S::operator_rem(&a, &b as *const S,) }).v) == (1)));
+    assert!((((unsafe { S::operator_add_pconstS_const(&a, &b,) }).v) == (9)));
+    assert!((((unsafe { S::operator_sub_pconstS_const(&a, &b,) }).v) == (5)));
+    assert!((((unsafe { S::operator_mul(&a, &b,) }).v) == (14)));
+    assert!((((unsafe { S::operator_div(&a, &b,) }).v) == (3)));
+    assert!((((unsafe { S::operator_rem(&a, &b,) }).v) == (1)));
     assert!((((unsafe { S::operator_pos_const(&a,) }).v) == (7)));
     assert!((((unsafe { S::operator_neg_const(&a,) }).v) == (-7_i32)));
     assert!((((*(unsafe { S::operator_inc(&mut a,) })).v) == (8)));
diff --git a/tests/unit/out/unsafe/operator_bitwise_free.rs b/tests/unit/out/unsafe/operator_bitwise_free.rs
index f6c11f71..5bfdae44 100644
--- a/tests/unit/out/unsafe/operator_bitwise_free.rs
+++ b/tests/unit/out/unsafe/operator_bitwise_free.rs
@@ -49,42 +49,42 @@ unsafe fn main_0() -> i32 {
     let mut b: S = S { v: 10_u32 };
     assert!(
         (((unsafe {
-            let _a: *const S = &a as *const S;
+            let _a: *const S = &a;
             operator_bitnot_0(_a)
         })
         .v) == (!12_u32))
     );
     assert!(
         (((unsafe {
-            let _a: *const S = &a as *const S;
-            operator_bitand_1(_a, &b as *const S)
+            let _a: *const S = &a;
+            operator_bitand_1(_a, &b)
         })
         .v) == (8_u32))
     );
     assert!(
         (((unsafe {
-            let _a: *const S = &a as *const S;
-            operator_bitor_2(_a, &b as *const S)
+            let _a: *const S = &a;
+            operator_bitor_2(_a, &b)
         })
         .v) == (14_u32))
     );
     assert!(
         (((unsafe {
-            let _a: *const S = &a as *const S;
-            operator_bitxor_3(_a, &b as *const S)
+            let _a: *const S = &a;
+            operator_bitxor_3(_a, &b)
         })
         .v) == (6_u32))
     );
     assert!(
         (((unsafe {
-            let _a: *const S = &a as *const S;
+            let _a: *const S = &a;
             operator_shl_4(_a, 2)
         })
         .v) == (48_u32))
     );
     assert!(
         (((unsafe {
-            let _a: *const S = &a as *const S;
+            let _a: *const S = &a;
             operator_shr_5(_a, 2)
         })
         .v) == (3_u32))
diff --git a/tests/unit/out/unsafe/operator_bitwise_member.rs b/tests/unit/out/unsafe/operator_bitwise_member.rs
index f4abca28..161a57fa 100644
--- a/tests/unit/out/unsafe/operator_bitwise_member.rs
+++ b/tests/unit/out/unsafe/operator_bitwise_member.rs
@@ -50,9 +50,9 @@ unsafe fn main_0() -> i32 {
     let mut a: S = S { v: 12_u32 };
     let mut b: S = S { v: 10_u32 };
     assert!((((unsafe { S::operator_bitnot(&a,) }).v) == (!12_u32)));
-    assert!((((unsafe { S::operator_bitand(&a, &b as *const S,) }).v) == (8_u32)));
-    assert!((((unsafe { S::operator_bitor(&a, &b as *const S,) }).v) == (14_u32)));
-    assert!((((unsafe { S::operator_bitxor(&a, &b as *const S,) }).v) == (6_u32)));
+    assert!((((unsafe { S::operator_bitand(&a, &b,) }).v) == (8_u32)));
+    assert!((((unsafe { S::operator_bitor(&a, &b,) }).v) == (14_u32)));
+    assert!((((unsafe { S::operator_bitxor(&a, &b,) }).v) == (6_u32)));
     assert!((((unsafe { S::operator_shl(&a, 2,) }).v) == (48_u32)));
     assert!((((unsafe { S::operator_shr(&a, 2,) }).v) == (3_u32)));
     return 0;
diff --git a/tests/unit/out/unsafe/operator_comparison_defaulted.rs b/tests/unit/out/unsafe/operator_comparison_defaulted.rs
index 72c41b77..a4c454c5 100644
--- a/tests/unit/out/unsafe/operator_comparison_defaulted.rs
+++ b/tests/unit/out/unsafe/operator_comparison_defaulted.rs
@@ -179,7 +179,7 @@ impl Outer {
     pub unsafe fn operator_cmp(&self, _a0: *const Outer) -> std::cmp::Ordering {
         {
             let mut cmp: std::cmp::Ordering = (unsafe {
-                let _arg0: *const Inner = &(*_a0).i as *const Inner;
+                let _arg0: *const Inner = &(*_a0).i;
                 Inner::operator_cmp(&(*(self as *const Outer)).i, _arg0)
             });
             if !(cmp == std::cmp::Ordering::Equal) {
@@ -196,7 +196,7 @@ impl Outer {
     }
     pub unsafe fn operator_eq(&self, _a0: *const Outer) -> bool {
         return (unsafe {
-            let _arg0: *const Inner = &(*_a0).i as *const Inner;
+            let _arg0: *const Inner = &(*_a0).i;
             Inner::operator_eq(&(*(self as *const Outer)).i, _arg0)
         }) && (((*(self as *const Outer)).y) == ((*_a0).y));
     }
@@ -279,39 +279,34 @@ unsafe fn main_0() -> i32 {
     let mut e1: Eq = Eq { a: 1, b: 2 };
     let mut e2: Eq = Eq { a: 1, b: 2 };
     let mut e3: Eq = Eq { a: 1, b: 3 };
-    assert!((unsafe { Eq::operator_eq(&e1, &e2 as *const Eq,) }));
-    assert!(!(unsafe { Eq::operator_eq(&e1, &e3 as *const Eq,) }));
+    assert!((unsafe { Eq::operator_eq(&e1, &e2,) }));
+    assert!(!(unsafe { Eq::operator_eq(&e1, &e3,) }));
     let mut c1: Cmp = Cmp { a: 1, b: 2 };
     let mut c2: Cmp = Cmp { a: 1, b: 3 };
     let mut c3: Cmp = Cmp { a: 2, b: 0 };
     let mut c4: Cmp = Cmp { a: 1, b: 9 };
-    assert!((unsafe { Cmp::operator_cmp(&c1, &c2 as *const Cmp,) }) == std::cmp::Ordering::Less);
-    assert!((unsafe { Cmp::operator_cmp(&c3, &c4 as *const Cmp,) }) == std::cmp::Ordering::Greater);
+    assert!((unsafe { Cmp::operator_cmp(&c1, &c2,) }) == std::cmp::Ordering::Less);
+    assert!((unsafe { Cmp::operator_cmp(&c3, &c4,) }) == std::cmp::Ordering::Greater);
     assert!(
         (unsafe {
-            let _arg0: *const Cmp = &c1 as *const Cmp;
+            let _arg0: *const Cmp = &c1;
             Cmp::operator_eq(&c1, _arg0)
         })
     );
-    assert!((unsafe { Cmp::operator_cmp(&c1, &c2 as *const Cmp,) }) == std::cmp::Ordering::Less);
+    assert!((unsafe { Cmp::operator_cmp(&c1, &c2,) }) == std::cmp::Ordering::Less);
     let mut b1: Both = Both { a: 1 };
     let mut b2: Both = Both { a: 2 };
-    assert!((unsafe { Both::operator_cmp(&b1, &b2 as *const Both,) }) == std::cmp::Ordering::Less);
+    assert!((unsafe { Both::operator_cmp(&b1, &b2,) }) == std::cmp::Ordering::Less);
     assert!(
         (unsafe {
-            let _arg0: *const Both = &b2 as *const Both;
+            let _arg0: *const Both = &b2;
             Both::operator_eq(&b2, _arg0)
         })
     );
     let mut o1: OrdOnly = OrdOnly { a: 1 };
     let mut o2: OrdOnly = OrdOnly { a: 2 };
-    assert!(
-        (unsafe { OrdOnly::operator_cmp(&o1, &o2 as *const OrdOnly,) }) == std::cmp::Ordering::Less
-    );
-    assert!(
-        (unsafe { OrdOnly::operator_cmp(&o2, &o1 as *const OrdOnly,) })
-            == std::cmp::Ordering::Greater
-    );
+    assert!((unsafe { OrdOnly::operator_cmp(&o1, &o2,) }) == std::cmp::Ordering::Less);
+    assert!((unsafe { OrdOnly::operator_cmp(&o2, &o1,) }) == std::cmp::Ordering::Greater);
     let mut x1: Outer = Outer {
         i: Inner { x: 1 },
         y: 9,
@@ -324,18 +319,14 @@ unsafe fn main_0() -> i32 {
         i: Inner { x: 1 },
         y: 9,
     };
-    assert!(
-        (unsafe { Outer::operator_cmp(&x1, &x2 as *const Outer,) }) == std::cmp::Ordering::Less
-    );
-    assert!((unsafe { Outer::operator_eq(&x1, &x3 as *const Outer,) }));
-    assert!(
-        (unsafe { Outer::operator_cmp(&x2, &x1 as *const Outer,) }) == std::cmp::Ordering::Greater
-    );
+    assert!((unsafe { Outer::operator_cmp(&x1, &x2,) }) == std::cmp::Ordering::Less);
+    assert!((unsafe { Outer::operator_eq(&x1, &x3,) }));
+    assert!((unsafe { Outer::operator_cmp(&x2, &x1,) }) == std::cmp::Ordering::Greater);
     let mut s1: Secondary = Secondary { a: 1 };
     let mut s2: Secondary = Secondary { a: 2 };
-    assert!((unsafe { Secondary::operator_ne(&s1, &s2 as *const Secondary,) }));
-    assert!((unsafe { Secondary::operator_lt(&s1, &s2 as *const Secondary,) }));
-    assert!((unsafe { Secondary::operator_ge(&s2, &s1 as *const Secondary,) }));
-    assert!(!(unsafe { Secondary::operator_lt(&s2, &s1 as *const Secondary,) }));
+    assert!((unsafe { Secondary::operator_ne(&s1, &s2,) }));
+    assert!((unsafe { Secondary::operator_lt(&s1, &s2,) }));
+    assert!((unsafe { Secondary::operator_ge(&s2, &s1,) }));
+    assert!(!(unsafe { Secondary::operator_lt(&s2, &s1,) }));
     return 0;
 }
diff --git a/tests/unit/out/unsafe/operator_comparison_free.rs b/tests/unit/out/unsafe/operator_comparison_free.rs
index dea30f04..ecf85bb0 100644
--- a/tests/unit/out/unsafe/operator_comparison_free.rs
+++ b/tests/unit/out/unsafe/operator_comparison_free.rs
@@ -70,52 +70,52 @@ unsafe fn main_0() -> i32 {
     let mut c: S = S { v: 1 };
     assert!(
         (unsafe {
-            let _a: *const S = &a as *const S;
-            operator_eq_1(_a, &c as *const S)
+            let _a: *const S = &a;
+            operator_eq_1(_a, &c)
         })
     );
     assert!(
         (unsafe {
-            let _a: *const S = &a as *const S;
-            operator_ne_2(_a, &b as *const S)
+            let _a: *const S = &a;
+            operator_ne_2(_a, &b)
         })
     );
     assert!(
         (unsafe {
-            let _a: *const S = &a as *const S;
-            operator_lt_0(_a, &b as *const S)
+            let _a: *const S = &a;
+            operator_lt_0(_a, &b)
         })
     );
     assert!(
         (unsafe {
-            let _a: *const S = &b as *const S;
-            operator_gt_3(_a, &a as *const S)
+            let _a: *const S = &b;
+            operator_gt_3(_a, &a)
         })
     );
     assert!(
         (unsafe {
-            let _a: *const S = &a as *const S;
-            operator_le_4(_a, &c as *const S)
+            let _a: *const S = &a;
+            operator_le_4(_a, &c)
         })
     );
     assert!(
         (unsafe {
-            let _a: *const S = &a as *const S;
-            operator_ge_5(_a, &c as *const S)
+            let _a: *const S = &a;
+            operator_ge_5(_a, &c)
         })
     );
     assert!(
         !(unsafe {
-            let _a: *const S = &b as *const S;
-            operator_lt_0(_a, &a as *const S)
+            let _a: *const S = &b;
+            operator_lt_0(_a, &a)
         })
     );
     assert!(
         (unsafe {
-            let _a: *const S = &a as *const S;
+            let _a: *const S = &a;
             operator_lt_6(_a, 5)
         })
     );
-    assert!((unsafe { operator_lt_7(0, &a as *const S,) }));
+    assert!((unsafe { operator_lt_7(0, &a,) }));
     return 0;
 }
diff --git a/tests/unit/out/unsafe/operator_comparison_member.rs b/tests/unit/out/unsafe/operator_comparison_member.rs
index c10a280f..12b44efa 100644
--- a/tests/unit/out/unsafe/operator_comparison_member.rs
+++ b/tests/unit/out/unsafe/operator_comparison_member.rs
@@ -67,13 +67,13 @@ unsafe fn main_0() -> i32 {
     let mut a: S = S { v: 1 };
     let mut b: S = S { v: 2 };
     let mut c: S = S { v: 1 };
-    assert!((unsafe { S::operator_eq(&a, &c as *const S,) }));
-    assert!((unsafe { S::operator_ne(&a, &b as *const S,) }));
-    assert!((unsafe { S::operator_lt_pconstS_const(&a, &b as *const S,) }));
-    assert!((unsafe { S::operator_gt(&b, &a as *const S,) }));
-    assert!((unsafe { S::operator_le(&a, &c as *const S,) }));
-    assert!((unsafe { S::operator_ge(&a, &c as *const S,) }));
-    assert!(!(unsafe { S::operator_lt_pconstS_const(&b, &a as *const S,) }));
+    assert!((unsafe { S::operator_eq(&a, &c,) }));
+    assert!((unsafe { S::operator_ne(&a, &b,) }));
+    assert!((unsafe { S::operator_lt_pconstS_const(&a, &b,) }));
+    assert!((unsafe { S::operator_gt(&b, &a,) }));
+    assert!((unsafe { S::operator_le(&a, &c,) }));
+    assert!((unsafe { S::operator_ge(&a, &c,) }));
+    assert!(!(unsafe { S::operator_lt_pconstS_const(&b, &a,) }));
     assert!((unsafe { S::operator_lt_i32_const(&a, 5,) }));
     return 0;
 }
diff --git a/tests/unit/out/unsafe/operator_comparison_mixed.rs b/tests/unit/out/unsafe/operator_comparison_mixed.rs
index 729ab83d..47bc31c8 100644
--- a/tests/unit/out/unsafe/operator_comparison_mixed.rs
+++ b/tests/unit/out/unsafe/operator_comparison_mixed.rs
@@ -59,28 +59,28 @@ pub fn main() {
 }
 unsafe fn main_0() -> i32 {
     let mut s: S = S { v: 5 };
-    let cs: *const S = &s as *const S;
+    let cs: *const S = &s;
     assert!((unsafe { S::operator_eq(&(*cs), 5,) }));
     assert!((unsafe { S::operator_ne(&(*cs), 4,) }));
     assert!((unsafe { S::operator_lt(&(*cs), 6,) }));
     assert!((unsafe { S::operator_gt(&(*cs), 4.5E+0,) }));
     assert!((unsafe { S::operator_le(&(*cs), 5_i64,) }));
     assert!((unsafe { S::operator_ge(&(*cs), c"3".as_ptr(),) }));
-    assert!((unsafe { operator_eq_0(5, &s as *const S,) }));
-    assert!((unsafe { operator_ne_1(4, &s as *const S,) }));
-    assert!((unsafe { operator_lt_2(4, &s as *const S,) }));
-    assert!((unsafe { operator_gt_3(5.5E+0, &s as *const S,) }));
-    assert!((unsafe { operator_le_4(5_i64, &s as *const S,) }));
-    assert!((unsafe { operator_ge_5(c"7".as_ptr(), &s as *const S,) }));
+    assert!((unsafe { operator_eq_0(5, &s,) }));
+    assert!((unsafe { operator_ne_1(4, &s,) }));
+    assert!((unsafe { operator_lt_2(4, &s,) }));
+    assert!((unsafe { operator_gt_3(5.5E+0, &s,) }));
+    assert!((unsafe { operator_le_4(5_i64, &s,) }));
+    assert!((unsafe { operator_ge_5(c"7".as_ptr(), &s,) }));
     assert!(
         (unsafe {
-            let _a: *mut S = &mut s as *mut S;
+            let _a: *mut S = &mut s;
             operator_lt_6(_a, 7)
         })
     );
     assert!(
         !(unsafe {
-            let _a: *mut S = &mut s as *mut S;
+            let _a: *mut S = &mut s;
             operator_lt_6(_a, 6)
         })
     );
diff --git a/tests/unit/out/unsafe/operator_comparison_noncopyable.rs b/tests/unit/out/unsafe/operator_comparison_noncopyable.rs
index 6fcf71c0..a4f9676d 100644
--- a/tests/unit/out/unsafe/operator_comparison_noncopyable.rs
+++ b/tests/unit/out/unsafe/operator_comparison_noncopyable.rs
@@ -58,20 +58,20 @@ unsafe fn main_0() -> i32 {
     let mut c: S = S::S({ 1 });
     assert!(
         (unsafe {
-            let _x: *const S = &a as *const S;
-            operator_eq_0(_x, &c as *const S)
+            let _x: *const S = &a;
+            operator_eq_0(_x, &c)
         })
     );
     assert!(
         (unsafe {
-            let _x: *const S = &a as *const S;
-            operator_lt_1(_x, &b as *const S)
+            let _x: *const S = &a;
+            operator_lt_1(_x, &b)
         })
     );
     assert!(
         !(unsafe {
-            let _x: *const S = &b as *const S;
-            operator_lt_1(_x, &a as *const S)
+            let _x: *const S = &b;
+            operator_lt_1(_x, &a)
         })
     );
     return 0;
diff --git a/tests/unit/out/unsafe/operator_compound_assignment_free.rs b/tests/unit/out/unsafe/operator_compound_assignment_free.rs
index 5011fa87..b432a037 100644
--- a/tests/unit/out/unsafe/operator_compound_assignment_free.rs
+++ b/tests/unit/out/unsafe/operator_compound_assignment_free.rs
@@ -60,62 +60,62 @@ unsafe fn main_0() -> i32 {
     let mut a: S = S { v: 6_u32 };
     let mut b: S = S { v: 4_u32 };
     (unsafe {
-        let _a: *mut S = &mut a as *mut S;
-        operator_add_assign_0(_a, &b as *const S)
+        let _a: *mut S = &mut a;
+        operator_add_assign_0(_a, &b)
     });
     assert!(((a.v) == (10_u32)));
     (unsafe {
-        let _a: *mut S = &mut a as *mut S;
-        operator_sub_assign_1(_a, &b as *const S)
+        let _a: *mut S = &mut a;
+        operator_sub_assign_1(_a, &b)
     });
     assert!(((a.v) == (6_u32)));
     (unsafe {
-        let _a: *mut S = &mut a as *mut S;
-        operator_mul_assign_2(_a, &b as *const S)
+        let _a: *mut S = &mut a;
+        operator_mul_assign_2(_a, &b)
     });
     assert!(((a.v) == (24_u32)));
     (unsafe {
-        let _a: *mut S = &mut a as *mut S;
-        operator_div_assign_3(_a, &b as *const S)
+        let _a: *mut S = &mut a;
+        operator_div_assign_3(_a, &b)
     });
     assert!(((a.v) == (6_u32)));
     (unsafe {
-        let _a: *mut S = &mut a as *mut S;
-        operator_rem_assign_4(_a, &b as *const S)
+        let _a: *mut S = &mut a;
+        operator_rem_assign_4(_a, &b)
     });
     assert!(((a.v) == (2_u32)));
     (unsafe {
-        let _a: *mut S = &mut a as *mut S;
-        operator_bitor_assign_6(_a, &b as *const S)
+        let _a: *mut S = &mut a;
+        operator_bitor_assign_6(_a, &b)
     });
     assert!(((a.v) == (6_u32)));
     (unsafe {
-        let _a: *mut S = &mut a as *mut S;
-        operator_bitand_assign_5(_a, &b as *const S)
+        let _a: *mut S = &mut a;
+        operator_bitand_assign_5(_a, &b)
     });
     assert!(((a.v) == (4_u32)));
     (unsafe {
-        let _a: *mut S = &mut a as *mut S;
-        operator_bitxor_assign_7(_a, &b as *const S)
+        let _a: *mut S = &mut a;
+        operator_bitxor_assign_7(_a, &b)
     });
     assert!(((a.v) == (0_u32)));
     a.v = 3_u32;
     (unsafe {
-        let _a: *mut S = &mut a as *mut S;
+        let _a: *mut S = &mut a;
         operator_shl_assign_8(_a, 2)
     });
     assert!(((a.v) == (12_u32)));
     (unsafe {
-        let _a: *mut S = &mut a as *mut S;
+        let _a: *mut S = &mut a;
         operator_shr_assign_9(_a, 1)
     });
     assert!(((a.v) == (6_u32)));
     (unsafe {
         let _a: *mut S = &mut (*(unsafe {
-            let _a: *mut S = &mut a as *mut S;
-            operator_add_assign_0(_a, &b as *const S)
-        })) as *mut S;
-        let _b: *const S = &b as *const S;
+            let _a: *mut S = &mut a;
+            operator_add_assign_0(_a, &b)
+        }));
+        let _b: *const S = &b;
         operator_add_assign_0(_a, _b)
     });
     assert!(((a.v) == (14_u32)));
diff --git a/tests/unit/out/unsafe/operator_compound_assignment_member.rs b/tests/unit/out/unsafe/operator_compound_assignment_member.rs
index e1858378..8d169d4e 100644
--- a/tests/unit/out/unsafe/operator_compound_assignment_member.rs
+++ b/tests/unit/out/unsafe/operator_compound_assignment_member.rs
@@ -14,47 +14,47 @@ pub struct S {
 impl S {
     pub unsafe fn operator_assign_u32(&mut self, mut n: u32) -> *mut S {
         self.v = n;
-        return &mut (*(self as *mut S)) as *mut S;
+        return &mut (*(self as *mut S));
     }
     pub unsafe fn operator_add_assign(&mut self, o: *const S) -> *mut S {
         self.v = (self.v).wrapping_add((*o).v);
-        return &mut (*(self as *mut S)) as *mut S;
+        return &mut (*(self as *mut S));
     }
     pub unsafe fn operator_sub_assign(&mut self, o: *const S) -> *mut S {
         self.v = (self.v).wrapping_sub((*o).v);
-        return &mut (*(self as *mut S)) as *mut S;
+        return &mut (*(self as *mut S));
     }
     pub unsafe fn operator_mul_assign(&mut self, o: *const S) -> *mut S {
         self.v = (self.v).wrapping_mul((*o).v);
-        return &mut (*(self as *mut S)) as *mut S;
+        return &mut (*(self as *mut S));
     }
     pub unsafe fn operator_div_assign(&mut self, o: *const S) -> *mut S {
         self.v = (self.v).wrapping_div((*o).v);
-        return &mut (*(self as *mut S)) as *mut S;
+        return &mut (*(self as *mut S));
     }
     pub unsafe fn operator_rem_assign(&mut self, o: *const S) -> *mut S {
         self.v = (self.v).wrapping_rem((*o).v);
-        return &mut (*(self as *mut S)) as *mut S;
+        return &mut (*(self as *mut S));
     }
     pub unsafe fn operator_bitand_assign(&mut self, o: *const S) -> *mut S {
         self.v &= (*o).v;
-        return &mut (*(self as *mut S)) as *mut S;
+        return &mut (*(self as *mut S));
     }
     pub unsafe fn operator_bitor_assign(&mut self, o: *const S) -> *mut S {
         self.v |= (*o).v;
-        return &mut (*(self as *mut S)) as *mut S;
+        return &mut (*(self as *mut S));
     }
     pub unsafe fn operator_bitxor_assign(&mut self, o: *const S) -> *mut S {
         self.v ^= (*o).v;
-        return &mut (*(self as *mut S)) as *mut S;
+        return &mut (*(self as *mut S));
     }
     pub unsafe fn operator_shl_assign(&mut self, mut n: i32) -> *mut S {
         self.v <<= n;
-        return &mut (*(self as *mut S)) as *mut S;
+        return &mut (*(self as *mut S));
     }
     pub unsafe fn operator_shr_assign(&mut self, mut n: i32) -> *mut S {
         self.v >>= n;
-        return &mut (*(self as *mut S)) as *mut S;
+        return &mut (*(self as *mut S));
     }
 }
 pub fn main() {
@@ -65,21 +65,21 @@ pub fn main() {
 unsafe fn main_0() -> i32 {
     let mut a: S = S { v: 6_u32 };
     let mut b: S = S { v: 4_u32 };
-    (unsafe { S::operator_add_assign(&mut a, &b as *const S) });
+    (unsafe { S::operator_add_assign(&mut a, &b) });
     assert!(((a.v) == (10_u32)));
-    (unsafe { S::operator_sub_assign(&mut a, &b as *const S) });
+    (unsafe { S::operator_sub_assign(&mut a, &b) });
     assert!(((a.v) == (6_u32)));
-    (unsafe { S::operator_mul_assign(&mut a, &b as *const S) });
+    (unsafe { S::operator_mul_assign(&mut a, &b) });
     assert!(((a.v) == (24_u32)));
-    (unsafe { S::operator_div_assign(&mut a, &b as *const S) });
+    (unsafe { S::operator_div_assign(&mut a, &b) });
     assert!(((a.v) == (6_u32)));
-    (unsafe { S::operator_rem_assign(&mut a, &b as *const S) });
+    (unsafe { S::operator_rem_assign(&mut a, &b) });
     assert!(((a.v) == (2_u32)));
-    (unsafe { S::operator_bitor_assign(&mut a, &b as *const S) });
+    (unsafe { S::operator_bitor_assign(&mut a, &b) });
     assert!(((a.v) == (6_u32)));
-    (unsafe { S::operator_bitand_assign(&mut a, &b as *const S) });
+    (unsafe { S::operator_bitand_assign(&mut a, &b) });
     assert!(((a.v) == (4_u32)));
-    (unsafe { S::operator_bitxor_assign(&mut a, &b as *const S) });
+    (unsafe { S::operator_bitxor_assign(&mut a, &b) });
     assert!(((a.v) == (0_u32)));
     (unsafe { S::operator_assign_u32(&mut a, 3_u32) });
     assert!(((a.v) == (3_u32)));
@@ -88,11 +88,8 @@ unsafe fn main_0() -> i32 {
     (unsafe { S::operator_shr_assign(&mut a, 1) });
     assert!(((a.v) == (6_u32)));
     (unsafe {
-        let _o: *const S = &b as *const S;
-        S::operator_add_assign(
-            &mut (*(unsafe { S::operator_add_assign(&mut a, &b as *const S) })),
-            _o,
-        )
+        let _o: *const S = &b;
+        S::operator_add_assign(&mut (*(unsafe { S::operator_add_assign(&mut a, &b) })), _o)
     });
     assert!(((a.v) == (14_u32)));
     let mut c: S = S { v: 0_u32 };
diff --git a/tests/unit/out/unsafe/operator_less_than.rs b/tests/unit/out/unsafe/operator_less_than.rs
index 94937ae4..364a0df8 100644
--- a/tests/unit/out/unsafe/operator_less_than.rs
+++ b/tests/unit/out/unsafe/operator_less_than.rs
@@ -53,6 +53,6 @@ pub fn main() {
 unsafe fn main_0() -> i32 {
     let mut pair1: Pair = Pair { x: 1, y: 2 };
     let mut pair2: Pair = Pair { x: 1, y: 3 };
-    assert!((unsafe { Pair::operator_lt(&mut pair1, &pair2 as *const Pair,) }));
+    assert!((unsafe { Pair::operator_lt(&mut pair1, &pair2,) }));
     return 0;
 }
diff --git a/tests/unit/out/unsafe/operator_logical_free.rs b/tests/unit/out/unsafe/operator_logical_free.rs
index db3d5cd5..459c8329 100644
--- a/tests/unit/out/unsafe/operator_logical_free.rs
+++ b/tests/unit/out/unsafe/operator_logical_free.rs
@@ -30,39 +30,39 @@ unsafe fn main_0() -> i32 {
     let mut f: S = S { v: 0 };
     assert!(
         (unsafe {
-            let _a: *const S = &f as *const S;
+            let _a: *const S = &f;
             operator_not_0(_a)
         })
     );
     assert!(
         !(unsafe {
-            let _a: *const S = &t as *const S;
+            let _a: *const S = &t;
             operator_not_0(_a)
         })
     );
     assert!(
         (unsafe {
-            let _a: *const S = &t as *const S;
-            let _b: *const S = &t as *const S;
+            let _a: *const S = &t;
+            let _b: *const S = &t;
             operator_and_1(_a, _b)
         })
     );
     assert!(
         !(unsafe {
-            let _a: *const S = &t as *const S;
-            operator_and_1(_a, &f as *const S)
+            let _a: *const S = &t;
+            operator_and_1(_a, &f)
         })
     );
     assert!(
         (unsafe {
-            let _a: *const S = &t as *const S;
-            operator_or_2(_a, &f as *const S)
+            let _a: *const S = &t;
+            operator_or_2(_a, &f)
         })
     );
     assert!(
         !(unsafe {
-            let _a: *const S = &f as *const S;
-            let _b: *const S = &f as *const S;
+            let _a: *const S = &f;
+            let _b: *const S = &f;
             operator_or_2(_a, _b)
         })
     );
diff --git a/tests/unit/out/unsafe/operator_logical_member.rs b/tests/unit/out/unsafe/operator_logical_member.rs
index d6854ea2..d0c47a73 100644
--- a/tests/unit/out/unsafe/operator_logical_member.rs
+++ b/tests/unit/out/unsafe/operator_logical_member.rs
@@ -34,15 +34,15 @@ unsafe fn main_0() -> i32 {
     assert!(!(unsafe { S::operator_not(&t,) }));
     assert!(
         (unsafe {
-            let _o: *const S = &t as *const S;
+            let _o: *const S = &t;
             S::operator_and(&t, _o)
         })
     );
-    assert!(!(unsafe { S::operator_and(&t, &f as *const S,) }));
-    assert!((unsafe { S::operator_or(&t, &f as *const S,) }));
+    assert!(!(unsafe { S::operator_and(&t, &f,) }));
+    assert!((unsafe { S::operator_or(&t, &f,) }));
     assert!(
         !(unsafe {
-            let _o: *const S = &f as *const S;
+            let _o: *const S = &f;
             S::operator_or(&f, _o)
         })
     );
diff --git a/tests/unit/out/unsafe/operator_member_pointer_free.rs b/tests/unit/out/unsafe/operator_member_pointer_free.rs
index fb4920e4..ba261236 100644
--- a/tests/unit/out/unsafe/operator_member_pointer_free.rs
+++ b/tests/unit/out/unsafe/operator_member_pointer_free.rs
@@ -26,7 +26,7 @@ impl Default for S {
     }
 }
 pub unsafe fn operator_deref_0(s: *mut S) -> *mut Inner {
-    return &mut (*s).inner as *mut Inner;
+    return &mut (*s).inner;
 }
 pub unsafe fn operator_addr_1(s: *mut S) -> *mut i32 {
     return (&mut (*s).data[(0) as usize] as *mut i32);
@@ -43,19 +43,19 @@ unsafe fn main_0() -> i32 {
     };
     assert!(
         (((*(unsafe {
-            let _s: *mut S = &mut s as *mut S;
+            let _s: *mut S = &mut s;
             operator_deref_0(_s)
         }))
         .x) == (9))
     );
     (*(unsafe {
-        let _s: *mut S = &mut s as *mut S;
+        let _s: *mut S = &mut s;
         operator_deref_0(_s)
     }))
     .x = 10;
     assert!(((s.inner.x) == (10)));
     let mut p: *mut i32 = (unsafe {
-        let _s: *mut S = &mut s as *mut S;
+        let _s: *mut S = &mut s;
         operator_addr_1(_s)
     });
     assert!(((*p) == (1)));
diff --git a/tests/unit/out/unsafe/operator_member_pointer_member.rs b/tests/unit/out/unsafe/operator_member_pointer_member.rs
index bcc55d81..f1836980 100644
--- a/tests/unit/out/unsafe/operator_member_pointer_member.rs
+++ b/tests/unit/out/unsafe/operator_member_pointer_member.rs
@@ -16,7 +16,7 @@ pub struct Inner {
 pub struct Table {}
 impl Table {
     pub unsafe fn operator_index(mut i: i32) -> *mut i32 {
-        return &mut table_0[(i) as usize] as *mut i32;
+        return &mut table_0[(i) as usize];
     }
 }
 pub static mut table_0: [i32; 3] = unsafe { [7, 8, 9] };
@@ -28,13 +28,13 @@ pub struct S {
 }
 impl S {
     pub unsafe fn operator_index_i32(&mut self, mut i: i32) -> *mut i32 {
-        return &mut self.data[(i) as usize] as *mut i32;
+        return &mut self.data[(i) as usize];
     }
     pub unsafe fn operator_index_i32_const(&self, mut i: i32) -> *const i32 {
-        return &self.data[(i) as usize] as *const i32;
+        return &self.data[(i) as usize];
     }
     pub unsafe fn operator_deref(&mut self) -> *mut Inner {
-        return &mut self.inner as *mut Inner;
+        return &mut self.inner;
     }
     pub unsafe fn operator_arrow(&mut self) -> *mut Inner {
         return (&mut self.inner as *mut Inner);
@@ -64,7 +64,7 @@ unsafe fn main_0() -> i32 {
     assert!(((*(unsafe { S::operator_index_i32(&mut s, 1,) })) == (2)));
     (*(unsafe { S::operator_index_i32(&mut s, 1) })) = 20;
     assert!(((*(unsafe { S::operator_index_i32(&mut s, 1,) })) == (20)));
-    let cs: *const S = &s as *const S;
+    let cs: *const S = &s;
     assert!(((*(unsafe { S::operator_index_i32_const(&(*cs), 2,) })) == (3)));
     assert!((((*(unsafe { S::operator_deref(&mut s,) })).x) == (9)));
     (*(unsafe { S::operator_deref(&mut s) })).x = 10;
diff --git a/tests/unit/out/unsafe/operator_other_free.rs b/tests/unit/out/unsafe/operator_other_free.rs
index e927438f..5d6da5e5 100644
--- a/tests/unit/out/unsafe/operator_other_free.rs
+++ b/tests/unit/out/unsafe/operator_other_free.rs
@@ -26,18 +26,18 @@ unsafe fn main_0() -> i32 {
     let mut t: S = S { v: 4 };
     assert!(
         (((unsafe {
-            let _a: *const S = &s as *const S;
-            operator_comma_0(_a, &t as *const S)
+            let _a: *const S = &s;
+            operator_comma_0(_a, &t)
         })
         .v) == (34))
     );
     assert!(
         (((unsafe {
             let mut _a: S = (unsafe {
-                let _a: *const S = &s as *const S;
-                operator_comma_0(_a, &t as *const S)
+                let _a: *const S = &s;
+                operator_comma_0(_a, &t)
             });
-            let _b: *const S = &s as *const S;
+            let _b: *const S = &s;
             operator_comma_0(&mut _a, _b)
         })
         .v) == (343))
diff --git a/tests/unit/out/unsafe/operator_other_member.rs b/tests/unit/out/unsafe/operator_other_member.rs
index de4d9ced..03c53a9a 100644
--- a/tests/unit/out/unsafe/operator_other_member.rs
+++ b/tests/unit/out/unsafe/operator_other_member.rs
@@ -52,7 +52,7 @@ unsafe fn main_0() -> i32 {
     assert!(((unsafe { S::operator_call_const(&s,) }) == (3)));
     assert!(((unsafe { S::operator_call_i32_const(&s, 1,) }) == (4)));
     assert!(((unsafe { S::operator_call_i32_i32_const(&s, 1, 2,) }) == (6)));
-    assert!((((unsafe { S::operator_comma(&s, &t as *const S,) }).v) == (34)));
+    assert!((((unsafe { S::operator_comma(&s, &t,) }).v) == (34)));
     let mut i: i32 = (unsafe { S::operator_int(&s) });
     assert!(((i) == (3)));
     assert!((((unsafe { S::operator_int(&s,) }) + (1)) == (4)));
diff --git a/tests/unit/out/unsafe/operator_overloads.rs b/tests/unit/out/unsafe/operator_overloads.rs
index 4a304668..50de25ab 100644
--- a/tests/unit/out/unsafe/operator_overloads.rs
+++ b/tests/unit/out/unsafe/operator_overloads.rs
@@ -64,14 +64,14 @@ unsafe fn main_0() -> i32 {
     assert!(((unsafe { S::operator_eq_i64_const(&s, 6_i64,) }) == (2)));
     assert!(((unsafe { S::operator_eq_f64_const(&s, 6.0E+0,) }) == (3)));
     assert!(((unsafe { S::operator_eq_i32_const(&s, 7,) }) == (0)));
-    assert!(((unsafe { S::operator_add(&s, &t as *const S,) }) == (10)));
+    assert!(((unsafe { S::operator_add(&s, &t,) }) == (10)));
     assert!(((unsafe { S::operator_sub(&s, t,) }) == (2)));
-    assert!(((unsafe { S::operator_mul_pconstS_const(&s, &t as *const S,) }) == (24)));
+    assert!(((unsafe { S::operator_mul_pconstS_const(&s, &t,) }) == (24)));
     assert!(((unsafe { S::operator_mul_i32_const(&s, 2,) }) == (13)));
     assert!(
         ((unsafe {
-            let _a: *const S = &s as *const S;
-            operator_div_0(_a, &t as *const S)
+            let _a: *const S = &s;
+            operator_div_0(_a, &t)
         }) == (1))
     );
     assert!(
@@ -88,11 +88,11 @@ unsafe fn main_0() -> i32 {
     );
     assert!(
         ((unsafe {
-            let _a: *const S = &s as *const S;
+            let _a: *const S = &s;
             operator_rem_3(_a, 4)
         }) == (3))
     );
     assert!(((unsafe { operator_eq_4(6, s,) }) == (4)));
-    assert!(((unsafe { operator_eq_5(6_i64, &s as *const S,) }) == (5)));
+    assert!(((unsafe { operator_eq_5(6_i64, &s,) }) == (5)));
     return 0;
 }
diff --git a/tests/unit/out/unsafe/operator_three_way.rs b/tests/unit/out/unsafe/operator_three_way.rs
index f4ee1154..3145dbc7 100644
--- a/tests/unit/out/unsafe/operator_three_way.rs
+++ b/tests/unit/out/unsafe/operator_three_way.rs
@@ -49,11 +49,11 @@ pub fn main() {
 unsafe fn main_0() -> i32 {
     let mut a: S = S { v: 1 };
     let mut b: S = S { v: 2 };
-    assert!((unsafe { S::operator_cmp(&a, &b as *const S,) }) == std::cmp::Ordering::Less);
-    assert!((unsafe { S::operator_cmp(&b, &a as *const S,) }) == std::cmp::Ordering::Greater);
-    assert!((unsafe { S::operator_cmp(&a, &b as *const S,) }) != std::cmp::Ordering::Greater);
-    assert!((unsafe { S::operator_cmp(&b, &a as *const S,) }) != std::cmp::Ordering::Less);
-    assert!(!(unsafe { S::operator_eq(&a, &b as *const S,) }));
-    assert!((unsafe { S::operator_cmp(&a, &b as *const S,) }) == std::cmp::Ordering::Less);
+    assert!((unsafe { S::operator_cmp(&a, &b,) }) == std::cmp::Ordering::Less);
+    assert!((unsafe { S::operator_cmp(&b, &a,) }) == std::cmp::Ordering::Greater);
+    assert!((unsafe { S::operator_cmp(&a, &b,) }) != std::cmp::Ordering::Greater);
+    assert!((unsafe { S::operator_cmp(&b, &a,) }) != std::cmp::Ordering::Less);
+    assert!(!(unsafe { S::operator_eq(&a, &b,) }));
+    assert!((unsafe { S::operator_cmp(&a, &b,) }) == std::cmp::Ordering::Less);
     return 0;
 }
diff --git a/tests/unit/out/unsafe/pod.rs b/tests/unit/out/unsafe/pod.rs
index cf4af260..181a2b9a 100644
--- a/tests/unit/out/unsafe/pod.rs
+++ b/tests/unit/out/unsafe/pod.rs
@@ -34,7 +34,7 @@ unsafe fn main_0() -> i32 {
         x2: p1.x2,
         x3: p1.x3,
     };
-    (unsafe { PODIncrement_0(&mut p2 as *mut POD) });
+    (unsafe { PODIncrement_0(&mut p2) });
     assert!(((((p2.x1) + (p2.x2)) + (p2.x3)) == (39)));
     return 0;
 }
diff --git a/tests/unit/out/unsafe/pointer_array.rs b/tests/unit/out/unsafe/pointer_array.rs
index 0daf128b..12111292 100644
--- a/tests/unit/out/unsafe/pointer_array.rs
+++ b/tests/unit/out/unsafe/pointer_array.rs
@@ -39,7 +39,7 @@ unsafe fn main_0() -> i32 {
             (&mut x as *mut i32),
         ],
     };
-    (unsafe { IncrementAll_0(&mut s as *mut StackArray) });
+    (unsafe { IncrementAll_0(&mut s) });
     assert!(((x) == (3)));
     return 0;
 }
diff --git a/tests/unit/out/unsafe/printfs.rs b/tests/unit/out/unsafe/printfs.rs
index 636b5163..55fe7854 100644
--- a/tests/unit/out/unsafe/printfs.rs
+++ b/tests/unit/out/unsafe/printfs.rs
@@ -53,7 +53,7 @@ unsafe fn main_0() -> i32 {
     );
     printf(
         c"%s\n".as_ptr() as *const i8,
-        (*(unsafe { fn2_1(&s as *const Vec<libc::c_char>) })).as_ptr(),
+        (*(unsafe { fn2_1(&s) })).as_ptr(),
     );
     return 0;
 }
diff --git a/tests/unit/out/unsafe/prvalue-as-lvalue.rs b/tests/unit/out/unsafe/prvalue-as-lvalue.rs
index 935f5325..7dfaf49a 100644
--- a/tests/unit/out/unsafe/prvalue-as-lvalue.rs
+++ b/tests/unit/out/unsafe/prvalue-as-lvalue.rs
@@ -17,7 +17,7 @@ pub fn main() {
 unsafe fn main_0() -> i32 {
     let mut a: i32 = 1;
     let mut pa: *mut i32 = (&mut a as *mut i32);
-    let b: *const i32 = (unsafe { foo_0(&(*pa) as *const i32) });
+    let b: *const i32 = (unsafe { foo_0(&(*pa)) });
     assert!(((*b) == (1)));
     return 0;
 }
diff --git a/tests/unit/out/unsafe/random.rs b/tests/unit/out/unsafe/random.rs
index 22e4c969..106726b1 100644
--- a/tests/unit/out/unsafe/random.rs
+++ b/tests/unit/out/unsafe/random.rs
@@ -31,7 +31,7 @@ impl Pair {
         return self.x;
     }
     pub unsafe fn as_ref(&mut self) -> *mut i32 {
-        return &mut self.x as *mut i32;
+        return &mut self.x;
     }
     pub unsafe fn as_ptr(&mut self) -> *mut i32 {
         return (&mut self.x as *mut i32);
@@ -66,13 +66,13 @@ pub fn main() {
 unsafe fn main_0() -> i32 {
     let mut x1: i32 = 1;
     let mut c1: i32 = x1;
-    let rx1: *mut i32 = &mut x1 as *mut i32;
+    let rx1: *mut i32 = &mut x1;
     let mut px1: *mut i32 = (&mut x1 as *mut i32);
     let mut x2: i32 = (*rx1);
     let rx2: *mut i32 = rx1;
     let mut px2: *mut i32 = (rx1);
     let mut x3: i32 = (*px1);
-    let rx3: *mut i32 = &mut (*px1) as *mut i32;
+    let rx3: *mut i32 = &mut (*px1);
     let mut px3: *mut i32 = px1;
     let mut res: i32 = ((x1) + (x2));
     res = ((x1) + (x2));
@@ -80,7 +80,7 @@ unsafe fn main_0() -> i32 {
         x: 1,
         y: 2,
         a: [1, 2, 3, 4, 5],
-        r: &mut x1 as *mut i32,
+        r: &mut x1,
         p: std::ptr::null_mut(),
         pair: std::ptr::null_mut(),
         ap: [std::ptr::null_mut(), std::ptr::null_mut()],
@@ -100,7 +100,7 @@ unsafe fn main_0() -> i32 {
         pair: y1.pair,
         ap: [y1.ap[(0) as usize], y1.ap[(1) as usize]],
     };
-    let ry1: *mut Pair = &mut y1 as *mut Pair;
+    let ry1: *mut Pair = &mut y1;
     let mut py1: *mut Pair = (&mut y1 as *mut Pair);
     let mut y2: Pair = Pair {
         x: (*ry1).x,
@@ -134,15 +134,15 @@ unsafe fn main_0() -> i32 {
         pair: (*py1).pair,
         ap: [(*py1).ap[(0) as usize], (*py1).ap[(1) as usize]],
     };
-    let ry3: *mut Pair = &mut (*py1) as *mut Pair;
+    let ry3: *mut Pair = &mut (*py1);
     let mut py3: *mut Pair = py1;
     py3 = std::ptr::null_mut();
     let mut ptr2pair: *mut Pair = py3;
     (unsafe {
         let _x1: i32 = x1;
-        let _x2: *mut i32 = &mut x1 as *mut i32;
+        let _x2: *mut i32 = &mut x1;
         let _x3: *mut i32 = (&mut x1 as *mut i32);
-        let _p2: *mut Pair = &mut y1 as *mut Pair;
+        let _p2: *mut Pair = &mut y1;
         let _p3: *mut Pair = (&mut y1 as *mut Pair);
         foo_1(_x1, _x2, _x3, _p2, _p3)
     });
@@ -156,13 +156,13 @@ unsafe fn main_0() -> i32 {
     });
     (unsafe {
         let _x1: i32 = (*px1);
-        let _x2: *mut i32 = &mut (*px1) as *mut i32;
+        let _x2: *mut i32 = &mut (*px1);
         let _x3: *mut i32 = px1;
-        let _p2: *mut Pair = &mut (*py1) as *mut Pair;
+        let _p2: *mut Pair = &mut (*py1);
         let _p3: *mut Pair = py1;
         foo_1(_x1, _x2, _x3, _p2, _p3)
     });
-    let cr1: *mut i32 = &mut c1 as *mut i32;
+    let cr1: *mut i32 = &mut c1;
     let mut cp1: *mut i32 = (&mut c1 as *mut i32);
     x1 = c1;
     x1 = 1;
@@ -196,7 +196,7 @@ unsafe fn main_0() -> i32 {
         x: 1,
         y: 2,
         a: [1, 2, 3, 4, 5],
-        r: &mut j as *mut i32,
+        r: &mut j,
         p: std::ptr::null_mut(),
         pair: std::ptr::null_mut(),
         ap: [std::ptr::null_mut(), std::ptr::null_mut()],
diff --git a/tests/unit/out/unsafe/rebind.rs b/tests/unit/out/unsafe/rebind.rs
index 3f13e57b..bd96f5c8 100644
--- a/tests/unit/out/unsafe/rebind.rs
+++ b/tests/unit/out/unsafe/rebind.rs
@@ -13,7 +13,7 @@ pub fn main() {
 }
 unsafe fn main_0() -> i32 {
     let mut x: i32 = 1;
-    let r: *mut i32 = &mut x as *mut i32;
+    let r: *mut i32 = &mut x;
     let mut y: i32 = 10;
     (*r) = y;
     y += 1;
diff --git a/tests/unit/out/unsafe/ref_calls.rs b/tests/unit/out/unsafe/ref_calls.rs
index f04d2505..8a1f4e56 100644
--- a/tests/unit/out/unsafe/ref_calls.rs
+++ b/tests/unit/out/unsafe/ref_calls.rs
@@ -19,11 +19,10 @@ pub fn main() {
 }
 unsafe fn main_0() -> i32 {
     let mut x: i32 = 5;
-    let mut y: i32 = (*(unsafe { foo_1(&mut x as *mut i32) }));
-    let z: *mut i32 = (unsafe { foo_1(&mut x as *mut i32) });
+    let mut y: i32 = (*(unsafe { foo_1(&mut x) }));
+    let z: *mut i32 = (unsafe { foo_1(&mut x) });
     assert!(
-        (((((*(unsafe { foo_1(&mut x as *mut i32,) }))
-            + (*(unsafe { foo_1(&mut y as *mut i32,) })))
+        (((((*(unsafe { foo_1(&mut x,) })) + (*(unsafe { foo_1(&mut y,) })))
             + (*(unsafe { foo_1(z,) })))
             + (unsafe { bar_0() }))
             == (16))
diff --git a/tests/unit/out/unsafe/references.rs b/tests/unit/out/unsafe/references.rs
index 957787eb..13c26f77 100644
--- a/tests/unit/out/unsafe/references.rs
+++ b/tests/unit/out/unsafe/references.rs
@@ -13,7 +13,7 @@ pub fn main() {
 }
 unsafe fn main_0() -> i32 {
     let mut x: i32 = 1;
-    let r: *mut i32 = &mut x as *mut i32;
+    let r: *mut i32 = &mut x;
     (*r) = 5;
     assert!(((x) == (5)));
     return 0;
diff --git a/tests/unit/out/unsafe/references2.rs b/tests/unit/out/unsafe/references2.rs
index 8e3254e5..812b637d 100644
--- a/tests/unit/out/unsafe/references2.rs
+++ b/tests/unit/out/unsafe/references2.rs
@@ -17,7 +17,7 @@ pub fn main() {
 }
 unsafe fn main_0() -> i32 {
     let mut a: Option<Box<i32>> = Some(Box::new(5));
-    (unsafe { change_0(&mut a as *mut Option<Box<i32>>) });
+    (unsafe { change_0(&mut a) });
     assert!(((*a.as_deref_mut().unwrap()) == (7)));
     return 0;
 }
diff --git a/tests/unit/out/unsafe/refs_as_args.rs b/tests/unit/out/unsafe/refs_as_args.rs
index 2c8923db..b71d10a6 100644
--- a/tests/unit/out/unsafe/refs_as_args.rs
+++ b/tests/unit/out/unsafe/refs_as_args.rs
@@ -7,12 +7,12 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub unsafe fn more_refs_0(mut x1: i32, mut x2: i32, r1: *mut i32, r2: *const i32) {
-    let rx1: *const i32 = &x1 as *const i32;
-    let rx2: *mut i32 = &mut x2 as *mut i32;
+    let rx1: *const i32 = &x1;
+    let rx2: *mut i32 = &mut x2;
     let mut pr1: *const i32 = (r1).cast_const();
     let mut pr2: *const i32 = (r2);
-    let rpr1: *const i32 = &(*pr1) as *const i32;
-    let rpr2: *const i32 = &(*pr2) as *const i32;
+    let rpr1: *const i32 = &(*pr1);
+    let rpr2: *const i32 = &(*pr2);
     let r: *const i32 = r1;
     (*rx2) += ((((((((1) + (*rx1)) + (*rx2)) + (*pr1)) + (*pr2)) + (*rpr1)) + (*rpr2)) + (*r));
     (*r1) = (*rx2);
@@ -25,7 +25,7 @@ pub fn main() {
 unsafe fn main_0() -> i32 {
     let mut x1: i32 = 1;
     let x2: i32 = 2;
-    (unsafe { more_refs_0(3, 4, &mut x1 as *mut i32, &x2 as *const i32) });
+    (unsafe { more_refs_0(3, 4, &mut x1, &x2) });
     assert!((((x1) + (x2)) == (21)));
     return 0;
 }
diff --git a/tests/unit/out/unsafe/rule_of_five.rs b/tests/unit/out/unsafe/rule_of_five.rs
index eaf5d228..d3878224 100644
--- a/tests/unit/out/unsafe/rule_of_five.rs
+++ b/tests/unit/out/unsafe/rule_of_five.rs
@@ -64,7 +64,7 @@ impl Buffer {
     }
     pub unsafe fn operator_assign_pconstBuffer(&mut self, o: *const Buffer) -> *mut Buffer {
         if (((self as *mut Buffer).cast_const()) == (o)) {
-            return &mut (*(self as *mut Buffer)) as *mut Buffer;
+            return &mut (*(self as *mut Buffer));
         }
         self.size = (*o).size;
         let mut i: i32 = 0;
@@ -73,11 +73,11 @@ impl Buffer {
             i.prefix_inc();
         }
         copies_1.prefix_inc();
-        return &mut (*(self as *mut Buffer)) as *mut Buffer;
+        return &mut (*(self as *mut Buffer));
     }
     pub unsafe fn operator_assign_pmutBuffer(&mut self, o: *mut Buffer) -> *mut Buffer {
         if ((self as *mut Buffer) == (o)) {
-            return &mut (*(self as *mut Buffer)) as *mut Buffer;
+            return &mut (*(self as *mut Buffer));
         }
         self.size = (*o).size;
         let mut i: i32 = 0;
@@ -88,7 +88,7 @@ impl Buffer {
         }
         (*o).size = 0;
         moves_2.prefix_inc();
-        return &mut (*(self as *mut Buffer)) as *mut Buffer;
+        return &mut (*(self as *mut Buffer));
     }
 }
 impl Clone for Buffer {
@@ -118,7 +118,7 @@ unsafe fn main_0() -> i32 {
     {
         let mut a: Buffer = Buffer::Buffer({ 4 });
         let _dtor_a = ScopedDestructorUnsafe::new(&raw mut a, Buffer::destructor);
-        let mut b: Buffer = Buffer::Buffer_pconstBuffer({ &a as *const Buffer });
+        let mut b: Buffer = Buffer::Buffer_pconstBuffer({ &a });
         let _dtor_b = ScopedDestructorUnsafe::new(&raw mut b, Buffer::destructor);
         assert!((((alive_0) == (2)) && ((copies_1) == (1))) && ((moves_2) == (0)));
         b.data[(0) as usize] = 100;
@@ -131,7 +131,7 @@ unsafe fn main_0() -> i32 {
         let mut d: Buffer = (unsafe { make_3(2) });
         let _dtor_d = ScopedDestructorUnsafe::new(&raw mut d, Buffer::destructor);
         assert!(((d.size) == (2)) && ((moves_2) == (2)));
-        (unsafe { Buffer::operator_assign_pconstBuffer(&mut d, &b as *const Buffer) });
+        (unsafe { Buffer::operator_assign_pconstBuffer(&mut d, &b) });
         assert!((((d.size) == (4)) && ((d.data[(0) as usize]) == (100))) && ((copies_1) == (2)));
         (unsafe { Buffer::operator_assign_pmutBuffer(&mut d, &mut c) });
         assert!((((d.data[(0) as usize]) == (0)) && ((c.size) == (0))) && ((moves_2) == (3)));
diff --git a/tests/unit/out/unsafe/rule_of_three.rs b/tests/unit/out/unsafe/rule_of_three.rs
index fe1b8cb5..f358e026 100644
--- a/tests/unit/out/unsafe/rule_of_three.rs
+++ b/tests/unit/out/unsafe/rule_of_three.rs
@@ -47,7 +47,7 @@ impl Buffer {
     }
     pub unsafe fn operator_assign(&mut self, o: *const Buffer) -> *mut Buffer {
         if (((self as *mut Buffer).cast_const()) == (o)) {
-            return &mut (*(self as *mut Buffer)) as *mut Buffer;
+            return &mut (*(self as *mut Buffer));
         }
         self.size = (*o).size;
         let mut i: i32 = 0;
@@ -56,7 +56,7 @@ impl Buffer {
             i.prefix_inc();
         }
         copies_1.prefix_inc();
-        return &mut (*(self as *mut Buffer)) as *mut Buffer;
+        return &mut (*(self as *mut Buffer));
     }
 }
 impl Clone for Buffer {
@@ -90,23 +90,23 @@ unsafe fn main_0() -> i32 {
     {
         let mut a: Buffer = Buffer::Buffer({ 4 });
         let _dtor_a = ScopedDestructorUnsafe::new(&raw mut a, Buffer::destructor);
-        let mut b: Buffer = Buffer::Buffer_pconstBuffer({ &a as *const Buffer });
+        let mut b: Buffer = Buffer::Buffer_pconstBuffer({ &a });
         let _dtor_b = ScopedDestructorUnsafe::new(&raw mut b, Buffer::destructor);
         assert!(((alive_0) == (2)) && ((copies_1) == (1)));
         b.data[(0) as usize] = 100;
         assert!(((a.data[(0) as usize]) == (0)));
         let mut c: Buffer = Buffer::Buffer({ 2 });
         let _dtor_c = ScopedDestructorUnsafe::new(&raw mut c, Buffer::destructor);
-        (unsafe { Buffer::operator_assign(&mut c, &a as *const Buffer) });
+        (unsafe { Buffer::operator_assign(&mut c, &a) });
         assert!(((c.size) == (4)) && ((c.data[(3) as usize]) == (3)));
         assert!(((alive_0) == (3)) && ((copies_1) == (2)));
         (unsafe {
-            let _o: *const Buffer = &c as *const Buffer;
+            let _o: *const Buffer = &c;
             Buffer::operator_assign(&mut c, _o)
         });
         assert!(((copies_1) == (2)));
-        assert!(((unsafe { sum_2(&a as *const Buffer,) }) == (6)));
-        assert!(((unsafe { sum_2(&b as *const Buffer,) }) == (106)));
+        assert!(((unsafe { sum_2(&a,) }) == (6)));
+        assert!(((unsafe { sum_2(&b,) }) == (106)));
         let mut d: Buffer = Buffer::Buffer_pconstBuffer({ &mut a });
         let _dtor_d = ScopedDestructorUnsafe::new(&raw mut d, Buffer::destructor);
         assert!(((alive_0) == (4)) && ((copies_1) == (3)));
diff --git a/tests/unit/out/unsafe/split_binop_aliased_borrows.rs b/tests/unit/out/unsafe/split_binop_aliased_borrows.rs
index c8383e39..561b4b24 100644
--- a/tests/unit/out/unsafe/split_binop_aliased_borrows.rs
+++ b/tests/unit/out/unsafe/split_binop_aliased_borrows.rs
@@ -14,7 +14,7 @@ pub fn main() {
 unsafe fn main_0() -> i32 {
     let mut v: Vec<i32> = vec![1, 2];
     let mut p: *mut i32 = v.as_mut_ptr();
-    let r: *const i32 = &v[(1_usize)] as *const i32;
+    let r: *const i32 = &v[(1_usize)];
     (*p) = (*r);
     assert!(((v[(0_usize)]) == (2)));
     return 0;
diff --git a/tests/unit/out/unsafe/struct_ctor.rs b/tests/unit/out/unsafe/struct_ctor.rs
index 45ce263a..7e2d6c9c 100644
--- a/tests/unit/out/unsafe/struct_ctor.rs
+++ b/tests/unit/out/unsafe/struct_ctor.rs
@@ -20,10 +20,10 @@ impl StructWithCtor {
         this
     }
     pub unsafe fn x1(&self) -> *const i32 {
-        return &self.x1_ as *const i32;
+        return &self.x1_;
     }
     pub unsafe fn x2(&self) -> *const i32 {
-        return &self.x2_ as *const i32;
+        return &self.x2_;
     }
 }
 pub unsafe fn foo_0(x: *mut i32) -> *mut i32 {
@@ -38,7 +38,7 @@ unsafe fn main_0() -> i32 {
     let mut struct_with_ctor: StructWithCtor = StructWithCtor::StructWithCtor({ 1 }, { 2 });
     let mut x: i32 = 3;
     assert!(
-        (((*(unsafe { foo_0(&mut x as *mut i32,) })) == (3))
+        (((*(unsafe { foo_0(&mut x,) })) == (3))
             && ((*(unsafe { StructWithCtor::x1(&struct_with_ctor,) })) == (2)))
             && ((*(unsafe { StructWithCtor::x2(&struct_with_ctor,) })) == (1))
     );
diff --git a/tests/unit/out/unsafe/swap.rs b/tests/unit/out/unsafe/swap.rs
index 08bfb83c..6ca3f645 100644
--- a/tests/unit/out/unsafe/swap.rs
+++ b/tests/unit/out/unsafe/swap.rs
@@ -33,7 +33,7 @@ unsafe fn main_0() -> i32 {
     p = (&mut (b) as *mut i32);
     p = (&mut a as *mut i32);
     (unsafe { swap_by_ptr_1(p, (&mut b as *mut i32)) });
-    (unsafe { swap_by_ref_2(&mut a as *mut i32, &mut c as *mut i32) });
+    (unsafe { swap_by_ref_2(&mut a, &mut c) });
     assert!(((c) == (2)));
     return 0;
 }
diff --git a/tests/unit/out/unsafe/swap_extended.rs b/tests/unit/out/unsafe/swap_extended.rs
index 8e7a8fd4..902a6898 100644
--- a/tests/unit/out/unsafe/swap_extended.rs
+++ b/tests/unit/out/unsafe/swap_extended.rs
@@ -68,7 +68,7 @@ unsafe fn main_0() -> i32 {
     (unsafe { swap_by_ptr_1((&mut d as *mut i32), (&mut e as *mut i32)) });
     let mut f: i32 = 4;
     let mut g: i32 = 5;
-    (unsafe { swap_by_ref_2(&mut f as *mut i32, &mut g as *mut i32) });
+    (unsafe { swap_by_ref_2(&mut f, &mut g) });
     let mut h: *mut i32 = (Box::leak(Box::new(6)) as *mut i32);
     write!(
         std::fs::File::from_raw_fd(
@@ -114,14 +114,14 @@ unsafe fn main_0() -> i32 {
     });
     (unsafe {
         swap_by_ref_2(
-            &mut (*(Box::leak(Box::new(9)) as *mut i32)) as *mut i32,
-            &mut (*(Box::leak(Box::new(10)) as *mut i32)) as *mut i32,
+            &mut (*(Box::leak(Box::new(9)) as *mut i32)),
+            &mut (*(Box::leak(Box::new(10)) as *mut i32)),
         )
     });
     (unsafe {
         swap_by_ref_2(
-            &mut (*(Box::leak(Box::new(9)) as *mut i32).offset((0) as isize)) as *mut i32,
-            &mut (*(Box::leak(Box::new(10)) as *mut i32).offset((0) as isize)) as *mut i32,
+            &mut (*(Box::leak(Box::new(9)) as *mut i32).offset((0) as isize)),
+            &mut (*(Box::leak(Box::new(10)) as *mut i32).offset((0) as isize)),
         )
     });
     let mut j: Option<Box<i32>> = Some(Box::from_raw((Box::leak(Box::new(11)) as *mut i32)));
diff --git a/tests/unit/out/unsafe/this.rs b/tests/unit/out/unsafe/this.rs
index 12438299..bd7ea5eb 100644
--- a/tests/unit/out/unsafe/this.rs
+++ b/tests/unit/out/unsafe/this.rs
@@ -43,14 +43,14 @@ impl S {
         this
     }
     pub unsafe fn returns_this_reference(&mut self) -> *mut S {
-        return &mut (*(self as *mut S)) as *mut S;
+        return &mut (*(self as *mut S));
     }
     pub unsafe fn returns_this_pointer(&mut self) -> *mut S {
         return (self as *mut S);
     }
     pub unsafe fn inc(&mut self) -> *mut S {
         self.a_.postfix_inc();
-        return &mut (*(self as *mut S)) as *mut S;
+        return &mut (*(self as *mut S));
     }
     pub unsafe fn set_from_this(&mut self) {
         self.a_ = ((self.a_) + (1));
@@ -68,7 +68,7 @@ impl S {
         (unsafe { bump_0((self as *mut S)) });
     }
     pub unsafe fn cref(&self) -> *const S {
-        return &(*(self as *const S)) as *const S;
+        return &(*(self as *const S));
     }
     pub unsafe fn is(&self, mut o: *const S) -> bool {
         return ((o) == (self as *const S));
diff --git a/tests/unit/out/unsafe/unique_ptr.rs b/tests/unit/out/unsafe/unique_ptr.rs
index 3c79812b..5b700600 100644
--- a/tests/unit/out/unsafe/unique_ptr.rs
+++ b/tests/unit/out/unsafe/unique_ptr.rs
@@ -150,7 +150,7 @@ pub fn main() {
 unsafe fn main_0() -> i32 {
     let mut x: Option<Box<i32>> = Some(Box::new(0));
     let mut safe_ptr: Option<Box<SafePointer>> = Some(Box::new(SafePointer { ptr: x.take() }));
-    (unsafe { DoStuffWithSafePointer_0(&mut safe_ptr as *mut Option<Box<SafePointer>>) });
+    (unsafe { DoStuffWithSafePointer_0(&mut safe_ptr) });
     assert!(((unsafe { Consume_1(safe_ptr.take(),) }) == (60)));
     return 0;
 }
diff --git a/tests/unit/out/unsafe/unique_ptr_small.rs b/tests/unit/out/unsafe/unique_ptr_small.rs
index 9abcb151..4645417f 100644
--- a/tests/unit/out/unsafe/unique_ptr_small.rs
+++ b/tests/unit/out/unsafe/unique_ptr_small.rs
@@ -17,7 +17,7 @@ pub fn main() {
 }
 unsafe fn main_0() -> i32 {
     let mut n: Option<Box<i32>> = Some(Box::new(10));
-    (unsafe { change_0(&mut n as *mut Option<Box<i32>>) });
+    (unsafe { change_0(&mut n) });
     assert!(((*n.as_deref_mut().unwrap()) == (20)));
     return 0;
 }
diff --git a/tests/unit/out/unsafe/vector2.rs b/tests/unit/out/unsafe/vector2.rs
index b23aebcd..1fd2d1a7 100644
--- a/tests/unit/out/unsafe/vector2.rs
+++ b/tests/unit/out/unsafe/vector2.rs
@@ -44,6 +44,6 @@ unsafe fn main_0() -> i32 {
     v.push(6);
     v2.push(8);
     v2.push(9);
-    (unsafe { fn_0(&mut v as *mut Vec<i32>, v2.clone()) });
+    (unsafe { fn_0(&mut v, v2.clone()) });
     return 0;
 }
diff --git a/tests/unit/out/unsafe/vector_with_allocator.rs b/tests/unit/out/unsafe/vector_with_allocator.rs
index 44d0acdb..178b6609 100644
--- a/tests/unit/out/unsafe/vector_with_allocator.rs
+++ b/tests/unit/out/unsafe/vector_with_allocator.rs
@@ -185,7 +185,7 @@ unsafe fn main_0() -> i32 {
     v7.push(6);
     v8.push(8);
     v8.push(9);
-    (unsafe { fn_1(&mut v7 as *mut Vec<i32>, v8.clone()) });
+    (unsafe { fn_1(&mut v7, v8.clone()) });
     let mut src: [u32; 3] = [1_u32, 2_u32, 3_u32];
     let mut v9: Vec<u32> = core::slice::from_raw_parts(
         src.as_mut_ptr(),
diff --git a/tests/unit/out/unsafe/void_cast.rs b/tests/unit/out/unsafe/void_cast.rs
index 0ce11d69..aea1827d 100644
--- a/tests/unit/out/unsafe/void_cast.rs
+++ b/tests/unit/out/unsafe/void_cast.rs
@@ -101,14 +101,14 @@ unsafe fn main_0() -> i32 {
     let mut hp: *mut Holder = (&mut h as *mut Holder);
     &((*hp).field);
     let mut nt: NonTrivial = <NonTrivial>::default();
-    (unsafe { unused_ref_param_1(&nt as *const NonTrivial) });
+    (unsafe { unused_ref_param_1(&nt) });
     (unsafe { unused_ptr_param_2((&mut nt as *mut NonTrivial).cast_const()) });
     let mut g: NonCopyable = NonCopyable {
         value: Some(Box::new(9)),
     };
     (&(g));
     &(g);
-    (unsafe { unused_noncopyable_param_5(&g as *const NonCopyable) });
+    (unsafe { unused_noncopyable_param_5(&g) });
     assert!(((*g.value.as_deref_mut().unwrap()) == (9)));
     return 0;
 }