diff --git a/cpp2rust/converter/converter.cpp b/cpp2rust/converter/converter.cpp
index 1318c6f1..d3b04bd3 100644
--- a/cpp2rust/converter/converter.cpp
+++ b/cpp2rust/converter/converter.cpp
@@ -1731,6 +1731,16 @@ bool Converter::VisitCXXBoolLiteralExpr(clang::CXXBoolLiteralExpr *expr) {
   return false;
 }
 
+void Converter::ConvertIntegerToEnumeralCast(clang::Expr *to,
+                                             clang::Expr *from) {
+  StrCat(GetUnsafeTypeAsString(to->getType()), "::from");
+  PushParen paren(*this);
+  Convert(from);
+  if (!from->getType()->isSpecificBuiltinType(clang::BuiltinType::Int)) {
+    StrCat(keyword::kAs, "i32");
+  }
+}
+
 bool Converter::VisitImplicitCastExpr(clang::ImplicitCastExpr *expr) {
   auto *sub_expr = expr->getSubExpr();
   auto type = expr->getType();
@@ -1846,6 +1856,10 @@ bool Converter::VisitImplicitCastExpr(clang::ImplicitCastExpr *expr) {
       Convert(sub_expr);
       break;
     }
+    if (type->isEnumeralType() && !sub_expr->getType()->isEnumeralType()) {
+      ConvertIntegerToEnumeralCast(expr, sub_expr);
+      break;
+    }
     {
       PushParen outer(*this);
       if (clang::isa<clang::BinaryOperator>(sub_expr)) {
@@ -1890,6 +1904,10 @@ bool Converter::VisitExplicitCastExpr(clang::ExplicitCastExpr *expr) {
       StrCat(')');
       return false;
     }
+    if (type->isEnumeralType() && !sub_expr->getType()->isEnumeralType()) {
+      ConvertIntegerToEnumeralCast(expr, sub_expr);
+      return false;
+    }
     {
       PushParen paren(*this);
       Convert(sub_expr);
@@ -2200,10 +2218,14 @@ std::string Converter::ConvertDeclRefExpr(clang::DeclRefExpr *expr) {
   }
 
   if (auto enum_constant = clang::dyn_cast<clang::EnumConstantDecl>(decl)) {
-    return std::format("{}::{}",
-                       GetRecordName(clang::dyn_cast<clang::EnumDecl>(
-                           enum_constant->getDeclContext())),
-                       std::string_view(enum_constant->getName()));
+    auto qualified = std::format("{}::{}",
+                                 GetRecordName(clang::dyn_cast<clang::EnumDecl>(
+                                     enum_constant->getDeclContext())),
+                                 std::string_view(enum_constant->getName()));
+    if (!expr->getType()->isEnumeralType()) {
+      return std::format("({} as i32)", qualified);
+    }
+    return qualified;
   }
 
   if (IsGlobalVar(expr)) {
@@ -2704,9 +2726,29 @@ bool Converter::VisitEnumDecl(clang::EnumDecl *decl) {
                        std::string_view(init.data(), init.size())));
   }
   StrCat("}");
+
+  AddFromImpl(decl);
   return false;
 }
 
+void Converter::AddFromImpl(clang::EnumDecl *decl) {
+  auto name = GetRecordName(decl);
+  StrCat(std::format("impl From<i32> for {}", name));
+  PushBrace impl(*this);
+  StrCat(std::format("fn from(n: i32) -> {}", name));
+  PushBrace fn(*this);
+  StrCat("match n");
+  PushBrace match(*this);
+  for (auto e : decl->enumerators()) {
+    llvm::SmallVector<char, 32> init;
+    e->getInitVal().toString(init, 10);
+    StrCat(std::format("{} => {}::{},",
+                       std::string_view(init.data(), init.size()), name,
+                       std::string_view(e->getName())));
+  }
+  StrCat(std::format("_ => panic!(\"invalid {} value: {{}}\", n),", name));
+}
+
 bool Converter::VisitCXXDefaultArgExpr(clang::CXXDefaultArgExpr *expr) {
   if (expr->getType()->isPointerType()) {
     StrCat(keyword_default_);
diff --git a/cpp2rust/converter/converter.h b/cpp2rust/converter/converter.h
index 139b025a..27a78041 100644
--- a/cpp2rust/converter/converter.h
+++ b/cpp2rust/converter/converter.h
@@ -241,6 +241,8 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
 
   virtual bool VisitCXXBoolLiteralExpr(clang::CXXBoolLiteralExpr *expr);
 
+  void ConvertIntegerToEnumeralCast(clang::Expr *to, clang::Expr *from);
+
   virtual bool VisitImplicitCastExpr(clang::ImplicitCastExpr *expr);
 
   virtual bool VisitExplicitCastExpr(clang::ExplicitCastExpr *expr);
@@ -293,6 +295,8 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
 
   virtual bool VisitEnumDecl(clang::EnumDecl *decl);
 
+  virtual void AddFromImpl(clang::EnumDecl *decl);
+
   virtual bool VisitCXXDefaultArgExpr(clang::CXXDefaultArgExpr *expr);
 
   virtual bool VisitLambdaExpr(clang::LambdaExpr *expr);
diff --git a/tests/ub/enum_out_of_range_cast.cpp b/tests/ub/enum_out_of_range_cast.cpp
new file mode 100644
index 00000000..1549920c
--- /dev/null
+++ b/tests/ub/enum_out_of_range_cast.cpp
@@ -0,0 +1,9 @@
+// panic
+
+enum Color { RED, GREEN, BLUE };
+
+int main() {
+  int n = 3;
+  Color c = (Color)n;
+  return c == BLUE ? 0 : 1;
+}
diff --git a/tests/ub/out/refcount/enum_out_of_range_cast.rs b/tests/ub/out/refcount/enum_out_of_range_cast.rs
new file mode 100644
index 00000000..2ee58dc0
--- /dev/null
+++ b/tests/ub/out/refcount/enum_out_of_range_cast.rs
@@ -0,0 +1,37 @@
+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 Color {
+    #[default]
+    RED = 0,
+    GREEN = 1,
+    BLUE = 2,
+}
+impl From<i32> for Color {
+    fn from(n: i32) -> Color {
+        match n {
+            0 => Color::RED,
+            1 => Color::GREEN,
+            2 => Color::BLUE,
+            _ => panic!("invalid Color value: {}", n),
+        }
+    }
+}
+pub fn main() {
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    let n: Value<i32> = Rc::new(RefCell::new(3));
+    let c: Value<Color> = Rc::new(RefCell::new(Color::from((*n.borrow()))));
+    return if (((*c.borrow()) as i32) == (Color::BLUE as i32)) {
+        0
+    } else {
+        1
+    };
+}
diff --git a/tests/ub/out/unsafe/enum_out_of_range_cast.rs b/tests/ub/out/unsafe/enum_out_of_range_cast.rs
new file mode 100644
index 00000000..8f0a5ac5
--- /dev/null
+++ b/tests/ub/out/unsafe/enum_out_of_range_cast.rs
@@ -0,0 +1,39 @@
+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 Color {
+    #[default]
+    RED = 0,
+    GREEN = 1,
+    BLUE = 2,
+}
+impl From<i32> for Color {
+    fn from(n: i32) -> Color {
+        match n {
+            0 => Color::RED,
+            1 => Color::GREEN,
+            2 => Color::BLUE,
+            _ => panic!("invalid Color value: {}", n),
+        }
+    }
+}
+pub fn main() {
+    unsafe {
+        std::process::exit(main_0() as i32);
+    }
+}
+unsafe fn main_0() -> i32 {
+    let mut n: i32 = 3;
+    let mut c: Color = Color::from(n);
+    return if ((c as i32) == (Color::BLUE as i32)) {
+        0
+    } else {
+        1
+    };
+}
diff --git a/tests/unit/enum_int_interop.cpp b/tests/unit/enum_int_interop.cpp
new file mode 100644
index 00000000..02aeee10
--- /dev/null
+++ b/tests/unit/enum_int_interop.cpp
@@ -0,0 +1,117 @@
+#include <assert.h>
+
+enum Color { RED, GREEN, BLUE };
+
+enum Option {
+  OPT_NONE = 0,
+  OPT_A = 10,
+  OPT_B = 20,
+  OPT_C = 30,
+};
+
+typedef enum {
+  TAG_ZERO = 0,
+  TAG_ONE = 1,
+  TAG_TWO = 2,
+} Tag;
+
+int as_int(Color c) { return c; }
+
+int classify_option(int option) {
+  switch (option) {
+  case OPT_NONE:
+    return -1;
+  case OPT_A:
+    return 1;
+  case OPT_B:
+    return 2;
+  case OPT_C:
+    return 3;
+  default:
+    return 0;
+  }
+}
+
+Color make_color(int n) { return (Color)n; }
+
+int main() {
+  Color c = RED;
+
+  assert(c == RED);
+  assert(c == 0);
+  assert(c != 1);
+
+  if (c == GREEN) {
+    return 1;
+  }
+
+  switch (c) {
+  case 0:
+    break;
+  case 1:
+    return 1;
+  case 2:
+    return 2;
+  default:
+    return 99;
+  }
+
+  int x = c;
+  assert(x == 0);
+
+  int y = c + 1;
+  assert(y == 1);
+
+  c = (Color)2;
+  assert(c == BLUE);
+  assert(c == 2);
+
+  c = make_color(1);
+  assert(c == GREEN);
+
+  Color cmp = (Color)(c + 1);
+  assert(cmp == BLUE);
+
+  Option o = OPT_A;
+  assert(o == OPT_A);
+  assert(o == 10);
+
+  int oi = o;
+  assert(oi == 10);
+
+  o = (Option)20;
+  assert(o == OPT_B);
+
+  int rc = classify_option(o);
+  assert(rc == 2);
+
+  rc = classify_option(20);
+  assert(rc == 2);
+
+  rc = classify_option(OPT_C);
+  assert(rc == 3);
+
+  Tag t = TAG_ONE;
+  assert(t == 1);
+  assert(t == TAG_ONE);
+
+  int ti = t;
+  assert(ti == 1);
+
+  t = (Tag)2;
+  assert(t == TAG_TWO);
+
+  switch (t) {
+  case TAG_ZERO:
+    return 90;
+  case 1:
+    return 91;
+  case 2:
+    break;
+  }
+
+  int extra = (int)RED + (int)GREEN + (int)BLUE;
+  assert(extra == 0 + 1 + 2);
+
+  return 0;
+}
diff --git a/tests/unit/enum_int_interop_c.c b/tests/unit/enum_int_interop_c.c
new file mode 100644
index 00000000..ed22035a
--- /dev/null
+++ b/tests/unit/enum_int_interop_c.c
@@ -0,0 +1,117 @@
+#include <assert.h>
+
+enum Color { RED, GREEN, BLUE };
+
+enum Option {
+  OPT_NONE = 0,
+  OPT_A = 10,
+  OPT_B = 20,
+  OPT_C = 30,
+};
+
+typedef enum {
+  TAG_ZERO = 0,
+  TAG_ONE = 1,
+  TAG_TWO = 2,
+} Tag;
+
+int as_int(enum Color c) { return c; }
+
+int classify_option(int option) {
+  switch (option) {
+  case OPT_NONE:
+    return -1;
+  case OPT_A:
+    return 1;
+  case OPT_B:
+    return 2;
+  case OPT_C:
+    return 3;
+  default:
+    return 0;
+  }
+}
+
+enum Color make_color(int n) { return (enum Color)n; }
+
+int main() {
+  enum Color c = RED;
+
+  assert(c == RED);
+  assert(c == 0);
+  assert(c != 1);
+
+  if (c == GREEN) {
+    return 1;
+  }
+
+  switch (c) {
+  case 0:
+    break;
+  case 1:
+    return 1;
+  case 2:
+    return 2;
+  default:
+    return 99;
+  }
+
+  int x = c;
+  assert(x == 0);
+
+  int y = c + 1;
+  assert(y == 1);
+
+  c = (enum Color)2;
+  assert(c == BLUE);
+  assert(c == 2);
+
+  c = make_color(1);
+  assert(c == GREEN);
+
+  enum Color cmp = (enum Color)(c + 1);
+  assert(cmp == BLUE);
+
+  enum Option o = OPT_A;
+  assert(o == OPT_A);
+  assert(o == 10);
+
+  int oi = o;
+  assert(oi == 10);
+
+  o = (enum Option)20;
+  assert(o == OPT_B);
+
+  int rc = classify_option(o);
+  assert(rc == 2);
+
+  rc = classify_option(20);
+  assert(rc == 2);
+
+  rc = classify_option(OPT_C);
+  assert(rc == 3);
+
+  Tag t = TAG_ONE;
+  assert(t == 1);
+  assert(t == TAG_ONE);
+
+  int ti = t;
+  assert(ti == 1);
+
+  t = (Tag)2;
+  assert(t == TAG_TWO);
+
+  switch (t) {
+  case TAG_ZERO:
+    return 90;
+  case 1:
+    return 91;
+  case 2:
+    break;
+  }
+
+  int extra = (int)RED + (int)GREEN + (int)BLUE;
+  assert(extra == 0 + 1 + 2);
+
+  return 0;
+}
diff --git a/tests/unit/out/refcount/anonymous_enum.rs b/tests/unit/out/refcount/anonymous_enum.rs
index 47dcf325..fd913572 100644
--- a/tests/unit/out/refcount/anonymous_enum.rs
+++ b/tests/unit/out/refcount/anonymous_enum.rs
@@ -12,12 +12,30 @@ enum anon_enum_3 {
     FIRST_A = 0,
     FIRST_B = 1,
 }
+impl From<i32> for anon_enum_3 {
+    fn from(n: i32) -> anon_enum_3 {
+        match n {
+            0 => anon_enum_3::FIRST_A,
+            1 => anon_enum_3::FIRST_B,
+            _ => panic!("invalid anon_enum_3 value: {}", n),
+        }
+    }
+}
 #[derive(Clone, Copy, PartialEq, Debug, Default)]
 enum anon_enum_11 {
     #[default]
     SECOND_A = 0,
     SECOND_B = 1,
 }
+impl From<i32> for anon_enum_11 {
+    fn from(n: i32) -> anon_enum_11 {
+        match n {
+            0 => anon_enum_11::SECOND_A,
+            1 => anon_enum_11::SECOND_B,
+            _ => panic!("invalid anon_enum_11 value: {}", n),
+        }
+    }
+}
 #[derive(Default)]
 pub struct S {
     pub a: Value<i32>,
@@ -37,12 +55,30 @@ enum TdEnum {
     TD_A = 0,
     TD_B = 1,
 }
+impl From<i32> for TdEnum {
+    fn from(n: i32) -> TdEnum {
+        match n {
+            0 => TdEnum::TD_A,
+            1 => TdEnum::TD_B,
+            _ => panic!("invalid TdEnum value: {}", n),
+        }
+    }
+}
 #[derive(Clone, Copy, PartialEq, Debug, Default)]
 enum anon_enum_24 {
     #[default]
     FIELD_A = 0,
     FIELD_B = 1,
 }
+impl From<i32> for anon_enum_24 {
+    fn from(n: i32) -> anon_enum_24 {
+        match n {
+            0 => anon_enum_24::FIELD_A,
+            1 => anon_enum_24::FIELD_B,
+            _ => panic!("invalid anon_enum_24 value: {}", n),
+        }
+    }
+}
 #[derive(Default)]
 pub struct WithAnonField {
     pub a: Value<i32>,
@@ -67,6 +103,15 @@ fn main_0() -> i32 {
         #[default]
         THIRD_A = 0,
         THIRD_B = 1,
+    }
+    impl From<i32> for anon_enum_31 {
+        fn from(n: i32) -> anon_enum_31 {
+            match n {
+                0 => anon_enum_31::THIRD_A,
+                1 => anon_enum_31::THIRD_B,
+                _ => panic!("invalid anon_enum_31 value: {}", n),
+            }
+        }
     };
     assert!(((anon_enum_3::FIRST_A as i32) != (anon_enum_3::FIRST_B as i32)));
     assert!(((anon_enum_11::SECOND_A as i32) != (anon_enum_11::SECOND_B as i32)));
diff --git a/tests/unit/out/refcount/anonymous_enum_c.rs b/tests/unit/out/refcount/anonymous_enum_c.rs
index 0b0c762c..41278782 100644
--- a/tests/unit/out/refcount/anonymous_enum_c.rs
+++ b/tests/unit/out/refcount/anonymous_enum_c.rs
@@ -12,12 +12,30 @@ enum anon_enum_3 {
     FIRST_A = 0,
     FIRST_B = 1,
 }
+impl From<i32> for anon_enum_3 {
+    fn from(n: i32) -> anon_enum_3 {
+        match n {
+            0 => anon_enum_3::FIRST_A,
+            1 => anon_enum_3::FIRST_B,
+            _ => panic!("invalid anon_enum_3 value: {}", n),
+        }
+    }
+}
 #[derive(Clone, Copy, PartialEq, Debug, Default)]
 enum anon_enum_11 {
     #[default]
     SECOND_A = 0,
     SECOND_B = 1,
 }
+impl From<i32> for anon_enum_11 {
+    fn from(n: i32) -> anon_enum_11 {
+        match n {
+            0 => anon_enum_11::SECOND_A,
+            1 => anon_enum_11::SECOND_B,
+            _ => panic!("invalid anon_enum_11 value: {}", n),
+        }
+    }
+}
 #[derive(Default)]
 pub struct S {
     pub a: Value<i32>,
@@ -29,12 +47,30 @@ enum TdEnum {
     TD_A = 0,
     TD_B = 1,
 }
+impl From<i32> for TdEnum {
+    fn from(n: i32) -> TdEnum {
+        match n {
+            0 => TdEnum::TD_A,
+            1 => TdEnum::TD_B,
+            _ => panic!("invalid TdEnum value: {}", n),
+        }
+    }
+}
 #[derive(Clone, Copy, PartialEq, Debug, Default)]
 enum anon_enum_24 {
     #[default]
     FIELD_A = 0,
     FIELD_B = 1,
 }
+impl From<i32> for anon_enum_24 {
+    fn from(n: i32) -> anon_enum_24 {
+        match n {
+            0 => anon_enum_24::FIELD_A,
+            1 => anon_enum_24::FIELD_B,
+            _ => panic!("invalid anon_enum_24 value: {}", n),
+        }
+    }
+}
 #[derive(Default)]
 pub struct WithAnonField {
     pub a: Value<i32>,
@@ -50,18 +86,27 @@ fn main_0() -> i32 {
         #[default]
         THIRD_A = 0,
         THIRD_B = 1,
+    }
+    impl From<i32> for anon_enum_31 {
+        fn from(n: i32) -> anon_enum_31 {
+            match n {
+                0 => anon_enum_31::THIRD_A,
+                1 => anon_enum_31::THIRD_B,
+                _ => panic!("invalid anon_enum_31 value: {}", n),
+            }
+        }
     };
-    assert!((anon_enum_3::FIRST_A != anon_enum_3::FIRST_B));
-    assert!((anon_enum_11::SECOND_A != anon_enum_11::SECOND_B));
-    assert!((anon_enum_31::THIRD_A != anon_enum_31::THIRD_B));
-    let td: Value<TdEnum> = Rc::new(RefCell::new((TdEnum::TD_A as TdEnum)));
-    assert!((((*td.borrow()) as u32) == (TdEnum::TD_A as u32)));
-    (*td.borrow_mut()) = (TdEnum::TD_B as TdEnum);
-    assert!((((*td.borrow()) as u32) == (TdEnum::TD_B as u32)));
+    assert!(((anon_enum_3::FIRST_A as i32) != (anon_enum_3::FIRST_B as i32)));
+    assert!(((anon_enum_11::SECOND_A as i32) != (anon_enum_11::SECOND_B as i32)));
+    assert!(((anon_enum_31::THIRD_A as i32) != (anon_enum_31::THIRD_B as i32)));
+    let td: Value<TdEnum> = Rc::new(RefCell::new(TdEnum::from((TdEnum::TD_A as i32))));
+    assert!((((*td.borrow()) as u32) == ((TdEnum::TD_A as i32) as u32)));
+    (*td.borrow_mut()) = TdEnum::from((TdEnum::TD_B as i32));
+    assert!((((*td.borrow()) as u32) == ((TdEnum::TD_B as i32) as u32)));
     let w: Value<WithAnonField> = <Value<WithAnonField>>::default();
-    (*(*w.borrow()).field.borrow_mut()) = (anon_enum_24::FIELD_A as anon_enum_24);
-    assert!((((*(*w.borrow()).field.borrow()) as u32) == (anon_enum_24::FIELD_A as u32)));
-    (*(*w.borrow()).field.borrow_mut()) = (anon_enum_24::FIELD_B as anon_enum_24);
-    assert!((((*(*w.borrow()).field.borrow()) as u32) == (anon_enum_24::FIELD_B as u32)));
+    (*(*w.borrow()).field.borrow_mut()) = anon_enum_24::from((anon_enum_24::FIELD_A as i32));
+    assert!((((*(*w.borrow()).field.borrow()) as u32) == ((anon_enum_24::FIELD_A as i32) as u32)));
+    (*(*w.borrow()).field.borrow_mut()) = anon_enum_24::from((anon_enum_24::FIELD_B as i32));
+    assert!((((*(*w.borrow()).field.borrow()) as u32) == ((anon_enum_24::FIELD_B as i32) as u32)));
     return 0;
 }
diff --git a/tests/unit/out/refcount/c_struct.rs b/tests/unit/out/refcount/c_struct.rs
index 2343bb35..2e2499a2 100644
--- a/tests/unit/out/refcount/c_struct.rs
+++ b/tests/unit/out/refcount/c_struct.rs
@@ -31,6 +31,16 @@ enum Color {
     GREEN = 1,
     BLUE = 2,
 }
+impl From<i32> for Color {
+    fn from(n: i32) -> Color {
+        match n {
+            0 => Color::RED,
+            1 => Color::GREEN,
+            2 => Color::BLUE,
+            _ => panic!("invalid Color value: {}", n),
+        }
+    }
+}
 #[derive(Default)]
 pub struct Inner {
     pub a: Value<i32>,
@@ -85,15 +95,15 @@ fn main_0() -> i32 {
             a: Rc::new(RefCell::new(5)),
             b: Rc::new(RefCell::new(6)),
         })),
-        color: Rc::new(RefCell::new((Color::GREEN as Color))),
+        color: Rc::new(RefCell::new(Color::from((Color::GREEN as i32)))),
         count: Rc::new(RefCell::new(42)),
     }));
     assert!(((*(*(*c.borrow()).inner.borrow()).a.borrow()) == 5));
     assert!(((*(*(*c.borrow()).inner.borrow()).b.borrow()) == 6));
-    assert!((((*(*c.borrow()).color.borrow()) as u32) == (Color::GREEN as u32)));
+    assert!((((*(*c.borrow()).color.borrow()) as u32) == ((Color::GREEN as i32) as u32)));
     assert!(((*(*c.borrow()).count.borrow()) == 42));
     let c2: Value<Container> = <Value<Container>>::default();
-    (*(*c2.borrow()).color.borrow_mut()) = (Color::BLUE as Color);
+    (*(*c2.borrow()).color.borrow_mut()) = Color::from((Color::BLUE as i32));
     assert!((((*(*c2.borrow()).color.borrow()) as u32) == 2_u32));
     return 0;
 }
diff --git a/tests/unit/out/refcount/enum_int_interop.rs b/tests/unit/out/refcount/enum_int_interop.rs
new file mode 100644
index 00000000..64e02edf
--- /dev/null
+++ b/tests/unit/out/refcount/enum_int_interop.rs
@@ -0,0 +1,189 @@
+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 Color {
+    #[default]
+    RED = 0,
+    GREEN = 1,
+    BLUE = 2,
+}
+impl From<i32> for Color {
+    fn from(n: i32) -> Color {
+        match n {
+            0 => Color::RED,
+            1 => Color::GREEN,
+            2 => Color::BLUE,
+            _ => panic!("invalid Color value: {}", n),
+        }
+    }
+}
+#[derive(Clone, Copy, PartialEq, Debug, Default)]
+enum Option {
+    #[default]
+    OPT_NONE = 0,
+    OPT_A = 10,
+    OPT_B = 20,
+    OPT_C = 30,
+}
+impl From<i32> for Option {
+    fn from(n: i32) -> Option {
+        match n {
+            0 => Option::OPT_NONE,
+            10 => Option::OPT_A,
+            20 => Option::OPT_B,
+            30 => Option::OPT_C,
+            _ => panic!("invalid Option value: {}", n),
+        }
+    }
+}
+#[derive(Clone, Copy, PartialEq, Debug, Default)]
+enum Tag {
+    #[default]
+    TAG_ZERO = 0,
+    TAG_ONE = 1,
+    TAG_TWO = 2,
+}
+impl From<i32> for Tag {
+    fn from(n: i32) -> Tag {
+        match n {
+            0 => Tag::TAG_ZERO,
+            1 => Tag::TAG_ONE,
+            2 => Tag::TAG_TWO,
+            _ => panic!("invalid Tag value: {}", n),
+        }
+    }
+}
+pub fn as_int_0(c: Color) -> i32 {
+    let c: Value<Color> = Rc::new(RefCell::new(c));
+    return ((*c.borrow()) as i32).clone();
+}
+pub fn classify_option_1(option: i32) -> i32 {
+    let option: Value<i32> = Rc::new(RefCell::new(option));
+    'switch: {
+        let __match_cond = (*option.borrow());
+        match __match_cond {
+            v if v == (Option::OPT_NONE as i32) => {
+                return -1_i32;
+            }
+            v if v == (Option::OPT_A as i32) => {
+                return 1;
+            }
+            v if v == (Option::OPT_B as i32) => {
+                return 2;
+            }
+            v if v == (Option::OPT_C as i32) => {
+                return 3;
+            }
+            _ => {
+                return 0;
+            }
+        }
+    };
+    panic!("ub: non-void function does not return a value")
+}
+pub fn make_color_2(n: i32) -> Color {
+    let n: Value<i32> = Rc::new(RefCell::new(n));
+    return Color::from((*n.borrow()));
+}
+pub fn main() {
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    let c: Value<Color> = Rc::new(RefCell::new(Color::RED));
+    assert!((((*c.borrow()) as i32) == (Color::RED as i32)));
+    assert!((((*c.borrow()) as i32) == 0));
+    assert!((((*c.borrow()) as i32) != 1));
+    if (((*c.borrow()) as i32) == (Color::GREEN as i32)) {
+        return 1;
+    }
+    'switch: {
+        let __match_cond = ((*c.borrow()) as i32);
+        match __match_cond {
+            v if v == 0 => {
+                break 'switch;
+            }
+            v if v == 1 => {
+                return 1;
+            }
+            v if v == 2 => {
+                return 2;
+            }
+            _ => {
+                return 99;
+            }
+        }
+    };
+    let x: Value<i32> = Rc::new(RefCell::new(((*c.borrow()) as i32).clone()));
+    assert!(((*x.borrow()) == 0));
+    let y: Value<i32> = Rc::new(RefCell::new((((*c.borrow()) as i32) + 1)));
+    assert!(((*y.borrow()) == 1));
+    (*c.borrow_mut()) = Color::from(2);
+    assert!((((*c.borrow()) as i32) == (Color::BLUE as i32)));
+    assert!((((*c.borrow()) as i32) == 2));
+    (*c.borrow_mut()) = ({
+        let _n: i32 = 1;
+        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),
+    )));
+    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)));
+    assert!((((*o.borrow()) as i32) == 10));
+    let oi: Value<i32> = Rc::new(RefCell::new(((*o.borrow()) as i32).clone()));
+    assert!(((*oi.borrow()) == 10));
+    (*o.borrow_mut()) = Option::from(20);
+    assert!((((*o.borrow()) as i32) == (Option::OPT_B as i32)));
+    let rc: Value<i32> = Rc::new(RefCell::new(
+        ({
+            let _option: i32 = ((*o.borrow()) as i32).clone();
+            classify_option_1(_option)
+        }),
+    ));
+    assert!(((*rc.borrow()) == 2));
+    (*rc.borrow_mut()) = ({
+        let _option: i32 = 20;
+        classify_option_1(_option)
+    });
+    assert!(((*rc.borrow()) == 2));
+    (*rc.borrow_mut()) = ({
+        let _option: i32 = (Option::OPT_C as i32);
+        classify_option_1(_option)
+    });
+    assert!(((*rc.borrow()) == 3));
+    let t: Value<Tag> = Rc::new(RefCell::new(Tag::TAG_ONE));
+    assert!((((*t.borrow()) as i32) == 1));
+    assert!((((*t.borrow()) as i32) == (Tag::TAG_ONE as i32)));
+    let ti: Value<i32> = Rc::new(RefCell::new(((*t.borrow()) as i32).clone()));
+    assert!(((*ti.borrow()) == 1));
+    (*t.borrow_mut()) = Tag::from(2);
+    assert!((((*t.borrow()) as i32) == (Tag::TAG_TWO as i32)));
+    'switch: {
+        let __match_cond = ((*t.borrow()) as i32);
+        match __match_cond {
+            v if v == (Tag::TAG_ZERO as i32) => {
+                return 90;
+            }
+            v if v == 1 => {
+                return 91;
+            }
+            v if v == 2 => {
+                break 'switch;
+            }
+            _ => {}
+        }
+    };
+    let extra: Value<i32> = Rc::new(RefCell::new(
+        (((Color::RED as i32) + (Color::GREEN as i32)) + (Color::BLUE as i32)),
+    ));
+    assert!(((*extra.borrow()) == ((0 + 1) + 2)));
+    return 0;
+}
diff --git a/tests/unit/out/refcount/enum_int_interop_c.rs b/tests/unit/out/refcount/enum_int_interop_c.rs
new file mode 100644
index 00000000..39a09b4d
--- /dev/null
+++ b/tests/unit/out/refcount/enum_int_interop_c.rs
@@ -0,0 +1,191 @@
+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 Color {
+    #[default]
+    RED = 0,
+    GREEN = 1,
+    BLUE = 2,
+}
+impl From<i32> for Color {
+    fn from(n: i32) -> Color {
+        match n {
+            0 => Color::RED,
+            1 => Color::GREEN,
+            2 => Color::BLUE,
+            _ => panic!("invalid Color value: {}", n),
+        }
+    }
+}
+#[derive(Clone, Copy, PartialEq, Debug, Default)]
+enum Option {
+    #[default]
+    OPT_NONE = 0,
+    OPT_A = 10,
+    OPT_B = 20,
+    OPT_C = 30,
+}
+impl From<i32> for Option {
+    fn from(n: i32) -> Option {
+        match n {
+            0 => Option::OPT_NONE,
+            10 => Option::OPT_A,
+            20 => Option::OPT_B,
+            30 => Option::OPT_C,
+            _ => panic!("invalid Option value: {}", n),
+        }
+    }
+}
+#[derive(Clone, Copy, PartialEq, Debug, Default)]
+enum Tag {
+    #[default]
+    TAG_ZERO = 0,
+    TAG_ONE = 1,
+    TAG_TWO = 2,
+}
+impl From<i32> for Tag {
+    fn from(n: i32) -> Tag {
+        match n {
+            0 => Tag::TAG_ZERO,
+            1 => Tag::TAG_ONE,
+            2 => Tag::TAG_TWO,
+            _ => panic!("invalid Tag value: {}", n),
+        }
+    }
+}
+pub fn as_int_0(c: Color) -> i32 {
+    let c: Value<Color> = Rc::new(RefCell::new(c));
+    return ((*c.borrow()) as i32).clone();
+}
+pub fn classify_option_1(option: i32) -> i32 {
+    let option: Value<i32> = Rc::new(RefCell::new(option));
+    'switch: {
+        let __match_cond = (*option.borrow());
+        match __match_cond {
+            v if v == (Option::OPT_NONE as i32) => {
+                return -1_i32;
+            }
+            v if v == (Option::OPT_A as i32) => {
+                return 1;
+            }
+            v if v == (Option::OPT_B as i32) => {
+                return 2;
+            }
+            v if v == (Option::OPT_C as i32) => {
+                return 3;
+            }
+            _ => {
+                return 0;
+            }
+        }
+    };
+    panic!("ub: non-void function does not return a value")
+}
+pub fn make_color_2(n: i32) -> Color {
+    let n: Value<i32> = Rc::new(RefCell::new(n));
+    return Color::from((*n.borrow()));
+}
+pub fn main() {
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    let c: Value<Color> = Rc::new(RefCell::new(Color::from((Color::RED as i32))));
+    assert!((((*c.borrow()) as u32) == ((Color::RED as i32) as u32)));
+    assert!((((*c.borrow()) as u32) == 0_u32));
+    assert!((((*c.borrow()) as u32) != 1_u32));
+    if (((*c.borrow()) as u32) == ((Color::GREEN as i32) as u32)) {
+        return 1;
+    }
+    'switch: {
+        let __match_cond = ((*c.borrow()) as u32);
+        match __match_cond {
+            v if v == (0 as u32) => {
+                break 'switch;
+            }
+            v if v == (1 as u32) => {
+                return 1;
+            }
+            v if v == (2 as u32) => {
+                return 2;
+            }
+            _ => {
+                return 99;
+            }
+        }
+    };
+    let x: Value<i32> = Rc::new(RefCell::new(((*c.borrow()) as i32).clone()));
+    assert!(((*x.borrow()) == 0));
+    let y: Value<i32> = Rc::new(RefCell::new(
+        ((((*c.borrow()) as u32).wrapping_add(1_u32)) as i32),
+    ));
+    assert!(((*y.borrow()) == 1));
+    (*c.borrow_mut()) = Color::from(2);
+    assert!((((*c.borrow()) as u32) == ((Color::BLUE as i32) as u32)));
+    assert!((((*c.borrow()) as u32) == 2_u32));
+    (*c.borrow_mut()) = ({
+        let _n: i32 = 1;
+        make_color_2(_n)
+    });
+    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,
+    )));
+    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))));
+    assert!((((*o.borrow()) as u32) == ((Option::OPT_A as i32) as u32)));
+    assert!((((*o.borrow()) as u32) == 10_u32));
+    let oi: Value<i32> = Rc::new(RefCell::new(((*o.borrow()) as i32).clone()));
+    assert!(((*oi.borrow()) == 10));
+    (*o.borrow_mut()) = Option::from(20);
+    assert!((((*o.borrow()) as u32) == ((Option::OPT_B as i32) as u32)));
+    let rc: Value<i32> = Rc::new(RefCell::new(
+        ({
+            let _option: i32 = ((*o.borrow()) as i32).clone();
+            classify_option_1(_option)
+        }),
+    ));
+    assert!(((*rc.borrow()) == 2));
+    (*rc.borrow_mut()) = ({
+        let _option: i32 = 20;
+        classify_option_1(_option)
+    });
+    assert!(((*rc.borrow()) == 2));
+    (*rc.borrow_mut()) = ({
+        let _option: i32 = (Option::OPT_C as i32);
+        classify_option_1(_option)
+    });
+    assert!(((*rc.borrow()) == 3));
+    let t: Value<Tag> = Rc::new(RefCell::new(Tag::from((Tag::TAG_ONE as i32))));
+    assert!((((*t.borrow()) as u32) == 1_u32));
+    assert!((((*t.borrow()) as u32) == ((Tag::TAG_ONE as i32) as u32)));
+    let ti: Value<i32> = Rc::new(RefCell::new(((*t.borrow()) as i32).clone()));
+    assert!(((*ti.borrow()) == 1));
+    (*t.borrow_mut()) = Tag::from(2);
+    assert!((((*t.borrow()) as u32) == ((Tag::TAG_TWO as i32) as u32)));
+    'switch: {
+        let __match_cond = ((*t.borrow()) as u32);
+        match __match_cond {
+            v if v == ((Tag::TAG_ZERO as i32) as u32) => {
+                return 90;
+            }
+            v if v == (1 as u32) => {
+                return 91;
+            }
+            v if v == (2 as u32) => {
+                break 'switch;
+            }
+            _ => {}
+        }
+    };
+    let extra: Value<i32> = Rc::new(RefCell::new(
+        (((Color::RED as i32) + (Color::GREEN as i32)) + (Color::BLUE as i32)),
+    ));
+    assert!(((*extra.borrow()) == ((0 + 1) + 2)));
+    return 0;
+}
diff --git a/tests/unit/out/refcount/switch_char.rs b/tests/unit/out/refcount/switch_char.rs
index b04e6f65..4c756a76 100644
--- a/tests/unit/out/refcount/switch_char.rs
+++ b/tests/unit/out/refcount/switch_char.rs
@@ -37,6 +37,16 @@ enum Color {
     kGreen = 1,
     kBlue = 2,
 }
+impl From<i32> for Color {
+    fn from(n: i32) -> Color {
+        match n {
+            0 => Color::kRed,
+            1 => Color::kGreen,
+            2 => Color::kBlue,
+            _ => panic!("invalid Color value: {}", n),
+        }
+    }
+}
 pub fn main() {
     std::process::exit(main_0());
 }
diff --git a/tests/unit/out/refcount/switch_enum.rs b/tests/unit/out/refcount/switch_enum.rs
index 79ac28c4..03c48ef1 100644
--- a/tests/unit/out/refcount/switch_enum.rs
+++ b/tests/unit/out/refcount/switch_enum.rs
@@ -13,6 +13,16 @@ enum Color {
     kGreen = 1,
     kBlue = 2,
 }
+impl From<i32> for Color {
+    fn from(n: i32) -> Color {
+        match n {
+            0 => Color::kRed,
+            1 => Color::kGreen,
+            2 => Color::kBlue,
+            _ => panic!("invalid Color value: {}", n),
+        }
+    }
+}
 pub fn switch_enum_0(c: Color) -> i32 {
     let c: Value<Color> = Rc::new(RefCell::new(c));
     'switch: {
diff --git a/tests/unit/out/unsafe/anonymous_enum.rs b/tests/unit/out/unsafe/anonymous_enum.rs
index a327b394..a16f0d6e 100644
--- a/tests/unit/out/unsafe/anonymous_enum.rs
+++ b/tests/unit/out/unsafe/anonymous_enum.rs
@@ -12,12 +12,30 @@ enum anon_enum_3 {
     FIRST_A = 0,
     FIRST_B = 1,
 }
+impl From<i32> for anon_enum_3 {
+    fn from(n: i32) -> anon_enum_3 {
+        match n {
+            0 => anon_enum_3::FIRST_A,
+            1 => anon_enum_3::FIRST_B,
+            _ => panic!("invalid anon_enum_3 value: {}", n),
+        }
+    }
+}
 #[derive(Clone, Copy, PartialEq, Debug, Default)]
 enum anon_enum_11 {
     #[default]
     SECOND_A = 0,
     SECOND_B = 1,
 }
+impl From<i32> for anon_enum_11 {
+    fn from(n: i32) -> anon_enum_11 {
+        match n {
+            0 => anon_enum_11::SECOND_A,
+            1 => anon_enum_11::SECOND_B,
+            _ => panic!("invalid anon_enum_11 value: {}", n),
+        }
+    }
+}
 #[repr(C)]
 #[derive(Copy, Clone, Default)]
 pub struct S {
@@ -29,12 +47,30 @@ enum TdEnum {
     TD_A = 0,
     TD_B = 1,
 }
+impl From<i32> for TdEnum {
+    fn from(n: i32) -> TdEnum {
+        match n {
+            0 => TdEnum::TD_A,
+            1 => TdEnum::TD_B,
+            _ => panic!("invalid TdEnum value: {}", n),
+        }
+    }
+}
 #[derive(Clone, Copy, PartialEq, Debug, Default)]
 enum anon_enum_24 {
     #[default]
     FIELD_A = 0,
     FIELD_B = 1,
 }
+impl From<i32> for anon_enum_24 {
+    fn from(n: i32) -> anon_enum_24 {
+        match n {
+            0 => anon_enum_24::FIELD_A,
+            1 => anon_enum_24::FIELD_B,
+            _ => panic!("invalid anon_enum_24 value: {}", n),
+        }
+    }
+}
 #[repr(C)]
 #[derive(Copy, Clone, Default)]
 pub struct WithAnonField {
@@ -52,6 +88,15 @@ unsafe fn main_0() -> i32 {
         #[default]
         THIRD_A = 0,
         THIRD_B = 1,
+    }
+    impl From<i32> for anon_enum_31 {
+        fn from(n: i32) -> anon_enum_31 {
+            match n {
+                0 => anon_enum_31::THIRD_A,
+                1 => anon_enum_31::THIRD_B,
+                _ => panic!("invalid anon_enum_31 value: {}", n),
+            }
+        }
     };
     assert!(((anon_enum_3::FIRST_A as i32) != (anon_enum_3::FIRST_B as i32)));
     assert!(((anon_enum_11::SECOND_A as i32) != (anon_enum_11::SECOND_B as i32)));
diff --git a/tests/unit/out/unsafe/anonymous_enum_c.rs b/tests/unit/out/unsafe/anonymous_enum_c.rs
index 881be82d..374d1c8e 100644
--- a/tests/unit/out/unsafe/anonymous_enum_c.rs
+++ b/tests/unit/out/unsafe/anonymous_enum_c.rs
@@ -12,12 +12,30 @@ enum anon_enum_3 {
     FIRST_A = 0,
     FIRST_B = 1,
 }
+impl From<i32> for anon_enum_3 {
+    fn from(n: i32) -> anon_enum_3 {
+        match n {
+            0 => anon_enum_3::FIRST_A,
+            1 => anon_enum_3::FIRST_B,
+            _ => panic!("invalid anon_enum_3 value: {}", n),
+        }
+    }
+}
 #[derive(Clone, Copy, PartialEq, Debug, Default)]
 enum anon_enum_11 {
     #[default]
     SECOND_A = 0,
     SECOND_B = 1,
 }
+impl From<i32> for anon_enum_11 {
+    fn from(n: i32) -> anon_enum_11 {
+        match n {
+            0 => anon_enum_11::SECOND_A,
+            1 => anon_enum_11::SECOND_B,
+            _ => panic!("invalid anon_enum_11 value: {}", n),
+        }
+    }
+}
 #[repr(C)]
 #[derive(Copy, Clone, Default)]
 pub struct S {
@@ -29,12 +47,30 @@ enum TdEnum {
     TD_A = 0,
     TD_B = 1,
 }
+impl From<i32> for TdEnum {
+    fn from(n: i32) -> TdEnum {
+        match n {
+            0 => TdEnum::TD_A,
+            1 => TdEnum::TD_B,
+            _ => panic!("invalid TdEnum value: {}", n),
+        }
+    }
+}
 #[derive(Clone, Copy, PartialEq, Debug, Default)]
 enum anon_enum_24 {
     #[default]
     FIELD_A = 0,
     FIELD_B = 1,
 }
+impl From<i32> for anon_enum_24 {
+    fn from(n: i32) -> anon_enum_24 {
+        match n {
+            0 => anon_enum_24::FIELD_A,
+            1 => anon_enum_24::FIELD_B,
+            _ => panic!("invalid anon_enum_24 value: {}", n),
+        }
+    }
+}
 #[repr(C)]
 #[derive(Copy, Clone, Default)]
 pub struct WithAnonField {
@@ -52,18 +88,27 @@ unsafe fn main_0() -> i32 {
         #[default]
         THIRD_A = 0,
         THIRD_B = 1,
+    }
+    impl From<i32> for anon_enum_31 {
+        fn from(n: i32) -> anon_enum_31 {
+            match n {
+                0 => anon_enum_31::THIRD_A,
+                1 => anon_enum_31::THIRD_B,
+                _ => panic!("invalid anon_enum_31 value: {}", n),
+            }
+        }
     };
-    assert!(((anon_enum_3::FIRST_A) != (anon_enum_3::FIRST_B)));
-    assert!(((anon_enum_11::SECOND_A) != (anon_enum_11::SECOND_B)));
-    assert!(((anon_enum_31::THIRD_A) != (anon_enum_31::THIRD_B)));
-    let mut td: TdEnum = (TdEnum::TD_A as TdEnum);
-    assert!(((td as u32) == (TdEnum::TD_A as u32)));
-    td = (TdEnum::TD_B as TdEnum).clone();
-    assert!(((td as u32) == (TdEnum::TD_B as u32)));
+    assert!(((anon_enum_3::FIRST_A as i32) != (anon_enum_3::FIRST_B as i32)));
+    assert!(((anon_enum_11::SECOND_A as i32) != (anon_enum_11::SECOND_B as i32)));
+    assert!(((anon_enum_31::THIRD_A as i32) != (anon_enum_31::THIRD_B as i32)));
+    let mut td: TdEnum = TdEnum::from((TdEnum::TD_A as i32));
+    assert!(((td as u32) == ((TdEnum::TD_A as i32) as u32)));
+    td = (TdEnum::from((TdEnum::TD_B as i32))).clone();
+    assert!(((td as u32) == ((TdEnum::TD_B as i32) as u32)));
     let mut w: WithAnonField = <WithAnonField>::default();
-    w.field = (anon_enum_24::FIELD_A as anon_enum_24);
-    assert!(((w.field as u32) == (anon_enum_24::FIELD_A as u32)));
-    w.field = (anon_enum_24::FIELD_B as anon_enum_24).clone();
-    assert!(((w.field as u32) == (anon_enum_24::FIELD_B as u32)));
+    w.field = anon_enum_24::from((anon_enum_24::FIELD_A as i32));
+    assert!(((w.field as u32) == ((anon_enum_24::FIELD_A as i32) as u32)));
+    w.field = (anon_enum_24::from((anon_enum_24::FIELD_B as i32))).clone();
+    assert!(((w.field as u32) == ((anon_enum_24::FIELD_B as i32) as u32)));
     return 0;
 }
diff --git a/tests/unit/out/unsafe/c_struct.rs b/tests/unit/out/unsafe/c_struct.rs
index 1d2fcd32..6f7a4c63 100644
--- a/tests/unit/out/unsafe/c_struct.rs
+++ b/tests/unit/out/unsafe/c_struct.rs
@@ -31,6 +31,16 @@ enum Color {
     GREEN = 1,
     BLUE = 2,
 }
+impl From<i32> for Color {
+    fn from(n: i32) -> Color {
+        match n {
+            0 => Color::RED,
+            1 => Color::GREEN,
+            2 => Color::BLUE,
+            _ => panic!("invalid Color value: {}", n),
+        }
+    }
+}
 #[repr(C)]
 #[derive(Copy, Clone, Default)]
 pub struct Inner {
@@ -70,15 +80,15 @@ unsafe fn main_0() -> i32 {
     assert!((((*b.next).value) == (1)));
     let mut c: Container = Container {
         inner: Inner { a: 5, b: 6 },
-        color: (Color::GREEN as Color),
+        color: Color::from((Color::GREEN as i32)),
         count: 42,
     };
     assert!(((c.inner.a) == (5)));
     assert!(((c.inner.b) == (6)));
-    assert!(((c.color as u32) == (Color::GREEN as u32)));
+    assert!(((c.color as u32) == ((Color::GREEN as i32) as u32)));
     assert!(((c.count) == (42)));
     let mut c2: Container = <Container>::default();
-    c2.color = (Color::BLUE as Color);
+    c2.color = Color::from((Color::BLUE as i32));
     assert!(((c2.color as u32) == (2_u32)));
     return 0;
 }
diff --git a/tests/unit/out/unsafe/enum_int_interop.rs b/tests/unit/out/unsafe/enum_int_interop.rs
new file mode 100644
index 00000000..4a6bdc58
--- /dev/null
+++ b/tests/unit/out/unsafe/enum_int_interop.rs
@@ -0,0 +1,182 @@
+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 Color {
+    #[default]
+    RED = 0,
+    GREEN = 1,
+    BLUE = 2,
+}
+impl From<i32> for Color {
+    fn from(n: i32) -> Color {
+        match n {
+            0 => Color::RED,
+            1 => Color::GREEN,
+            2 => Color::BLUE,
+            _ => panic!("invalid Color value: {}", n),
+        }
+    }
+}
+#[derive(Clone, Copy, PartialEq, Debug, Default)]
+enum Option {
+    #[default]
+    OPT_NONE = 0,
+    OPT_A = 10,
+    OPT_B = 20,
+    OPT_C = 30,
+}
+impl From<i32> for Option {
+    fn from(n: i32) -> Option {
+        match n {
+            0 => Option::OPT_NONE,
+            10 => Option::OPT_A,
+            20 => Option::OPT_B,
+            30 => Option::OPT_C,
+            _ => panic!("invalid Option value: {}", n),
+        }
+    }
+}
+#[derive(Clone, Copy, PartialEq, Debug, Default)]
+enum Tag {
+    #[default]
+    TAG_ZERO = 0,
+    TAG_ONE = 1,
+    TAG_TWO = 2,
+}
+impl From<i32> for Tag {
+    fn from(n: i32) -> Tag {
+        match n {
+            0 => Tag::TAG_ZERO,
+            1 => Tag::TAG_ONE,
+            2 => Tag::TAG_TWO,
+            _ => panic!("invalid Tag value: {}", n),
+        }
+    }
+}
+pub unsafe fn as_int_0(mut c: Color) -> i32 {
+    return (c as i32);
+}
+pub unsafe fn classify_option_1(mut option: i32) -> i32 {
+    'switch: {
+        let __match_cond = option;
+        match __match_cond {
+            v if v == (Option::OPT_NONE as i32) => {
+                return -1_i32;
+            }
+            v if v == (Option::OPT_A as i32) => {
+                return 1;
+            }
+            v if v == (Option::OPT_B as i32) => {
+                return 2;
+            }
+            v if v == (Option::OPT_C as i32) => {
+                return 3;
+            }
+            _ => {
+                return 0;
+            }
+        }
+    };
+    panic!("ub: non-void function does not return a value")
+}
+pub unsafe fn make_color_2(mut n: i32) -> Color {
+    return Color::from(n);
+}
+pub fn main() {
+    unsafe {
+        std::process::exit(main_0() as i32);
+    }
+}
+unsafe fn main_0() -> i32 {
+    let mut c: Color = Color::RED;
+    assert!(((c as i32) == (Color::RED as i32)));
+    assert!(((c as i32) == (0)));
+    assert!(((c as i32) != (1)));
+    if ((c as i32) == (Color::GREEN as i32)) {
+        return 1;
+    }
+    'switch: {
+        let __match_cond = (c as i32);
+        match __match_cond {
+            v if v == 0 => {
+                break 'switch;
+            }
+            v if v == 1 => {
+                return 1;
+            }
+            v if v == 2 => {
+                return 2;
+            }
+            _ => {
+                return 99;
+            }
+        }
+    };
+    let mut x: i32 = (c as i32);
+    assert!(((x) == (0)));
+    let mut y: i32 = ((c as i32) + (1));
+    assert!(((y) == (1)));
+    c = Color::from(2);
+    assert!(((c as i32) == (Color::BLUE as i32)));
+    assert!(((c as i32) == (2)));
+    c = (unsafe {
+        let _n: i32 = 1;
+        make_color_2(_n)
+    });
+    assert!(((c as i32) == (Color::GREEN as i32)));
+    let mut cmp: Color = Color::from((((c as i32) + (1)) as i32));
+    assert!(((cmp as i32) == (Color::BLUE as i32)));
+    let mut o: Option = Option::OPT_A;
+    assert!(((o as i32) == (Option::OPT_A as i32)));
+    assert!(((o as i32) == (10)));
+    let mut oi: i32 = (o as i32);
+    assert!(((oi) == (10)));
+    o = Option::from(20);
+    assert!(((o as i32) == (Option::OPT_B as i32)));
+    let mut rc: i32 = (unsafe {
+        let _option: i32 = (o as i32);
+        classify_option_1(_option)
+    });
+    assert!(((rc) == (2)));
+    rc = (unsafe {
+        let _option: i32 = 20;
+        classify_option_1(_option)
+    });
+    assert!(((rc) == (2)));
+    rc = (unsafe {
+        let _option: i32 = (Option::OPT_C as i32);
+        classify_option_1(_option)
+    });
+    assert!(((rc) == (3)));
+    let mut t: Tag = Tag::TAG_ONE;
+    assert!(((t as i32) == (1)));
+    assert!(((t as i32) == (Tag::TAG_ONE as i32)));
+    let mut ti: i32 = (t as i32);
+    assert!(((ti) == (1)));
+    t = Tag::from(2);
+    assert!(((t as i32) == (Tag::TAG_TWO as i32)));
+    'switch: {
+        let __match_cond = (t as i32);
+        match __match_cond {
+            v if v == (Tag::TAG_ZERO as i32) => {
+                return 90;
+            }
+            v if v == 1 => {
+                return 91;
+            }
+            v if v == 2 => {
+                break 'switch;
+            }
+            _ => {}
+        }
+    };
+    let mut extra: i32 = (((Color::RED as i32) + (Color::GREEN as i32)) + (Color::BLUE as i32));
+    assert!(((extra) == (((0) + (1)) + (2))));
+    return 0;
+}
diff --git a/tests/unit/out/unsafe/enum_int_interop_c.rs b/tests/unit/out/unsafe/enum_int_interop_c.rs
new file mode 100644
index 00000000..c3300c2a
--- /dev/null
+++ b/tests/unit/out/unsafe/enum_int_interop_c.rs
@@ -0,0 +1,182 @@
+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 Color {
+    #[default]
+    RED = 0,
+    GREEN = 1,
+    BLUE = 2,
+}
+impl From<i32> for Color {
+    fn from(n: i32) -> Color {
+        match n {
+            0 => Color::RED,
+            1 => Color::GREEN,
+            2 => Color::BLUE,
+            _ => panic!("invalid Color value: {}", n),
+        }
+    }
+}
+#[derive(Clone, Copy, PartialEq, Debug, Default)]
+enum Option {
+    #[default]
+    OPT_NONE = 0,
+    OPT_A = 10,
+    OPT_B = 20,
+    OPT_C = 30,
+}
+impl From<i32> for Option {
+    fn from(n: i32) -> Option {
+        match n {
+            0 => Option::OPT_NONE,
+            10 => Option::OPT_A,
+            20 => Option::OPT_B,
+            30 => Option::OPT_C,
+            _ => panic!("invalid Option value: {}", n),
+        }
+    }
+}
+#[derive(Clone, Copy, PartialEq, Debug, Default)]
+enum Tag {
+    #[default]
+    TAG_ZERO = 0,
+    TAG_ONE = 1,
+    TAG_TWO = 2,
+}
+impl From<i32> for Tag {
+    fn from(n: i32) -> Tag {
+        match n {
+            0 => Tag::TAG_ZERO,
+            1 => Tag::TAG_ONE,
+            2 => Tag::TAG_TWO,
+            _ => panic!("invalid Tag value: {}", n),
+        }
+    }
+}
+pub unsafe fn as_int_0(mut c: Color) -> i32 {
+    return (c as i32);
+}
+pub unsafe fn classify_option_1(mut option: i32) -> i32 {
+    'switch: {
+        let __match_cond = option;
+        match __match_cond {
+            v if v == (Option::OPT_NONE as i32) => {
+                return -1_i32;
+            }
+            v if v == (Option::OPT_A as i32) => {
+                return 1;
+            }
+            v if v == (Option::OPT_B as i32) => {
+                return 2;
+            }
+            v if v == (Option::OPT_C as i32) => {
+                return 3;
+            }
+            _ => {
+                return 0;
+            }
+        }
+    };
+    panic!("ub: non-void function does not return a value")
+}
+pub unsafe fn make_color_2(mut n: i32) -> Color {
+    return Color::from(n);
+}
+pub fn main() {
+    unsafe {
+        std::process::exit(main_0() as i32);
+    }
+}
+unsafe fn main_0() -> i32 {
+    let mut c: Color = Color::from((Color::RED as i32));
+    assert!(((c as u32) == ((Color::RED as i32) as u32)));
+    assert!(((c as u32) == (0_u32)));
+    assert!(((c as u32) != (1_u32)));
+    if ((c as u32) == ((Color::GREEN as i32) as u32)) {
+        return 1;
+    }
+    'switch: {
+        let __match_cond = (c as u32);
+        match __match_cond {
+            v if v == (0 as u32) => {
+                break 'switch;
+            }
+            v if v == (1 as u32) => {
+                return 1;
+            }
+            v if v == (2 as u32) => {
+                return 2;
+            }
+            _ => {
+                return 99;
+            }
+        }
+    };
+    let mut x: i32 = (c as i32);
+    assert!(((x) == (0)));
+    let mut y: i32 = (((c as u32).wrapping_add(1_u32)) as i32);
+    assert!(((y) == (1)));
+    c = Color::from(2);
+    assert!(((c as u32) == ((Color::BLUE as i32) as u32)));
+    assert!(((c as u32) == (2_u32)));
+    c = (unsafe {
+        let _n: i32 = 1;
+        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);
+    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)));
+    assert!(((o as u32) == (10_u32)));
+    let mut oi: i32 = (o as i32);
+    assert!(((oi) == (10)));
+    o = Option::from(20);
+    assert!(((o as u32) == ((Option::OPT_B as i32) as u32)));
+    let mut rc: i32 = (unsafe {
+        let _option: i32 = (o as i32);
+        classify_option_1(_option)
+    });
+    assert!(((rc) == (2)));
+    rc = (unsafe {
+        let _option: i32 = 20;
+        classify_option_1(_option)
+    });
+    assert!(((rc) == (2)));
+    rc = (unsafe {
+        let _option: i32 = (Option::OPT_C as i32);
+        classify_option_1(_option)
+    });
+    assert!(((rc) == (3)));
+    let mut t: Tag = Tag::from((Tag::TAG_ONE as i32));
+    assert!(((t as u32) == (1_u32)));
+    assert!(((t as u32) == ((Tag::TAG_ONE as i32) as u32)));
+    let mut ti: i32 = (t as i32);
+    assert!(((ti) == (1)));
+    t = Tag::from(2);
+    assert!(((t as u32) == ((Tag::TAG_TWO as i32) as u32)));
+    'switch: {
+        let __match_cond = (t as u32);
+        match __match_cond {
+            v if v == ((Tag::TAG_ZERO as i32) as u32) => {
+                return 90;
+            }
+            v if v == (1 as u32) => {
+                return 91;
+            }
+            v if v == (2 as u32) => {
+                break 'switch;
+            }
+            _ => {}
+        }
+    };
+    let mut extra: i32 = (((Color::RED as i32) + (Color::GREEN as i32)) + (Color::BLUE as i32));
+    assert!(((extra) == (((0) + (1)) + (2))));
+    return 0;
+}
diff --git a/tests/unit/out/unsafe/switch_char.rs b/tests/unit/out/unsafe/switch_char.rs
index ddafcfa9..e32ee055 100644
--- a/tests/unit/out/unsafe/switch_char.rs
+++ b/tests/unit/out/unsafe/switch_char.rs
@@ -36,6 +36,16 @@ enum Color {
     kGreen = 1,
     kBlue = 2,
 }
+impl From<i32> for Color {
+    fn from(n: i32) -> Color {
+        match n {
+            0 => Color::kRed,
+            1 => Color::kGreen,
+            2 => Color::kBlue,
+            _ => panic!("invalid Color value: {}", n),
+        }
+    }
+}
 pub fn main() {
     unsafe {
         std::process::exit(main_0() as i32);
diff --git a/tests/unit/out/unsafe/switch_enum.rs b/tests/unit/out/unsafe/switch_enum.rs
index 4644a2bd..e75e4a28 100644
--- a/tests/unit/out/unsafe/switch_enum.rs
+++ b/tests/unit/out/unsafe/switch_enum.rs
@@ -13,6 +13,16 @@ enum Color {
     kGreen = 1,
     kBlue = 2,
 }
+impl From<i32> for Color {
+    fn from(n: i32) -> Color {
+        match n {
+            0 => Color::kRed,
+            1 => Color::kGreen,
+            2 => Color::kBlue,
+            _ => panic!("invalid Color value: {}", n),
+        }
+    }
+}
 pub unsafe fn switch_enum_0(mut c: Color) -> i32 {
     'switch: {
         let __match_cond = (c as i32);
diff --git a/tests/unit/out/unsafe/union_tagged_many_arms.rs b/tests/unit/out/unsafe/union_tagged_many_arms.rs
index 8429c230..57d54863 100644
--- a/tests/unit/out/unsafe/union_tagged_many_arms.rs
+++ b/tests/unit/out/unsafe/union_tagged_many_arms.rs
@@ -15,6 +15,18 @@ enum Tag {
     T_FLOAT = 3,
     T_REF = 4,
 }
+impl From<i32> for Tag {
+    fn from(n: i32) -> Tag {
+        match n {
+            0 => Tag::T_NUM_S,
+            1 => Tag::T_NUM_U,
+            2 => Tag::T_TEXT,
+            3 => Tag::T_FLOAT,
+            4 => Tag::T_REF,
+            _ => panic!("invalid Tag value: {}", n),
+        }
+    }
+}
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub union Slot_anon_0 {
@@ -42,24 +54,24 @@ pub fn main() {
 }
 unsafe fn main_0() -> i32 {
     let mut a: Slot = <Slot>::default();
-    a.tag = (Tag::T_NUM_S as Tag);
+    a.tag = Tag::from((Tag::T_NUM_S as i32));
     a.payload.signed_n = (-7_i32 as i64);
     assert!(((a.payload.signed_n) == (-7_i32 as i64)));
     let mut b: Slot = <Slot>::default();
-    b.tag = (Tag::T_NUM_U as Tag);
+    b.tag = Tag::from((Tag::T_NUM_U as i32));
     b.payload.unsigned_n = 3735928559_u64;
     assert!(((b.payload.unsigned_n) == (3735928559_u64)));
     let mut c: Slot = <Slot>::default();
-    c.tag = (Tag::T_TEXT as Tag);
+    c.tag = Tag::from((Tag::T_TEXT as i32));
     c.payload.text = b"hello\0".as_ptr().cast_mut().cast_const();
     assert!((((*c.payload.text.offset((0) as isize)) as i32) == ('h' as i32)));
     let mut d: Slot = <Slot>::default();
-    d.tag = (Tag::T_FLOAT as Tag);
+    d.tag = Tag::from((Tag::T_FLOAT as i32));
     d.payload.f = 1.5E+0;
     assert!(((d.payload.f) == (1.5E+0)));
     let mut x: i32 = 0;
     let mut e: Slot = <Slot>::default();
-    e.tag = (Tag::T_REF as Tag);
+    e.tag = Tag::from((Tag::T_REF as i32));
     e.payload.handle = ((&mut x as *mut i32) as *mut i32 as *mut ::libc::c_void);
     assert!(((e.payload.handle) == ((&mut x as *mut i32) as *mut i32 as *mut ::libc::c_void)));
     return 0;
diff --git a/tests/unit/out/unsafe/union_tagged_simple.rs b/tests/unit/out/unsafe/union_tagged_simple.rs
index ea3282b6..6eff67aa 100644
--- a/tests/unit/out/unsafe/union_tagged_simple.rs
+++ b/tests/unit/out/unsafe/union_tagged_simple.rs
@@ -12,6 +12,15 @@ enum Kind {
     KIND_NONE = 0,
     KIND_DONE = 1,
 }
+impl From<i32> for Kind {
+    fn from(n: i32) -> Kind {
+        match n {
+            0 => Kind::KIND_NONE,
+            1 => Kind::KIND_DONE,
+            _ => panic!("invalid Kind value: {}", n),
+        }
+    }
+}
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub union Event_anon_0 {
@@ -38,13 +47,13 @@ pub fn main() {
 unsafe fn main_0() -> i32 {
     let mut dummy: i32 = 0;
     let mut m1: Event = <Event>::default();
-    m1.kind = (Kind::KIND_DONE as Kind);
+    m1.kind = Kind::from((Kind::KIND_DONE as i32));
     m1.handle = ((&mut dummy as *mut i32) as *mut i32 as *mut ::libc::c_void);
     m1.payload.code = 42;
-    assert!(((m1.kind as u32) == (Kind::KIND_DONE as u32)));
+    assert!(((m1.kind as u32) == ((Kind::KIND_DONE as i32) as u32)));
     assert!(((m1.payload.code) == (42)));
     let mut m2: Event = <Event>::default();
-    m2.kind = (Kind::KIND_NONE as Kind);
+    m2.kind = Kind::from((Kind::KIND_NONE as i32));
     m2.handle = ((&mut dummy as *mut i32) as *mut i32 as *mut ::libc::c_void);
     m2.payload.obj = ((&mut dummy as *mut i32) as *mut i32 as *mut ::libc::c_void);
     assert!(((m2.payload.obj) == ((&mut dummy as *mut i32) as *mut i32 as *mut ::libc::c_void)));
diff --git a/tests/unit/out/unsafe/union_tagged_struct_arms.rs b/tests/unit/out/unsafe/union_tagged_struct_arms.rs
index 32c74dd6..c3cf2f12 100644
--- a/tests/unit/out/unsafe/union_tagged_struct_arms.rs
+++ b/tests/unit/out/unsafe/union_tagged_struct_arms.rs
@@ -13,6 +13,16 @@ enum Choice {
     C_LETTERS = 2,
     C_INTEGERS = 3,
 }
+impl From<i32> for Choice {
+    fn from(n: i32) -> Choice {
+        match n {
+            1 => Choice::C_LIST,
+            2 => Choice::C_LETTERS,
+            3 => Choice::C_INTEGERS,
+            _ => panic!("invalid Choice value: {}", n),
+        }
+    }
+}
 #[repr(C)]
 #[derive(Copy, Clone, Default)]
 pub struct Branch_anon_0_anon_0 {
@@ -68,7 +78,7 @@ unsafe fn main_0() -> i32 {
         b"c\0".as_ptr().cast_mut(),
     ];;
     let mut p_list: Branch = <Branch>::default();
-    p_list.choice = (Choice::C_LIST as Choice);
+    p_list.choice = Choice::from((Choice::C_LIST as i32));
     p_list.index = 0;
     p_list.v.list.items = items.as_mut_ptr();
     p_list.v.list.count = 3_i64;
@@ -79,7 +89,7 @@ unsafe fn main_0() -> i32 {
             == ('b' as i32))
     );
     let mut p_letters: Branch = <Branch>::default();
-    p_letters.choice = (Choice::C_LETTERS as Choice);
+    p_letters.choice = Choice::from((Choice::C_LETTERS as i32));
     p_letters.index = 1;
     p_letters.v.letters.lo = ('a' as i32);
     p_letters.v.letters.hi = ('z' as i32);
@@ -87,7 +97,7 @@ unsafe fn main_0() -> i32 {
     p_letters.v.letters.step = 1_u8;
     assert!((((p_letters.v.letters.hi) - (p_letters.v.letters.lo)) == (25)));
     let mut p_integers: Branch = <Branch>::default();
-    p_integers.choice = (Choice::C_INTEGERS as Choice);
+    p_integers.choice = Choice::from((Choice::C_INTEGERS as i32));
     p_integers.index = 2;
     p_integers.v.integers.lo = 1_i64;
     p_integers.v.integers.hi = 100_i64;
diff --git a/tests/unit/out/unsafe/union_void_ptr_sized_deref.rs b/tests/unit/out/unsafe/union_void_ptr_sized_deref.rs
index 785dec47..99c35644 100644
--- a/tests/unit/out/unsafe/union_void_ptr_sized_deref.rs
+++ b/tests/unit/out/unsafe/union_void_ptr_sized_deref.rs
@@ -13,6 +13,16 @@ enum Width {
     W_32 = 1,
     W_16 = 2,
 }
+impl From<i32> for Width {
+    fn from(n: i32) -> Width {
+        match n {
+            0 => Width::W_64,
+            1 => Width::W_32,
+            2 => Width::W_16,
+            _ => panic!("invalid Width value: {}", n),
+        }
+    }
+}
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub union Sink_anon_0 {
@@ -36,15 +46,15 @@ pub unsafe fn write_count_0(mut s: *mut Sink, mut count: i64) {
     'switch: {
         let __match_cond = ((*s).width as u32);
         match __match_cond {
-            v if v == (Width::W_64 as u32) => {
+            v if v == ((Width::W_64 as i32) as u32) => {
                 (*((*s).out.handle as *mut i64)) = count;
                 break 'switch;
             }
-            v if v == (Width::W_32 as u32) => {
+            v if v == ((Width::W_32 as i32) as u32) => {
                 (*((*s).out.handle as *mut i32)) = (count as i32);
                 break 'switch;
             }
-            v if v == (Width::W_16 as u32) => {
+            v if v == ((Width::W_16 as i32) as u32) => {
                 (*((*s).out.handle as *mut i16)) = (count as i16);
                 break 'switch;
             }
@@ -62,7 +72,7 @@ unsafe fn main_0() -> i32 {
     let mut buf32: i32 = 0;
     let mut buf16: i16 = 0_i16;
     let mut s: Sink = <Sink>::default();
-    s.width = (Width::W_64 as Width);
+    s.width = Width::from((Width::W_64 as i32));
     s.out.handle = ((&mut buf64 as *mut i64) as *mut i64 as *mut ::libc::c_void);
     (unsafe {
         let _s: *mut Sink = (&mut s as *mut Sink);
@@ -70,7 +80,7 @@ unsafe fn main_0() -> i32 {
         write_count_0(_s, _count)
     });
     assert!(((buf64) == (1234605616436508552_i64)));
-    s.width = (Width::W_32 as Width);
+    s.width = Width::from((Width::W_32 as i32));
     s.out.handle = ((&mut buf32 as *mut i32) as *mut i32 as *mut ::libc::c_void);
     (unsafe {
         let _s: *mut Sink = (&mut s as *mut Sink);
@@ -78,7 +88,7 @@ unsafe fn main_0() -> i32 {
         write_count_0(_s, _count)
     });
     assert!(((buf32) == (305419896)));
-    s.width = (Width::W_16 as Width);
+    s.width = Width::from((Width::W_16 as i32));
     s.out.handle = ((&mut buf16 as *mut i16) as *mut i16 as *mut ::libc::c_void);
     (unsafe {
         let _s: *mut Sink = (&mut s as *mut Sink);