diff --git a/cpp2rust/converter/converter.cpp b/cpp2rust/converter/converter.cpp
index 6d56236a..17c1075d 100644
--- a/cpp2rust/converter/converter.cpp
+++ b/cpp2rust/converter/converter.cpp
@@ -965,12 +965,8 @@ bool Converter::VisitReturnStmt(clang::ReturnStmt *stmt) {
 }
 
 void Converter::ConvertCondition(clang::Expr *cond) {
-  if (!cond->getType()->isBooleanType()) {
-    PushExprKind push(*this, ExprKind::RValue);
-    Convert(CreateConversionToBool(cond, ctx_));
-    return;
-  }
-  Convert(cond);
+  PushExprKind push(*this, ExprKind::RValue);
+  Convert(NormalizeToBool(cond, ctx_));
 }
 
 bool Converter::VisitIfStmt(clang::IfStmt *stmt) {
@@ -1741,6 +1737,41 @@ void Converter::ConvertIntegerToEnumeralCast(clang::Expr *to,
   }
 }
 
+void Converter::ConvertIntegralToBooleanCast(clang::ImplicitCastExpr *expr) {
+  auto sub_expr = expr->getSubExpr();
+  auto *stripped = sub_expr->IgnoreParenImpCasts();
+
+  if (auto binop = clang::dyn_cast<clang::BinaryOperator>(stripped)) {
+    // Comparison already produces bool, no wrap needed.
+    if (binop->isComparisonOp()) {
+      Convert(sub_expr);
+      return;
+    }
+    // Distribute bool conversion to each argument of the logical op.
+    if (binop->isLogicalOp()) {
+      {
+        PushParen paren(*this);
+        ConvertCondition(binop->getLHS());
+      }
+      StrCat(binop->getOpcodeStr());
+      {
+        PushParen paren(*this);
+        ConvertCondition(binop->getRHS());
+      }
+      return;
+    }
+  }
+
+  PushParen paren(*this);
+  Convert(sub_expr);
+  StrCat(token::kDiff);
+  if (sub_expr->getType()->isEnumeralType()) {
+    StrCat(GetUnsafeTypeAsString(sub_expr->getType()), "::from(0)");
+  } else /* sub_expr->getType()->isIntegerType() */ {
+    StrCat(token::kZero);
+  }
+}
+
 bool Converter::VisitImplicitCastExpr(clang::ImplicitCastExpr *expr) {
   auto *sub_expr = expr->getSubExpr();
   auto type = expr->getType();
@@ -1816,20 +1847,7 @@ bool Converter::VisitImplicitCastExpr(clang::ImplicitCastExpr *expr) {
     Convert(sub_expr);
     break;
   case clang::CastKind::CK_IntegralToBoolean:
-    if (auto binop = clang::dyn_cast<clang::BinaryOperator>(
-            sub_expr->IgnoreParenImpCasts())) {
-      // This already produces bool, no need for != 0
-      if (binop->isComparisonOp()) {
-        Convert(sub_expr);
-        break;
-      }
-    }
-
-    {
-      PushParen paren(*this);
-      Convert(sub_expr);
-      StrCat(token::kDiff, token::kZero);
-    }
+    ConvertIntegralToBooleanCast(expr);
     break;
   case clang::CastKind::CK_PointerToBoolean:
     StrCat(token::kNot);
@@ -2130,6 +2148,18 @@ bool Converter::VisitUnaryOperator(clang::UnaryOperator *expr) {
     Convert(sub_expr);
     computed_expr_type_ = ComputedExprType::FreshValue;
     break;
+  case clang::UO_LNot: {
+    bool needs_int_cast =
+        expr->getType()->isIntegerType() && !expr->getType()->isBooleanType();
+    PushParen paren_cast(*this, needs_int_cast);
+    StrCat(token::kNot);
+    ConvertCondition(sub_expr);
+    if (needs_int_cast) {
+      ConvertCast(expr->getType());
+    }
+    computed_expr_type_ = ComputedExprType::FreshValue;
+    break;
+  }
   case clang::UO_Minus:
     if (auto *literal = clang::dyn_cast<clang::IntegerLiteral>(sub_expr)) {
       if (sub_expr->getType()->isUnsignedIntegerType()) {
@@ -2173,7 +2203,7 @@ void Converter::EmitStmtExprTail(clang::Expr *tail) { Convert(tail); }
 
 bool Converter::VisitConditionalOperator(clang::ConditionalOperator *expr) {
   StrCat(keyword::kIf);
-  Convert(expr->getCond());
+  ConvertCondition(expr->getCond());
   {
     PushBrace then_brace(*this);
     if (expr->isLValue() && !isRValue() && !expr->getType()->isFunctionType()) {
@@ -2290,21 +2320,11 @@ bool Converter::VisitParenExpr(clang::ParenExpr *expr) {
     }
   }
 
-  // Add cast to avoid ambigous integers. Don't add cast if sub expression is a
-  // pointer dereference because we might want to mutate the dereferenced value.
-  bool should_add_integral_cast =
-      expr->getType()->isIntegralOrEnumerationType() && !isAddrOf() &&
-      !isVoid() && !clang::isa<clang::UnaryOperator>(expr->getSubExpr());
-  PushParen outer(*this, should_add_integral_cast);
-
   {
     PushParen inner(*this);
     Convert(expr->getSubExpr());
   }
 
-  if (should_add_integral_cast) {
-    ConvertCast(expr->getType());
-  }
   return false;
 }
 
diff --git a/cpp2rust/converter/converter.h b/cpp2rust/converter/converter.h
index 27a78041..9d7a7418 100644
--- a/cpp2rust/converter/converter.h
+++ b/cpp2rust/converter/converter.h
@@ -243,6 +243,8 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
 
   void ConvertIntegerToEnumeralCast(clang::Expr *to, clang::Expr *from);
 
+  void ConvertIntegralToBooleanCast(clang::ImplicitCastExpr *expr);
+
   virtual bool VisitImplicitCastExpr(clang::ImplicitCastExpr *expr);
 
   virtual bool VisitExplicitCastExpr(clang::ExplicitCastExpr *expr);
diff --git a/cpp2rust/converter/converter_lib.cpp b/cpp2rust/converter/converter_lib.cpp
index 027d3245..ed6ddc9f 100644
--- a/cpp2rust/converter/converter_lib.cpp
+++ b/cpp2rust/converter/converter_lib.cpp
@@ -683,9 +683,32 @@ bool ContainsVAArgExpr(const clang::Stmt *stmt) {
   return false;
 }
 
-clang::Expr *CreateConversionToBool(clang::Expr *expr, clang::ASTContext &ctx) {
+clang::Expr *NormalizeToBool(clang::Expr *expr, clang::ASTContext &ctx) {
+  if (expr->getType()->isBooleanType()) {
+    return expr;
+  }
+
+  // If logical not returns integer, then craft a new logical not that returns
+  // bool.
+  if (auto bin = clang::dyn_cast<clang::UnaryOperator>(expr)) {
+    if (bin->getOpcode() == clang::UO_LNot) {
+      return clang::UnaryOperator::Create(
+          ctx, bin->getSubExpr(), clang::UO_LNot, ctx.BoolTy, clang::VK_PRValue,
+          clang::OK_Ordinary, clang::SourceLocation(), false,
+          clang::FPOptionsOverride());
+    }
+  }
+
+  // Either to pointer -> bool, or int -> bool.
+  clang::CastKind cast_kind;
+  if (expr->getType()->isPointerType()) {
+    cast_kind = clang::CK_PointerToBoolean;
+  } else /* expr->getType()->isIntegerType() */ {
+    cast_kind = clang::CK_IntegralToBoolean;
+  }
+
   return clang::ImplicitCastExpr::Create(
-      ctx, ctx.BoolTy, clang::CK_IntegralToBoolean, expr,
+      ctx, ctx.BoolTy, cast_kind, expr,
       /*BasePath=*/nullptr, clang::VK_PRValue, clang::FPOptionsOverride());
 }
 
diff --git a/cpp2rust/converter/converter_lib.h b/cpp2rust/converter/converter_lib.h
index 3a3cf25d..97fbde64 100644
--- a/cpp2rust/converter/converter_lib.h
+++ b/cpp2rust/converter/converter_lib.h
@@ -154,7 +154,7 @@ bool IsBuiltinVaCopy(const clang::CallExpr *expr);
 
 bool ContainsVAArgExpr(const clang::Stmt *stmt);
 
-clang::Expr *CreateConversionToBool(clang::Expr *expr, clang::ASTContext &ctx);
+clang::Expr *NormalizeToBool(clang::Expr *expr, clang::ASTContext &ctx);
 
 std::vector<clang::SwitchCase *>
 GetTopLevelSwitchCases(clang::SwitchStmt *stmt);
diff --git a/cpp2rust/converter/models/converter_refcount.cpp b/cpp2rust/converter/models/converter_refcount.cpp
index 645cf63b..9b3c310e 100644
--- a/cpp2rust/converter/models/converter_refcount.cpp
+++ b/cpp2rust/converter/models/converter_refcount.cpp
@@ -615,7 +615,8 @@ bool ConverterRefCount::ConvertIncAndDec(clang::UnaryOperator *expr) {
 
 bool ConverterRefCount::VisitConditionalOperator(
     clang::ConditionalOperator *expr) {
-  StrCat(keyword::kIf, ConvertRValue(expr->getCond()));
+  StrCat(keyword::kIf);
+  ConvertCondition(expr->getCond());
   {
     PushBrace then_brace(*this);
     StrCat(ConvertFresh(expr->getTrueExpr()));
@@ -1046,9 +1047,12 @@ bool ConverterRefCount::VisitImplicitCastExpr(clang::ImplicitCastExpr *expr) {
     }
   }
 
-  if (expr->getCastKind() == clang::CastKind::CK_NullToPointer &&
-      expr->getType()->isFunctionPointerType()) {
-    StrCat("FnPtr::null()");
+  if (expr->getCastKind() == clang::CastKind::CK_NullToPointer) {
+    if (expr->getType()->isFunctionPointerType()) {
+      StrCat("FnPtr::null()");
+    } else {
+      StrCat("Default::default()");
+    }
     computed_expr_type_ = ComputedExprType::FreshPointer;
     return false;
   }
@@ -1137,6 +1141,11 @@ bool ConverterRefCount::VisitExplicitCastExpr(clang::ExplicitCastExpr *expr) {
     }
     return false;
   }
+  if (expr->getCastKind() == clang::CK_NullToPointer) {
+    StrCat("Default::default()");
+    computed_expr_type_ = ComputedExprType::FreshPointer;
+    return false;
+  }
   switch (expr->getStmtClass()) {
   case clang::Stmt::CXXReinterpretCastExprClass:
     assert(expr->getType()->isPointerType() &&
diff --git a/tests/ub/out/refcount/ub4.rs b/tests/ub/out/refcount/ub4.rs
index 8864310c..58bb8f61 100644
--- a/tests/ub/out/refcount/ub4.rs
+++ b/tests/ub/out/refcount/ub4.rs
@@ -7,11 +7,10 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn smaller_0(x1: Ptr<i32>, x2: Ptr<i32>) -> Ptr<i32> {
-    return if (({
+    return if ({
         let _lhs = (x1.read());
         _lhs < (x2.read())
-    }) as bool)
-    {
+    }) {
         (x1).clone()
     } else {
         (x2).clone()
diff --git a/tests/ub/out/unsafe/ub4.rs b/tests/ub/out/unsafe/ub4.rs
index 9d642ab8..4e49a9ab 100644
--- a/tests/ub/out/unsafe/ub4.rs
+++ b/tests/ub/out/unsafe/ub4.rs
@@ -7,11 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub unsafe fn smaller_0(x1: *mut i32, x2: *mut i32) -> *mut i32 {
-    return if (((*x1) < (*x2)) as bool) {
-        (x1)
-    } else {
-        (x2)
-    };
+    return if ((*x1) < (*x2)) { (x1) } else { (x2) };
 }
 pub fn main() {
     unsafe {
diff --git a/tests/unit/bool_condition_enum.cpp b/tests/unit/bool_condition_enum.cpp
new file mode 100644
index 00000000..fb24e8e5
--- /dev/null
+++ b/tests/unit/bool_condition_enum.cpp
@@ -0,0 +1,29 @@
+#include <assert.h>
+
+enum Code { CODE_OK = 0, CODE_ERR = 1, CODE_FATAL = 2 };
+
+int main() {
+  Code code = CODE_OK;
+  Code err = CODE_ERR;
+
+  if (code) {
+    assert(false);
+  }
+  if (!code) {
+    assert(true);
+  }
+  if (err) {
+    assert(true);
+  }
+  if (!err) {
+    assert(false);
+  }
+
+  int t9 = !code;
+  assert(t9 == 1);
+
+  bool b4 = code;
+  assert(!b4);
+
+  return 0;
+}
diff --git a/tests/unit/bool_condition_enum_c.c b/tests/unit/bool_condition_enum_c.c
new file mode 100644
index 00000000..617bf9e6
--- /dev/null
+++ b/tests/unit/bool_condition_enum_c.c
@@ -0,0 +1,30 @@
+#include <assert.h>
+#include <stdbool.h>
+
+enum Code { CODE_OK = 0, CODE_ERR = 1, CODE_FATAL = 2 };
+
+int main() {
+  enum Code code = CODE_OK;
+  enum Code err = CODE_ERR;
+
+  if (code) {
+    assert(false);
+  }
+  if (!code) {
+    assert(true);
+  }
+  if (err) {
+    assert(true);
+  }
+  if (!err) {
+    assert(false);
+  }
+
+  int t9 = !code;
+  assert(t9 == 1);
+
+  bool b4 = code;
+  assert(!b4);
+
+  return 0;
+}
diff --git a/tests/unit/bool_condition_int.cpp b/tests/unit/bool_condition_int.cpp
new file mode 100644
index 00000000..4a1b889c
--- /dev/null
+++ b/tests/unit/bool_condition_int.cpp
@@ -0,0 +1,63 @@
+#include <assert.h>
+
+int main() {
+  int n = 3;
+  int zero = 0;
+  unsigned u = 4;
+  unsigned long ul = 5;
+  long long ll = 6;
+  char ch = 'a';
+
+  if (n) {
+    assert(true);
+  }
+  if (!n) {
+    assert(false);
+  }
+  if (zero) {
+    assert(false);
+  }
+  if (!zero) {
+    assert(true);
+  }
+
+  if (u) {
+    assert(true);
+  }
+  if (ul) {
+    assert(true);
+  }
+  if (ll) {
+    assert(true);
+  }
+  if (ch) {
+    assert(true);
+  }
+
+  int loop_count = 0;
+  int counter = 3;
+  while (counter) {
+    --counter;
+    ++loop_count;
+  }
+  assert(loop_count == 3);
+
+  for (int i = 5; i; --i) {
+    ++loop_count;
+  }
+  assert(loop_count == 8);
+
+  int t = n ? 100 : 200;
+  assert(t == 100);
+  int t2 = zero ? 100 : 200;
+  assert(t2 == 200);
+  int t7 = !n;
+  assert(t7 == 0);
+  int t8 = !zero;
+  assert(t8 == 1);
+
+  bool b1 = n;
+  assert(b1);
+
+  return 0;
+}
diff --git a/tests/unit/bool_condition_int_c.c b/tests/unit/bool_condition_int_c.c
new file mode 100644
index 00000000..8d9d68db
--- /dev/null
+++ b/tests/unit/bool_condition_int_c.c
@@ -0,0 +1,64 @@
+#include <assert.h>
+#include <stdbool.h>
+
+int main() {
+  int n = 3;
+  int zero = 0;
+  unsigned u = 4;
+  unsigned long ul = 5;
+  long long ll = 6;
+  char ch = 'a';
+
+  if (n) {
+    assert(true);
+  }
+  if (!n) {
+    assert(false);
+  }
+  if (zero) {
+    assert(false);
+  }
+  if (!zero) {
+    assert(true);
+  }
+
+  if (u) {
+    assert(true);
+  }
+  if (ul) {
+    assert(true);
+  }
+  if (ll) {
+    assert(true);
+  }
+  if (ch) {
+    assert(true);
+  }
+
+  int loop_count = 0;
+  int counter = 3;
+  while (counter) {
+    --counter;
+    ++loop_count;
+  }
+  assert(loop_count == 3);
+
+  for (int i = 5; i; --i) {
+    ++loop_count;
+  }
+  assert(loop_count == 8);
+
+  int t = n ? 100 : 200;
+  assert(t == 100);
+  int t2 = zero ? 100 : 200;
+  assert(t2 == 200);
+  int t7 = !n;
+  assert(t7 == 0);
+  int t8 = !zero;
+  assert(t8 == 1);
+
+  bool b1 = n;
+  assert(b1);
+
+  return 0;
+}
diff --git a/tests/unit/bool_condition_logical.cpp b/tests/unit/bool_condition_logical.cpp
new file mode 100644
index 00000000..eff2ae58
--- /dev/null
+++ b/tests/unit/bool_condition_logical.cpp
@@ -0,0 +1,81 @@
+#include <assert.h>
+#include <stddef.h>
+
+enum Code { CODE_OK = 0, CODE_ERR = 1, CODE_FATAL = 2 };
+
+int side_effect = 0;
+int observe(int v) {
+  ++side_effect;
+  return v;
+}
+
+int main() {
+  int n = 3;
+  int zero = 0;
+  int storage = 7;
+  int *p = &storage;
+  int *np = nullptr;
+  unsigned u = 4;
+  Code code = CODE_OK;
+
+  if (n && p) {
+    assert(true);
+  }
+  if (n && np) {
+    assert(false);
+  }
+  if (zero || p) {
+    assert(true);
+  }
+  if (zero || np) {
+    assert(false);
+  }
+  if (n && u && p && code == CODE_OK) {
+    assert(true);
+  }
+
+  side_effect = 0;
+  if (zero && observe(1)) {
+    assert(false);
+  }
+  assert(side_effect == 0);
+
+  if (n || observe(1)) {
+    assert(true);
+  }
+  assert(side_effect == 0);
+
+  int x = 5;
+  int y = 3;
+  unsigned flags = 0x2u;
+  if ((x > y) || (flags & 0x1u)) {
+    assert(true);
+  }
+  if ((x < y) || (flags & 0x1u)) {
+    assert(false);
+  }
+
+  unsigned a = 1u;
+  unsigned b = 2u;
+  unsigned c = 3u;
+  if (((a != c)) && ((b != c))) {
+    assert(true);
+  }
+
+  int s = -1;
+  if ((p != nullptr) && (s < 0)) {
+    assert(true);
+  }
+
+  unsigned k = 2u;
+  bool done = false;
+  if ((k > 1u) || !done) {
+    assert(true);
+  }
+
+  if (((x > y)) || ((flags & 0x4u))) {
+    assert(true);
+  }
+
+  return 0;
+}
diff --git a/tests/unit/bool_condition_logical_c.c b/tests/unit/bool_condition_logical_c.c
new file mode 100644
index 00000000..c7870f3f
--- /dev/null
+++ b/tests/unit/bool_condition_logical_c.c
@@ -0,0 +1,82 @@
+#include <assert.h>
+#include <stdbool.h>
+#include <stddef.h>
+
+enum Code { CODE_OK = 0, CODE_ERR = 1, CODE_FATAL = 2 };
+
+int side_effect = 0;
+int observe(int v) {
+  ++side_effect;
+  return v;
+}
+
+int main() {
+  int n = 3;
+  int zero = 0;
+  int storage = 7;
+  int *p = &storage;
+  int *np = NULL;
+  unsigned u = 4;
+  enum Code code = CODE_OK;
+
+  if (n && p) {
+    assert(true);
+  }
+  if (n && np) {
+    assert(false);
+  }
+  if (zero || p) {
+    assert(true);
+  }
+  if (zero || np) {
+    assert(false);
+  }
+  if (n && u && p && code == CODE_OK) {
+    assert(true);
+  }
+
+  side_effect = 0;
+  if (zero && observe(1)) {
+    assert(false);
+  }
+  assert(side_effect == 0);
+
+  if (n || observe(1)) {
+    assert(true);
+  }
+  assert(side_effect == 0);
+
+  int x = 5;
+  int y = 3;
+  unsigned flags = 0x2u;
+  if ((x > y) || (flags & 0x1u)) {
+    assert(true);
+  }
+  if ((x < y) || (flags & 0x1u)) {
+    assert(false);
+  }
+
+  unsigned a = 1u;
+  unsigned b = 2u;
+  unsigned c = 3u;
+  if (((a != c)) && ((b != c))) {
+    assert(true);
+  }
+
+  int s = -1;
+  if ((p != NULL) && (s < 0)) {
+    assert(true);
+  }
+
+  unsigned k = 2u;
+  bool done = false;
+  if ((k > 1u) || !done) {
+    assert(true);
+  }
+
+  if (((x > y)) || ((flags & 0x4u))) {
+    assert(true);
+  }
+
+  return 0;
+}
diff --git a/tests/unit/bool_condition_ptr.cpp b/tests/unit/bool_condition_ptr.cpp
new file mode 100644
index 00000000..ccf4714a
--- /dev/null
+++ b/tests/unit/bool_condition_ptr.cpp
@@ -0,0 +1,45 @@
+#include <assert.h>
+#include <stddef.h>
+
+int main() {
+  int storage = 7;
+  int *p = &storage;
+  int *np = nullptr;
+
+  if (p) {
+    assert(true);
+  }
+  if (!p) {
+    assert(false);
+  }
+  if (np) {
+    assert(false);
+  }
+  if (!np) {
+    assert(true);
+  }
+
+  int *iter = p;
+  int iters = 0;
+  while (iter) {
+    ++iters;
+    iter = nullptr;
+  }
+  assert(iters == 1);
+
+  int t3 = p ? 1 : 0;
+  assert(t3 == 1);
+  int t4 = np ? 1 : 0;
+  assert(t4 == 0);
+  int t5 = !p;
+  assert(t5 == 0);
+  int t6 = !np;
+  assert(t6 == 1);
+
+  bool b2 = p;
+  bool b3 = np;
+  assert(b2);
+  assert(!b3);
+
+  return 0;
+}
diff --git a/tests/unit/bool_condition_ptr_c.c b/tests/unit/bool_condition_ptr_c.c
new file mode 100644
index 00000000..420e204c
--- /dev/null
+++ b/tests/unit/bool_condition_ptr_c.c
@@ -0,0 +1,46 @@
+#include <assert.h>
+#include <stdbool.h>
+#include <stddef.h>
+
+int main() {
+  int storage = 7;
+  int *p = &storage;
+  int *np = NULL;
+
+  if (p) {
+    assert(true);
+  }
+  if (!p) {
+    assert(false);
+  }
+  if (np) {
+    assert(false);
+  }
+  if (!np) {
+    assert(true);
+  }
+
+  int *iter = p;
+  int iters = 0;
+  while (iter) {
+    ++iters;
+    iter = NULL;
+  }
+  assert(iters == 1);
+
+  int t3 = p ? 1 : 0;
+  assert(t3 == 1);
+  int t4 = np ? 1 : 0;
+  assert(t4 == 0);
+  int t5 = !p;
+  assert(t5 == 0);
+  int t6 = !np;
+  assert(t6 == 1);
+
+  bool b2 = p;
+  bool b3 = np;
+  assert(b2);
+  assert(!b3);
+
+  return 0;
+}
diff --git a/tests/unit/out/refcount/bool_condition_enum.rs b/tests/unit/out/refcount/bool_condition_enum.rs
new file mode 100644
index 00000000..312017ae
--- /dev/null
+++ b/tests/unit/out/refcount/bool_condition_enum.rs
@@ -0,0 +1,49 @@
+extern crate libcc2rs;
+use libcc2rs::*;
+use std::cell::RefCell;
+use std::collections::BTreeMap;
+use std::io::prelude::*;
+use std::io::{Read, Seek, Write};
+use std::os::fd::AsFd;
+use std::rc::{Rc, Weak};
+#[derive(Clone, Copy, PartialEq, Debug, Default)]
+enum Code {
+    #[default]
+    CODE_OK = 0,
+    CODE_ERR = 1,
+    CODE_FATAL = 2,
+}
+impl From<i32> for Code {
+    fn from(n: i32) -> Code {
+        match n {
+            0 => Code::CODE_OK,
+            1 => Code::CODE_ERR,
+            2 => Code::CODE_FATAL,
+            _ => panic!("invalid Code value: {}", n),
+        }
+    }
+}
+pub fn main() {
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    let code: Value<Code> = Rc::new(RefCell::new(Code::CODE_OK));
+    let err: Value<Code> = Rc::new(RefCell::new(Code::CODE_ERR));
+    if ((*code.borrow()) != Code::from(0)) {
+        assert!(false);
+    }
+    if !((*code.borrow()) != Code::from(0)) {
+        assert!(true);
+    }
+    if ((*err.borrow()) != Code::from(0)) {
+        assert!(true);
+    }
+    if !((*err.borrow()) != Code::from(0)) {
+        assert!(false);
+    }
+    let t9: Value<i32> = Rc::new(RefCell::new((!((*code.borrow()) != Code::from(0)) as i32)));
+    assert!(((*t9.borrow()) == 1));
+    let b4: Value<bool> = Rc::new(RefCell::new(((*code.borrow()) != Code::from(0)).clone()));
+    assert!(!(*b4.borrow()));
+    return 0;
+}
diff --git a/tests/unit/out/refcount/bool_condition_enum_c.rs b/tests/unit/out/refcount/bool_condition_enum_c.rs
new file mode 100644
index 00000000..150f2611
--- /dev/null
+++ b/tests/unit/out/refcount/bool_condition_enum_c.rs
@@ -0,0 +1,49 @@
+extern crate libcc2rs;
+use libcc2rs::*;
+use std::cell::RefCell;
+use std::collections::BTreeMap;
+use std::io::prelude::*;
+use std::io::{Read, Seek, Write};
+use std::os::fd::AsFd;
+use std::rc::{Rc, Weak};
+#[derive(Clone, Copy, PartialEq, Debug, Default)]
+enum Code {
+    #[default]
+    CODE_OK = 0,
+    CODE_ERR = 1,
+    CODE_FATAL = 2,
+}
+impl From<i32> for Code {
+    fn from(n: i32) -> Code {
+        match n {
+            0 => Code::CODE_OK,
+            1 => Code::CODE_ERR,
+            2 => Code::CODE_FATAL,
+            _ => panic!("invalid Code value: {}", n),
+        }
+    }
+}
+pub fn main() {
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    let code: Value<Code> = Rc::new(RefCell::new(Code::from((Code::CODE_OK as i32))));
+    let err: Value<Code> = Rc::new(RefCell::new(Code::from((Code::CODE_ERR as i32))));
+    if ((*code.borrow()) != Code::from(0)) {
+        assert!((0 != 0));
+    }
+    if !((*code.borrow()) != Code::from(0)) {
+        assert!((1 != 0));
+    }
+    if ((*err.borrow()) != Code::from(0)) {
+        assert!((1 != 0));
+    }
+    if !((*err.borrow()) != Code::from(0)) {
+        assert!((0 != 0));
+    }
+    let t9: Value<i32> = Rc::new(RefCell::new((!((*code.borrow()) != Code::from(0)) as i32)));
+    assert!(((*t9.borrow()) == 1));
+    let b4: Value<bool> = Rc::new(RefCell::new(((*code.borrow()) != Code::from(0)).clone()));
+    assert!(((!(*b4.borrow()) as i32) != 0));
+    return 0;
+}
diff --git a/tests/unit/out/refcount/bool_condition_int.rs b/tests/unit/out/refcount/bool_condition_int.rs
new file mode 100644
index 00000000..ad21faed
--- /dev/null
+++ b/tests/unit/out/refcount/bool_condition_int.rs
@@ -0,0 +1,71 @@
+extern crate libcc2rs;
+use libcc2rs::*;
+use std::cell::RefCell;
+use std::collections::BTreeMap;
+use std::io::prelude::*;
+use std::io::{Read, Seek, Write};
+use std::os::fd::AsFd;
+use std::rc::{Rc, Weak};
+pub fn main() {
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    let n: Value<i32> = Rc::new(RefCell::new(3));
+    let zero: Value<i32> = Rc::new(RefCell::new(0));
+    let u: Value<u32> = Rc::new(RefCell::new(4_u32));
+    let ul: Value<u64> = Rc::new(RefCell::new(5_u64));
+    let ll: Value<i64> = Rc::new(RefCell::new(6_i64));
+    let ch: Value<u8> = Rc::new(RefCell::new(('a' as u8)));
+    if ((*n.borrow()) != 0) {
+        assert!(true);
+    }
+    if !((*n.borrow()) != 0) {
+        assert!(false);
+    }
+    if ((*zero.borrow()) != 0) {
+        assert!(false);
+    }
+    if !((*zero.borrow()) != 0) {
+        assert!(true);
+    }
+    if ((*u.borrow()) != 0) {
+        assert!(true);
+    }
+    if ((*ul.borrow()) != 0) {
+        assert!(true);
+    }
+    if ((*ll.borrow()) != 0) {
+        assert!(true);
+    }
+    if ((*ch.borrow()) != 0) {
+        assert!(true);
+    }
+    let loop_count: Value<i32> = Rc::new(RefCell::new(0));
+    let counter: Value<i32> = Rc::new(RefCell::new(3));
+    'loop_: while ((*counter.borrow()) != 0) {
+        (*counter.borrow_mut()).prefix_dec();
+        (*loop_count.borrow_mut()).prefix_inc();
+    }
+    assert!(((*loop_count.borrow()) == 3));
+    let i: Value<i32> = Rc::new(RefCell::new(5));
+    'loop_: while ((*i.borrow()) != 0) {
+        (*loop_count.borrow_mut()).prefix_inc();
+        (*i.borrow_mut()).prefix_dec();
+    }
+    assert!(((*loop_count.borrow()) == 8));
+    let t: Value<i32> = Rc::new(RefCell::new(if ((*n.borrow()) != 0) { 100 } else { 200 }));
+    assert!(((*t.borrow()) == 100));
+    let t2: Value<i32> = Rc::new(RefCell::new(if ((*zero.borrow()) != 0) {
+        100
+    } else {
+        200
+    }));
+    assert!(((*t2.borrow()) == 200));
+    let t7: Value<i32> = Rc::new(RefCell::new((!((*n.borrow()) != 0) as i32)));
+    assert!(((*t7.borrow()) == 0));
+    let t8: Value<i32> = Rc::new(RefCell::new((!((*zero.borrow()) != 0) as i32)));
+    assert!(((*t8.borrow()) == 1));
+    let b1: Value<bool> = Rc::new(RefCell::new(((*n.borrow()) != 0)));
+    assert!((*b1.borrow()));
+    return 0;
+}
diff --git a/tests/unit/out/refcount/bool_condition_int_c.rs b/tests/unit/out/refcount/bool_condition_int_c.rs
new file mode 100644
index 00000000..7d685281
--- /dev/null
+++ b/tests/unit/out/refcount/bool_condition_int_c.rs
@@ -0,0 +1,71 @@
+extern crate libcc2rs;
+use libcc2rs::*;
+use std::cell::RefCell;
+use std::collections::BTreeMap;
+use std::io::prelude::*;
+use std::io::{Read, Seek, Write};
+use std::os::fd::AsFd;
+use std::rc::{Rc, Weak};
+pub fn main() {
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    let n: Value<i32> = Rc::new(RefCell::new(3));
+    let zero: Value<i32> = Rc::new(RefCell::new(0));
+    let u: Value<u32> = Rc::new(RefCell::new(4_u32));
+    let ul: Value<u64> = Rc::new(RefCell::new(5_u64));
+    let ll: Value<i64> = Rc::new(RefCell::new(6_i64));
+    let ch: Value<u8> = Rc::new(RefCell::new((('a' as i32) as u8)));
+    if ((*n.borrow()) != 0) {
+        assert!((1 != 0));
+    }
+    if !((*n.borrow()) != 0) {
+        assert!((0 != 0));
+    }
+    if ((*zero.borrow()) != 0) {
+        assert!((0 != 0));
+    }
+    if !((*zero.borrow()) != 0) {
+        assert!((1 != 0));
+    }
+    if ((*u.borrow()) != 0) {
+        assert!((1 != 0));
+    }
+    if ((*ul.borrow()) != 0) {
+        assert!((1 != 0));
+    }
+    if ((*ll.borrow()) != 0) {
+        assert!((1 != 0));
+    }
+    if ((*ch.borrow()) != 0) {
+        assert!((1 != 0));
+    }
+    let loop_count: Value<i32> = Rc::new(RefCell::new(0));
+    let counter: Value<i32> = Rc::new(RefCell::new(3));
+    'loop_: while ((*counter.borrow()) != 0) {
+        (*counter.borrow_mut()).prefix_dec();
+        (*loop_count.borrow_mut()).prefix_inc();
+    }
+    assert!(((*loop_count.borrow()) == 3));
+    let i: Value<i32> = Rc::new(RefCell::new(5));
+    'loop_: while ((*i.borrow()) != 0) {
+        (*loop_count.borrow_mut()).prefix_inc();
+        (*i.borrow_mut()).prefix_dec();
+    }
+    assert!(((*loop_count.borrow()) == 8));
+    let t: Value<i32> = Rc::new(RefCell::new(if ((*n.borrow()) != 0) { 100 } else { 200 }));
+    assert!(((*t.borrow()) == 100));
+    let t2: Value<i32> = Rc::new(RefCell::new(if ((*zero.borrow()) != 0) {
+        100
+    } else {
+        200
+    }));
+    assert!(((*t2.borrow()) == 200));
+    let t7: Value<i32> = Rc::new(RefCell::new((!((*n.borrow()) != 0) as i32)));
+    assert!(((*t7.borrow()) == 0));
+    let t8: Value<i32> = Rc::new(RefCell::new((!((*zero.borrow()) != 0) as i32)));
+    assert!(((*t8.borrow()) == 1));
+    let b1: Value<bool> = Rc::new(RefCell::new(((*n.borrow()) != 0)));
+    assert!((*b1.borrow()));
+    return 0;
+}
diff --git a/tests/unit/out/refcount/bool_condition_logical.rs b/tests/unit/out/refcount/bool_condition_logical.rs
new file mode 100644
index 00000000..a25a429d
--- /dev/null
+++ b/tests/unit/out/refcount/bool_condition_logical.rs
@@ -0,0 +1,128 @@
+extern crate libcc2rs;
+use libcc2rs::*;
+use std::cell::RefCell;
+use std::collections::BTreeMap;
+use std::io::prelude::*;
+use std::io::{Read, Seek, Write};
+use std::os::fd::AsFd;
+use std::rc::{Rc, Weak};
+#[derive(Clone, Copy, PartialEq, Debug, Default)]
+enum Code {
+    #[default]
+    CODE_OK = 0,
+    CODE_ERR = 1,
+    CODE_FATAL = 2,
+}
+impl From<i32> for Code {
+    fn from(n: i32) -> Code {
+        match n {
+            0 => Code::CODE_OK,
+            1 => Code::CODE_ERR,
+            2 => Code::CODE_FATAL,
+            _ => panic!("invalid Code value: {}", n),
+        }
+    }
+}
+thread_local!(
+    pub static side_effect: Value<i32> = Rc::new(RefCell::new(0));
+);
+pub fn observe_0(v: i32) -> i32 {
+    let v: Value<i32> = Rc::new(RefCell::new(v));
+    (*side_effect.with(Value::clone).borrow_mut()).prefix_inc();
+    return (*v.borrow());
+}
+pub fn main() {
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    let n: Value<i32> = Rc::new(RefCell::new(3));
+    let zero: Value<i32> = Rc::new(RefCell::new(0));
+    let storage: Value<i32> = Rc::new(RefCell::new(7));
+    let p: Value<Ptr<i32>> = Rc::new(RefCell::new((storage.as_pointer())));
+    let np: Value<Ptr<i32>> = Rc::new(RefCell::new(Default::default()));
+    let u: Value<u32> = Rc::new(RefCell::new(4_u32));
+    let code: Value<Code> = Rc::new(RefCell::new(Code::CODE_OK));
+    if {
+        let _lhs = ((*n.borrow()) != 0);
+        _lhs && (!(*p.borrow()).is_null()).clone()
+    } {
+        assert!(true);
+    }
+    if {
+        let _lhs = ((*n.borrow()) != 0);
+        _lhs && (!(*np.borrow()).is_null()).clone()
+    } {
+        assert!(false);
+    }
+    if {
+        let _lhs = ((*zero.borrow()) != 0);
+        _lhs || (!(*p.borrow()).is_null()).clone()
+    } {
+        assert!(true);
+    }
+    if {
+        let _lhs = ((*zero.borrow()) != 0);
+        _lhs || (!(*np.borrow()).is_null()).clone()
+    } {
+        assert!(false);
+    }
+    if {
+        let _lhs = {
+            let _lhs = (((*n.borrow()) != 0) && ((*u.borrow()) != 0));
+            _lhs && (!(*p.borrow()).is_null()).clone()
+        };
+        _lhs && (((*code.borrow()) as i32) == (Code::CODE_OK as i32)).clone()
+    } {
+        assert!(true);
+    }
+    (*side_effect.with(Value::clone).borrow_mut()) = 0;
+    if (((*zero.borrow()) != 0)
+        && (({
+            let _v: i32 = 1;
+            observe_0(_v)
+        }) != 0))
+    {
+        assert!(false);
+    }
+    assert!(((*side_effect.with(Value::clone).borrow()) == 0));
+    if (((*n.borrow()) != 0)
+        || (({
+            let _v: i32 = 1;
+            observe_0(_v)
+        }) != 0))
+    {
+        assert!(true);
+    }
+    assert!(((*side_effect.with(Value::clone).borrow()) == 0));
+    let x: Value<i32> = Rc::new(RefCell::new(5));
+    let y: Value<i32> = Rc::new(RefCell::new(3));
+    let flags: Value<u32> = Rc::new(RefCell::new(2_u32));
+    if (((*x.borrow()) > (*y.borrow())) || (((*flags.borrow()) & 1_u32) != 0)) {
+        assert!(true);
+    }
+    if (((*x.borrow()) < (*y.borrow())) || (((*flags.borrow()) & 1_u32) != 0)) {
+        assert!(false);
+    }
+    let a: Value<u32> = Rc::new(RefCell::new(1_u32));
+    let b: Value<u32> = Rc::new(RefCell::new(2_u32));
+    let c: Value<u32> = Rc::new(RefCell::new(3_u32));
+    if (((*a.borrow()) != (*c.borrow())) && ((*b.borrow()) != (*c.borrow()))) {
+        assert!(true);
+    }
+    let s: Value<i32> = Rc::new(RefCell::new(-1_i32));
+    if {
+        let _lhs = (!((*p.borrow()).is_null())).clone();
+        _lhs && ((*s.borrow()) < 0)
+    } {
+        assert!(true);
+    }
+    let k: Value<u32> = Rc::new(RefCell::new(2_u32));
+    let done: Value<bool> = Rc::new(RefCell::new(false));
+    if (((*k.borrow()) > 1_u32) || !(*done.borrow())) {
+        assert!(true);
+    }
+    if (((*x.borrow()) > (*y.borrow())) || (((*flags.borrow()) & 4_u32) != 0)) {
+        assert!(true);
+    }
+    return 0;
+}
diff --git a/tests/unit/out/refcount/bool_condition_logical_c.rs b/tests/unit/out/refcount/bool_condition_logical_c.rs
new file mode 100644
index 00000000..fcf9535b
--- /dev/null
+++ b/tests/unit/out/refcount/bool_condition_logical_c.rs
@@ -0,0 +1,109 @@
+extern crate libcc2rs;
+use libcc2rs::*;
+use std::cell::RefCell;
+use std::collections::BTreeMap;
+use std::io::prelude::*;
+use std::io::{Read, Seek, Write};
+use std::os::fd::AsFd;
+use std::rc::{Rc, Weak};
+#[derive(Clone, Copy, PartialEq, Debug, Default)]
+enum Code {
+    #[default]
+    CODE_OK = 0,
+    CODE_ERR = 1,
+    CODE_FATAL = 2,
+}
+impl From<i32> for Code {
+    fn from(n: i32) -> Code {
+        match n {
+            0 => Code::CODE_OK,
+            1 => Code::CODE_ERR,
+            2 => Code::CODE_FATAL,
+            _ => panic!("invalid Code value: {}", n),
+        }
+    }
+}
+thread_local!(
+    pub static side_effect: Value<i32> = Rc::new(RefCell::new(0));
+);
+pub fn observe_0(v: i32) -> i32 {
+    let v: Value<i32> = Rc::new(RefCell::new(v));
+    (*side_effect.with(Value::clone).borrow_mut()).prefix_inc();
+    return (*v.borrow());
+}
+pub fn main() {
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    let n: Value<i32> = Rc::new(RefCell::new(3));
+    let zero: Value<i32> = Rc::new(RefCell::new(0));
+    let storage: Value<i32> = Rc::new(RefCell::new(7));
+    let p: Value<Ptr<i32>> = Rc::new(RefCell::new((storage.as_pointer())));
+    let np: Value<Ptr<i32>> = Rc::new(RefCell::new(Default::default()));
+    let u: Value<u32> = Rc::new(RefCell::new(4_u32));
+    let code: Value<Code> = Rc::new(RefCell::new(Code::from((Code::CODE_OK as i32))));
+    if ((*n.borrow()) != 0) && (!(*p.borrow()).is_null()) {
+        assert!((1 != 0));
+    }
+    if ((*n.borrow()) != 0) && (!(*np.borrow()).is_null()) {
+        assert!((0 != 0));
+    }
+    if ((*zero.borrow()) != 0) || (!(*p.borrow()).is_null()) {
+        assert!((1 != 0));
+    }
+    if ((*zero.borrow()) != 0) || (!(*np.borrow()).is_null()) {
+        assert!((0 != 0));
+    }
+    if ((((*n.borrow()) != 0) && ((*u.borrow()) != 0)) && (!(*p.borrow()).is_null()))
+        && (((*code.borrow()) as u32) == ((Code::CODE_OK as i32) as u32))
+    {
+        assert!((1 != 0));
+    }
+    (*side_effect.with(Value::clone).borrow_mut()) = 0;
+    if ((*zero.borrow()) != 0)
+        && (({
+            let _v: i32 = 1;
+            observe_0(_v)
+        }) != 0)
+    {
+        assert!((0 != 0));
+    }
+    assert!(((*side_effect.with(Value::clone).borrow()) == 0));
+    if ((*n.borrow()) != 0)
+        || (({
+            let _v: i32 = 1;
+            observe_0(_v)
+        }) != 0)
+    {
+        assert!((1 != 0));
+    }
+    assert!(((*side_effect.with(Value::clone).borrow()) == 0));
+    let x: Value<i32> = Rc::new(RefCell::new(5));
+    let y: Value<i32> = Rc::new(RefCell::new(3));
+    let flags: Value<u32> = Rc::new(RefCell::new(2_u32));
+    if ((*x.borrow()) > (*y.borrow())) || (((*flags.borrow()) & 1_u32) != 0) {
+        assert!((1 != 0));
+    }
+    if ((*x.borrow()) < (*y.borrow())) || (((*flags.borrow()) & 1_u32) != 0) {
+        assert!((0 != 0));
+    }
+    let a: Value<u32> = Rc::new(RefCell::new(1_u32));
+    let b: Value<u32> = Rc::new(RefCell::new(2_u32));
+    let c: Value<u32> = Rc::new(RefCell::new(3_u32));
+    if ((*a.borrow()) != (*c.borrow())) && ((*b.borrow()) != (*c.borrow())) {
+        assert!((1 != 0));
+    }
+    let s: Value<i32> = Rc::new(RefCell::new(-1_i32));
+    if ((*p.borrow()) != (Default::default())) && ((*s.borrow()) < 0) {
+        assert!((1 != 0));
+    }
+    let k: Value<u32> = Rc::new(RefCell::new(2_u32));
+    let done: Value<bool> = Rc::new(RefCell::new((0 != 0)));
+    if ((*k.borrow()) > 1_u32) || (!(*done.borrow())) {
+        assert!((1 != 0));
+    }
+    if ((*x.borrow()) > (*y.borrow())) || (((*flags.borrow()) & 4_u32) != 0) {
+        assert!((1 != 0));
+    }
+    return 0;
+}
diff --git a/tests/unit/out/refcount/bool_condition_ptr.rs b/tests/unit/out/refcount/bool_condition_ptr.rs
new file mode 100644
index 00000000..87545fdb
--- /dev/null
+++ b/tests/unit/out/refcount/bool_condition_ptr.rs
@@ -0,0 +1,48 @@
+extern crate libcc2rs;
+use libcc2rs::*;
+use std::cell::RefCell;
+use std::collections::BTreeMap;
+use std::io::prelude::*;
+use std::io::{Read, Seek, Write};
+use std::os::fd::AsFd;
+use std::rc::{Rc, Weak};
+pub fn main() {
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    let storage: Value<i32> = Rc::new(RefCell::new(7));
+    let p: Value<Ptr<i32>> = Rc::new(RefCell::new((storage.as_pointer())));
+    let np: Value<Ptr<i32>> = Rc::new(RefCell::new(Default::default()));
+    if !(*p.borrow()).is_null() {
+        assert!(true);
+    }
+    if !!(*p.borrow()).is_null() {
+        assert!(false);
+    }
+    if !(*np.borrow()).is_null() {
+        assert!(false);
+    }
+    if !!(*np.borrow()).is_null() {
+        assert!(true);
+    }
+    let iter: Value<Ptr<i32>> = Rc::new(RefCell::new((*p.borrow()).clone()));
+    let iters: Value<i32> = Rc::new(RefCell::new(0));
+    'loop_: while !(*iter.borrow()).is_null() {
+        (*iters.borrow_mut()).prefix_inc();
+        (*iter.borrow_mut()) = Default::default();
+    }
+    assert!(((*iters.borrow()) == 1));
+    let t3: Value<i32> = Rc::new(RefCell::new(if !(*p.borrow()).is_null() { 1 } else { 0 }));
+    assert!(((*t3.borrow()) == 1));
+    let t4: Value<i32> = Rc::new(RefCell::new(if !(*np.borrow()).is_null() { 1 } else { 0 }));
+    assert!(((*t4.borrow()) == 0));
+    let t5: Value<i32> = Rc::new(RefCell::new((!!(*p.borrow()).is_null() as i32)));
+    assert!(((*t5.borrow()) == 0));
+    let t6: Value<i32> = Rc::new(RefCell::new((!!(*np.borrow()).is_null() as i32)));
+    assert!(((*t6.borrow()) == 1));
+    let b2: Value<bool> = Rc::new(RefCell::new((!(*p.borrow()).is_null()).clone()));
+    let b3: Value<bool> = Rc::new(RefCell::new((!(*np.borrow()).is_null()).clone()));
+    assert!((*b2.borrow()));
+    assert!(!(*b3.borrow()));
+    return 0;
+}
diff --git a/tests/unit/out/refcount/bool_condition_ptr_c.rs b/tests/unit/out/refcount/bool_condition_ptr_c.rs
new file mode 100644
index 00000000..68f93d26
--- /dev/null
+++ b/tests/unit/out/refcount/bool_condition_ptr_c.rs
@@ -0,0 +1,48 @@
+extern crate libcc2rs;
+use libcc2rs::*;
+use std::cell::RefCell;
+use std::collections::BTreeMap;
+use std::io::prelude::*;
+use std::io::{Read, Seek, Write};
+use std::os::fd::AsFd;
+use std::rc::{Rc, Weak};
+pub fn main() {
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    let storage: Value<i32> = Rc::new(RefCell::new(7));
+    let p: Value<Ptr<i32>> = Rc::new(RefCell::new((storage.as_pointer())));
+    let np: Value<Ptr<i32>> = Rc::new(RefCell::new(Default::default()));
+    if !(*p.borrow()).is_null() {
+        assert!((1 != 0));
+    }
+    if !!(*p.borrow()).is_null() {
+        assert!((0 != 0));
+    }
+    if !(*np.borrow()).is_null() {
+        assert!((0 != 0));
+    }
+    if !!(*np.borrow()).is_null() {
+        assert!((1 != 0));
+    }
+    let iter: Value<Ptr<i32>> = Rc::new(RefCell::new((*p.borrow()).clone()));
+    let iters: Value<i32> = Rc::new(RefCell::new(0));
+    'loop_: while !(*iter.borrow()).is_null() {
+        (*iters.borrow_mut()).prefix_inc();
+        (*iter.borrow_mut()) = Default::default();
+    }
+    assert!(((*iters.borrow()) == 1));
+    let t3: Value<i32> = Rc::new(RefCell::new(if !(*p.borrow()).is_null() { 1 } else { 0 }));
+    assert!(((*t3.borrow()) == 1));
+    let t4: Value<i32> = Rc::new(RefCell::new(if !(*np.borrow()).is_null() { 1 } else { 0 }));
+    assert!(((*t4.borrow()) == 0));
+    let t5: Value<i32> = Rc::new(RefCell::new((!!(*p.borrow()).is_null() as i32)));
+    assert!(((*t5.borrow()) == 0));
+    let t6: Value<i32> = Rc::new(RefCell::new((!!(*np.borrow()).is_null() as i32)));
+    assert!(((*t6.borrow()) == 1));
+    let b2: Value<bool> = Rc::new(RefCell::new((!(*p.borrow()).is_null()).clone()));
+    let b3: Value<bool> = Rc::new(RefCell::new((!(*np.borrow()).is_null()).clone()));
+    assert!((*b2.borrow()));
+    assert!(((!(*b3.borrow()) as i32) != 0));
+    return 0;
+}
diff --git a/tests/unit/out/refcount/enum_int_interop.rs b/tests/unit/out/refcount/enum_int_interop.rs
index 64e02edf..6ba4c69f 100644
--- a/tests/unit/out/refcount/enum_int_interop.rs
+++ b/tests/unit/out/refcount/enum_int_interop.rs
@@ -131,9 +131,7 @@ fn main_0() -> i32 {
         make_color_2(_n)
     });
     assert!((((*c.borrow()) as i32) == (Color::GREEN as i32)));
-    let cmp: Value<Color> = Rc::new(RefCell::new(Color::from(
-        ((((*c.borrow()) as i32) + 1) as i32),
-    )));
+    let cmp: Value<Color> = Rc::new(RefCell::new(Color::from((((*c.borrow()) as i32) + 1))));
     assert!((((*cmp.borrow()) as i32) == (Color::BLUE as i32)));
     let o: Value<Option> = Rc::new(RefCell::new(Option::OPT_A));
     assert!((((*o.borrow()) as i32) == (Option::OPT_A as i32)));
diff --git a/tests/unit/out/refcount/enum_int_interop_c.rs b/tests/unit/out/refcount/enum_int_interop_c.rs
index 39a09b4d..5d77dc56 100644
--- a/tests/unit/out/refcount/enum_int_interop_c.rs
+++ b/tests/unit/out/refcount/enum_int_interop_c.rs
@@ -134,7 +134,7 @@ fn main_0() -> i32 {
     });
     assert!((((*c.borrow()) as u32) == ((Color::GREEN as i32) as u32)));
     let cmp: Value<Color> = Rc::new(RefCell::new(Color::from(
-        ((((*c.borrow()) as u32).wrapping_add(1_u32)) as u32) as i32,
+        (((*c.borrow()) as u32).wrapping_add(1_u32)) as i32,
     )));
     assert!((((*cmp.borrow()) as u32) == ((Color::BLUE as i32) as u32)));
     let o: Value<Option> = Rc::new(RefCell::new(Option::from((Option::OPT_A as i32))));
diff --git a/tests/unit/out/refcount/expr_as_bool_c.rs b/tests/unit/out/refcount/expr_as_bool_c.rs
index 4352b92e..da10e40c 100644
--- a/tests/unit/out/refcount/expr_as_bool_c.rs
+++ b/tests/unit/out/refcount/expr_as_bool_c.rs
@@ -17,21 +17,20 @@ fn main_0() -> i32 {
         (*b.borrow())
     } != 0)
     {}
-    'loop_: while ((({
+    'loop_: while (({
         (*b.borrow_mut()) = (*a.borrow());
         (*b.borrow())
-    }) as i32)
-        != 0)
+    }) != 0)
     {}
     if ((*a.borrow()) != 0) {}
     if ((*a.borrow()) == (*b.borrow())) {}
     if ((*a.borrow()) < (*b.borrow())) {}
     assert!(((*a.borrow()) == (*b.borrow())));
     assert!(
-        (!(({
+        ((!(({
             (*a.borrow_mut()) = (*b.borrow());
             (*a.borrow())
-        }) as i32)
+        }) != 0) as i32)
             != 0)
     );
     let c: Value<bool> = <Value<bool>>::default();
@@ -39,11 +38,10 @@ fn main_0() -> i32 {
         (*a.borrow_mut()) = (*b.borrow());
         (*a.borrow())
     } != 0);
-    (*c.borrow_mut()) = ((({
+    (*c.borrow_mut()) = (({
         (*b.borrow_mut()) = (*a.borrow());
         (*b.borrow())
-    }) as i32)
-        != 0);
+    }) != 0);
     (*c.borrow_mut()) = ((*a.borrow()) != 0);
     (*c.borrow_mut()) = ((*a.borrow()) == (*b.borrow()));
     (*c.borrow_mut()) = ((*a.borrow()) < (*b.borrow()));
diff --git a/tests/unit/out/refcount/expr_as_bool_cpp.rs b/tests/unit/out/refcount/expr_as_bool_cpp.rs
index e7955823..2e6ece8a 100644
--- a/tests/unit/out/refcount/expr_as_bool_cpp.rs
+++ b/tests/unit/out/refcount/expr_as_bool_cpp.rs
@@ -17,33 +17,30 @@ fn main_0() -> i32 {
         (*b.borrow())
     } != 0)
     {}
-    'loop_: while ((({
+    'loop_: while (({
         (*b.borrow_mut()) = (*a.borrow());
         (*b.borrow())
-    }) as i32)
-        != 0)
+    }) != 0)
     {}
     if ((*a.borrow()) != 0) {}
     if ((*a.borrow()) == (*b.borrow())) {}
     if ((*a.borrow()) < (*b.borrow())) {}
     assert!(((*a.borrow()) == (*b.borrow())));
     assert!(
-        !((({
+        !(({
             (*a.borrow_mut()) = (*b.borrow());
             (*a.borrow())
-        }) as i32)
-            != 0)
+        }) != 0)
     );
     let c: Value<bool> = <Value<bool>>::default();
     (*c.borrow_mut()) = ({
         (*a.borrow_mut()) = (*b.borrow());
         (*a.borrow())
     } != 0);
-    (*c.borrow_mut()) = ((({
+    (*c.borrow_mut()) = (({
         (*b.borrow_mut()) = (*a.borrow());
         (*b.borrow())
-    }) as i32)
-        != 0);
+    }) != 0);
     (*c.borrow_mut()) = ((*a.borrow()) != 0);
     (*c.borrow_mut()) = ((*a.borrow()) == (*b.borrow()));
     (*c.borrow_mut()) = ((*a.borrow()) < (*b.borrow()));
diff --git a/tests/unit/out/refcount/fft.rs b/tests/unit/out/refcount/fft.rs
index f717d180..6d93ea2e 100644
--- a/tests/unit/out/refcount/fft.rs
+++ b/tests/unit/out/refcount/fft.rs
@@ -269,16 +269,13 @@ fn main_0() -> i32 {
         (*imgs.borrow()).as_ref().unwrap().borrow_mut()[((*i.borrow()) as u64) as usize] = __rhs;
         (*i.borrow_mut()).prefix_inc();
     }
-    return ((((((((*reals.borrow()).as_ref().unwrap().borrow()[(0_u64) as usize] == 10)
+    return (((((((*reals.borrow()).as_ref().unwrap().borrow()[(0_u64) as usize] == 10)
         && ((*imgs.borrow()).as_ref().unwrap().borrow()[(0_u64) as usize] == 0))
-        as bool)
-        && ((((*reals.borrow()).as_ref().unwrap().borrow()[(1_u64) as usize] == -2_i32)
-            && ((*imgs.borrow()).as_ref().unwrap().borrow()[(1_u64) as usize] == 2))
-            as bool))
-        && ((((*reals.borrow()).as_ref().unwrap().borrow()[(2_u64) as usize] == -2_i32)
-            && ((*imgs.borrow()).as_ref().unwrap().borrow()[(2_u64) as usize] == 0))
-            as bool))
-        && ((((*reals.borrow()).as_ref().unwrap().borrow()[(3_u64) as usize] == -2_i32)
-            && ((*imgs.borrow()).as_ref().unwrap().borrow()[(3_u64) as usize] == -2_i32))
-            as bool)) as i32);
+        && (((*reals.borrow()).as_ref().unwrap().borrow()[(1_u64) as usize] == -2_i32)
+            && ((*imgs.borrow()).as_ref().unwrap().borrow()[(1_u64) as usize] == 2)))
+        && (((*reals.borrow()).as_ref().unwrap().borrow()[(2_u64) as usize] == -2_i32)
+            && ((*imgs.borrow()).as_ref().unwrap().borrow()[(2_u64) as usize] == 0)))
+        && (((*reals.borrow()).as_ref().unwrap().borrow()[(3_u64) as usize] == -2_i32)
+            && ((*imgs.borrow()).as_ref().unwrap().borrow()[(3_u64) as usize] == -2_i32)))
+        as i32);
 }
diff --git a/tests/unit/out/refcount/fn_ptr_as_condition.rs b/tests/unit/out/refcount/fn_ptr_as_condition.rs
index 72708ae5..d629dfba 100644
--- a/tests/unit/out/refcount/fn_ptr_as_condition.rs
+++ b/tests/unit/out/refcount/fn_ptr_as_condition.rs
@@ -44,7 +44,7 @@ fn main_0() -> i32 {
     assert!(((*b.borrow()) == 5));
     let fn_: Value<FnPtr<fn(Ptr<i32>)>> = Rc::new(RefCell::new(FnPtr::null()));
     if !!(*fn_.borrow()).is_null() {
-        (*fn_.borrow_mut()) = (FnPtr::<fn(Ptr<i32>)>::new(double_it_0)).clone();
+        (*fn_.borrow_mut()) = FnPtr::<fn(Ptr<i32>)>::new(double_it_0);
     }
     let c: Value<i32> = Rc::new(RefCell::new(3));
     if !(*fn_.borrow()).is_null() {
diff --git a/tests/unit/out/refcount/huffman.rs b/tests/unit/out/refcount/huffman.rs
index c60de2ad..fbac7892 100644
--- a/tests/unit/out/refcount/huffman.rs
+++ b/tests/unit/out/refcount/huffman.rs
@@ -166,7 +166,7 @@ impl MinHeap {
             _lhs && {
                 let _lhs = (*(*(*node.borrow()).upgrade().deref()).freq.borrow());
                 _lhs < (*(*(*self.arr.borrow()).as_ref().unwrap().borrow()
-                    [(((((*i.borrow()) - 1) as i32) / 2) as u64) as usize]
+                    [((((*i.borrow()) - 1) / 2) as u64) as usize]
                     .upgrade()
                     .deref())
                 .freq
@@ -174,11 +174,11 @@ impl MinHeap {
             }
         } {
             let __rhs = ((*self.arr.borrow()).as_ref().unwrap().borrow()
-                [(((((*i.borrow()) - 1) as i32) / 2) as u64) as usize])
+                [((((*i.borrow()) - 1) / 2) as u64) as usize])
                 .clone();
             (*self.arr.borrow()).as_ref().unwrap().borrow_mut()[((*i.borrow()) as u64) as usize] =
                 __rhs;
-            let __rhs = ((((*i.borrow()) - 1) as i32) / 2);
+            let __rhs = (((*i.borrow()) - 1) / 2);
             (*i.borrow_mut()) = __rhs;
         }
         (*self.arr.borrow()).as_ref().unwrap().borrow_mut()[((*i.borrow()) as u64) as usize] =
@@ -203,7 +203,7 @@ impl MinHeap {
             });
             (*i.borrow_mut()).prefix_inc();
         }
-        let i: Value<i32> = Rc::new(RefCell::new(((((*self.size.borrow()) - 2) as i32) / 2)));
+        let i: Value<i32> = Rc::new(RefCell::new((((*self.size.borrow()) - 2) / 2)));
         'loop_: while ((*i.borrow()) >= 0) {
             ({
                 let _idx: i32 = (*i.borrow());
diff --git a/tests/unit/out/refcount/linked_list.rs b/tests/unit/out/refcount/linked_list.rs
index d06957b6..926a9986 100644
--- a/tests/unit/out/refcount/linked_list.rs
+++ b/tests/unit/out/refcount/linked_list.rs
@@ -164,7 +164,7 @@ fn main_0() -> i32 {
         Delete_2(_head, _val)
     });
     (*head.borrow_mut()) = __rhs;
-    return ((((((((*(*({
+    return (((((((*(*({
         let _head: Ptr<Node> = (*head.borrow()).clone();
         let _idx: i32 = 0;
         Find_0(_head, _idx)
@@ -173,8 +173,8 @@ fn main_0() -> i32 {
     .deref())
     .val
     .borrow())
-        == 4) as bool)
-        && (((*(*({
+        == 4)
+        && ((*(*({
             let _head: Ptr<Node> = (*head.borrow()).clone();
             let _idx: i32 = 1;
             Find_0(_head, _idx)
@@ -183,8 +183,8 @@ fn main_0() -> i32 {
         .deref())
         .val
         .borrow())
-            == 3) as bool))
-        && (((*(*({
+            == 3))
+        && ((*(*({
             let _head: Ptr<Node> = (*head.borrow()).clone();
             let _idx: i32 = 2;
             Find_0(_head, _idx)
@@ -193,8 +193,8 @@ fn main_0() -> i32 {
         .deref())
         .val
         .borrow())
-            == 2) as bool))
-        && (((*(*({
+            == 2))
+        && ((*(*({
             let _head: Ptr<Node> = (*head.borrow()).clone();
             let _idx: i32 = 3;
             Find_0(_head, _idx)
@@ -203,8 +203,8 @@ fn main_0() -> i32 {
         .deref())
         .val
         .borrow())
-            == 1) as bool))
-        && (({
+            == 1))
+        && ({
             let _lhs = ((*(*({
                 let _head: Ptr<Node> = (*head.borrow()).clone();
                 let _idx: i32 = 4;
@@ -215,11 +215,11 @@ fn main_0() -> i32 {
             .val
             .borrow())
                 == -1_i32);
-            _lhs && ((({
+            _lhs && (({
                 let _head: Ptr<Node> = (*head.borrow()).clone();
                 let _idx: i32 = 5;
                 Find_0(_head, _idx)
             })
-            .is_null()) as bool)
-        }) as bool)) as i32);
+            .is_null())
+        })) as i32);
 }
diff --git a/tests/unit/out/refcount/main.rs b/tests/unit/out/refcount/main.rs
index c1cc92c4..40a2e60d 100644
--- a/tests/unit/out/refcount/main.rs
+++ b/tests/unit/out/refcount/main.rs
@@ -33,5 +33,5 @@ fn main_0(argc: i32, argv: Ptr<Ptr<u8>>) -> i32 {
     ));
     assert!(((*argc.borrow()) == 1));
     assert!((((*s.borrow()).len() - 1) as u64 > 0_u64));
-    return ((*argc.borrow()) + (((((*s.borrow()).len() - 1) as u64 > 0_u64) as bool) as i32));
+    return ((*argc.borrow()) + ((((*s.borrow()).len() - 1) as u64 > 0_u64) as i32));
 }
diff --git a/tests/unit/out/refcount/map-reallocation.rs b/tests/unit/out/refcount/map-reallocation.rs
index caae8df7..e89d1027 100644
--- a/tests/unit/out/refcount/map-reallocation.rs
+++ b/tests/unit/out/refcount/map-reallocation.rs
@@ -93,7 +93,7 @@ fn main_0() -> i32 {
             == 57005)
     );
     assert!((((*p.borrow()).read()) == 57005));
-    assert!(((*m.borrow()).len() as u64 == (((((*N.borrow()) + 1) as i32) as u32) as u64)));
+    assert!(((*m.borrow()).len() as u64 == ((((*N.borrow()) + 1) as u32) as u64)));
     let prev: Value<i32> = Rc::new(RefCell::new(-1_i32));
     'loop_: for pair in RefcountMapIter::begin(m.as_pointer()) {
         assert!({
diff --git a/tests/unit/out/refcount/operator_less_than.rs b/tests/unit/out/refcount/operator_less_than.rs
index 30ef4288..f2a57561 100644
--- a/tests/unit/out/refcount/operator_less_than.rs
+++ b/tests/unit/out/refcount/operator_less_than.rs
@@ -18,7 +18,7 @@ impl Pair {
                 let _lhs = (*self.x.borrow());
                 _lhs < (*(*other.upgrade().deref()).x.borrow())
             };
-            _lhs || (({
+            _lhs || ({
                 let _lhs = {
                     let _lhs = (*self.x.borrow());
                     _lhs == (*(*other.upgrade().deref()).x.borrow())
@@ -27,7 +27,7 @@ impl Pair {
                     let _lhs = (*self.y.borrow());
                     _lhs < (*(*other.upgrade().deref()).y.borrow())
                 }
-            }) as bool)
+            })
         };
     }
 }
diff --git a/tests/unit/out/refcount/pointer_usize_arith.rs b/tests/unit/out/refcount/pointer_usize_arith.rs
index 6d5edec0..69b913bd 100644
--- a/tests/unit/out/refcount/pointer_usize_arith.rs
+++ b/tests/unit/out/refcount/pointer_usize_arith.rs
@@ -23,7 +23,7 @@ fn main_0() -> i32 {
     ));
     assert!(((*diff.borrow()) == 3_i64));
     let idx: Value<u64> = Rc::new(RefCell::new(
-        (((((*r.borrow()).clone() - (*p.borrow()).clone()) as i64) as i64) as u64),
+        ((((*r.borrow()).clone() - (*p.borrow()).clone()) as i64) as u64),
     ));
     assert!(((*idx.borrow()) == 3_u64));
     let q2: Value<Ptr<i32>> = Rc::new(RefCell::new((*p.borrow()).clone()));
diff --git a/tests/unit/out/refcount/reinterpret_cast_iterate.rs b/tests/unit/out/refcount/reinterpret_cast_iterate.rs
index cda01e08..8e14bd3f 100644
--- a/tests/unit/out/refcount/reinterpret_cast_iterate.rs
+++ b/tests/unit/out/refcount/reinterpret_cast_iterate.rs
@@ -21,7 +21,7 @@ fn main_0() -> i32 {
     'loop_: while ((*i.borrow()) < 8) {
         assert!({
             let _lhs = (((*words.borrow()).offset((*i.borrow()) as isize).read()) as i32);
-            _lhs == (((((*i.borrow()) + 1) as i32) as u16) as i32)
+            _lhs == ((((*i.borrow()) + 1) as u16) as i32)
         });
         (*i.borrow_mut()).postfix_inc();
     }
diff --git a/tests/unit/out/refcount/switch_continue_inside_switch.rs b/tests/unit/out/refcount/switch_continue_inside_switch.rs
index 7fd4f4d3..4cc45fb4 100644
--- a/tests/unit/out/refcount/switch_continue_inside_switch.rs
+++ b/tests/unit/out/refcount/switch_continue_inside_switch.rs
@@ -37,7 +37,7 @@ fn main_0() -> i32 {
         (({
             let _n: i32 = 6;
             continue_inside_switch_0(_n)
-        }) == ((((1 + 3) + 5) as i32) + (3 * 1000)))
+        }) == (((1 + 3) + 5) + (3 * 1000)))
     );
     return 0;
 }
diff --git a/tests/unit/out/refcount/types.rs b/tests/unit/out/refcount/types.rs
index b23f8370..1489f3ee 100644
--- a/tests/unit/out/refcount/types.rs
+++ b/tests/unit/out/refcount/types.rs
@@ -20,7 +20,7 @@ fn main_0() -> i32 {
     let xi2: Value<i16> = Rc::new(RefCell::new(16_i16));
     let xi3: Value<i32> = Rc::new(RefCell::new(32));
     let xi4: Value<i64> = Rc::new(RefCell::new(64_i64));
-    let b: Value<bool> = Rc::new(RefCell::new((((*xu64.borrow()) == 64_u64) as bool)));
+    let b: Value<bool> = Rc::new(RefCell::new(((*xu64.borrow()) == 64_u64)));
     return ((((((((((((((*xu8.borrow()) as i32) + ((*xu16.borrow()) as i32)) as u32)
         .wrapping_add((*xu32.borrow()))) as u64)
         .wrapping_add((*xu64.borrow())))
diff --git a/tests/unit/out/refcount/va_arg_concat.rs b/tests/unit/out/refcount/va_arg_concat.rs
index dd051114..d765683c 100644
--- a/tests/unit/out/refcount/va_arg_concat.rs
+++ b/tests/unit/out/refcount/va_arg_concat.rs
@@ -12,11 +12,10 @@ pub fn sum_ints_0(first: i32, args: &[VaArg]) -> i32 {
     let total: Value<i32> = Rc::new(RefCell::new((*first.borrow())));
     (*ap.borrow_mut()) = VaList::new(args);
     let val: Value<i32> = <Value<i32>>::default();
-    'loop_: while ((({
+    'loop_: while (({
         (*val.borrow_mut()) = ((*ap.borrow_mut()).arg::<i32>()).clone();
         (*val.borrow())
-    }) as i32)
-        != 0)
+    }) != 0)
     {
         (*total.borrow_mut()) += (*val.borrow());
     }
diff --git a/tests/unit/out/refcount/va_arg_two_passes.rs b/tests/unit/out/refcount/va_arg_two_passes.rs
index ac6425a7..0172995e 100644
--- a/tests/unit/out/refcount/va_arg_two_passes.rs
+++ b/tests/unit/out/refcount/va_arg_two_passes.rs
@@ -13,20 +13,18 @@ pub fn sum_then_product_0(first: i32, args: &[VaArg]) -> i32 {
     let product: Value<i32> = Rc::new(RefCell::new((*first.borrow())));
     (*ap.borrow_mut()) = VaList::new(args);
     let val: Value<i32> = <Value<i32>>::default();
-    'loop_: while ((({
+    'loop_: while (({
         (*val.borrow_mut()) = ((*ap.borrow_mut()).arg::<i32>()).clone();
         (*val.borrow())
-    }) as i32)
-        != 0)
+    }) != 0)
     {
         (*sum.borrow_mut()) += (*val.borrow());
     }
     (*ap.borrow_mut()) = VaList::new(args);
-    'loop_: while ((({
+    'loop_: while (({
         (*val.borrow_mut()) = ((*ap.borrow_mut()).arg::<i32>()).clone();
         (*val.borrow())
-    }) as i32)
-        != 0)
+    }) != 0)
     {
         (*product.borrow_mut()) *= (*val.borrow());
     }
diff --git a/tests/unit/out/unsafe/bool_condition_enum.rs b/tests/unit/out/unsafe/bool_condition_enum.rs
new file mode 100644
index 00000000..da7dae3e
--- /dev/null
+++ b/tests/unit/out/unsafe/bool_condition_enum.rs
@@ -0,0 +1,51 @@
+extern crate libc;
+use libc::*;
+extern crate libcc2rs;
+use libcc2rs::*;
+use std::collections::BTreeMap;
+use std::io::{Read, Seek, Write};
+use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
+use std::rc::Rc;
+#[derive(Clone, Copy, PartialEq, Debug, Default)]
+enum Code {
+    #[default]
+    CODE_OK = 0,
+    CODE_ERR = 1,
+    CODE_FATAL = 2,
+}
+impl From<i32> for Code {
+    fn from(n: i32) -> Code {
+        match n {
+            0 => Code::CODE_OK,
+            1 => Code::CODE_ERR,
+            2 => Code::CODE_FATAL,
+            _ => panic!("invalid Code value: {}", n),
+        }
+    }
+}
+pub fn main() {
+    unsafe {
+        std::process::exit(main_0() as i32);
+    }
+}
+unsafe fn main_0() -> i32 {
+    let mut code: Code = Code::CODE_OK;
+    let mut err: Code = Code::CODE_ERR;
+    if (code != Code::from(0)) {
+        assert!(false);
+    }
+    if !(code != Code::from(0)) {
+        assert!(true);
+    }
+    if (err != Code::from(0)) {
+        assert!(true);
+    }
+    if !(err != Code::from(0)) {
+        assert!(false);
+    }
+    let mut t9: i32 = (!(code != Code::from(0)) as i32);
+    assert!(((t9) == (1)));
+    let mut b4: bool = (code != Code::from(0));
+    assert!(!b4);
+    return 0;
+}
diff --git a/tests/unit/out/unsafe/bool_condition_enum_c.rs b/tests/unit/out/unsafe/bool_condition_enum_c.rs
new file mode 100644
index 00000000..3f6a45e1
--- /dev/null
+++ b/tests/unit/out/unsafe/bool_condition_enum_c.rs
@@ -0,0 +1,51 @@
+extern crate libc;
+use libc::*;
+extern crate libcc2rs;
+use libcc2rs::*;
+use std::collections::BTreeMap;
+use std::io::{Read, Seek, Write};
+use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
+use std::rc::Rc;
+#[derive(Clone, Copy, PartialEq, Debug, Default)]
+enum Code {
+    #[default]
+    CODE_OK = 0,
+    CODE_ERR = 1,
+    CODE_FATAL = 2,
+}
+impl From<i32> for Code {
+    fn from(n: i32) -> Code {
+        match n {
+            0 => Code::CODE_OK,
+            1 => Code::CODE_ERR,
+            2 => Code::CODE_FATAL,
+            _ => panic!("invalid Code value: {}", n),
+        }
+    }
+}
+pub fn main() {
+    unsafe {
+        std::process::exit(main_0() as i32);
+    }
+}
+unsafe fn main_0() -> i32 {
+    let mut code: Code = Code::from((Code::CODE_OK as i32));
+    let mut err: Code = Code::from((Code::CODE_ERR as i32));
+    if (code != Code::from(0)) {
+        assert!((0 != 0));
+    }
+    if !(code != Code::from(0)) {
+        assert!((1 != 0));
+    }
+    if (err != Code::from(0)) {
+        assert!((1 != 0));
+    }
+    if !(err != Code::from(0)) {
+        assert!((0 != 0));
+    }
+    let mut t9: i32 = (!(code != Code::from(0)) as i32);
+    assert!(((t9) == (1)));
+    let mut b4: bool = (code != Code::from(0));
+    assert!(((!b4 as i32) != 0));
+    return 0;
+}
diff --git a/tests/unit/out/unsafe/bool_condition_int.rs b/tests/unit/out/unsafe/bool_condition_int.rs
new file mode 100644
index 00000000..ba4559ad
--- /dev/null
+++ b/tests/unit/out/unsafe/bool_condition_int.rs
@@ -0,0 +1,69 @@
+extern crate libc;
+use libc::*;
+extern crate libcc2rs;
+use libcc2rs::*;
+use std::collections::BTreeMap;
+use std::io::{Read, Seek, Write};
+use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
+use std::rc::Rc;
+pub fn main() {
+    unsafe {
+        std::process::exit(main_0() as i32);
+    }
+}
+unsafe fn main_0() -> i32 {
+    let mut n: i32 = 3;
+    let mut zero: i32 = 0;
+    let mut u: u32 = 4_u32;
+    let mut ul: u64 = 5_u64;
+    let mut ll: i64 = 6_i64;
+    let mut ch: u8 = ('a' as u8);
+    if (n != 0) {
+        assert!(true);
+    }
+    if !(n != 0) {
+        assert!(false);
+    }
+    if (zero != 0) {
+        assert!(false);
+    }
+    if !(zero != 0) {
+        assert!(true);
+    }
+    if (u != 0) {
+        assert!(true);
+    }
+    if (ul != 0) {
+        assert!(true);
+    }
+    if (ll != 0) {
+        assert!(true);
+    }
+    if (ch != 0) {
+        assert!(true);
+    }
+    let mut loop_count: i32 = 0;
+    let mut counter: i32 = 3;
+    'loop_: while (counter != 0) {
+        counter.prefix_dec();
+        loop_count.prefix_inc();
+    }
+    assert!(((loop_count) == (3)));
+    let mut i: i32 = 5;
+    'loop_: while (i != 0) {
+        loop_count.prefix_inc();
+        i.prefix_dec();
+    }
+    assert!(((loop_count) == (8)));
+    let mut t: i32 = if (n != 0) { 100 } else { 200 };
+    assert!(((t) == (100)));
+    let mut t2: i32 = if (zero != 0) { 100 } else { 200 };
+    assert!(((t2) == (200)));
+    let mut t7: i32 = (!(n != 0) as i32);
+    assert!(((t7) == (0)));
+    let mut t8: i32 = (!(zero != 0) as i32);
+    assert!(((t8) == (1)));
+    let mut b1: bool = (n != 0);
+    assert!(b1);
+    return 0;
+}
diff --git a/tests/unit/out/unsafe/bool_condition_int_c.rs b/tests/unit/out/unsafe/bool_condition_int_c.rs
new file mode 100644
index 00000000..3847ed1c
--- /dev/null
+++ b/tests/unit/out/unsafe/bool_condition_int_c.rs
@@ -0,0 +1,69 @@
+extern crate libc;
+use libc::*;
+extern crate libcc2rs;
+use libcc2rs::*;
+use std::collections::BTreeMap;
+use std::io::{Read, Seek, Write};
+use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
+use std::rc::Rc;
+pub fn main() {
+    unsafe {
+        std::process::exit(main_0() as i32);
+    }
+}
+unsafe fn main_0() -> i32 {
+    let mut n: i32 = 3;
+    let mut zero: i32 = 0;
+    let mut u: u32 = 4_u32;
+    let mut ul: u64 = 5_u64;
+    let mut ll: i64 = 6_i64;
+    let mut ch: u8 = (('a' as i32) as u8);
+    if (n != 0) {
+        assert!((1 != 0));
+    }
+    if !(n != 0) {
+        assert!((0 != 0));
+    }
+    if (zero != 0) {
+        assert!((0 != 0));
+    }
+    if !(zero != 0) {
+        assert!((1 != 0));
+    }
+    if (u != 0) {
+        assert!((1 != 0));
+    }
+    if (ul != 0) {
+        assert!((1 != 0));
+    }
+    if (ll != 0) {
+        assert!((1 != 0));
+    }
+    if (ch != 0) {
+        assert!((1 != 0));
+    }
+    let mut loop_count: i32 = 0;
+    let mut counter: i32 = 3;
+    'loop_: while (counter != 0) {
+        counter.prefix_dec();
+        loop_count.prefix_inc();
+    }
+    assert!(((loop_count) == (3)));
+    let mut i: i32 = 5;
+    'loop_: while (i != 0) {
+        loop_count.prefix_inc();
+        i.prefix_dec();
+    }
+    assert!(((loop_count) == (8)));
+    let mut t: i32 = if (n != 0) { 100 } else { 200 };
+    assert!(((t) == (100)));
+    let mut t2: i32 = if (zero != 0) { 100 } else { 200 };
+    assert!(((t2) == (200)));
+    let mut t7: i32 = (!(n != 0) as i32);
+    assert!(((t7) == (0)));
+    let mut t8: i32 = (!(zero != 0) as i32);
+    assert!(((t8) == (1)));
+    let mut b1: bool = (n != 0);
+    assert!(b1);
+    return 0;
+}
diff --git a/tests/unit/out/unsafe/bool_condition_logical.rs b/tests/unit/out/unsafe/bool_condition_logical.rs
new file mode 100644
index 00000000..245d026b
--- /dev/null
+++ b/tests/unit/out/unsafe/bool_condition_logical.rs
@@ -0,0 +1,106 @@
+extern crate libc;
+use libc::*;
+extern crate libcc2rs;
+use libcc2rs::*;
+use std::collections::BTreeMap;
+use std::io::{Read, Seek, Write};
+use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
+use std::rc::Rc;
+#[derive(Clone, Copy, PartialEq, Debug, Default)]
+enum Code {
+    #[default]
+    CODE_OK = 0,
+    CODE_ERR = 1,
+    CODE_FATAL = 2,
+}
+impl From<i32> for Code {
+    fn from(n: i32) -> Code {
+        match n {
+            0 => Code::CODE_OK,
+            1 => Code::CODE_ERR,
+            2 => Code::CODE_FATAL,
+            _ => panic!("invalid Code value: {}", n),
+        }
+    }
+}
+pub static mut side_effect: i32 = 0;
+pub unsafe fn observe_0(mut v: i32) -> i32 {
+    side_effect.prefix_inc();
+    return v;
+}
+pub fn main() {
+    unsafe {
+        std::process::exit(main_0() as i32);
+    }
+}
+unsafe fn main_0() -> i32 {
+    let mut n: i32 = 3;
+    let mut zero: i32 = 0;
+    let mut storage: i32 = 7;
+    let mut p: *mut i32 = (&mut storage as *mut i32);
+    let mut np: *mut i32 = Default::default();
+    let mut u: u32 = 4_u32;
+    let mut code: Code = Code::CODE_OK;
+    if ((n != 0) && (!(p).is_null())) {
+        assert!(true);
+    }
+    if ((n != 0) && (!(np).is_null())) {
+        assert!(false);
+    }
+    if ((zero != 0) || (!(p).is_null())) {
+        assert!(true);
+    }
+    if ((zero != 0) || (!(np).is_null())) {
+        assert!(false);
+    }
+    if ((((n != 0) && (u != 0)) && (!(p).is_null())) && ((code as i32) == (Code::CODE_OK as i32))) {
+        assert!(true);
+    }
+    side_effect = 0;
+    if ((zero != 0)
+        && ((unsafe {
+            let _v: i32 = 1;
+            observe_0(_v)
+        }) != 0))
+    {
+        assert!(false);
+    }
+    assert!(((side_effect) == (0)));
+    if ((n != 0)
+        || ((unsafe {
+            let _v: i32 = 1;
+            observe_0(_v)
+        }) != 0))
+    {
+        assert!(true);
+    }
+    assert!(((side_effect) == (0)));
+    let mut x: i32 = 5;
+    let mut y: i32 = 3;
+    let mut flags: u32 = 2_u32;
+    if (((x) > (y)) || (((flags) & (1_u32)) != 0)) {
+        assert!(true);
+    }
+    if (((x) < (y)) || (((flags) & (1_u32)) != 0)) {
+        assert!(false);
+    }
+    let mut a: u32 = 1_u32;
+    let mut b: u32 = 2_u32;
+    let mut c: u32 = 3_u32;
+    if (((a) != (c)) && ((b) != (c))) {
+        assert!(true);
+    }
+    let mut s: i32 = -1_i32;
+    if ((!((p).is_null())) && ((s) < (0))) {
+        assert!(true);
+    }
+    let mut k: u32 = 2_u32;
+    let mut done: bool = false;
+    if (((k) > (1_u32)) || (!done)) {
+        assert!(true);
+    }
+    if (((x) > (y)) || (((flags) & (4_u32)) != 0)) {
+        assert!(true);
+    }
+    return 0;
+}
diff --git a/tests/unit/out/unsafe/bool_condition_logical_c.rs b/tests/unit/out/unsafe/bool_condition_logical_c.rs
new file mode 100644
index 00000000..1fd7b027
--- /dev/null
+++ b/tests/unit/out/unsafe/bool_condition_logical_c.rs
@@ -0,0 +1,108 @@
+extern crate libc;
+use libc::*;
+extern crate libcc2rs;
+use libcc2rs::*;
+use std::collections::BTreeMap;
+use std::io::{Read, Seek, Write};
+use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
+use std::rc::Rc;
+#[derive(Clone, Copy, PartialEq, Debug, Default)]
+enum Code {
+    #[default]
+    CODE_OK = 0,
+    CODE_ERR = 1,
+    CODE_FATAL = 2,
+}
+impl From<i32> for Code {
+    fn from(n: i32) -> Code {
+        match n {
+            0 => Code::CODE_OK,
+            1 => Code::CODE_ERR,
+            2 => Code::CODE_FATAL,
+            _ => panic!("invalid Code value: {}", n),
+        }
+    }
+}
+pub static mut side_effect: i32 = 0;
+pub unsafe fn observe_0(mut v: i32) -> i32 {
+    side_effect.prefix_inc();
+    return v;
+}
+pub fn main() {
+    unsafe {
+        std::process::exit(main_0() as i32);
+    }
+}
+unsafe fn main_0() -> i32 {
+    let mut n: i32 = 3;
+    let mut zero: i32 = 0;
+    let mut storage: i32 = 7;
+    let mut p: *mut i32 = (&mut storage as *mut i32);
+    let mut np: *mut i32 = Default::default();
+    let mut u: u32 = 4_u32;
+    let mut code: Code = Code::from((Code::CODE_OK as i32));
+    if (n != 0) && (!(p).is_null()) {
+        assert!((1 != 0));
+    }
+    if (n != 0) && (!(np).is_null()) {
+        assert!((0 != 0));
+    }
+    if (zero != 0) || (!(p).is_null()) {
+        assert!((1 != 0));
+    }
+    if (zero != 0) || (!(np).is_null()) {
+        assert!((0 != 0));
+    }
+    if (((n != 0) && (u != 0)) && (!(p).is_null()))
+        && ((code as u32) == ((Code::CODE_OK as i32) as u32))
+    {
+        assert!((1 != 0));
+    }
+    side_effect = 0;
+    if (zero != 0)
+        && ((unsafe {
+            let _v: i32 = 1;
+            observe_0(_v)
+        }) != 0)
+    {
+        assert!((0 != 0));
+    }
+    assert!(((side_effect) == (0)));
+    if (n != 0)
+        || ((unsafe {
+            let _v: i32 = 1;
+            observe_0(_v)
+        }) != 0)
+    {
+        assert!((1 != 0));
+    }
+    assert!(((side_effect) == (0)));
+    let mut x: i32 = 5;
+    let mut y: i32 = 3;
+    let mut flags: u32 = 2_u32;
+    if ((x) > (y)) || (((flags) & (1_u32)) != 0) {
+        assert!((1 != 0));
+    }
+    if ((x) < (y)) || (((flags) & (1_u32)) != 0) {
+        assert!((0 != 0));
+    }
+    let mut a: u32 = 1_u32;
+    let mut b: u32 = 2_u32;
+    let mut c: u32 = 3_u32;
+    if ((a) != (c)) && ((b) != (c)) {
+        assert!((1 != 0));
+    }
+    let mut s: i32 = -1_i32;
+    if ((p) != ((0 as *mut ::libc::c_void) as *mut i32)) && ((s) < (0)) {
+        assert!((1 != 0));
+    }
+    let mut k: u32 = 2_u32;
+    let mut done: bool = (0 != 0);
+    if ((k) > (1_u32)) || (!done) {
+        assert!((1 != 0));
+    }
+    if ((x) > (y)) || (((flags) & (4_u32)) != 0) {
+        assert!((1 != 0));
+    }
+    return 0;
+}
diff --git a/tests/unit/out/unsafe/bool_condition_ptr.rs b/tests/unit/out/unsafe/bool_condition_ptr.rs
new file mode 100644
index 00000000..35aa449e
--- /dev/null
+++ b/tests/unit/out/unsafe/bool_condition_ptr.rs
@@ -0,0 +1,50 @@
+extern crate libc;
+use libc::*;
+extern crate libcc2rs;
+use libcc2rs::*;
+use std::collections::BTreeMap;
+use std::io::{Read, Seek, Write};
+use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
+use std::rc::Rc;
+pub fn main() {
+    unsafe {
+        std::process::exit(main_0() as i32);
+    }
+}
+unsafe fn main_0() -> i32 {
+    let mut storage: i32 = 7;
+    let mut p: *mut i32 = (&mut storage as *mut i32);
+    let mut np: *mut i32 = Default::default();
+    if !(p).is_null() {
+        assert!(true);
+    }
+    if !!(p).is_null() {
+        assert!(false);
+    }
+    if !(np).is_null() {
+        assert!(false);
+    }
+    if !!(np).is_null() {
+        assert!(true);
+    }
+    let mut iter: *mut i32 = p;
+    let mut iters: i32 = 0;
+    'loop_: while !(iter).is_null() {
+        iters.prefix_inc();
+        iter = Default::default();
+    }
+    assert!(((iters) == (1)));
+    let mut t3: i32 = if !(p).is_null() { 1 } else { 0 };
+    assert!(((t3) == (1)));
+    let mut t4: i32 = if !(np).is_null() { 1 } else { 0 };
+    assert!(((t4) == (0)));
+    let mut t5: i32 = (!!(p).is_null() as i32);
+    assert!(((t5) == (0)));
+    let mut t6: i32 = (!!(np).is_null() as i32);
+    assert!(((t6) == (1)));
+    let mut b2: bool = !(p).is_null();
+    let mut b3: bool = !(np).is_null();
+    assert!(b2);
+    assert!(!b3);
+    return 0;
+}
diff --git a/tests/unit/out/unsafe/bool_condition_ptr_c.rs b/tests/unit/out/unsafe/bool_condition_ptr_c.rs
new file mode 100644
index 00000000..efd06591
--- /dev/null
+++ b/tests/unit/out/unsafe/bool_condition_ptr_c.rs
@@ -0,0 +1,50 @@
+extern crate libc;
+use libc::*;
+extern crate libcc2rs;
+use libcc2rs::*;
+use std::collections::BTreeMap;
+use std::io::{Read, Seek, Write};
+use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
+use std::rc::Rc;
+pub fn main() {
+    unsafe {
+        std::process::exit(main_0() as i32);
+    }
+}
+unsafe fn main_0() -> i32 {
+    let mut storage: i32 = 7;
+    let mut p: *mut i32 = (&mut storage as *mut i32);
+    let mut np: *mut i32 = Default::default();
+    if !(p).is_null() {
+        assert!((1 != 0));
+    }
+    if !!(p).is_null() {
+        assert!((0 != 0));
+    }
+    if !(np).is_null() {
+        assert!((0 != 0));
+    }
+    if !!(np).is_null() {
+        assert!((1 != 0));
+    }
+    let mut iter: *mut i32 = p;
+    let mut iters: i32 = 0;
+    'loop_: while !(iter).is_null() {
+        iters.prefix_inc();
+        iter = Default::default();
+    }
+    assert!(((iters) == (1)));
+    let mut t3: i32 = if !(p).is_null() { 1 } else { 0 };
+    assert!(((t3) == (1)));
+    let mut t4: i32 = if !(np).is_null() { 1 } else { 0 };
+    assert!(((t4) == (0)));
+    let mut t5: i32 = (!!(p).is_null() as i32);
+    assert!(((t5) == (0)));
+    let mut t6: i32 = (!!(np).is_null() as i32);
+    assert!(((t6) == (1)));
+    let mut b2: bool = !(p).is_null();
+    let mut b3: bool = !(np).is_null();
+    assert!(b2);
+    assert!(((!b3 as i32) != 0));
+    return 0;
+}
diff --git a/tests/unit/out/unsafe/enum_int_interop.rs b/tests/unit/out/unsafe/enum_int_interop.rs
index 4a6bdc58..a422befe 100644
--- a/tests/unit/out/unsafe/enum_int_interop.rs
+++ b/tests/unit/out/unsafe/enum_int_interop.rs
@@ -130,7 +130,7 @@ unsafe fn main_0() -> i32 {
         make_color_2(_n)
     });
     assert!(((c as i32) == (Color::GREEN as i32)));
-    let mut cmp: Color = Color::from((((c as i32) + (1)) as i32));
+    let mut cmp: Color = Color::from(((c as i32) + (1)));
     assert!(((cmp as i32) == (Color::BLUE as i32)));
     let mut o: Option = Option::OPT_A;
     assert!(((o as i32) == (Option::OPT_A as i32)));
diff --git a/tests/unit/out/unsafe/enum_int_interop_c.rs b/tests/unit/out/unsafe/enum_int_interop_c.rs
index c3300c2a..90c18b26 100644
--- a/tests/unit/out/unsafe/enum_int_interop_c.rs
+++ b/tests/unit/out/unsafe/enum_int_interop_c.rs
@@ -130,7 +130,7 @@ unsafe fn main_0() -> i32 {
         make_color_2(_n)
     });
     assert!(((c as u32) == ((Color::GREEN as i32) as u32)));
-    let mut cmp: Color = Color::from((((c as u32).wrapping_add(1_u32)) as u32) as i32);
+    let mut cmp: Color = Color::from(((c as u32).wrapping_add(1_u32)) as i32);
     assert!(((cmp as u32) == ((Color::BLUE as i32) as u32)));
     let mut o: Option = Option::from((Option::OPT_A as i32));
     assert!(((o as u32) == ((Option::OPT_A as i32) as u32)));
diff --git a/tests/unit/out/unsafe/expr_as_bool_c.rs b/tests/unit/out/unsafe/expr_as_bool_c.rs
index 070f108e..fa316e5c 100644
--- a/tests/unit/out/unsafe/expr_as_bool_c.rs
+++ b/tests/unit/out/unsafe/expr_as_bool_c.rs
@@ -19,21 +19,20 @@ unsafe fn main_0() -> i32 {
         b
     } != 0)
     {}
-    'loop_: while ((({
+    'loop_: while (({
         b = a;
         b
-    }) as i32)
-        != (0))
+    }) != (0))
     {}
     if (a != 0) {}
     if ((a) == (b)) {}
     if ((a) < (b)) {}
     assert!(((a) == (b)));
     assert!(
-        (!(({
+        ((!(({
             a = b;
             a
-        }) as i32)
+        }) != 0) as i32)
             != 0)
     );
     let mut c: bool = false;
@@ -41,11 +40,10 @@ unsafe fn main_0() -> i32 {
         a = b;
         a
     } != 0);
-    c = ((({
+    c = (({
         b = a;
         b
-    }) as i32)
-        != (0));
+    }) != (0));
     c = (a != 0);
     c = ((a) == (b));
     c = ((a) < (b));
diff --git a/tests/unit/out/unsafe/expr_as_bool_cpp.rs b/tests/unit/out/unsafe/expr_as_bool_cpp.rs
index ae65ed24..3216a2a0 100644
--- a/tests/unit/out/unsafe/expr_as_bool_cpp.rs
+++ b/tests/unit/out/unsafe/expr_as_bool_cpp.rs
@@ -19,33 +19,30 @@ unsafe fn main_0() -> i32 {
         b
     } != 0)
     {}
-    'loop_: while ((({
+    'loop_: while (({
         b = a;
         b
-    }) as i32)
-        != (0))
+    }) != (0))
     {}
     if (a != 0) {}
     if ((a) == (b)) {}
     if ((a) < (b)) {}
     assert!(((a) == (b)));
     assert!(
-        !((({
+        !(({
             a = b;
             a
-        }) as i32)
-            != 0)
+        }) != 0)
     );
     let mut c: bool = false;
     c = ({
         a = b;
         a
     } != 0);
-    c = ((({
+    c = (({
         b = a;
         b
-    }) as i32)
-        != (0));
+    }) != (0));
     c = (a != 0);
     c = ((a) == (b));
     c = ((a) < (b));
diff --git a/tests/unit/out/unsafe/fft.rs b/tests/unit/out/unsafe/fft.rs
index 3235a4bd..1e659fa5 100644
--- a/tests/unit/out/unsafe/fft.rs
+++ b/tests/unit/out/unsafe/fft.rs
@@ -170,13 +170,12 @@ unsafe fn main_0() -> i32 {
             (b.as_mut().unwrap()[(i as u64) as usize].img.round() as i32);
         i.prefix_inc();
     }
-    return ((((((((reals.as_mut().unwrap()[(0_u64) as usize]) == (10))
-        && ((imgs.as_mut().unwrap()[(0_u64) as usize]) == (0))) as bool)
-        && ((((reals.as_mut().unwrap()[(1_u64) as usize]) == (-2_i32))
-            && ((imgs.as_mut().unwrap()[(1_u64) as usize]) == (2))) as bool))
-        && ((((reals.as_mut().unwrap()[(2_u64) as usize]) == (-2_i32))
-            && ((imgs.as_mut().unwrap()[(2_u64) as usize]) == (0))) as bool))
-        && ((((reals.as_mut().unwrap()[(3_u64) as usize]) == (-2_i32))
-            && ((imgs.as_mut().unwrap()[(3_u64) as usize]) == (-2_i32))) as bool))
-        as i32);
+    return (((((((reals.as_mut().unwrap()[(0_u64) as usize]) == (10))
+        && ((imgs.as_mut().unwrap()[(0_u64) as usize]) == (0)))
+        && (((reals.as_mut().unwrap()[(1_u64) as usize]) == (-2_i32))
+            && ((imgs.as_mut().unwrap()[(1_u64) as usize]) == (2))))
+        && (((reals.as_mut().unwrap()[(2_u64) as usize]) == (-2_i32))
+            && ((imgs.as_mut().unwrap()[(2_u64) as usize]) == (0))))
+        && (((reals.as_mut().unwrap()[(3_u64) as usize]) == (-2_i32))
+            && ((imgs.as_mut().unwrap()[(3_u64) as usize]) == (-2_i32)))) as i32);
 }
diff --git a/tests/unit/out/unsafe/huffman.rs b/tests/unit/out/unsafe/huffman.rs
index 868c697e..f7e5f669 100644
--- a/tests/unit/out/unsafe/huffman.rs
+++ b/tests/unit/out/unsafe/huffman.rs
@@ -108,12 +108,11 @@ impl MinHeap {
         let mut i: i32 = ((self.size) - (1));
         'loop_: while (((i) != (0))
             && (((*node).freq)
-                < ((*self.arr.as_mut().unwrap()[(((((i) - (1)) as i32) / (2)) as u64) as usize])
-                    .freq)))
+                < ((*self.arr.as_mut().unwrap()[((((i) - (1)) / (2)) as u64) as usize]).freq)))
         {
             self.arr.as_mut().unwrap()[(i as u64) as usize] =
-                self.arr.as_mut().unwrap()[(((((i) - (1)) as i32) / (2)) as u64) as usize];
-            i = ((((i) - (1)) as i32) / (2));
+                self.arr.as_mut().unwrap()[((((i) - (1)) / (2)) as u64) as usize];
+            i = (((i) - (1)) / (2));
         }
         self.arr.as_mut().unwrap()[(i as u64) as usize] = node;
     }
@@ -132,7 +131,7 @@ impl MinHeap {
             });
             i.prefix_inc();
         }
-        let mut i: i32 = ((((self.size) - (2)) as i32) / (2));
+        let mut i: i32 = (((self.size) - (2)) / (2));
         'loop_: while ((i) >= (0)) {
             (unsafe {
                 let _idx: i32 = i;
diff --git a/tests/unit/out/unsafe/linked_list.rs b/tests/unit/out/unsafe/linked_list.rs
index b9141c36..5ec1a27f 100644
--- a/tests/unit/out/unsafe/linked_list.rs
+++ b/tests/unit/out/unsafe/linked_list.rs
@@ -142,45 +142,45 @@ unsafe fn main_0() -> i32 {
         let _val: i32 = -2_i32;
         Delete_2(_head, _val)
     });
-    return (((((((((*(unsafe {
+    return ((((((((*(unsafe {
         let _head: *mut Node = head;
         let _idx: i32 = 0;
         Find_0(_head, _idx)
     }))
     .val)
-        == (4)) as bool)
-        && ((((*(unsafe {
+        == (4))
+        && (((*(unsafe {
             let _head: *mut Node = head;
             let _idx: i32 = 1;
             Find_0(_head, _idx)
         }))
         .val)
-            == (3)) as bool))
-        && ((((*(unsafe {
+            == (3)))
+        && (((*(unsafe {
             let _head: *mut Node = head;
             let _idx: i32 = 2;
             Find_0(_head, _idx)
         }))
         .val)
-            == (2)) as bool))
-        && ((((*(unsafe {
+            == (2)))
+        && (((*(unsafe {
             let _head: *mut Node = head;
             let _idx: i32 = 3;
             Find_0(_head, _idx)
         }))
         .val)
-            == (1)) as bool))
-        && (((((*(unsafe {
+            == (1)))
+        && ((((*(unsafe {
             let _head: *mut Node = head;
             let _idx: i32 = 4;
             Find_0(_head, _idx)
         }))
         .val)
             == (-1_i32))
-            && (((unsafe {
+            && ((unsafe {
                 let _head: *mut Node = head;
                 let _idx: i32 = 5;
                 Find_0(_head, _idx)
             })
-            .is_null()) as bool)) as bool)) as i32);
+            .is_null()))) as i32);
 }
diff --git a/tests/unit/out/unsafe/main.rs b/tests/unit/out/unsafe/main.rs
index 3114a94a..92774363 100644
--- a/tests/unit/out/unsafe/main.rs
+++ b/tests/unit/out/unsafe/main.rs
@@ -23,5 +23,5 @@ unsafe fn main_0(mut argc: i32, mut argv: *mut *mut u8) -> i32 {
     };
     assert!(((argc) == (1)));
     assert!((((s.len() - 1) as u64) > (0_u64)));
-    return ((argc) + (((((s.len() - 1) as u64) > (0_u64)) as bool) as i32));
+    return ((argc) + ((((s.len() - 1) as u64) > (0_u64)) as i32));
 }
diff --git a/tests/unit/out/unsafe/map-reallocation.rs b/tests/unit/out/unsafe/map-reallocation.rs
index 8b9abd69..4db83bd3 100644
--- a/tests/unit/out/unsafe/map-reallocation.rs
+++ b/tests/unit/out/unsafe/map-reallocation.rs
@@ -53,7 +53,7 @@ unsafe fn main_0() -> i32 {
     *it.second() = 57005;
     assert!(((*m.entry(sentinel).or_default().as_mut()) == (57005)));
     assert!(((*p) == (57005)));
-    assert!(((m.len() as u64) == (((((N) + (1)) as i32) as u32) as u64)));
+    assert!(((m.len() as u64) == ((((N) + (1)) as u32) as u64)));
     let mut prev: i32 = -1_i32;
     'loop_: for pair in UnsafeMapIterator::begin(&m as *const BTreeMap<i32, Box<i32>>) {
         assert!(((*pair.first()) > (prev)));
diff --git a/tests/unit/out/unsafe/operator_less_than.rs b/tests/unit/out/unsafe/operator_less_than.rs
index d183314f..e69d5c91 100644
--- a/tests/unit/out/unsafe/operator_less_than.rs
+++ b/tests/unit/out/unsafe/operator_less_than.rs
@@ -15,7 +15,7 @@ pub struct Pair {
 impl Pair {
     pub unsafe fn lt(&self, other: *const Pair) -> bool {
         return (((self.x) < ((*other).x))
-            || ((((self.x) == ((*other).x)) && ((self.y) < ((*other).y))) as bool));
+            || (((self.x) == ((*other).x)) && ((self.y) < ((*other).y))));
     }
 }
 impl Ord for Pair {
diff --git a/tests/unit/out/unsafe/pointer_usize_arith.rs b/tests/unit/out/unsafe/pointer_usize_arith.rs
index 693f1b46..b77184ed 100644
--- a/tests/unit/out/unsafe/pointer_usize_arith.rs
+++ b/tests/unit/out/unsafe/pointer_usize_arith.rs
@@ -22,8 +22,7 @@ unsafe fn main_0() -> i32 {
     assert!(((*s) == (11)));
     let mut diff: i64 = ((r as usize - p as usize) / ::std::mem::size_of::<i32>()) as i64;
     assert!(((diff) == (3_i64)));
-    let mut idx: u64 =
-        (((((r as usize - p as usize) / ::std::mem::size_of::<i32>()) as i64) as i64) as u64);
+    let mut idx: u64 = ((((r as usize - p as usize) / ::std::mem::size_of::<i32>()) as i64) as u64);
     assert!(((idx) == (3_u64)));
     let mut q2: *mut i32 = p;
     q2.prefix_inc();
diff --git a/tests/unit/out/unsafe/reinterpret_cast_iterate.rs b/tests/unit/out/unsafe/reinterpret_cast_iterate.rs
index 24c74d34..af3b6746 100644
--- a/tests/unit/out/unsafe/reinterpret_cast_iterate.rs
+++ b/tests/unit/out/unsafe/reinterpret_cast_iterate.rs
@@ -16,7 +16,7 @@ unsafe fn main_0() -> i32 {
     let mut words: *mut u16 = (arr.as_mut_ptr() as *mut u16);
     let mut i: i32 = 0;
     'loop_: while ((i) < (8)) {
-        assert!((((*words.offset((i) as isize)) as i32) == (((((i) + (1)) as i32) as u16) as i32)));
+        assert!((((*words.offset((i) as isize)) as i32) == ((((i) + (1)) as u16) as i32)));
         i.postfix_inc();
     }
     return 0;
diff --git a/tests/unit/out/unsafe/swap.rs b/tests/unit/out/unsafe/swap.rs
index ae3f71fc..4759d97b 100644
--- a/tests/unit/out/unsafe/swap.rs
+++ b/tests/unit/out/unsafe/swap.rs
@@ -33,7 +33,7 @@ unsafe fn main_0() -> i32 {
         identity_0(_x)
     });
     let mut p: *mut i32 = (&mut a as *mut i32);
-    p = (&mut ((b) as i32) as *mut i32);
+    p = (&mut (b) as *mut i32);
     p = (&mut a as *mut i32);
     (unsafe {
         let _a: *mut i32 = p;
diff --git a/tests/unit/out/unsafe/switch_continue_inside_switch.rs b/tests/unit/out/unsafe/switch_continue_inside_switch.rs
index bff9614b..60e40df1 100644
--- a/tests/unit/out/unsafe/switch_continue_inside_switch.rs
+++ b/tests/unit/out/unsafe/switch_continue_inside_switch.rs
@@ -38,7 +38,7 @@ unsafe fn main_0() -> i32 {
         ((unsafe {
             let _n: i32 = 6;
             continue_inside_switch_0(_n)
-        }) == (((((1) + (3)) + (5)) as i32) + ((3) * (1000))))
+        }) == ((((1) + (3)) + (5)) + ((3) * (1000))))
     );
     return 0;
 }
diff --git a/tests/unit/out/unsafe/types.rs b/tests/unit/out/unsafe/types.rs
index 512c43ec..ff70426f 100644
--- a/tests/unit/out/unsafe/types.rs
+++ b/tests/unit/out/unsafe/types.rs
@@ -22,7 +22,7 @@ unsafe fn main_0() -> i32 {
     let xi2: i16 = 16_i16;
     let mut xi3: i32 = 32;
     let mut xi4: i64 = 64_i64;
-    let mut b: bool = (((xu64) == (64_u64)) as bool);
+    let mut b: bool = ((xu64) == (64_u64));
     return (((((((((((((xu8 as i32) + (xu16 as i32)) as u32).wrapping_add(xu32)) as u64)
         .wrapping_add(xu64))
     .wrapping_add(xsz1))
diff --git a/tests/unit/out/unsafe/va_arg_concat.rs b/tests/unit/out/unsafe/va_arg_concat.rs
index 571cd946..7f587015 100644
--- a/tests/unit/out/unsafe/va_arg_concat.rs
+++ b/tests/unit/out/unsafe/va_arg_concat.rs
@@ -11,11 +11,10 @@ pub unsafe fn sum_ints_0(mut first: i32, args: &[VaArg]) -> i32 {
     let mut total: i32 = first;
     ap = VaList::new(args);
     let mut val: i32 = 0_i32;
-    'loop_: while ((({
+    'loop_: while (({
         val = ap.arg::<i32>();
         val
-    }) as i32)
-        != (0))
+    }) != (0))
     {
         total += val;
     }
diff --git a/tests/unit/out/unsafe/va_arg_two_passes.rs b/tests/unit/out/unsafe/va_arg_two_passes.rs
index 56cdb54c..99889949 100644
--- a/tests/unit/out/unsafe/va_arg_two_passes.rs
+++ b/tests/unit/out/unsafe/va_arg_two_passes.rs
@@ -12,20 +12,18 @@ pub unsafe fn sum_then_product_0(mut first: i32, args: &[VaArg]) -> i32 {
     let mut product: i32 = first;
     ap = VaList::new(args);
     let mut val: i32 = 0_i32;
-    'loop_: while ((({
+    'loop_: while (({
         val = ap.arg::<i32>();
         val
-    }) as i32)
-        != (0))
+    }) != (0))
     {
         sum += val;
     }
     ap = VaList::new(args);
-    'loop_: while ((({
+    'loop_: while (({
         val = ap.arg::<i32>();
         val
-    }) as i32)
-        != (0))
+    }) != (0))
     {
         product *= val;
     }