diff --git a/cpp2rust/converter/converter.cpp b/cpp2rust/converter/converter.cpp
index 359210aa..14be77f5 100644
--- a/cpp2rust/converter/converter.cpp
+++ b/cpp2rust/converter/converter.cpp
@@ -990,6 +990,7 @@ bool Converter::VisitIfStmt(clang::IfStmt *stmt) {
 }
 
 bool Converter::VisitWhileStmt(clang::WhileStmt *stmt) {
+  PushBreakTarget push(break_target_stack_, BreakTarget::Loop);
   StrCat("'loop_:");
   StrCat(keyword::kWhile);
   ConvertCondition(stmt->getCond());
@@ -1002,6 +1003,7 @@ bool Converter::VisitWhileStmt(clang::WhileStmt *stmt) {
 }
 
 bool Converter::VisitDoStmt(clang::DoStmt *stmt) {
+  PushBreakTarget push(break_target_stack_, BreakTarget::Loop);
   StrCat("'loop_:");
   StrCat(keyword::kLoop, token::kOpenCurlyBracket);
   curr_for_inc_.emplace(nullptr);
@@ -1016,6 +1018,7 @@ bool Converter::VisitDoStmt(clang::DoStmt *stmt) {
 }
 
 bool Converter::VisitForStmt(clang::ForStmt *stmt) {
+  PushBreakTarget push(break_target_stack_, BreakTarget::Loop);
   Convert(stmt->getInit());
   StrCat("'loop_:");
   StrCat(keyword::kWhile);
@@ -1055,6 +1058,7 @@ void Converter::ConvertLoopVariable(clang::VarDecl *decl,
 
 void Converter::ConvertForRangeBody(clang::CXXForRangeStmt *stmt,
                                     const clang::VarDecl *map_iter_decl) {
+  PushBreakTarget push(break_target_stack_, BreakTarget::Loop);
   std::optional<ScopedMapIterDecl> skip;
   if (map_iter_decl)
     skip.emplace(*this, map_iter_decl);
@@ -1136,10 +1140,12 @@ bool Converter::VisitCXXForRangeStmtIndexBased(clang::CXXForRangeStmt *stmt,
 }
 
 bool Converter::VisitBreakStmt([[maybe_unused]] clang::BreakStmt *stmt) {
-  StrCat(keyword::kBreak);
-  if (break_with_explicit_label_) {
+  if (break_target_stack_.isRegularSwitch()) {
+    StrCat(keyword::kBreak);
     StrCat("'switch");
+    return false;
   }
+  StrCat(keyword::kBreak);
   return false;
 }
 
@@ -2617,69 +2623,80 @@ bool Converter::VisitImplicitValueInitExpr(clang::ImplicitValueInitExpr *expr) {
   return false;
 }
 
-static std::unordered_set<clang::SwitchCase *> visited_cases;
-
 bool Converter::VisitSwitchCase(clang::SwitchCase *stmt) {
-  if (visited_cases.contains(stmt)) {
-    return false;
-  }
-  visited_cases.insert(stmt);
-
-  if (auto case_stmt = clang::dyn_cast<clang::CaseStmt>(stmt)) {
-    Convert(case_stmt->getLHS());
-  }
-
-  if (clang::isa<clang::CaseStmt>(stmt->getSubStmt())) {
-    StrCat("|| v == ");
-  } else {
-    if (clang::isa<clang::CaseStmt>(stmt)) {
-      StrCat(" => {");
-    } else {
-      StrCat("_ => {");
+  clang::Stmt *cur = stmt;
+  clang::SwitchCase *last = nullptr;
+  bool first = true;
+
+  while (auto *sc = clang::dyn_cast<clang::SwitchCase>(cur)) {
+    if (auto *case_stmt = clang::dyn_cast<clang::CaseStmt>(sc)) {
+      if (!first) {
+        StrCat("|| v == ");
+      }
+      Convert(case_stmt->getLHS());
     }
+    last = sc;
+    first = false;
+    cur = sc->getSubStmt();
   }
 
-  Convert(stmt->getSubStmt());
+  if (clang::isa<clang::CaseStmt>(last)) {
+    StrCat(" => {");
+  } else /* DefaultStmt */ {
+    StrCat("_ => {");
+  }
   return false;
 }
 
 bool Converter::VisitSwitchStmt(clang::SwitchStmt *stmt) {
-  StrCat("'switch: {");
-  StrCat(std::format("let __match_cond = {};", ToString(stmt->getCond())));
-  StrCat("match __match_cond");
-  StrCat("{");
-
-  bool has_default_case = false;
-  auto body = llvm::cast<clang::CompoundStmt>(stmt->getBody());
+  auto *body = clang::dyn_cast<clang::CompoundStmt>(stmt->getBody());
   assert(body);
 
-  break_with_explicit_label_ = true;
-  for (auto it = body->body_begin(), end = body->body_end(); it != end;) {
-    if (auto switch_case = clang::dyn_cast<clang::SwitchCase>(*it)) {
-      if (clang::isa<clang::CaseStmt>(switch_case)) {
-        StrCat("v if v == ");
-      } else {
-        has_default_case = true;
-      }
-      VisitSwitchCase(switch_case);
-      ++it;
-    }
+  bool has_fallthrough = SwitchHasFallthrough(stmt);
 
-    while (it != end && !clang::isa<clang::SwitchCase>(*it)) {
-      Convert(*it);
-      ++it;
-    }
+  if (has_fallthrough) {
+    StrCat("switch!(match ", ToString(stmt->getCond()), " {");
+  } else {
+    StrCat("'switch: {");
+    StrCat(std::format("let __match_cond = {};", ToString(stmt->getCond())));
+    StrCat("match __match_cond");
+    StrCat("{");
+  }
+
+  PushBreakTarget push(break_target_stack_, has_fallthrough
+                                                ? BreakTarget::FallthroughSwitch
+                                                : BreakTarget::RegularSwitch);
 
+  clang::SwitchCase *default_case = nullptr;
+  for (auto *sc : GetTopLevelSwitchCases(stmt)) {
+    if (SwitchCaseContainsDefault(sc)) {
+      default_case = sc;
+      continue;
+    }
+    StrCat("v if v == ");
+    VisitSwitchCase(sc);
+    for (auto *t : GetSwitchCaseBody(body, sc)) {
+      Convert(t);
+    }
     StrCat("},");
   }
 
-  if (!has_default_case) {
+  if (default_case) {
+    StrCat("_ => {");
+    for (auto *t : GetSwitchCaseBody(body, default_case)) {
+      Convert(t);
+    }
+    StrCat("},");
+  } else {
     StrCat(R"( _ => {})");
   }
-  break_with_explicit_label_ = false;
 
-  StrCat("}");
-  StrCat("}");
+  if (has_fallthrough) {
+    StrCat("})");
+  } else {
+    StrCat("}");
+    StrCat("}");
+  }
   return false;
 }
 
diff --git a/cpp2rust/converter/converter.h b/cpp2rust/converter/converter.h
index 74e8e750..9e3a31c2 100644
--- a/cpp2rust/converter/converter.h
+++ b/cpp2rust/converter/converter.h
@@ -463,7 +463,35 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
   clang::ASTContext &ctx_;
   clang::FunctionDecl *curr_function_ = nullptr;
   bool in_function_formals_ = false;
-  bool break_with_explicit_label_ = false;
+
+  enum class BreakTarget { Loop, RegularSwitch, FallthroughSwitch };
+  class BreakTargetStack {
+  public:
+    void push(BreakTarget t) { stack_.push(t); }
+    void pop() { stack_.pop(); }
+    bool isRegularSwitch() const {
+      return !stack_.empty() && stack_.top() == BreakTarget::RegularSwitch;
+    }
+
+  private:
+    std::stack<BreakTarget> stack_;
+  };
+  BreakTargetStack break_target_stack_;
+
+  class PushBreakTarget {
+  public:
+    PushBreakTarget(BreakTargetStack &stack, BreakTarget target)
+        : stack_(stack) {
+      stack_.push(target);
+    }
+    ~PushBreakTarget() { stack_.pop(); }
+    PushBreakTarget(const PushBreakTarget &) = delete;
+    PushBreakTarget &operator=(const PushBreakTarget &) = delete;
+
+  private:
+    BreakTargetStack &stack_;
+  };
+
   std::stack<clang::Expr *> curr_for_inc_;
   std::stack<clang::QualType> curr_init_type_;
 
diff --git a/cpp2rust/converter/converter_lib.cpp b/cpp2rust/converter/converter_lib.cpp
index d493ad74..efcc0c4a 100644
--- a/cpp2rust/converter/converter_lib.cpp
+++ b/cpp2rust/converter/converter_lib.cpp
@@ -660,4 +660,78 @@ clang::Expr *CreateConversionToBool(clang::Expr *expr, clang::ASTContext &ctx) {
       /*BasePath=*/nullptr, clang::VK_PRValue, clang::FPOptionsOverride());
 }
 
+std::vector<clang::SwitchCase *>
+GetTopLevelSwitchCases(clang::SwitchStmt *stmt) {
+  std::vector<clang::SwitchCase *> cases;
+  if (auto *body = llvm::dyn_cast<clang::CompoundStmt>(stmt->getBody())) {
+    for (auto *s : body->body()) {
+      if (auto *sc = clang::dyn_cast<clang::SwitchCase>(s)) {
+        cases.push_back(sc);
+      }
+    }
+  }
+  return cases;
+}
+
+bool SwitchCaseContainsDefault(clang::SwitchCase *c) {
+  for (clang::Stmt *cur = c;;) {
+    if (clang::isa<clang::DefaultStmt>(cur)) {
+      return true;
+    }
+    auto *sc = clang::dyn_cast<clang::SwitchCase>(cur);
+    if (!sc) {
+      return false;
+    }
+    cur = sc->getSubStmt();
+  }
+  return false;
+}
+
+static clang::Stmt *GetLastStmtOfSwitchCase(clang::SwitchCase *c) {
+  clang::Stmt *cur = c->getSubStmt();
+  while (auto *sc = clang::dyn_cast<clang::SwitchCase>(cur)) {
+    cur = sc->getSubStmt();
+  }
+  return cur;
+}
+
+std::vector<clang::Stmt *> GetSwitchCaseBody(clang::CompoundStmt *body,
+                                             clang::SwitchCase *head) {
+  std::vector<clang::Stmt *> out;
+  out.push_back(GetLastStmtOfSwitchCase(head));
+  auto it = body->body_begin(), end = body->body_end();
+  while (it != end && *it != head) {
+    ++it;
+  }
+  assert(it != end);
+  ++it;
+  while (it != end && !clang::isa<clang::SwitchCase>(*it)) {
+    out.push_back(*it);
+    ++it;
+  }
+  return out;
+}
+
+static bool SwitchCaseHasFallthrough(clang::Stmt *stmt) {
+  if (stmt) {
+    if (clang::isa<clang::BreakStmt>(stmt) ||
+        clang::isa<clang::ReturnStmt>(stmt)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool SwitchHasFallthrough(clang::SwitchStmt *stmt) {
+  if (auto *body = clang::dyn_cast<clang::CompoundStmt>(stmt->getBody())) {
+    for (auto top_level_case : GetTopLevelSwitchCases(stmt)) {
+      auto arm = GetSwitchCaseBody(body, top_level_case);
+      if (arm.empty() || SwitchCaseHasFallthrough(arm.back())) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
 } // namespace cpp2rust
diff --git a/cpp2rust/converter/converter_lib.h b/cpp2rust/converter/converter_lib.h
index 36776336..91a3d44a 100644
--- a/cpp2rust/converter/converter_lib.h
+++ b/cpp2rust/converter/converter_lib.h
@@ -154,4 +154,14 @@ bool ContainsVAArgExpr(const clang::Stmt *stmt);
 
 clang::Expr *CreateConversionToBool(clang::Expr *expr, clang::ASTContext &ctx);
 
+std::vector<clang::SwitchCase *>
+GetTopLevelSwitchCases(clang::SwitchStmt *stmt);
+
+bool SwitchCaseContainsDefault(clang::SwitchCase *c);
+
+std::vector<clang::Stmt *> GetSwitchCaseBody(clang::CompoundStmt *body,
+                                             clang::SwitchCase *head);
+
+bool SwitchHasFallthrough(clang::SwitchStmt *stmt);
+
 } // namespace cpp2rust
diff --git a/libcc2rs-macros/Cargo.toml b/libcc2rs-macros/Cargo.toml
new file mode 100644
index 00000000..5a895659
--- /dev/null
+++ b/libcc2rs-macros/Cargo.toml
@@ -0,0 +1,15 @@
+[package]
+name = "libcc2rs-macros"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+proc-macro = true
+
+[dependencies]
+proc-macro2 = "1"
+quote = "1"
+syn = { version = "2", features = ["full", "visit-mut", "extra-traits"] }
+
+[dev-dependencies]
+trybuild = "1"
diff --git a/libcc2rs-macros/src/goto.rs b/libcc2rs-macros/src/goto.rs
new file mode 100644
index 00000000..916fd211
--- /dev/null
+++ b/libcc2rs-macros/src/goto.rs
@@ -0,0 +1,48 @@
+// Copyright (c) 2022-present INESC-ID.
+// Distributed under the MIT license that can be found in the LICENSE file.
+
+use proc_macro::TokenStream;
+use syn::parse::{Parse, ParseStream};
+use syn::{parse_macro_input, Expr, Lifetime, Token};
+
+use crate::state_machine::{Arm, GotoStateMachine, StateMachine};
+
+pub fn expand(input: TokenStream) -> TokenStream {
+    let GotoBlockInput { arms } = parse_macro_input!(input as GotoBlockInput);
+    GotoStateMachine {
+        arms: arms
+            .into_iter()
+            .map(|a| Arm {
+                label: a.label.ident.to_string(),
+                body: a.body,
+            })
+            .collect(),
+    }
+    .emit()
+    .into()
+}
+
+struct GotoBlockInput {
+    arms: Vec<GotoArm>,
+}
+
+struct GotoArm {
+    label: Lifetime,
+    body: Expr,
+}
+
+impl Parse for GotoBlockInput {
+    fn parse(input: ParseStream) -> syn::Result<Self> {
+        let mut arms = Vec::new();
+        while !input.is_empty() {
+            let label: Lifetime = input.parse()?;
+            input.parse::<Token![=>]>()?;
+            let body: Expr = input.parse()?;
+            arms.push(GotoArm { label, body });
+            if input.peek(Token![,]) {
+                input.parse::<Token![,]>()?;
+            }
+        }
+        Ok(Self { arms })
+    }
+}
diff --git a/libcc2rs-macros/src/lib.rs b/libcc2rs-macros/src/lib.rs
new file mode 100644
index 00000000..10317cf4
--- /dev/null
+++ b/libcc2rs-macros/src/lib.rs
@@ -0,0 +1,81 @@
+// Copyright (c) 2022-present INESC-ID.
+// Distributed under the MIT license that can be found in the LICENSE file.
+
+use proc_macro::TokenStream;
+
+mod goto;
+mod state_machine;
+mod switch;
+
+//     switch!(match <condition> {
+//         <pat> [if <guard>] => { /* body; may contain break or continue */ },
+//         ...
+//         _ => <body>,
+//     });
+//
+// Desugars to a goto_block! with a synthetic dispatch arm prepended.
+//
+//     goto_block! {
+//         '__dispatch => {
+//             match <condition> {
+//                 <pat_1> => { __s = 1; continue '__sm; }
+//                 ...
+//                 _       => break '__sm,
+//             }
+//         },
+//         '__c1 => { /* body_1 with `break` rewritten to `break '__sm` */ },
+//         ...
+//         '__cN => { /* body_N with same rewrite */ },
+//     };
+//
+// __sm is the inner label used to describe the state machine insinde goto_block. See goto_block!
+// for more info.
+
+#[proc_macro]
+pub fn switch(input: TokenStream) -> TokenStream {
+    switch::expand(input)
+}
+
+//     goto_block! {
+//         '<label> => { /* body; may contain `break` or `continue` */ },
+//         ...
+//     };
+//
+// Expands to
+//
+//     {
+//         let mut __user_break:    bool = false; // only if any arm has `break`
+//         let mut __user_continue: bool = false; // only if any arm has `continue`
+//         let mut __s: u32 = 0;
+//         '__sm: loop {
+//             match __s {
+//                 0u32 => {
+//                     /* body_0 with these rewrites (outside nested user loops): */
+//                     /*   break;    ->  { __user_break    = true; break '__sm; } */
+//                     /*   continue; ->  { __user_continue = true; break '__sm; } */
+//                     __s = 1; continue '__sm;
+//                 }
+//                 ...
+//                 (N-1)u32 => { /* body_N-1 with same rewrites */ break '__sm; }
+//                 _        => break '__sm, // written only for match exhaustiveness
+//             }
+//         }
+//         if __user_break    { break; }    // only if any arm has `break;`
+//         if __user_continue { continue; } // only if any arm has `continue;`
+//     }
+//
+//  __user_break and __user_continue propagate the `break`s and `continue`s outside the goto state
+//  machine loop.
+
+#[proc_macro]
+pub fn goto_block(input: TokenStream) -> TokenStream {
+    goto::expand(input)
+}
+
+#[proc_macro]
+pub fn goto(_input: TokenStream) -> TokenStream {
+    quote::quote! {
+        compile_error!("goto!() can only be used inside goto_block!")
+    }
+    .into()
+}
diff --git a/libcc2rs-macros/src/state_machine.rs b/libcc2rs-macros/src/state_machine.rs
new file mode 100644
index 00000000..ae366f94
--- /dev/null
+++ b/libcc2rs-macros/src/state_machine.rs
@@ -0,0 +1,269 @@
+// Copyright (c) 2022-present INESC-ID.
+// Distributed under the MIT license that can be found in the LICENSE file.
+
+use proc_macro2::{Ident, Span, TokenStream as TokenStream2};
+use quote::{format_ident, quote};
+use syn::visit_mut::{self, VisitMut};
+use syn::{Expr, ExprBreak, ExprContinue, Lifetime, Pat};
+
+pub struct Arm {
+    pub label: String,
+    pub body: Expr,
+}
+
+pub struct DispatchCase {
+    pub pat: Pat,
+    pub guard: Option<Expr>,
+    pub target: String,
+}
+
+pub trait StateMachine {
+    fn emit(self) -> TokenStream2;
+}
+
+fn sm_label() -> Lifetime {
+    Lifetime::new("'__sm", Span::call_site())
+}
+
+// Collection of labeled arms that fall-through by default
+pub struct GotoStateMachine {
+    pub arms: Vec<Arm>,
+}
+
+impl GotoStateMachine {
+    // Rewrites unlabeled break / continue to { flag = true; break '__sm; }
+    fn propagate_rewrite(
+        body: &mut Expr,
+        label: &Lifetime,
+        break_flag: &Ident,
+        cont_flag: &Ident,
+    ) -> (bool, bool) {
+        let mut br = PropagateRewriter::for_break(label.clone(), break_flag.clone());
+        br.visit_expr_mut(body);
+        let mut cr = PropagateRewriter::for_continue(label.clone(), cont_flag.clone());
+        cr.visit_expr_mut(body);
+        (br.found, cr.found)
+    }
+
+    // idx => { body; tail }
+    fn emit_body_arm(
+        idx: u32,
+        body: &Expr,
+        is_last: bool,
+        label: &Lifetime,
+        state: &Ident,
+    ) -> TokenStream2 {
+        let tail = if is_last {
+            quote! { break #label; }
+        } else {
+            let next = idx + 1;
+            quote! { #state = #next; continue #label; }
+        };
+        quote! {
+            #idx => {
+                #[allow(unreachable_code)]
+                { #body; #tail }
+            }
+        }
+    }
+
+    fn bailout(should_emit: bool, flag: &Ident, stmt: TokenStream2) -> (TokenStream2, TokenStream2) {
+        if !should_emit {
+            return (TokenStream2::new(), TokenStream2::new());
+        }
+        (
+            quote! { let mut #flag: bool = false; },
+            quote! {
+                #[allow(unreachable_code)]
+                if #flag { #stmt }
+            },
+        )
+    }
+}
+
+impl StateMachine for GotoStateMachine {
+    fn emit(self) -> TokenStream2 {
+        let lbl = sm_label();
+        let s = format_ident!("__s");
+        let break_flag = format_ident!("__user_break");
+        let cont_flag = format_ident!("__user_continue");
+
+        let n = self.arms.len();
+        let mut any_break = false;
+        let mut any_continue = false;
+        let body_arms: Vec<_> = self
+            .arms
+            .iter()
+            .enumerate()
+            .map(|(i, arm)| {
+                let mut body = arm.body.clone();
+                let (had_br, had_cn) =
+                    Self::propagate_rewrite(&mut body, &lbl, &break_flag, &cont_flag);
+                any_break |= had_br;
+                any_continue |= had_cn;
+                Self::emit_body_arm(i as u32, &body, i + 1 == n, &lbl, &s)
+            })
+            .collect();
+
+        let (brk_decl, brk_bailout) = Self::bailout(any_break, &break_flag, quote! { break; });
+        let (cnt_decl, cnt_bailout) = Self::bailout(any_continue, &cont_flag, quote! { continue; });
+
+        quote! {{
+            #brk_decl
+            #cnt_decl
+            let mut #s: u32 = 0;
+            #[allow(unreachable_code, unused_labels)]
+            #lbl: loop {
+                match #s {
+                    #(#body_arms)*
+                    _ => break #lbl,
+                }
+            }
+            #brk_bailout
+            #cnt_bailout
+        }}
+    }
+}
+
+// GotoStateMachine(dispatch arm + cases)
+pub struct SwitchStateMachine {
+    pub goto: GotoStateMachine,
+    pub condition: Expr,
+    pub cases: Vec<DispatchCase>,
+}
+
+impl SwitchStateMachine {
+    // Rewrite break into break '__sm
+    fn convert_break_to_switch_exit(arms: &Vec<Arm>, label: &Lifetime) -> Vec<Arm> {
+        arms.into_iter()
+            .map(|a| {
+                let mut body = a.body.clone();
+                ExitSwitchRewriter {
+                    label: label.clone(),
+                }
+                .visit_expr_mut(&mut body);
+                Arm {
+                    label: a.label.clone(),
+                    body,
+                }
+            })
+            .collect()
+    }
+
+    fn build_dispatch_arm(&self, user_arms: &[Arm], label: &Lifetime, state: &Ident) -> Arm {
+        let cond = &self.condition;
+        let case_arms = self.cases.iter().map(|c| {
+            let target_pos = user_arms
+                .iter()
+                .position(|a| a.label == c.target)
+                .expect("dispatch target must reference an arm label");
+            let idx = (target_pos as u32) + 1;
+            let pat = &c.pat;
+            let guard = c.guard.as_ref().map(|g| quote! { if #g });
+            quote! { #pat #guard => { #state = #idx; continue #label; } }
+        });
+        let body: Expr = syn::parse_quote! {
+            {
+                #[allow(unreachable_patterns)]
+                match #cond {
+                    #(#case_arms,)*
+                    _ => break #label,
+                }
+            }
+        };
+        Arm {
+            label: "__dispatch".into(),
+            body,
+        }
+    }
+}
+
+impl StateMachine for SwitchStateMachine {
+    fn emit(self) -> TokenStream2 {
+        let lbl = sm_label();
+        let s = format_ident!("__s");
+
+        let user_arms = Self::convert_break_to_switch_exit(&self.goto.arms, &lbl);
+        let dispatch = self.build_dispatch_arm(&user_arms, &lbl, &s);
+
+        let mut arms = Vec::new();
+        arms.push(dispatch);
+        arms.extend(user_arms);
+
+        GotoStateMachine { arms }.emit()
+    }
+}
+
+// Rewrite break into break '__sm
+struct ExitSwitchRewriter {
+    label: Lifetime,
+}
+
+impl VisitMut for ExitSwitchRewriter {
+    fn visit_expr_break_mut(&mut self, node: &mut ExprBreak) {
+        if node.label.is_none() {
+            node.label = Some(self.label.clone());
+        }
+    }
+    fn visit_expr_loop_mut(&mut self, _: &mut syn::ExprLoop) {}
+    fn visit_expr_while_mut(&mut self, _: &mut syn::ExprWhile) {}
+    fn visit_expr_for_loop_mut(&mut self, _: &mut syn::ExprForLoop) {}
+}
+
+enum ControlKind {
+    Break,
+    Continue,
+}
+
+// Rewrites unlabeled break / continue to { flag = true; break '__sm; }
+struct PropagateRewriter {
+    label: Lifetime,
+    flag: Ident,
+    kind: ControlKind,
+    found: bool,
+}
+
+impl PropagateRewriter {
+    fn for_break(label: Lifetime, flag: Ident) -> Self {
+        Self {
+            label,
+            flag,
+            kind: ControlKind::Break,
+            found: false,
+        }
+    }
+    fn for_continue(label: Lifetime, flag: Ident) -> Self {
+        Self {
+            label,
+            flag,
+            kind: ControlKind::Continue,
+            found: false,
+        }
+    }
+}
+
+impl VisitMut for PropagateRewriter {
+    fn visit_expr_mut(&mut self, expr: &mut Expr) {
+        let hit = match self.kind {
+            ControlKind::Break => {
+                matches!(expr, Expr::Break(ExprBreak { label: None, .. }))
+            }
+            ControlKind::Continue => {
+                matches!(expr, Expr::Continue(ExprContinue { label: None, .. }))
+            }
+        };
+        if hit {
+            self.found = true;
+            let flag = &self.flag;
+            let lbl = &self.label;
+            *expr = syn::parse_quote! {
+                { #flag = true; break #lbl; }
+            };
+            return;
+        }
+        visit_mut::visit_expr_mut(self, expr);
+    }
+    fn visit_expr_loop_mut(&mut self, _: &mut syn::ExprLoop) {}
+    fn visit_expr_while_mut(&mut self, _: &mut syn::ExprWhile) {}
+    fn visit_expr_for_loop_mut(&mut self, _: &mut syn::ExprForLoop) {}
+}
diff --git a/libcc2rs-macros/src/switch.rs b/libcc2rs-macros/src/switch.rs
new file mode 100644
index 00000000..d433c91a
--- /dev/null
+++ b/libcc2rs-macros/src/switch.rs
@@ -0,0 +1,62 @@
+// Copyright (c) 2022-present INESC-ID.
+// Distributed under the MIT license that can be found in the LICENSE file.
+
+use proc_macro::TokenStream;
+use syn::parse::{Parse, ParseStream};
+use syn::{parse_macro_input, Expr, Pat};
+
+use crate::state_machine::{Arm, DispatchCase, GotoStateMachine, StateMachine, SwitchStateMachine};
+
+pub fn expand(input: TokenStream) -> TokenStream {
+    let SwitchInput { condition, arms } = parse_macro_input!(input as SwitchInput);
+    let mut cases = Vec::with_capacity(arms.len());
+    let mut cfg_arms = Vec::with_capacity(arms.len());
+    for (i, a) in arms.into_iter().enumerate() {
+        let label = format!("__c{}", i);
+        cases.push(DispatchCase {
+            pat: a.pat,
+            guard: a.guard,
+            target: label.clone(),
+        });
+        cfg_arms.push(Arm {
+            label,
+            body: a.body,
+        });
+    }
+    SwitchStateMachine {
+        goto: GotoStateMachine { arms: cfg_arms },
+        condition: condition,
+        cases,
+    }
+    .emit()
+    .into()
+}
+
+struct SwitchInput {
+    condition: Expr,
+    arms: Vec<SwitchArm>,
+}
+
+struct SwitchArm {
+    pat: Pat,
+    guard: Option<Expr>,
+    body: Expr,
+}
+
+impl Parse for SwitchInput {
+    fn parse(input: ParseStream) -> syn::Result<Self> {
+        let m: syn::ExprMatch = input.parse()?;
+        Ok(Self {
+            condition: *m.expr,
+            arms: m
+                .arms
+                .into_iter()
+                .map(|a| SwitchArm {
+                    pat: a.pat,
+                    guard: a.guard.map(|(_if, e)| *e),
+                    body: *a.body,
+                })
+                .collect(),
+        })
+    }
+}
diff --git a/libcc2rs-macros/tests/compile_fail.rs b/libcc2rs-macros/tests/compile_fail.rs
new file mode 100644
index 00000000..03eeb131
--- /dev/null
+++ b/libcc2rs-macros/tests/compile_fail.rs
@@ -0,0 +1,8 @@
+// Copyright (c) 2022-present INESC-ID.
+// Distributed under the MIT license that can be found in the LICENSE file.
+
+#[test]
+fn compile_fail() {
+    let t = trybuild::TestCases::new();
+    t.compile_fail("tests/ui/*.rs");
+}
diff --git a/libcc2rs-macros/tests/control_flow.rs b/libcc2rs-macros/tests/control_flow.rs
new file mode 100644
index 00000000..f5390511
--- /dev/null
+++ b/libcc2rs-macros/tests/control_flow.rs
@@ -0,0 +1,309 @@
+// Copyright (c) 2022-present INESC-ID.
+// Distributed under the MIT license that can be found in the LICENSE file.
+
+use libcc2rs_macros::{goto_block, switch};
+
+#[test]
+fn switch_dispatch_each_case() {
+    for (input, expected) in [(0, "zero"), (1, "one"), (2, "two"), (9, "default")] {
+        let mut out = "";
+        switch!(match input {
+            0 => {
+                out = "zero";
+                break;
+            }
+            1 => {
+                out = "one";
+                break;
+            }
+            2 => {
+                out = "two";
+                break;
+            }
+            _ => {
+                out = "default";
+                break;
+            }
+        });
+        assert_eq!(out, expected, "input = {}", input);
+    }
+}
+
+#[test]
+fn switch_fallthrough() {
+    let mut v = 0;
+    switch!(match 0 {
+        0 => {
+            v += 1;
+        } // fall-through
+        1 => {
+            v += 10;
+            break;
+        }
+        _ => {
+            v = -1;
+            break;
+        }
+    });
+    assert_eq!(v, 11);
+}
+
+#[test]
+fn switch_fallthrough_chain() {
+    let mut v = 0;
+    switch!(match 0 {
+        0 => {
+            v += 1;
+        }
+        1 => {
+            v += 10;
+        }
+        2 => {
+            v += 100;
+            break;
+        }
+        _ => {
+            v = -1;
+            break;
+        }
+    });
+    assert_eq!(v, 111);
+}
+
+#[test]
+fn switch_break_exits() {
+    let mut v = 0;
+    switch!(match 1 {
+        0 => {
+            v = 999;
+            break;
+        }
+        1 => {
+            v = 1;
+            break;
+        }
+        _ => {
+            v = 2;
+            break;
+        }
+    });
+    assert_eq!(v, 1);
+}
+
+#[test]
+fn switch_default_case() {
+    let mut v = 0;
+    switch!(match 42 {
+        0 => {
+            v = 1;
+            break;
+        }
+        _ => {
+            v = 2;
+            break;
+        }
+    });
+    assert_eq!(v, 2);
+}
+
+#[test]
+fn switch_or_pattern() {
+    for x in [1, 2, 5] {
+        let mut v = "other";
+        switch!(match x {
+            1 | 2 | 3 => {
+                v = "low";
+                break;
+            }
+            _ => {
+                v = "other";
+                break;
+            }
+        });
+        let expected = if x <= 3 { "low" } else { "other" };
+        assert_eq!(v, expected);
+    }
+}
+
+#[test]
+fn switch_guard_stacked_cases() {
+    for (x, expected) in [(1, 100), (2, 100), (3, 100), (4, 200), (5, 200), (9, 300)] {
+        let mut r = 0;
+        switch!(match x {
+            v if v == 1 || v == 2 || v == 3 => {
+                r = 100;
+                break;
+            }
+            v if v == 4 || v == 5 => {
+                r = 200;
+                break;
+            }
+            _ => {
+                r = 300;
+                break;
+            }
+        });
+        assert_eq!(r, expected, "x = {}", x);
+    }
+}
+
+#[test]
+fn switch_guard_fallthrough() {
+    let mut v = 0;
+    switch!(match 1 {
+        w if w == 0 || w == 1 => {
+            v += 1;
+        }
+        w if w == 2 => {
+            v += 10;
+            break;
+        }
+        _ => {
+            v = -1;
+            break;
+        }
+    });
+    assert_eq!(v, 11);
+}
+
+#[test]
+fn switch_guard_no_match_hits_default() {
+    let mut r = 0;
+    switch!(match 42 {
+        v if v == 1 => {
+            r = 1;
+            break;
+        }
+        v if v == 2 || v == 3 => {
+            r = 2;
+            break;
+        }
+        _ => {
+            r = 99;
+            break;
+        }
+    });
+    assert_eq!(r, 99);
+}
+
+#[test]
+fn switch_range_pattern() {
+    let mut v = 0;
+    switch!(match 50i32 {
+        0..=9 => {
+            v = 1;
+            break;
+        }
+        10..=99 => {
+            v = 2;
+            break;
+        }
+        _ => {
+            v = 3;
+            break;
+        }
+    });
+    assert_eq!(v, 2);
+}
+
+#[test]
+fn switch_nested_loop_break_targets_inner() {
+    let mut sum = 0;
+    switch!(match 0 {
+        0 => {
+            for i in 0..10 {
+                if i == 3 {
+                    break; // targets the for loop (LoopControlForbidden skips descent)
+                }
+                sum += i;
+            }
+            sum += 100;
+            break;
+        }
+        _ => {
+            break;
+        }
+    });
+    assert_eq!(sum, 103);
+}
+
+#[test]
+fn switch_return_from_case() {
+    #[allow(unreachable_code)]
+    fn classify(x: i32) -> &'static str {
+        switch!(match x {
+            0 => {
+                return "zero";
+            }
+            1 => {
+                return "one";
+            }
+            _ => {
+                return "other";
+            }
+        });
+        "unreachable"
+    }
+    assert_eq!(classify(0), "zero");
+    assert_eq!(classify(1), "one");
+    assert_eq!(classify(5), "other");
+}
+
+#[test]
+fn switch_in_loop() {
+    let mut count = 0;
+    for x in 0..5 {
+        switch!(match x {
+            0 | 2 | 4 => {
+                count += 1;
+                break;
+            }
+            _ => {
+                break;
+            }
+        });
+    }
+    assert_eq!(count, 3);
+}
+
+#[test]
+fn goto_block_linear_fallthrough() {
+    let mut v = 0;
+    goto_block! {
+        'a => { v += 1; },
+        'b => { v += 10; },
+        'c => { v += 100; },
+    };
+    assert_eq!(v, 111);
+}
+
+#[test]
+fn goto_block_return_from_arm() {
+    #[allow(unreachable_code)]
+    fn run(start: u32) -> &'static str {
+        goto_block! {
+            'a => { if start == 0 { return "a"; } },
+            'b => { if start == 1 { return "b"; } },
+            'c => { return "c"; },
+        };
+        "fallthrough"
+    }
+    assert_eq!(run(0), "a");
+    assert_eq!(run(1), "b");
+    assert_eq!(run(2), "c");
+}
+
+#[test]
+fn goto_block_nested_loop_break_targets_inner() {
+    let mut sum = 0;
+    goto_block! {
+        'entry => {
+            for i in 0..10 {
+                if i == 3 { break; } // targets the for loop
+                sum += i;
+            }
+            sum += 100;
+        },
+    };
+    assert_eq!(sum, 103);
+}
diff --git a/libcc2rs-macros/tests/ui/forbidden.rs b/libcc2rs-macros/tests/ui/forbidden.rs
new file mode 100644
index 00000000..c483c0d6
--- /dev/null
+++ b/libcc2rs-macros/tests/ui/forbidden.rs
@@ -0,0 +1,21 @@
+// Copyright (c) 2022-present INESC-ID.
+// Distributed under the MIT license that can be found in the LICENSE file.
+
+use libcc2rs_macros::{goto, switch};
+
+fn continue_with_no_outer_loop() {
+    let mut v = 0;
+    // No outer loop to continue
+    switch!(match 0 {
+        0 => { v = 1; continue; }
+        _ => { v = 2; }
+    });
+    let _ = v;
+}
+
+fn goto_outside_goto_block() {
+    // goto!() used outside goto_block!
+    goto!('nowhere);
+}
+
+fn main() {}
diff --git a/libcc2rs-macros/tests/ui/forbidden.stderr b/libcc2rs-macros/tests/ui/forbidden.stderr
new file mode 100644
index 00000000..e7e084a8
--- /dev/null
+++ b/libcc2rs-macros/tests/ui/forbidden.stderr
@@ -0,0 +1,18 @@
+error: goto!() can only be used inside goto_block!
+  --> tests/ui/forbidden.rs:22:5
+   |
+22 |     goto!('nowhere);
+   |     ^^^^^^^^^^^^^^^
+   |
+   = note: this error originates in the macro `goto` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0268]: `continue` outside of a loop
+  --> tests/ui/forbidden.rs:13:5
+   |
+13 | /     switch!(match 0 {
+14 | |         0 => { v = 1; continue; }
+15 | |         _ => { v = 2; }
+16 | |     });
+   | |______^ cannot `continue` outside of a loop
+   |
+   = note: this error originates in the macro `switch` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/libcc2rs/Cargo.toml b/libcc2rs/Cargo.toml
index cdc1405a..0ce61d9d 100644
--- a/libcc2rs/Cargo.toml
+++ b/libcc2rs/Cargo.toml
@@ -4,3 +4,6 @@ version = "0.1.0"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+libcc2rs-macros = { path = "../libcc2rs-macros", version = "0.1.0" }
diff --git a/libcc2rs/src/lib.rs b/libcc2rs/src/lib.rs
index 1271b941..859ba5cc 100644
--- a/libcc2rs/src/lib.rs
+++ b/libcc2rs/src/lib.rs
@@ -30,3 +30,5 @@ pub use compat::*;
 
 mod va_args;
 pub use va_args::*;
+
+pub use libcc2rs_macros::{goto, goto_block, switch};
diff --git a/tests/unit/out/refcount/switch.rs b/tests/unit/out/refcount/switch.rs
new file mode 100644
index 00000000..f2778239
--- /dev/null
+++ b/tests/unit/out/refcount/switch.rs
@@ -0,0 +1,1368 @@
+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 basic_0(x: i32) -> i32 {
+    let x: Value<i32> = Rc::new(RefCell::new(x));
+    let r: Value<i32> = Rc::new(RefCell::new(0));
+    'switch: {
+        let __match_cond = (*x.borrow());
+        match __match_cond {
+            v if v == 0 => {
+                (*r.borrow_mut()) = 10;
+                break 'switch;
+            }
+            v if v == 1 => {
+                (*r.borrow_mut()) = 20;
+                break 'switch;
+            }
+            v if v == 2 => {
+                (*r.borrow_mut()) = 30;
+                break 'switch;
+            }
+            _ => {
+                (*r.borrow_mut()) = 40;
+                break 'switch;
+            }
+        }
+    };
+    return (*r.borrow());
+}
+pub fn stacked_1(x: i32) -> i32 {
+    let x: Value<i32> = Rc::new(RefCell::new(x));
+    let r: Value<i32> = Rc::new(RefCell::new(0));
+    'switch: {
+        let __match_cond = (*x.borrow());
+        match __match_cond {
+            v if v == 1 || v == 2 || v == 3 => {
+                (*r.borrow_mut()) = 100;
+                break 'switch;
+            }
+            v if v == 4 || v == 5 => {
+                (*r.borrow_mut()) = 200;
+                break 'switch;
+            }
+            _ => {
+                (*r.borrow_mut()) = 300;
+                break 'switch;
+            }
+        }
+    };
+    return (*r.borrow());
+}
+pub fn no_default_2(x: i32) -> i32 {
+    let x: Value<i32> = Rc::new(RefCell::new(x));
+    let r: Value<i32> = Rc::new(RefCell::new(-1_i32));
+    'switch: {
+        let __match_cond = (*x.borrow());
+        match __match_cond {
+            v if v == 7 => {
+                (*r.borrow_mut()) = 1;
+                break 'switch;
+            }
+            v if v == 8 => {
+                (*r.borrow_mut()) = 2;
+                break 'switch;
+            }
+            _ => {}
+        }
+    };
+    return (*r.borrow());
+}
+pub fn only_default_3(x: i32) -> i32 {
+    let x: Value<i32> = Rc::new(RefCell::new(x));
+    let r: Value<i32> = Rc::new(RefCell::new(0));
+    'switch: {
+        let __match_cond = (*x.borrow());
+        match __match_cond {
+            _ => {
+                (*r.borrow_mut()) = 42;
+                break 'switch;
+            }
+        }
+    };
+    return (*r.borrow());
+}
+pub fn default_middle_4(x: i32) -> i32 {
+    let x: Value<i32> = Rc::new(RefCell::new(x));
+    let r: Value<i32> = Rc::new(RefCell::new(0));
+    'switch: {
+        let __match_cond = (*x.borrow());
+        match __match_cond {
+            v if v == 1 => {
+                (*r.borrow_mut()) = 1;
+                break 'switch;
+            }
+            v if v == 2 => {
+                (*r.borrow_mut()) = 2;
+                break 'switch;
+            }
+            _ => {
+                (*r.borrow_mut()) = 99;
+                break 'switch;
+            }
+        }
+    };
+    return (*r.borrow());
+}
+pub fn default_first_5(x: i32) -> i32 {
+    let x: Value<i32> = Rc::new(RefCell::new(x));
+    let r: Value<i32> = Rc::new(RefCell::new(0));
+    'switch: {
+        let __match_cond = (*x.borrow());
+        match __match_cond {
+            v if v == 1 => {
+                (*r.borrow_mut()) = 1;
+                break 'switch;
+            }
+            v if v == 2 => {
+                (*r.borrow_mut()) = 2;
+                break 'switch;
+            }
+            _ => {
+                (*r.borrow_mut()) = 7;
+                break 'switch;
+            }
+        }
+    };
+    return (*r.borrow());
+}
+pub fn empty_switch_6(x: i32) -> i32 {
+    let x: Value<i32> = Rc::new(RefCell::new(x));
+    'switch: {
+        let __match_cond = (*x.borrow());
+        match __match_cond {
+            _ => {}
+        }
+    };
+    return (*x.borrow());
+}
+pub fn switch_char_7(c: u8) -> i32 {
+    let c: Value<u8> = Rc::new(RefCell::new(c));
+    'switch: {
+        let __match_cond = ((*c.borrow()) as i32);
+        match __match_cond {
+            v if v == (('a' as u8) as i32) => {
+                return 1;
+            }
+            v if v == (('b' as u8) as i32) => {
+                return 2;
+            }
+            v if v == (('\n' as u8) as i32) => {
+                return 3;
+            }
+            v if v == (('\0' as u8) as i32) => {
+                return 4;
+            }
+            _ => {
+                return 0;
+            }
+        }
+    };
+    panic!("ub: non-void function does not return a value")
+}
+#[derive(Clone, Copy, PartialEq, Debug, Default)]
+enum Color {
+    #[default]
+    kRed = 0,
+    kGreen = 1,
+    kBlue = 2,
+}
+pub fn switch_enum_8(c: Color) -> i32 {
+    let c: Value<Color> = Rc::new(RefCell::new(c));
+    'switch: {
+        let __match_cond = ((*c.borrow()) as i32);
+        match __match_cond {
+            v if v == (Color::kRed as i32) => {
+                return 10;
+            }
+            v if v == (Color::kGreen as i32) => {
+                return 20;
+            }
+            v if v == (Color::kBlue as i32) => {
+                return 30;
+            }
+            _ => {}
+        }
+    };
+    return -1_i32;
+}
+pub fn compound_case_body_9(x: i32) -> i32 {
+    let x: Value<i32> = Rc::new(RefCell::new(x));
+    let r: Value<i32> = Rc::new(RefCell::new(0));
+    switch!(match (*x.borrow()) {
+        v if v == 1 => {
+            let y: Value<i32> = Rc::new(RefCell::new(10));
+            let z: Value<i32> = Rc::new(RefCell::new(20));
+            (*r.borrow_mut()) = ((*y.borrow()) + (*z.borrow()));
+            break;
+        }
+        v if v == 2 => {
+            let y: Value<i32> = Rc::new(RefCell::new(100));
+            (*r.borrow_mut()) = ((*y.borrow()) - 1);
+            break;
+        }
+        _ => {
+            (*r.borrow_mut()) = -1_i32;
+            break;
+        }
+    });
+    return (*r.borrow());
+}
+pub fn nested_10(a: i32, b: i32) -> i32 {
+    let a: Value<i32> = Rc::new(RefCell::new(a));
+    let b: Value<i32> = Rc::new(RefCell::new(b));
+    let r: Value<i32> = Rc::new(RefCell::new(0));
+    'switch: {
+        let __match_cond = (*a.borrow());
+        match __match_cond {
+            v if v == 1 => {
+                'switch: {
+                    let __match_cond = (*b.borrow());
+                    match __match_cond {
+                        v if v == 10 => {
+                            (*r.borrow_mut()) = 11;
+                            break 'switch;
+                        }
+                        v if v == 20 => {
+                            (*r.borrow_mut()) = 12;
+                            break 'switch;
+                        }
+                        _ => {
+                            (*r.borrow_mut()) = 13;
+                            break 'switch;
+                        }
+                    }
+                };
+                (*r.borrow_mut()) += 1;
+                break 'switch;
+            }
+            v if v == 2 => {
+                (*r.borrow_mut()) = 2;
+                break 'switch;
+            }
+            _ => {
+                (*r.borrow_mut()) = -1_i32;
+                break 'switch;
+            }
+        }
+    };
+    return (*r.borrow());
+}
+pub fn switch_in_loop_11(n: i32) -> i32 {
+    let n: Value<i32> = Rc::new(RefCell::new(n));
+    let r: Value<i32> = Rc::new(RefCell::new(0));
+    let i: Value<i32> = Rc::new(RefCell::new(0));
+    'loop_: while ((*i.borrow()) < (*n.borrow())) {
+        'switch: {
+            let __match_cond = ((*i.borrow()) % 3);
+            match __match_cond {
+                v if v == 0 => {
+                    (*r.borrow_mut()) += 1;
+                    break 'switch;
+                }
+                v if v == 1 => {
+                    (*r.borrow_mut()) += 2;
+                    break 'switch;
+                }
+                _ => {
+                    (*r.borrow_mut()) += 3;
+                    break 'switch;
+                }
+            }
+        };
+        (*r.borrow_mut()) += 10;
+        (*i.borrow_mut()).prefix_inc();
+    }
+    return (*r.borrow());
+}
+pub fn stacked_block_12(x: i32) -> i32 {
+    let x: Value<i32> = Rc::new(RefCell::new(x));
+    let r: Value<i32> = Rc::new(RefCell::new(0));
+    switch!(match (*x.borrow()) {
+        v if v == 1 || v == 2 || v == 3 => {
+            let y: Value<i32> = Rc::new(RefCell::new(((*x.borrow()) * 2)));
+            (*r.borrow_mut()) = ((*y.borrow()) + 1);
+            break;
+        }
+        _ => {
+            (*r.borrow_mut()) = 0;
+            break;
+        }
+    });
+    return (*r.borrow());
+}
+pub fn double_it_13(v: i32) -> i32 {
+    let v: Value<i32> = Rc::new(RefCell::new(v));
+    return ((*v.borrow()) * 2);
+}
+pub fn switch_on_call_14(x: i32) -> i32 {
+    let x: Value<i32> = Rc::new(RefCell::new(x));
+    'switch: {
+        let __match_cond = ({
+            let _v: i32 = (*x.borrow());
+            double_it_13(_v)
+        });
+        match __match_cond {
+            v if v == 0 => {
+                return 100;
+            }
+            v if v == 2 => {
+                return 200;
+            }
+            v if v == 4 => {
+                return 400;
+            }
+            _ => {
+                return -1_i32;
+            }
+        }
+    };
+    panic!("ub: non-void function does not return a value")
+}
+pub fn switch_on_assignment_15(x: i32) -> i32 {
+    let x: Value<i32> = Rc::new(RefCell::new(x));
+    let y: Value<i32> = Rc::new(RefCell::new(0));
+    let r: Value<i32> = Rc::new(RefCell::new(0));
+    'switch: {
+        let __match_cond = {
+            (*y.borrow_mut()) = ((*x.borrow()) + 1);
+            (*y.borrow())
+        };
+        match __match_cond {
+            v if v == 1 => {
+                (*r.borrow_mut()) = 10;
+                break 'switch;
+            }
+            v if v == 2 => {
+                (*r.borrow_mut()) = 20;
+                break 'switch;
+            }
+            _ => {
+                (*r.borrow_mut()) = (*y.borrow());
+                break 'switch;
+            }
+        }
+    };
+    return (*r.borrow());
+}
+pub fn mixed_literal_cases_16(x: i32) -> i32 {
+    let x: Value<i32> = Rc::new(RefCell::new(x));
+    'switch: {
+        let __match_cond = (*x.borrow());
+        match __match_cond {
+            v if v == -1_i32 => {
+                return 1;
+            }
+            v if v == 16 => {
+                return 2;
+            }
+            v if v == 65152 => {
+                return 3;
+            }
+            v if v == -255_i32 => {
+                return 4;
+            }
+            _ => {
+                return 0;
+            }
+        }
+    };
+    panic!("ub: non-void function does not return a value")
+}
+pub fn mixed_return_break_17(x: i32) -> i32 {
+    let x: Value<i32> = Rc::new(RefCell::new(x));
+    let r: Value<i32> = Rc::new(RefCell::new(-1_i32));
+    'switch: {
+        let __match_cond = (*x.borrow());
+        match __match_cond {
+            v if v == 0 => {
+                return 100;
+            }
+            v if v == 1 => {
+                (*r.borrow_mut()) = 10;
+                break 'switch;
+            }
+            v if v == 2 => {
+                return 200;
+            }
+            _ => {
+                (*r.borrow_mut()) = 99;
+                break 'switch;
+            }
+        }
+    };
+    return (*r.borrow());
+}
+pub fn empty_case_with_break_18(x: i32) -> i32 {
+    let x: Value<i32> = Rc::new(RefCell::new(x));
+    let r: Value<i32> = Rc::new(RefCell::new(5));
+    'switch: {
+        let __match_cond = (*x.borrow());
+        match __match_cond {
+            v if v == 1 => {
+                break 'switch;
+            }
+            v if v == 2 => {
+                (*r.borrow_mut()) = 2;
+                break 'switch;
+            }
+            _ => {
+                (*r.borrow_mut()) = 9;
+                break 'switch;
+            }
+        }
+    };
+    return (*r.borrow());
+}
+pub fn fallthrough_one_19(x: i32) -> i32 {
+    let x: Value<i32> = Rc::new(RefCell::new(x));
+    let r: Value<i32> = Rc::new(RefCell::new(0));
+    switch!(match (*x.borrow()) {
+        v if v == 1 => {
+            (*r.borrow_mut()) += 10;
+        }
+        v if v == 2 => {
+            (*r.borrow_mut()) += 20;
+            break;
+        }
+        _ => {
+            (*r.borrow_mut()) = -1_i32;
+            break;
+        }
+    });
+    return (*r.borrow());
+}
+pub fn fallthrough_chain_20(x: i32) -> i32 {
+    let x: Value<i32> = Rc::new(RefCell::new(x));
+    let r: Value<i32> = Rc::new(RefCell::new(0));
+    switch!(match (*x.borrow()) {
+        v if v == 1 => {
+            (*r.borrow_mut()) += 1;
+        }
+        v if v == 2 => {
+            (*r.borrow_mut()) += 2;
+        }
+        v if v == 3 => {
+            (*r.borrow_mut()) += 4;
+        }
+        v if v == 4 => {
+            (*r.borrow_mut()) += 8;
+            break;
+        }
+        _ => {
+            (*r.borrow_mut()) = -1_i32;
+            break;
+        }
+    });
+    return (*r.borrow());
+}
+pub fn fallthrough_default_21(x: i32, flag: i32) -> i32 {
+    let x: Value<i32> = Rc::new(RefCell::new(x));
+    let flag: Value<i32> = Rc::new(RefCell::new(flag));
+    let r: Value<i32> = Rc::new(RefCell::new(0));
+    switch!(match (*x.borrow()) {
+        v if v == 7 => {
+            if ((*flag.borrow()) != 0) {
+                (*r.borrow_mut()) = 100;
+                break;
+            };
+        }
+        _ => {
+            (*r.borrow_mut()) = 42;
+            break;
+        }
+    });
+    return (*r.borrow());
+}
+pub fn fallthrough_into_block_22(x: i32) -> i32 {
+    let x: Value<i32> = Rc::new(RefCell::new(x));
+    let r: Value<i32> = Rc::new(RefCell::new(0));
+    switch!(match (*x.borrow()) {
+        v if v == 1 => {
+            (*r.borrow_mut()) += 1;
+        }
+        v if v == 2 => {
+            let tmp: Value<i32> = Rc::new(RefCell::new(((*r.borrow()) * 10)));
+            (*r.borrow_mut()) = ((*tmp.borrow()) + 5);
+            break;
+        }
+        _ => {
+            (*r.borrow_mut()) = -1_i32;
+            break;
+        }
+    });
+    return (*r.borrow());
+}
+pub fn switch_complex_cond_23(p: Ptr<i32>, bias: i32) -> i32 {
+    let p: Value<Ptr<i32>> = Rc::new(RefCell::new(p));
+    let bias: Value<i32> = Rc::new(RefCell::new(bias));
+    'switch: {
+        let __match_cond = {
+            let _lhs = ((*p.borrow()).read());
+            _lhs + (*bias.borrow())
+        };
+        match __match_cond {
+            v if v == 0 => {
+                return 1;
+            }
+            v if v == 5 => {
+                return 2;
+            }
+            v if v == 10 => {
+                return 3;
+            }
+            _ => {
+                return 0;
+            }
+        }
+    };
+    panic!("ub: non-void function does not return a value")
+}
+pub fn switch_in_dowhile_24(n: i32) -> i32 {
+    let n: Value<i32> = Rc::new(RefCell::new(n));
+    let r: Value<i32> = Rc::new(RefCell::new(0));
+    let i: Value<i32> = Rc::new(RefCell::new(0));
+    'loop_: loop {
+        'switch: {
+            let __match_cond = (*i.borrow());
+            match __match_cond {
+                v if v == 0 => {
+                    (*r.borrow_mut()) += 1;
+                    break 'switch;
+                }
+                v if v == 1 => {
+                    (*r.borrow_mut()) += 10;
+                    break 'switch;
+                }
+                _ => {
+                    (*r.borrow_mut()) += 100;
+                    break 'switch;
+                }
+            }
+        };
+        (*i.borrow_mut()).prefix_inc();
+        if !((*i.borrow()) < (*n.borrow())) {
+            break;
+        }
+    }
+    return (*r.borrow());
+}
+pub fn continue_inside_switch_25(n: i32) -> i32 {
+    let n: Value<i32> = Rc::new(RefCell::new(n));
+    let r: Value<i32> = Rc::new(RefCell::new(0));
+    let i: Value<i32> = Rc::new(RefCell::new(0));
+    'loop_: while ((*i.borrow()) < (*n.borrow())) {
+        switch!(match (*i.borrow()) {
+            v if v == 0 || v == 2 || v == 4 => {
+                (*i.borrow_mut()).prefix_inc();
+                continue 'loop_;
+            }
+            _ => {
+                (*r.borrow_mut()) += (*i.borrow());
+                break;
+            }
+        });
+        (*r.borrow_mut()) += 1000;
+        (*i.borrow_mut()).prefix_inc();
+    }
+    return (*r.borrow());
+}
+pub fn case_then_default_26(x: i32) -> i32 {
+    let x: Value<i32> = Rc::new(RefCell::new(x));
+    let r: Value<i32> = Rc::new(RefCell::new(0));
+    'switch: {
+        let __match_cond = (*x.borrow());
+        match __match_cond {
+            v if v == 2 => {
+                (*r.borrow_mut()) = 20;
+                break 'switch;
+            }
+            _ => {
+                (*r.borrow_mut()) = 10;
+                break 'switch;
+            }
+        }
+    };
+    return (*r.borrow());
+}
+pub fn default_then_case_27(x: i32) -> i32 {
+    let x: Value<i32> = Rc::new(RefCell::new(x));
+    let r: Value<i32> = Rc::new(RefCell::new(0));
+    'switch: {
+        let __match_cond = (*x.borrow());
+        match __match_cond {
+            v if v == 1 => {
+                (*r.borrow_mut()) = 1;
+                break 'switch;
+            }
+            v if v == 3 => {
+                (*r.borrow_mut()) = 3;
+                break 'switch;
+            }
+            _ => {
+                (*r.borrow_mut()) = 77;
+                break 'switch;
+            }
+        }
+    };
+    return (*r.borrow());
+}
+pub fn cases_and_default_stacked_28(x: i32) -> i32 {
+    let x: Value<i32> = Rc::new(RefCell::new(x));
+    let r: Value<i32> = Rc::new(RefCell::new(0));
+    'switch: {
+        let __match_cond = (*x.borrow());
+        match __match_cond {
+            v if v == 3 => {
+                (*r.borrow_mut()) = 3;
+                break 'switch;
+            }
+            _ => {
+                (*r.borrow_mut()) = 42;
+                break 'switch;
+            }
+        }
+    };
+    return (*r.borrow());
+}
+pub fn stacked_with_inner_fallthrough_29(x: i32, flag: i32) -> i32 {
+    let x: Value<i32> = Rc::new(RefCell::new(x));
+    let flag: Value<i32> = Rc::new(RefCell::new(flag));
+    let r: Value<i32> = Rc::new(RefCell::new(0));
+    switch!(match (*x.borrow()) {
+        v if v == 1 || v == 2 || v == 3 => {
+            if !((*flag.borrow()) != 0) {
+                (*r.borrow_mut()) = 50;
+                break;
+            };
+        }
+        _ => {
+            (*r.borrow_mut()) = 999;
+            break;
+        }
+    });
+    return (*r.borrow());
+}
+pub fn borrow_in_condition_and_in_body_30(x: i32) -> i32 {
+    let x: Value<i32> = Rc::new(RefCell::new(x));
+    switch!(match (*x.borrow()) {
+        v if v == 0 => {}
+        _ => {
+            return ((*x.borrow()) + 1);
+        }
+    });
+    panic!("ub: non-void function does not return a value")
+}
+pub fn for_in_switch_break_31(n: i32) -> i32 {
+    let n: Value<i32> = Rc::new(RefCell::new(n));
+    let r: Value<i32> = Rc::new(RefCell::new(0));
+    'switch: {
+        let __match_cond = (*n.borrow());
+        match __match_cond {
+            v if v == 0 => {
+                let i: Value<i32> = Rc::new(RefCell::new(0));
+                'loop_: while ((*i.borrow()) < 10) {
+                    if ((*i.borrow()) == 3) {
+                        break;
+                    }
+                    (*r.borrow_mut()) += (*i.borrow());
+                    (*i.borrow_mut()).prefix_inc();
+                }
+                (*r.borrow_mut()) += 100;
+                break 'switch;
+            }
+            _ => {
+                (*r.borrow_mut()) = -1_i32;
+                break 'switch;
+            }
+        }
+    };
+    return (*r.borrow());
+}
+pub fn for_in_switch_continue_32(n: i32) -> i32 {
+    let n: Value<i32> = Rc::new(RefCell::new(n));
+    let r: Value<i32> = Rc::new(RefCell::new(0));
+    'switch: {
+        let __match_cond = (*n.borrow());
+        match __match_cond {
+            v if v == 0 => {
+                let i: Value<i32> = Rc::new(RefCell::new(0));
+                'loop_: while ((*i.borrow()) < 5) {
+                    if (((*i.borrow()) % 2) == 0) {
+                        (*i.borrow_mut()).prefix_inc();
+                        continue 'loop_;
+                    }
+                    (*r.borrow_mut()) += (*i.borrow());
+                    (*i.borrow_mut()).prefix_inc();
+                }
+                break 'switch;
+            }
+            _ => {
+                (*r.borrow_mut()) = -1_i32;
+                break 'switch;
+            }
+        }
+    };
+    return (*r.borrow());
+}
+pub fn while_in_switch_break_33(n: i32) -> i32 {
+    let n: Value<i32> = Rc::new(RefCell::new(n));
+    let r: Value<i32> = Rc::new(RefCell::new(0));
+    switch!(match (*n.borrow()) {
+        v if v == 0 => {
+            let i: Value<i32> = Rc::new(RefCell::new(0));
+            'loop_: while ((*i.borrow()) < 10) {
+                if ((*i.borrow()) == 4) {
+                    break;
+                }
+                (*r.borrow_mut()) += (*i.borrow());
+                (*i.borrow_mut()).prefix_inc();
+            }
+            (*r.borrow_mut()) += 1000;
+            break;
+        }
+        _ => {
+            (*r.borrow_mut()) = -1_i32;
+            break;
+        }
+    });
+    return (*r.borrow());
+}
+pub fn for_switch_for_break_34(n: i32) -> i32 {
+    let n: Value<i32> = Rc::new(RefCell::new(n));
+    let r: Value<i32> = Rc::new(RefCell::new(0));
+    let i: Value<i32> = Rc::new(RefCell::new(0));
+    'loop_: while ((*i.borrow()) < (*n.borrow())) {
+        'switch: {
+            let __match_cond = (*i.borrow());
+            match __match_cond {
+                v if v == 1 => {
+                    let j: Value<i32> = Rc::new(RefCell::new(0));
+                    'loop_: while ((*j.borrow()) < 10) {
+                        if ((*j.borrow()) == 2) {
+                            break;
+                        }
+                        (*r.borrow_mut()) += 1;
+                        (*j.borrow_mut()).prefix_inc();
+                    }
+                    (*r.borrow_mut()) += 100;
+                    break 'switch;
+                }
+                _ => {
+                    (*r.borrow_mut()) += 10;
+                    break 'switch;
+                }
+            }
+        };
+        (*i.borrow_mut()).prefix_inc();
+    }
+    return (*r.borrow());
+}
+pub fn main() {
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    assert!(
+        (({
+            let _x: i32 = 0;
+            basic_0(_x)
+        }) == 10)
+    );
+    assert!(
+        (({
+            let _x: i32 = 2;
+            basic_0(_x)
+        }) == 30)
+    );
+    assert!(
+        (({
+            let _x: i32 = 99;
+            basic_0(_x)
+        }) == 40)
+    );
+    assert!(
+        (({
+            let _x: i32 = 1;
+            stacked_1(_x)
+        }) == 100)
+    );
+    assert!(
+        (({
+            let _x: i32 = 3;
+            stacked_1(_x)
+        }) == 100)
+    );
+    assert!(
+        (({
+            let _x: i32 = 5;
+            stacked_1(_x)
+        }) == 200)
+    );
+    assert!(
+        (({
+            let _x: i32 = 9;
+            stacked_1(_x)
+        }) == 300)
+    );
+    assert!(
+        (({
+            let _x: i32 = 7;
+            no_default_2(_x)
+        }) == 1)
+    );
+    assert!(
+        (({
+            let _x: i32 = 42;
+            no_default_2(_x)
+        }) == -1_i32)
+    );
+    assert!(
+        (({
+            let _x: i32 = 1;
+            only_default_3(_x)
+        }) == 42)
+    );
+    assert!(
+        (({
+            let _x: i32 = 1;
+            default_middle_4(_x)
+        }) == 1)
+    );
+    assert!(
+        (({
+            let _x: i32 = 2;
+            default_middle_4(_x)
+        }) == 2)
+    );
+    assert!(
+        (({
+            let _x: i32 = 99;
+            default_middle_4(_x)
+        }) == 99)
+    );
+    assert!(
+        (({
+            let _x: i32 = 1;
+            default_first_5(_x)
+        }) == 1)
+    );
+    assert!(
+        (({
+            let _x: i32 = 99;
+            default_first_5(_x)
+        }) == 7)
+    );
+    assert!(
+        (({
+            let _x: i32 = 5;
+            empty_switch_6(_x)
+        }) == 5)
+    );
+    assert!(
+        (({
+            let _c: u8 = ('a' as u8);
+            switch_char_7(_c)
+        }) == 1)
+    );
+    assert!(
+        (({
+            let _c: u8 = ('b' as u8);
+            switch_char_7(_c)
+        }) == 2)
+    );
+    assert!(
+        (({
+            let _c: u8 = ('\n' as u8);
+            switch_char_7(_c)
+        }) == 3)
+    );
+    assert!(
+        (({
+            let _c: u8 = ('\0' as u8);
+            switch_char_7(_c)
+        }) == 4)
+    );
+    assert!(
+        (({
+            let _c: u8 = ('z' as u8);
+            switch_char_7(_c)
+        }) == 0)
+    );
+    assert!(
+        (({
+            let _c: Color = Color::kRed;
+            switch_enum_8(_c)
+        }) == 10)
+    );
+    assert!(
+        (({
+            let _c: Color = Color::kGreen;
+            switch_enum_8(_c)
+        }) == 20)
+    );
+    assert!(
+        (({
+            let _c: Color = Color::kBlue;
+            switch_enum_8(_c)
+        }) == 30)
+    );
+    assert!(
+        (({
+            let _x: i32 = 1;
+            compound_case_body_9(_x)
+        }) == 30)
+    );
+    assert!(
+        (({
+            let _x: i32 = 2;
+            compound_case_body_9(_x)
+        }) == 99)
+    );
+    assert!(
+        (({
+            let _x: i32 = 9;
+            compound_case_body_9(_x)
+        }) == -1_i32)
+    );
+    assert!(
+        (({
+            let _a: i32 = 1;
+            let _b: i32 = 10;
+            nested_10(_a, _b)
+        }) == 12)
+    );
+    assert!(
+        (({
+            let _a: i32 = 1;
+            let _b: i32 = 99;
+            nested_10(_a, _b)
+        }) == 14)
+    );
+    assert!(
+        (({
+            let _a: i32 = 2;
+            let _b: i32 = 0;
+            nested_10(_a, _b)
+        }) == 2)
+    );
+    assert!(
+        (({
+            let _a: i32 = 3;
+            let _b: i32 = 3;
+            nested_10(_a, _b)
+        }) == -1_i32)
+    );
+    assert!(
+        (({
+            let _n: i32 = 6;
+            switch_in_loop_11(_n)
+        }) == 72)
+    );
+    assert!(
+        (({
+            let _x: i32 = 2;
+            stacked_block_12(_x)
+        }) == 5)
+    );
+    assert!(
+        (({
+            let _x: i32 = 9;
+            stacked_block_12(_x)
+        }) == 0)
+    );
+    assert!(
+        (({
+            let _x: i32 = 0;
+            switch_on_call_14(_x)
+        }) == 100)
+    );
+    assert!(
+        (({
+            let _x: i32 = 1;
+            switch_on_call_14(_x)
+        }) == 200)
+    );
+    assert!(
+        (({
+            let _x: i32 = 2;
+            switch_on_call_14(_x)
+        }) == 400)
+    );
+    assert!(
+        (({
+            let _x: i32 = 99;
+            switch_on_call_14(_x)
+        }) == -1_i32)
+    );
+    assert!(
+        (({
+            let _x: i32 = 0;
+            switch_on_assignment_15(_x)
+        }) == 10)
+    );
+    assert!(
+        (({
+            let _x: i32 = 1;
+            switch_on_assignment_15(_x)
+        }) == 20)
+    );
+    assert!(
+        (({
+            let _x: i32 = 9;
+            switch_on_assignment_15(_x)
+        }) == 10)
+    );
+    assert!(
+        (({
+            let _x: i32 = -1_i32;
+            mixed_literal_cases_16(_x)
+        }) == 1)
+    );
+    assert!(
+        (({
+            let _x: i32 = 16;
+            mixed_literal_cases_16(_x)
+        }) == 2)
+    );
+    assert!(
+        (({
+            let _x: i32 = 65152;
+            mixed_literal_cases_16(_x)
+        }) == 3)
+    );
+    assert!(
+        (({
+            let _x: i32 = -255_i32;
+            mixed_literal_cases_16(_x)
+        }) == 4)
+    );
+    assert!(
+        (({
+            let _x: i32 = 7;
+            mixed_literal_cases_16(_x)
+        }) == 0)
+    );
+    assert!(
+        (({
+            let _x: i32 = 0;
+            mixed_return_break_17(_x)
+        }) == 100)
+    );
+    assert!(
+        (({
+            let _x: i32 = 1;
+            mixed_return_break_17(_x)
+        }) == 10)
+    );
+    assert!(
+        (({
+            let _x: i32 = 2;
+            mixed_return_break_17(_x)
+        }) == 200)
+    );
+    assert!(
+        (({
+            let _x: i32 = 99;
+            mixed_return_break_17(_x)
+        }) == 99)
+    );
+    assert!(
+        (({
+            let _x: i32 = 1;
+            empty_case_with_break_18(_x)
+        }) == 5)
+    );
+    assert!(
+        (({
+            let _x: i32 = 2;
+            empty_case_with_break_18(_x)
+        }) == 2)
+    );
+    assert!(
+        (({
+            let _x: i32 = 9;
+            empty_case_with_break_18(_x)
+        }) == 9)
+    );
+    assert!(
+        (({
+            let _x: i32 = 1;
+            fallthrough_one_19(_x)
+        }) == 30)
+    );
+    assert!(
+        (({
+            let _x: i32 = 2;
+            fallthrough_one_19(_x)
+        }) == 20)
+    );
+    assert!(
+        (({
+            let _x: i32 = 99;
+            fallthrough_one_19(_x)
+        }) == -1_i32)
+    );
+    assert!(
+        (({
+            let _x: i32 = 1;
+            fallthrough_chain_20(_x)
+        }) == 15)
+    );
+    assert!(
+        (({
+            let _x: i32 = 2;
+            fallthrough_chain_20(_x)
+        }) == 14)
+    );
+    assert!(
+        (({
+            let _x: i32 = 3;
+            fallthrough_chain_20(_x)
+        }) == 12)
+    );
+    assert!(
+        (({
+            let _x: i32 = 4;
+            fallthrough_chain_20(_x)
+        }) == 8)
+    );
+    assert!(
+        (({
+            let _x: i32 = 99;
+            fallthrough_chain_20(_x)
+        }) == -1_i32)
+    );
+    assert!(
+        (({
+            let _x: i32 = 7;
+            let _flag: i32 = 0;
+            fallthrough_default_21(_x, _flag)
+        }) == 42)
+    );
+    assert!(
+        (({
+            let _x: i32 = 7;
+            let _flag: i32 = 1;
+            fallthrough_default_21(_x, _flag)
+        }) == 100)
+    );
+    assert!(
+        (({
+            let _x: i32 = 99;
+            let _flag: i32 = 0;
+            fallthrough_default_21(_x, _flag)
+        }) == 42)
+    );
+    assert!(
+        (({
+            let _x: i32 = 1;
+            fallthrough_into_block_22(_x)
+        }) == 15)
+    );
+    assert!(
+        (({
+            let _x: i32 = 2;
+            fallthrough_into_block_22(_x)
+        }) == 5)
+    );
+    assert!(
+        (({
+            let _x: i32 = 99;
+            fallthrough_into_block_22(_x)
+        }) == -1_i32)
+    );
+    let p_val: Value<i32> = Rc::new(RefCell::new(5));
+    assert!(
+        (({
+            let _p: Ptr<i32> = (p_val.as_pointer());
+            let _bias: i32 = 0;
+            switch_complex_cond_23(_p, _bias)
+        }) == 2)
+    );
+    assert!(
+        (({
+            let _p: Ptr<i32> = (p_val.as_pointer());
+            let _bias: i32 = 5;
+            switch_complex_cond_23(_p, _bias)
+        }) == 3)
+    );
+    assert!(
+        (({
+            let _p: Ptr<i32> = (p_val.as_pointer());
+            let _bias: i32 = -5_i32;
+            switch_complex_cond_23(_p, _bias)
+        }) == 1)
+    );
+    assert!(
+        (({
+            let _p: Ptr<i32> = (p_val.as_pointer());
+            let _bias: i32 = 99;
+            switch_complex_cond_23(_p, _bias)
+        }) == 0)
+    );
+    assert!(
+        (({
+            let _n: i32 = 1;
+            switch_in_dowhile_24(_n)
+        }) == 1)
+    );
+    assert!(
+        (({
+            let _n: i32 = 3;
+            switch_in_dowhile_24(_n)
+        }) == ((1 + 10) + 100))
+    );
+    assert!(
+        (({
+            let _n: i32 = 6;
+            continue_inside_switch_25(_n)
+        }) == ((((1 + 3) + 5) as i32) + (3 * 1000)))
+    );
+    assert!(
+        (({
+            let _x: i32 = 1;
+            case_then_default_26(_x)
+        }) == 10)
+    );
+    assert!(
+        (({
+            let _x: i32 = 2;
+            case_then_default_26(_x)
+        }) == 20)
+    );
+    assert!(
+        (({
+            let _x: i32 = 99;
+            case_then_default_26(_x)
+        }) == 10)
+    );
+    assert!(
+        (({
+            let _x: i32 = 1;
+            default_then_case_27(_x)
+        }) == 1)
+    );
+    assert!(
+        (({
+            let _x: i32 = 2;
+            default_then_case_27(_x)
+        }) == 77)
+    );
+    assert!(
+        (({
+            let _x: i32 = 3;
+            default_then_case_27(_x)
+        }) == 3)
+    );
+    assert!(
+        (({
+            let _x: i32 = 99;
+            default_then_case_27(_x)
+        }) == 77)
+    );
+    assert!(
+        (({
+            let _x: i32 = 1;
+            cases_and_default_stacked_28(_x)
+        }) == 42)
+    );
+    assert!(
+        (({
+            let _x: i32 = 2;
+            cases_and_default_stacked_28(_x)
+        }) == 42)
+    );
+    assert!(
+        (({
+            let _x: i32 = 3;
+            cases_and_default_stacked_28(_x)
+        }) == 3)
+    );
+    assert!(
+        (({
+            let _x: i32 = 99;
+            cases_and_default_stacked_28(_x)
+        }) == 42)
+    );
+    assert!(
+        (({
+            let _x: i32 = 1;
+            let _flag: i32 = 0;
+            stacked_with_inner_fallthrough_29(_x, _flag)
+        }) == 50)
+    );
+    assert!(
+        (({
+            let _x: i32 = 2;
+            let _flag: i32 = 1;
+            stacked_with_inner_fallthrough_29(_x, _flag)
+        }) == 999)
+    );
+    assert!(
+        (({
+            let _x: i32 = 99;
+            let _flag: i32 = 0;
+            stacked_with_inner_fallthrough_29(_x, _flag)
+        }) == 999)
+    );
+    assert!(
+        (({
+            let _x: i32 = 0;
+            borrow_in_condition_and_in_body_30(_x)
+        }) == 1)
+    );
+    assert!(
+        (({
+            let _x: i32 = 1;
+            borrow_in_condition_and_in_body_30(_x)
+        }) == 2)
+    );
+    assert!(
+        (({
+            let _n: i32 = 0;
+            for_in_switch_break_31(_n)
+        }) == 103)
+    );
+    assert!(
+        (({
+            let _n: i32 = 99;
+            for_in_switch_break_31(_n)
+        }) == -1_i32)
+    );
+    assert!(
+        (({
+            let _n: i32 = 0;
+            for_in_switch_continue_32(_n)
+        }) == 4)
+    );
+    assert!(
+        (({
+            let _n: i32 = 99;
+            for_in_switch_continue_32(_n)
+        }) == -1_i32)
+    );
+    assert!(
+        (({
+            let _n: i32 = 0;
+            while_in_switch_break_33(_n)
+        }) == 1006)
+    );
+    assert!(
+        (({
+            let _n: i32 = 99;
+            while_in_switch_break_33(_n)
+        }) == -1_i32)
+    );
+    assert!(
+        (({
+            let _n: i32 = 3;
+            for_switch_for_break_34(_n)
+        }) == 122)
+    );
+    return 0;
+}
diff --git a/tests/unit/out/unsafe/switch.rs b/tests/unit/out/unsafe/switch.rs
new file mode 100644
index 00000000..becb0560
--- /dev/null
+++ b/tests/unit/out/unsafe/switch.rs
@@ -0,0 +1,1328 @@
+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 unsafe fn basic_0(mut x: i32) -> i32 {
+    let mut r: i32 = 0;
+    'switch: {
+        let __match_cond = x;
+        match __match_cond {
+            v if v == 0 => {
+                r = 10;
+                break 'switch;
+            }
+            v if v == 1 => {
+                r = 20;
+                break 'switch;
+            }
+            v if v == 2 => {
+                r = 30;
+                break 'switch;
+            }
+            _ => {
+                r = 40;
+                break 'switch;
+            }
+        }
+    };
+    return r;
+}
+pub unsafe fn stacked_1(mut x: i32) -> i32 {
+    let mut r: i32 = 0;
+    'switch: {
+        let __match_cond = x;
+        match __match_cond {
+            v if v == 1 || v == 2 || v == 3 => {
+                r = 100;
+                break 'switch;
+            }
+            v if v == 4 || v == 5 => {
+                r = 200;
+                break 'switch;
+            }
+            _ => {
+                r = 300;
+                break 'switch;
+            }
+        }
+    };
+    return r;
+}
+pub unsafe fn no_default_2(mut x: i32) -> i32 {
+    let mut r: i32 = -1_i32;
+    'switch: {
+        let __match_cond = x;
+        match __match_cond {
+            v if v == 7 => {
+                r = 1;
+                break 'switch;
+            }
+            v if v == 8 => {
+                r = 2;
+                break 'switch;
+            }
+            _ => {}
+        }
+    };
+    return r;
+}
+pub unsafe fn only_default_3(mut x: i32) -> i32 {
+    let mut r: i32 = 0;
+    'switch: {
+        let __match_cond = x;
+        match __match_cond {
+            _ => {
+                r = 42;
+                break 'switch;
+            }
+        }
+    };
+    return r;
+}
+pub unsafe fn default_middle_4(mut x: i32) -> i32 {
+    let mut r: i32 = 0;
+    'switch: {
+        let __match_cond = x;
+        match __match_cond {
+            v if v == 1 => {
+                r = 1;
+                break 'switch;
+            }
+            v if v == 2 => {
+                r = 2;
+                break 'switch;
+            }
+            _ => {
+                r = 99;
+                break 'switch;
+            }
+        }
+    };
+    return r;
+}
+pub unsafe fn default_first_5(mut x: i32) -> i32 {
+    let mut r: i32 = 0;
+    'switch: {
+        let __match_cond = x;
+        match __match_cond {
+            v if v == 1 => {
+                r = 1;
+                break 'switch;
+            }
+            v if v == 2 => {
+                r = 2;
+                break 'switch;
+            }
+            _ => {
+                r = 7;
+                break 'switch;
+            }
+        }
+    };
+    return r;
+}
+pub unsafe fn empty_switch_6(mut x: i32) -> i32 {
+    'switch: {
+        let __match_cond = x;
+        match __match_cond {
+            _ => {}
+        }
+    };
+    return x;
+}
+pub unsafe fn switch_char_7(mut c: u8) -> i32 {
+    'switch: {
+        let __match_cond = (c as i32);
+        match __match_cond {
+            v if v == (('a' as u8) as i32) => {
+                return 1;
+            }
+            v if v == (('b' as u8) as i32) => {
+                return 2;
+            }
+            v if v == (('\n' as u8) as i32) => {
+                return 3;
+            }
+            v if v == (('\0' as u8) as i32) => {
+                return 4;
+            }
+            _ => {
+                return 0;
+            }
+        }
+    };
+    panic!("ub: non-void function does not return a value")
+}
+#[derive(Clone, Copy, PartialEq, Debug, Default)]
+enum Color {
+    #[default]
+    kRed = 0,
+    kGreen = 1,
+    kBlue = 2,
+}
+pub unsafe fn switch_enum_8(mut c: Color) -> i32 {
+    'switch: {
+        let __match_cond = (c as i32);
+        match __match_cond {
+            v if v == (Color::kRed as i32) => {
+                return 10;
+            }
+            v if v == (Color::kGreen as i32) => {
+                return 20;
+            }
+            v if v == (Color::kBlue as i32) => {
+                return 30;
+            }
+            _ => {}
+        }
+    };
+    return -1_i32;
+}
+pub unsafe fn compound_case_body_9(mut x: i32) -> i32 {
+    let mut r: i32 = 0;
+    switch!(match x {
+        v if v == 1 => {
+            let mut y: i32 = 10;
+            let mut z: i32 = 20;
+            r = ((y) + (z));
+            break;
+        }
+        v if v == 2 => {
+            let mut y: i32 = 100;
+            r = ((y) - (1));
+            break;
+        }
+        _ => {
+            r = -1_i32;
+            break;
+        }
+    });
+    return r;
+}
+pub unsafe fn nested_10(mut a: i32, mut b: i32) -> i32 {
+    let mut r: i32 = 0;
+    'switch: {
+        let __match_cond = a;
+        match __match_cond {
+            v if v == 1 => {
+                'switch: {
+                    let __match_cond = b;
+                    match __match_cond {
+                        v if v == 10 => {
+                            r = 11;
+                            break 'switch;
+                        }
+                        v if v == 20 => {
+                            r = 12;
+                            break 'switch;
+                        }
+                        _ => {
+                            r = 13;
+                            break 'switch;
+                        }
+                    }
+                };
+                r += 1;
+                break 'switch;
+            }
+            v if v == 2 => {
+                r = 2;
+                break 'switch;
+            }
+            _ => {
+                r = -1_i32;
+                break 'switch;
+            }
+        }
+    };
+    return r;
+}
+pub unsafe fn switch_in_loop_11(mut n: i32) -> i32 {
+    let mut r: i32 = 0;
+    let mut i: i32 = 0;
+    'loop_: while ((i) < (n)) {
+        'switch: {
+            let __match_cond = ((i) % (3));
+            match __match_cond {
+                v if v == 0 => {
+                    r += 1;
+                    break 'switch;
+                }
+                v if v == 1 => {
+                    r += 2;
+                    break 'switch;
+                }
+                _ => {
+                    r += 3;
+                    break 'switch;
+                }
+            }
+        };
+        r += 10;
+        i.prefix_inc();
+    }
+    return r;
+}
+pub unsafe fn stacked_block_12(mut x: i32) -> i32 {
+    let mut r: i32 = 0;
+    switch!(match x {
+        v if v == 1 || v == 2 || v == 3 => {
+            let mut y: i32 = ((x) * (2));
+            r = ((y) + (1));
+            break;
+        }
+        _ => {
+            r = 0;
+            break;
+        }
+    });
+    return r;
+}
+pub unsafe fn double_it_13(mut v: i32) -> i32 {
+    return ((v) * (2));
+}
+pub unsafe fn switch_on_call_14(mut x: i32) -> i32 {
+    'switch: {
+        let __match_cond = (unsafe {
+            let _v: i32 = x;
+            double_it_13(_v)
+        });
+        match __match_cond {
+            v if v == 0 => {
+                return 100;
+            }
+            v if v == 2 => {
+                return 200;
+            }
+            v if v == 4 => {
+                return 400;
+            }
+            _ => {
+                return -1_i32;
+            }
+        }
+    };
+    panic!("ub: non-void function does not return a value")
+}
+pub unsafe fn switch_on_assignment_15(mut x: i32) -> i32 {
+    let mut y: i32 = 0;
+    let mut r: i32 = 0;
+    'switch: {
+        let __match_cond = {
+            y = ((x) + (1));
+            y
+        };
+        match __match_cond {
+            v if v == 1 => {
+                r = 10;
+                break 'switch;
+            }
+            v if v == 2 => {
+                r = 20;
+                break 'switch;
+            }
+            _ => {
+                r = y;
+                break 'switch;
+            }
+        }
+    };
+    return r;
+}
+pub unsafe fn mixed_literal_cases_16(mut x: i32) -> i32 {
+    'switch: {
+        let __match_cond = x;
+        match __match_cond {
+            v if v == -1_i32 => {
+                return 1;
+            }
+            v if v == 16 => {
+                return 2;
+            }
+            v if v == 65152 => {
+                return 3;
+            }
+            v if v == -255_i32 => {
+                return 4;
+            }
+            _ => {
+                return 0;
+            }
+        }
+    };
+    panic!("ub: non-void function does not return a value")
+}
+pub unsafe fn mixed_return_break_17(mut x: i32) -> i32 {
+    let mut r: i32 = -1_i32;
+    'switch: {
+        let __match_cond = x;
+        match __match_cond {
+            v if v == 0 => {
+                return 100;
+            }
+            v if v == 1 => {
+                r = 10;
+                break 'switch;
+            }
+            v if v == 2 => {
+                return 200;
+            }
+            _ => {
+                r = 99;
+                break 'switch;
+            }
+        }
+    };
+    return r;
+}
+pub unsafe fn empty_case_with_break_18(mut x: i32) -> i32 {
+    let mut r: i32 = 5;
+    'switch: {
+        let __match_cond = x;
+        match __match_cond {
+            v if v == 1 => {
+                break 'switch;
+            }
+            v if v == 2 => {
+                r = 2;
+                break 'switch;
+            }
+            _ => {
+                r = 9;
+                break 'switch;
+            }
+        }
+    };
+    return r;
+}
+pub unsafe fn fallthrough_one_19(mut x: i32) -> i32 {
+    let mut r: i32 = 0;
+    switch!(match x {
+        v if v == 1 => {
+            r += 10;
+        }
+        v if v == 2 => {
+            r += 20;
+            break;
+        }
+        _ => {
+            r = -1_i32;
+            break;
+        }
+    });
+    return r;
+}
+pub unsafe fn fallthrough_chain_20(mut x: i32) -> i32 {
+    let mut r: i32 = 0;
+    switch!(match x {
+        v if v == 1 => {
+            r += 1;
+        }
+        v if v == 2 => {
+            r += 2;
+        }
+        v if v == 3 => {
+            r += 4;
+        }
+        v if v == 4 => {
+            r += 8;
+            break;
+        }
+        _ => {
+            r = -1_i32;
+            break;
+        }
+    });
+    return r;
+}
+pub unsafe fn fallthrough_default_21(mut x: i32, mut flag: i32) -> i32 {
+    let mut r: i32 = 0;
+    switch!(match x {
+        v if v == 7 => {
+            if (flag != 0) {
+                r = 100;
+                break;
+            };
+        }
+        _ => {
+            r = 42;
+            break;
+        }
+    });
+    return r;
+}
+pub unsafe fn fallthrough_into_block_22(mut x: i32) -> i32 {
+    let mut r: i32 = 0;
+    switch!(match x {
+        v if v == 1 => {
+            r += 1;
+        }
+        v if v == 2 => {
+            let mut tmp: i32 = ((r) * (10));
+            r = ((tmp) + (5));
+            break;
+        }
+        _ => {
+            r = -1_i32;
+            break;
+        }
+    });
+    return r;
+}
+pub unsafe fn switch_complex_cond_23(mut p: *mut i32, mut bias: i32) -> i32 {
+    'switch: {
+        let __match_cond = ((*p) + (bias));
+        match __match_cond {
+            v if v == 0 => {
+                return 1;
+            }
+            v if v == 5 => {
+                return 2;
+            }
+            v if v == 10 => {
+                return 3;
+            }
+            _ => {
+                return 0;
+            }
+        }
+    };
+    panic!("ub: non-void function does not return a value")
+}
+pub unsafe fn switch_in_dowhile_24(mut n: i32) -> i32 {
+    let mut r: i32 = 0;
+    let mut i: i32 = 0;
+    'loop_: loop {
+        'switch: {
+            let __match_cond = i;
+            match __match_cond {
+                v if v == 0 => {
+                    r += 1;
+                    break 'switch;
+                }
+                v if v == 1 => {
+                    r += 10;
+                    break 'switch;
+                }
+                _ => {
+                    r += 100;
+                    break 'switch;
+                }
+            }
+        };
+        i.prefix_inc();
+        if !((i) < (n)) {
+            break;
+        }
+    }
+    return r;
+}
+pub unsafe fn continue_inside_switch_25(mut n: i32) -> i32 {
+    let mut r: i32 = 0;
+    let mut i: i32 = 0;
+    'loop_: while ((i) < (n)) {
+        switch!(match i {
+            v if v == 0 || v == 2 || v == 4 => {
+                i.prefix_inc();
+                continue 'loop_;
+            }
+            _ => {
+                r += i;
+                break;
+            }
+        });
+        r += 1000;
+        i.prefix_inc();
+    }
+    return r;
+}
+pub unsafe fn case_then_default_26(mut x: i32) -> i32 {
+    let mut r: i32 = 0;
+    'switch: {
+        let __match_cond = x;
+        match __match_cond {
+            v if v == 2 => {
+                r = 20;
+                break 'switch;
+            }
+            _ => {
+                r = 10;
+                break 'switch;
+            }
+        }
+    };
+    return r;
+}
+pub unsafe fn default_then_case_27(mut x: i32) -> i32 {
+    let mut r: i32 = 0;
+    'switch: {
+        let __match_cond = x;
+        match __match_cond {
+            v if v == 1 => {
+                r = 1;
+                break 'switch;
+            }
+            v if v == 3 => {
+                r = 3;
+                break 'switch;
+            }
+            _ => {
+                r = 77;
+                break 'switch;
+            }
+        }
+    };
+    return r;
+}
+pub unsafe fn cases_and_default_stacked_28(mut x: i32) -> i32 {
+    let mut r: i32 = 0;
+    'switch: {
+        let __match_cond = x;
+        match __match_cond {
+            v if v == 3 => {
+                r = 3;
+                break 'switch;
+            }
+            _ => {
+                r = 42;
+                break 'switch;
+            }
+        }
+    };
+    return r;
+}
+pub unsafe fn stacked_with_inner_fallthrough_29(mut x: i32, mut flag: i32) -> i32 {
+    let mut r: i32 = 0;
+    switch!(match x {
+        v if v == 1 || v == 2 || v == 3 => {
+            if !(flag != 0) {
+                r = 50;
+                break;
+            };
+        }
+        _ => {
+            r = 999;
+            break;
+        }
+    });
+    return r;
+}
+pub unsafe fn borrow_in_condition_and_in_body_30(mut x: i32) -> i32 {
+    switch!(match x {
+        v if v == 0 => {}
+        _ => {
+            return ((x) + (1));
+        }
+    });
+    panic!("ub: non-void function does not return a value")
+}
+pub unsafe fn for_in_switch_break_31(mut n: i32) -> i32 {
+    let mut r: i32 = 0;
+    'switch: {
+        let __match_cond = n;
+        match __match_cond {
+            v if v == 0 => {
+                let mut i: i32 = 0;
+                'loop_: while ((i) < (10)) {
+                    if ((i) == (3)) {
+                        break;
+                    }
+                    r += i;
+                    i.prefix_inc();
+                }
+                r += 100;
+                break 'switch;
+            }
+            _ => {
+                r = -1_i32;
+                break 'switch;
+            }
+        }
+    };
+    return r;
+}
+pub unsafe fn for_in_switch_continue_32(mut n: i32) -> i32 {
+    let mut r: i32 = 0;
+    'switch: {
+        let __match_cond = n;
+        match __match_cond {
+            v if v == 0 => {
+                let mut i: i32 = 0;
+                'loop_: while ((i) < (5)) {
+                    if (((i) % (2)) == (0)) {
+                        i.prefix_inc();
+                        continue 'loop_;
+                    }
+                    r += i;
+                    i.prefix_inc();
+                }
+                break 'switch;
+            }
+            _ => {
+                r = -1_i32;
+                break 'switch;
+            }
+        }
+    };
+    return r;
+}
+pub unsafe fn while_in_switch_break_33(mut n: i32) -> i32 {
+    let mut r: i32 = 0;
+    switch!(match n {
+        v if v == 0 => {
+            let mut i: i32 = 0;
+            'loop_: while ((i) < (10)) {
+                if ((i) == (4)) {
+                    break;
+                }
+                r += i;
+                i.prefix_inc();
+            }
+            r += 1000;
+            break;
+        }
+        _ => {
+            r = -1_i32;
+            break;
+        }
+    });
+    return r;
+}
+pub unsafe fn for_switch_for_break_34(mut n: i32) -> i32 {
+    let mut r: i32 = 0;
+    let mut i: i32 = 0;
+    'loop_: while ((i) < (n)) {
+        'switch: {
+            let __match_cond = i;
+            match __match_cond {
+                v if v == 1 => {
+                    let mut j: i32 = 0;
+                    'loop_: while ((j) < (10)) {
+                        if ((j) == (2)) {
+                            break;
+                        }
+                        r += 1;
+                        j.prefix_inc();
+                    }
+                    r += 100;
+                    break 'switch;
+                }
+                _ => {
+                    r += 10;
+                    break 'switch;
+                }
+            }
+        };
+        i.prefix_inc();
+    }
+    return r;
+}
+pub fn main() {
+    unsafe {
+        std::process::exit(main_0() as i32);
+    }
+}
+unsafe fn main_0() -> i32 {
+    assert!(
+        ((unsafe {
+            let _x: i32 = 0;
+            basic_0(_x)
+        }) == (10))
+    );
+    assert!(
+        ((unsafe {
+            let _x: i32 = 2;
+            basic_0(_x)
+        }) == (30))
+    );
+    assert!(
+        ((unsafe {
+            let _x: i32 = 99;
+            basic_0(_x)
+        }) == (40))
+    );
+    assert!(
+        ((unsafe {
+            let _x: i32 = 1;
+            stacked_1(_x)
+        }) == (100))
+    );
+    assert!(
+        ((unsafe {
+            let _x: i32 = 3;
+            stacked_1(_x)
+        }) == (100))
+    );
+    assert!(
+        ((unsafe {
+            let _x: i32 = 5;
+            stacked_1(_x)
+        }) == (200))
+    );
+    assert!(
+        ((unsafe {
+            let _x: i32 = 9;
+            stacked_1(_x)
+        }) == (300))
+    );
+    assert!(
+        ((unsafe {
+            let _x: i32 = 7;
+            no_default_2(_x)
+        }) == (1))
+    );
+    assert!(
+        ((unsafe {
+            let _x: i32 = 42;
+            no_default_2(_x)
+        }) == (-1_i32))
+    );
+    assert!(
+        ((unsafe {
+            let _x: i32 = 1;
+            only_default_3(_x)
+        }) == (42))
+    );
+    assert!(
+        ((unsafe {
+            let _x: i32 = 1;
+            default_middle_4(_x)
+        }) == (1))
+    );
+    assert!(
+        ((unsafe {
+            let _x: i32 = 2;
+            default_middle_4(_x)
+        }) == (2))
+    );
+    assert!(
+        ((unsafe {
+            let _x: i32 = 99;
+            default_middle_4(_x)
+        }) == (99))
+    );
+    assert!(
+        ((unsafe {
+            let _x: i32 = 1;
+            default_first_5(_x)
+        }) == (1))
+    );
+    assert!(
+        ((unsafe {
+            let _x: i32 = 99;
+            default_first_5(_x)
+        }) == (7))
+    );
+    assert!(
+        ((unsafe {
+            let _x: i32 = 5;
+            empty_switch_6(_x)
+        }) == (5))
+    );
+    assert!(
+        ((unsafe {
+            let _c: u8 = ('a' as u8);
+            switch_char_7(_c)
+        }) == (1))
+    );
+    assert!(
+        ((unsafe {
+            let _c: u8 = ('b' as u8);
+            switch_char_7(_c)
+        }) == (2))
+    );
+    assert!(
+        ((unsafe {
+            let _c: u8 = ('\n' as u8);
+            switch_char_7(_c)
+        }) == (3))
+    );
+    assert!(
+        ((unsafe {
+            let _c: u8 = ('\0' as u8);
+            switch_char_7(_c)
+        }) == (4))
+    );
+    assert!(
+        ((unsafe {
+            let _c: u8 = ('z' as u8);
+            switch_char_7(_c)
+        }) == (0))
+    );
+    assert!(
+        ((unsafe {
+            let _c: Color = Color::kRed;
+            switch_enum_8(_c)
+        }) == (10))
+    );
+    assert!(
+        ((unsafe {
+            let _c: Color = Color::kGreen;
+            switch_enum_8(_c)
+        }) == (20))
+    );
+    assert!(
+        ((unsafe {
+            let _c: Color = Color::kBlue;
+            switch_enum_8(_c)
+        }) == (30))
+    );
+    assert!(
+        ((unsafe {
+            let _x: i32 = 1;
+            compound_case_body_9(_x)
+        }) == (30))
+    );
+    assert!(
+        ((unsafe {
+            let _x: i32 = 2;
+            compound_case_body_9(_x)
+        }) == (99))
+    );
+    assert!(
+        ((unsafe {
+            let _x: i32 = 9;
+            compound_case_body_9(_x)
+        }) == (-1_i32))
+    );
+    assert!(
+        ((unsafe {
+            let _a: i32 = 1;
+            let _b: i32 = 10;
+            nested_10(_a, _b)
+        }) == (12))
+    );
+    assert!(
+        ((unsafe {
+            let _a: i32 = 1;
+            let _b: i32 = 99;
+            nested_10(_a, _b)
+        }) == (14))
+    );
+    assert!(
+        ((unsafe {
+            let _a: i32 = 2;
+            let _b: i32 = 0;
+            nested_10(_a, _b)
+        }) == (2))
+    );
+    assert!(
+        ((unsafe {
+            let _a: i32 = 3;
+            let _b: i32 = 3;
+            nested_10(_a, _b)
+        }) == (-1_i32))
+    );
+    assert!(
+        ((unsafe {
+            let _n: i32 = 6;
+            switch_in_loop_11(_n)
+        }) == (72))
+    );
+    assert!(
+        ((unsafe {
+            let _x: i32 = 2;
+            stacked_block_12(_x)
+        }) == (5))
+    );
+    assert!(
+        ((unsafe {
+            let _x: i32 = 9;
+            stacked_block_12(_x)
+        }) == (0))
+    );
+    assert!(
+        ((unsafe {
+            let _x: i32 = 0;
+            switch_on_call_14(_x)
+        }) == (100))
+    );
+    assert!(
+        ((unsafe {
+            let _x: i32 = 1;
+            switch_on_call_14(_x)
+        }) == (200))
+    );
+    assert!(
+        ((unsafe {
+            let _x: i32 = 2;
+            switch_on_call_14(_x)
+        }) == (400))
+    );
+    assert!(
+        ((unsafe {
+            let _x: i32 = 99;
+            switch_on_call_14(_x)
+        }) == (-1_i32))
+    );
+    assert!(
+        ((unsafe {
+            let _x: i32 = 0;
+            switch_on_assignment_15(_x)
+        }) == (10))
+    );
+    assert!(
+        ((unsafe {
+            let _x: i32 = 1;
+            switch_on_assignment_15(_x)
+        }) == (20))
+    );
+    assert!(
+        ((unsafe {
+            let _x: i32 = 9;
+            switch_on_assignment_15(_x)
+        }) == (10))
+    );
+    assert!(
+        ((unsafe {
+            let _x: i32 = -1_i32;
+            mixed_literal_cases_16(_x)
+        }) == (1))
+    );
+    assert!(
+        ((unsafe {
+            let _x: i32 = 16;
+            mixed_literal_cases_16(_x)
+        }) == (2))
+    );
+    assert!(
+        ((unsafe {
+            let _x: i32 = 65152;
+            mixed_literal_cases_16(_x)
+        }) == (3))
+    );
+    assert!(
+        ((unsafe {
+            let _x: i32 = -255_i32;
+            mixed_literal_cases_16(_x)
+        }) == (4))
+    );
+    assert!(
+        ((unsafe {
+            let _x: i32 = 7;
+            mixed_literal_cases_16(_x)
+        }) == (0))
+    );
+    assert!(
+        ((unsafe {
+            let _x: i32 = 0;
+            mixed_return_break_17(_x)
+        }) == (100))
+    );
+    assert!(
+        ((unsafe {
+            let _x: i32 = 1;
+            mixed_return_break_17(_x)
+        }) == (10))
+    );
+    assert!(
+        ((unsafe {
+            let _x: i32 = 2;
+            mixed_return_break_17(_x)
+        }) == (200))
+    );
+    assert!(
+        ((unsafe {
+            let _x: i32 = 99;
+            mixed_return_break_17(_x)
+        }) == (99))
+    );
+    assert!(
+        ((unsafe {
+            let _x: i32 = 1;
+            empty_case_with_break_18(_x)
+        }) == (5))
+    );
+    assert!(
+        ((unsafe {
+            let _x: i32 = 2;
+            empty_case_with_break_18(_x)
+        }) == (2))
+    );
+    assert!(
+        ((unsafe {
+            let _x: i32 = 9;
+            empty_case_with_break_18(_x)
+        }) == (9))
+    );
+    assert!(
+        ((unsafe {
+            let _x: i32 = 1;
+            fallthrough_one_19(_x)
+        }) == (30))
+    );
+    assert!(
+        ((unsafe {
+            let _x: i32 = 2;
+            fallthrough_one_19(_x)
+        }) == (20))
+    );
+    assert!(
+        ((unsafe {
+            let _x: i32 = 99;
+            fallthrough_one_19(_x)
+        }) == (-1_i32))
+    );
+    assert!(
+        ((unsafe {
+            let _x: i32 = 1;
+            fallthrough_chain_20(_x)
+        }) == (15))
+    );
+    assert!(
+        ((unsafe {
+            let _x: i32 = 2;
+            fallthrough_chain_20(_x)
+        }) == (14))
+    );
+    assert!(
+        ((unsafe {
+            let _x: i32 = 3;
+            fallthrough_chain_20(_x)
+        }) == (12))
+    );
+    assert!(
+        ((unsafe {
+            let _x: i32 = 4;
+            fallthrough_chain_20(_x)
+        }) == (8))
+    );
+    assert!(
+        ((unsafe {
+            let _x: i32 = 99;
+            fallthrough_chain_20(_x)
+        }) == (-1_i32))
+    );
+    assert!(
+        ((unsafe {
+            let _x: i32 = 7;
+            let _flag: i32 = 0;
+            fallthrough_default_21(_x, _flag)
+        }) == (42))
+    );
+    assert!(
+        ((unsafe {
+            let _x: i32 = 7;
+            let _flag: i32 = 1;
+            fallthrough_default_21(_x, _flag)
+        }) == (100))
+    );
+    assert!(
+        ((unsafe {
+            let _x: i32 = 99;
+            let _flag: i32 = 0;
+            fallthrough_default_21(_x, _flag)
+        }) == (42))
+    );
+    assert!(
+        ((unsafe {
+            let _x: i32 = 1;
+            fallthrough_into_block_22(_x)
+        }) == (15))
+    );
+    assert!(
+        ((unsafe {
+            let _x: i32 = 2;
+            fallthrough_into_block_22(_x)
+        }) == (5))
+    );
+    assert!(
+        ((unsafe {
+            let _x: i32 = 99;
+            fallthrough_into_block_22(_x)
+        }) == (-1_i32))
+    );
+    let mut p_val: i32 = 5;
+    assert!(
+        ((unsafe {
+            let _p: *mut i32 = (&mut p_val as *mut i32);
+            let _bias: i32 = 0;
+            switch_complex_cond_23(_p, _bias)
+        }) == (2))
+    );
+    assert!(
+        ((unsafe {
+            let _p: *mut i32 = (&mut p_val as *mut i32);
+            let _bias: i32 = 5;
+            switch_complex_cond_23(_p, _bias)
+        }) == (3))
+    );
+    assert!(
+        ((unsafe {
+            let _p: *mut i32 = (&mut p_val as *mut i32);
+            let _bias: i32 = -5_i32;
+            switch_complex_cond_23(_p, _bias)
+        }) == (1))
+    );
+    assert!(
+        ((unsafe {
+            let _p: *mut i32 = (&mut p_val as *mut i32);
+            let _bias: i32 = 99;
+            switch_complex_cond_23(_p, _bias)
+        }) == (0))
+    );
+    assert!(
+        ((unsafe {
+            let _n: i32 = 1;
+            switch_in_dowhile_24(_n)
+        }) == (1))
+    );
+    assert!(
+        ((unsafe {
+            let _n: i32 = 3;
+            switch_in_dowhile_24(_n)
+        }) == (((1) + (10)) + (100)))
+    );
+    assert!(
+        ((unsafe {
+            let _n: i32 = 6;
+            continue_inside_switch_25(_n)
+        }) == (((((1) + (3)) + (5)) as i32) + ((3) * (1000))))
+    );
+    assert!(
+        ((unsafe {
+            let _x: i32 = 1;
+            case_then_default_26(_x)
+        }) == (10))
+    );
+    assert!(
+        ((unsafe {
+            let _x: i32 = 2;
+            case_then_default_26(_x)
+        }) == (20))
+    );
+    assert!(
+        ((unsafe {
+            let _x: i32 = 99;
+            case_then_default_26(_x)
+        }) == (10))
+    );
+    assert!(
+        ((unsafe {
+            let _x: i32 = 1;
+            default_then_case_27(_x)
+        }) == (1))
+    );
+    assert!(
+        ((unsafe {
+            let _x: i32 = 2;
+            default_then_case_27(_x)
+        }) == (77))
+    );
+    assert!(
+        ((unsafe {
+            let _x: i32 = 3;
+            default_then_case_27(_x)
+        }) == (3))
+    );
+    assert!(
+        ((unsafe {
+            let _x: i32 = 99;
+            default_then_case_27(_x)
+        }) == (77))
+    );
+    assert!(
+        ((unsafe {
+            let _x: i32 = 1;
+            cases_and_default_stacked_28(_x)
+        }) == (42))
+    );
+    assert!(
+        ((unsafe {
+            let _x: i32 = 2;
+            cases_and_default_stacked_28(_x)
+        }) == (42))
+    );
+    assert!(
+        ((unsafe {
+            let _x: i32 = 3;
+            cases_and_default_stacked_28(_x)
+        }) == (3))
+    );
+    assert!(
+        ((unsafe {
+            let _x: i32 = 99;
+            cases_and_default_stacked_28(_x)
+        }) == (42))
+    );
+    assert!(
+        ((unsafe {
+            let _x: i32 = 1;
+            let _flag: i32 = 0;
+            stacked_with_inner_fallthrough_29(_x, _flag)
+        }) == (50))
+    );
+    assert!(
+        ((unsafe {
+            let _x: i32 = 2;
+            let _flag: i32 = 1;
+            stacked_with_inner_fallthrough_29(_x, _flag)
+        }) == (999))
+    );
+    assert!(
+        ((unsafe {
+            let _x: i32 = 99;
+            let _flag: i32 = 0;
+            stacked_with_inner_fallthrough_29(_x, _flag)
+        }) == (999))
+    );
+    assert!(
+        ((unsafe {
+            let _x: i32 = 0;
+            borrow_in_condition_and_in_body_30(_x)
+        }) == (1))
+    );
+    assert!(
+        ((unsafe {
+            let _x: i32 = 1;
+            borrow_in_condition_and_in_body_30(_x)
+        }) == (2))
+    );
+    assert!(
+        ((unsafe {
+            let _n: i32 = 0;
+            for_in_switch_break_31(_n)
+        }) == (103))
+    );
+    assert!(
+        ((unsafe {
+            let _n: i32 = 99;
+            for_in_switch_break_31(_n)
+        }) == (-1_i32))
+    );
+    assert!(
+        ((unsafe {
+            let _n: i32 = 0;
+            for_in_switch_continue_32(_n)
+        }) == (4))
+    );
+    assert!(
+        ((unsafe {
+            let _n: i32 = 99;
+            for_in_switch_continue_32(_n)
+        }) == (-1_i32))
+    );
+    assert!(
+        ((unsafe {
+            let _n: i32 = 0;
+            while_in_switch_break_33(_n)
+        }) == (1006))
+    );
+    assert!(
+        ((unsafe {
+            let _n: i32 = 99;
+            while_in_switch_break_33(_n)
+        }) == (-1_i32))
+    );
+    assert!(
+        ((unsafe {
+            let _n: i32 = 3;
+            for_switch_for_break_34(_n)
+        }) == (122))
+    );
+    return 0;
+}
diff --git a/tests/unit/switch.cpp b/tests/unit/switch.cpp
new file mode 100644
index 00000000..4fdb1705
--- /dev/null
+++ b/tests/unit/switch.cpp
@@ -0,0 +1,696 @@
+// Copyright (c) 2022-present INESC-ID.
+// Distributed under the MIT license that can be found in the LICENSE file.
+
+#include <cassert>
+
+int basic(int x) {
+  int r = 0;
+  switch (x) {
+  case 0:
+    r = 10;
+    break;
+  case 1:
+    r = 20;
+    break;
+  case 2:
+    r = 30;
+    break;
+  default:
+    r = 40;
+    break;
+  }
+  return r;
+}
+
+int stacked(int x) {
+  int r = 0;
+  switch (x) {
+  case 1:
+  case 2:
+  case 3:
+    r = 100;
+    break;
+  case 4:
+  case 5:
+    r = 200;
+    break;
+  default:
+    r = 300;
+    break;
+  }
+  return r;
+}
+
+int no_default(int x) {
+  int r = -1;
+  switch (x) {
+  case 7:
+    r = 1;
+    break;
+  case 8:
+    r = 2;
+    break;
+  }
+  return r;
+}
+
+int only_default(int x) {
+  int r = 0;
+  switch (x) {
+  default:
+    r = 42;
+    break;
+  }
+  return r;
+}
+
+int default_middle(int x) {
+  int r = 0;
+  switch (x) {
+  case 1:
+    r = 1;
+    break;
+  default:
+    r = 99;
+    break;
+  case 2:
+    r = 2;
+    break;
+  }
+  return r;
+}
+
+int default_first(int x) {
+  int r = 0;
+  switch (x) {
+  default:
+    r = 7;
+    break;
+  case 1:
+    r = 1;
+    break;
+  case 2:
+    r = 2;
+    break;
+  }
+  return r;
+}
+
+int empty_switch(int x) {
+  switch (x) {}
+  return x;
+}
+
+int switch_char(char c) {
+  switch (c) {
+  case 'a':
+    return 1;
+  case 'b':
+    return 2;
+  case '\n':
+    return 3;
+  case '\0':
+    return 4;
+  default:
+    return 0;
+  }
+}
+
+enum Color { kRed, kGreen, kBlue };
+
+int switch_enum(Color c) {
+  switch (c) {
+  case kRed:
+    return 10;
+  case kGreen:
+    return 20;
+  case kBlue:
+    return 30;
+  }
+  return -1;
+}
+
+int compound_case_body(int x) {
+  int r = 0;
+  switch (x) {
+  case 1: {
+    int y = 10;
+    int z = 20;
+    r = y + z;
+    break;
+  }
+  case 2: {
+    int y = 100;
+    r = y - 1;
+    break;
+  }
+  default:
+    r = -1;
+    break;
+  }
+  return r;
+}
+
+int nested(int a, int b) {
+  int r = 0;
+  switch (a) {
+  case 1:
+    switch (b) {
+    case 10:
+      r = 11;
+      break;
+    case 20:
+      r = 12;
+      break;
+    default:
+      r = 13;
+      break;
+    }
+    r += 1;
+    break;
+  case 2:
+    r = 2;
+    break;
+  default:
+    r = -1;
+    break;
+  }
+  return r;
+}
+
+int switch_in_loop(int n) {
+  int r = 0;
+  for (int i = 0; i < n; ++i) {
+    switch (i % 3) {
+    case 0:
+      r += 1;
+      break;
+    case 1:
+      r += 2;
+      break;
+    default:
+      r += 3;
+      break;
+    }
+    r += 10;
+  }
+  return r;
+}
+
+int stacked_block(int x) {
+  int r = 0;
+  switch (x) {
+  case 1:
+  case 2:
+  case 3: {
+    int y = x * 2;
+    r = y + 1;
+    break;
+  }
+  default:
+    r = 0;
+    break;
+  }
+  return r;
+}
+
+int double_it(int v) { return v * 2; }
+
+int switch_on_call(int x) {
+  switch (double_it(x)) {
+  case 0:
+    return 100;
+  case 2:
+    return 200;
+  case 4:
+    return 400;
+  default:
+    return -1;
+  }
+}
+
+int switch_on_assignment(int x) {
+  int y = 0;
+  int r = 0;
+  switch (y = x + 1) {
+  case 1:
+    r = 10;
+    break;
+  case 2:
+    r = 20;
+    break;
+  default:
+    r = y;
+    break;
+  }
+  return r;
+}
+
+int mixed_literal_cases(int x) {
+  switch (x) {
+  case -1:
+    return 1;
+  case 0x10:
+    return 2;
+  case 0xFE80:
+    return 3;
+  case -0xFF:
+    return 4;
+  default:
+    return 0;
+  }
+}
+
+int mixed_return_break(int x) {
+  int r = -1;
+  switch (x) {
+  case 0:
+    return 100;
+  case 1:
+    r = 10;
+    break;
+  case 2:
+    return 200;
+  default:
+    r = 99;
+    break;
+  }
+  return r;
+}
+
+int empty_case_with_break(int x) {
+  int r = 5;
+  switch (x) {
+  case 1:
+    break;
+  case 2:
+    r = 2;
+    break;
+  default:
+    r = 9;
+    break;
+  }
+  return r;
+}
+
+int fallthrough_one(int x) {
+  int r = 0;
+  switch (x) {
+  case 1:
+    r += 10;
+  case 2:
+    r += 20;
+    break;
+  default:
+    r = -1;
+    break;
+  }
+  return r;
+}
+
+int fallthrough_chain(int x) {
+  int r = 0;
+  switch (x) {
+  case 1:
+    r += 1;
+    [[fallthrough]];
+  case 2:
+    r += 2;
+    [[fallthrough]];
+  case 3:
+    r += 4;
+    [[fallthrough]];
+  case 4:
+    r += 8;
+    break;
+  default:
+    r = -1;
+    break;
+  }
+  return r;
+}
+
+int fallthrough_default(int x, int flag) {
+  int r = 0;
+  switch (x) {
+  case 7:
+    if (flag) {
+      r = 100;
+      break;
+    }
+    [[fallthrough]];
+  default:
+    r = 42;
+    break;
+  }
+  return r;
+}
+
+int fallthrough_into_block(int x) {
+  int r = 0;
+  switch (x) {
+  case 1:
+    r += 1;
+    [[fallthrough]];
+  case 2: {
+    int tmp = r * 10;
+    r = tmp + 5;
+    break;
+  }
+  default:
+    r = -1;
+    break;
+  }
+  return r;
+}
+
+int switch_complex_cond(int *p, int bias) {
+  switch (*p + bias) {
+  case 0:
+    return 1;
+  case 5:
+    return 2;
+  case 10:
+    return 3;
+  default:
+    return 0;
+  }
+}
+
+int switch_in_dowhile(int n) {
+  int r = 0;
+  int i = 0;
+  do {
+    switch (i) {
+    case 0:
+      r += 1;
+      break;
+    case 1:
+      r += 10;
+      break;
+    default:
+      r += 100;
+      break;
+    }
+    ++i;
+  } while (i < n);
+  return r;
+}
+
+int continue_inside_switch(int n) {
+  int r = 0;
+  for (int i = 0; i < n; ++i) {
+    switch (i) {
+    case 0:
+    case 2:
+    case 4:
+      continue;
+    default:
+      r += i;
+      break;
+    }
+    r += 1000;
+  }
+  return r;
+}
+
+int case_then_default(int x) {
+  int r = 0;
+  switch (x) {
+  case 1:
+  default:
+    r = 10;
+    break;
+  case 2:
+    r = 20;
+    break;
+  }
+  return r;
+}
+
+int default_then_case(int x) {
+  int r = 0;
+  switch (x) {
+  case 1:
+    r = 1;
+    break;
+  default:
+  case 2:
+    r = 77;
+    break;
+  case 3:
+    r = 3;
+    break;
+  }
+  return r;
+}
+
+int cases_and_default_stacked(int x) {
+  int r = 0;
+  switch (x) {
+  case 1:
+  case 2:
+  default:
+    r = 42;
+    break;
+  case 3:
+    r = 3;
+    break;
+  }
+  return r;
+}
+
+int stacked_with_inner_fallthrough(int x, int flag) {
+  int r = 0;
+  switch (x) {
+  case 1:
+  case 2:
+  case 3:
+    if (!flag) {
+      r = 50;
+      break;
+    }
+    [[fallthrough]];
+  default:
+    r = 999;
+    break;
+  }
+  return r;
+}
+
+int borrow_in_condition_and_in_body(int x) {
+  switch (x) {
+  case 0:
+    [[fallthrough]];
+  default:
+    return x + 1;
+  }
+}
+
+int for_in_switch_break(int n) {
+  int r = 0;
+  switch (n) {
+  case 0:
+    for (int i = 0; i < 10; ++i) {
+      if (i == 3) break;
+      r += i;
+    }
+    r += 100;
+    break;
+  default:
+    r = -1;
+    break;
+  }
+  return r;
+}
+
+int for_in_switch_continue(int n) {
+  int r = 0;
+  switch (n) {
+  case 0:
+    for (int i = 0; i < 5; ++i) {
+      if (i % 2 == 0) continue;
+      r += i;
+    }
+    break;
+  default:
+    r = -1;
+    break;
+  }
+  return r;
+}
+
+int while_in_switch_break(int n) {
+  int r = 0;
+  switch (n) {
+  case 0: {
+    int i = 0;
+    while (i < 10) {
+      if (i == 4) break;
+      r += i;
+      ++i;
+    }
+    r += 1000;
+    break;
+  }
+  default:
+    r = -1;
+    break;
+  }
+  return r;
+}
+
+int for_switch_for_break(int n) {
+  int r = 0;
+  for (int i = 0; i < n; ++i) {
+    switch (i) {
+    case 1:
+      for (int j = 0; j < 10; ++j) {
+        if (j == 2) break;
+        r += 1;
+      }
+      r += 100;
+      break;
+    default:
+      r += 10;
+      break;
+    }
+  }
+  return r;
+}
+
+int main() {
+  assert(basic(0) == 10);
+  assert(basic(2) == 30);
+  assert(basic(99) == 40);
+
+  assert(stacked(1) == 100);
+  assert(stacked(3) == 100);
+  assert(stacked(5) == 200);
+  assert(stacked(9) == 300);
+
+  assert(no_default(7) == 1);
+  assert(no_default(42) == -1);
+
+  assert(only_default(1) == 42);
+
+  assert(default_middle(1) == 1);
+  assert(default_middle(2) == 2);
+  assert(default_middle(99) == 99);
+
+  assert(default_first(1) == 1);
+  assert(default_first(99) == 7);
+
+  assert(empty_switch(5) == 5);
+
+  assert(switch_char('a') == 1);
+  assert(switch_char('b') == 2);
+  assert(switch_char('\n') == 3);
+  assert(switch_char('\0') == 4);
+  assert(switch_char('z') == 0);
+
+  assert(switch_enum(kRed) == 10);
+  assert(switch_enum(kGreen) == 20);
+  assert(switch_enum(kBlue) == 30);
+
+  assert(compound_case_body(1) == 30);
+  assert(compound_case_body(2) == 99);
+  assert(compound_case_body(9) == -1);
+
+  assert(nested(1, 10) == 12);
+  assert(nested(1, 99) == 14);
+  assert(nested(2, 0) == 2);
+  assert(nested(3, 3) == -1);
+
+  assert(switch_in_loop(6) == 72);
+
+  assert(stacked_block(2) == 5);
+  assert(stacked_block(9) == 0);
+
+  assert(switch_on_call(0) == 100);
+  assert(switch_on_call(1) == 200);
+  assert(switch_on_call(2) == 400);
+  assert(switch_on_call(99) == -1);
+
+  assert(switch_on_assignment(0) == 10);
+  assert(switch_on_assignment(1) == 20);
+  assert(switch_on_assignment(9) == 10);
+
+  assert(mixed_literal_cases(-1) == 1);
+  assert(mixed_literal_cases(0x10) == 2);
+  assert(mixed_literal_cases(0xFE80) == 3);
+  assert(mixed_literal_cases(-0xFF) == 4);
+  assert(mixed_literal_cases(7) == 0);
+
+  assert(mixed_return_break(0) == 100);
+  assert(mixed_return_break(1) == 10);
+  assert(mixed_return_break(2) == 200);
+  assert(mixed_return_break(99) == 99);
+
+  assert(empty_case_with_break(1) == 5);
+  assert(empty_case_with_break(2) == 2);
+  assert(empty_case_with_break(9) == 9);
+
+  assert(fallthrough_one(1) == 30);
+  assert(fallthrough_one(2) == 20);
+  assert(fallthrough_one(99) == -1);
+
+  assert(fallthrough_chain(1) == 15);
+  assert(fallthrough_chain(2) == 14);
+  assert(fallthrough_chain(3) == 12);
+  assert(fallthrough_chain(4) == 8);
+  assert(fallthrough_chain(99) == -1);
+
+  assert(fallthrough_default(7, 0) == 42);
+  assert(fallthrough_default(7, 1) == 100);
+  assert(fallthrough_default(99, 0) == 42);
+
+  assert(fallthrough_into_block(1) == 15);
+  assert(fallthrough_into_block(2) == 5);
+  assert(fallthrough_into_block(99) == -1);
+
+  int p_val = 5;
+  assert(switch_complex_cond(&p_val, 0) == 2);
+  assert(switch_complex_cond(&p_val, 5) == 3);
+  assert(switch_complex_cond(&p_val, -5) == 1);
+  assert(switch_complex_cond(&p_val, 99) == 0);
+
+  assert(switch_in_dowhile(1) == 1);
+  assert(switch_in_dowhile(3) == 1 + 10 + 100);
+
+  assert(continue_inside_switch(6) == (1 + 3 + 5) + 3 * 1000);
+
+  assert(case_then_default(1) == 10);
+  assert(case_then_default(2) == 20);
+  assert(case_then_default(99) == 10);
+
+  assert(default_then_case(1) == 1);
+  assert(default_then_case(2) == 77);
+  assert(default_then_case(3) == 3);
+  assert(default_then_case(99) == 77);
+
+  assert(cases_and_default_stacked(1) == 42);
+  assert(cases_and_default_stacked(2) == 42);
+  assert(cases_and_default_stacked(3) == 3);
+  assert(cases_and_default_stacked(99) == 42);
+
+  assert(stacked_with_inner_fallthrough(1, 0) == 50);
+  assert(stacked_with_inner_fallthrough(2, 1) == 999);
+  assert(stacked_with_inner_fallthrough(99, 0) == 999);
+
+  assert(borrow_in_condition_and_in_body(0) == 1);
+  assert(borrow_in_condition_and_in_body(1) == 2);
+
+  assert(for_in_switch_break(0) == 103);
+  assert(for_in_switch_break(99) == -1);
+
+  assert(for_in_switch_continue(0) == 4);
+  assert(for_in_switch_continue(99) == -1);
+
+  assert(while_in_switch_break(0) == 1006);
+  assert(while_in_switch_break(99) == -1);
+
+  assert(for_switch_for_break(3) == 122);
+
+  return 0;
+}