diff --git a/Cargo.lock b/Cargo.lock
index 727d459b3..24bd26697 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -755,26 +755,6 @@ version = "0.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e88a8acf291dafb59c2d96e8f59828f3838bb1a70398823ade51a84de6a6deed"
 
-[[package]]
-name = "fehler"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d5729fe49ba028cd550747b6e62cd3d841beccab5390aa398538c31a2d983635"
-dependencies = [
- "fehler-macros",
-]
-
-[[package]]
-name = "fehler-macros"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ccb5acb1045ebbfa222e2c50679e392a71dd77030b78fb0189f2d9c5974400f9"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
 [[package]]
 name = "fixedbitset"
 version = "0.2.0"
@@ -1129,16 +1109,13 @@ dependencies = [
 ]
 
 [[package]]
-name = "lz-fear"
-version = "0.1.1"
+name = "lz4_flex"
+version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "06aad1ce45e4ccf7a8d7d43e0c3ad38dc5d2255174a5f29a3c39d961fbc6181d"
+checksum = "2e7bea5a3a7bb3c040adc89eadadee33c3d39371b20dd980c952dd2642867b99"
 dependencies = [
- "bitflags",
  "byteorder",
- "fehler",
- "thiserror",
- "twox-hash",
+ "quick-error",
 ]
 
 [[package]]
@@ -1769,7 +1746,7 @@ dependencies = [
  "bitflags",
  "bstr",
  "itertools",
- "lz-fear",
+ "lz4_flex",
  "num-bigint",
  "num-complex",
  "serde",
@@ -1814,6 +1791,7 @@ dependencies = [
  "itertools",
  "log",
  "num-complex",
+ "num-traits",
  "rustpython-ast",
  "rustpython-bytecode",
  "rustpython-parser",
@@ -2394,16 +2372,6 @@ dependencies = [
  "serde",
 ]
 
-[[package]]
-name = "twox-hash"
-version = "1.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "04f8ab788026715fa63b31960869617cba39117e520eb415b0139543e325ab59"
-dependencies = [
- "cfg-if 0.1.10",
- "static_assertions",
-]
-
 [[package]]
 name = "typenum"
 version = "1.12.0"
diff --git a/bytecode/Cargo.toml b/bytecode/Cargo.toml
index a1c431d4e..303f429d5 100644
--- a/bytecode/Cargo.toml
+++ b/bytecode/Cargo.toml
@@ -11,7 +11,7 @@ license = "MIT"
 [dependencies]
 bincode =  "1.1"
 bitflags = "1.1"
-lz-fear = "0.1"
+lz4_flex = "0.4"
 num-bigint = { version = "0.3", features = ["serde"] }
 num-complex = { version = "0.3", features = ["serde"] }
 serde = { version = "1.0", features = ["derive"] }
diff --git a/bytecode/src/bytecode.rs b/bytecode/src/bytecode.rs
index 778455581..8051fa73d 100644
--- a/bytecode/src/bytecode.rs
+++ b/bytecode/src/bytecode.rs
@@ -117,15 +117,12 @@ pub struct CodeObject<C: Constant = ConstantData> {
 bitflags! {
     #[derive(Serialize, Deserialize)]
     pub struct CodeFlags: u16 {
-        const HAS_DEFAULTS = 0x01;
-        const HAS_KW_ONLY_DEFAULTS = 0x02;
-        const HAS_ANNOTATIONS = 0x04;
-        const NEW_LOCALS = 0x08;
-        const IS_GENERATOR = 0x10;
-        const IS_COROUTINE = 0x20;
-        const HAS_VARARGS = 0x40;
-        const HAS_VARKEYWORDS = 0x80;
-        const IS_OPTIMIZED = 0x0100;
+        const NEW_LOCALS = 0x01;
+        const IS_GENERATOR = 0x02;
+        const IS_COROUTINE = 0x04;
+        const HAS_VARARGS = 0x08;
+        const HAS_VARKEYWORDS = 0x10;
+        const IS_OPTIMIZED = 0x20;
     }
 }
 
@@ -145,8 +142,8 @@ impl CodeFlags {
 #[derive(Serialize, Debug, Deserialize, Clone, Copy, PartialEq, Eq, Hash, Ord, PartialOrd)]
 #[repr(transparent)]
 // XXX: if you add a new instruction that stores a Label, make sure to add it in
-// compile::CodeInfo::finalize_code and CodeObject::label_targets
-pub struct Label(pub usize);
+// Instruction::label_arg{,_mut}
+pub struct Label(pub u32);
 impl fmt::Display for Label {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         self.0.fmt(f)
@@ -156,6 +153,8 @@ impl fmt::Display for Label {
 /// Transforms a value prior to formatting it.
 #[derive(Copy, Clone, Debug, PartialEq, Serialize, Deserialize)]
 pub enum ConversionFlag {
+    /// No conversion
+    None,
     /// Converts by calling `str(<value>)`.
     Str,
     /// Converts by calling `ascii(<value>)`.
@@ -164,16 +163,22 @@ pub enum ConversionFlag {
     Repr,
 }
 
-pub type NameIdx = usize;
+#[derive(Copy, Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum RaiseKind {
+    Reraise,
+    Raise,
+    RaiseCause,
+}
+
+pub type NameIdx = u32;
 
 /// A Single bytecode instruction.
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 pub enum Instruction {
-    Import {
-        name_idx: Option<NameIdx>,
-        symbols_idx: Vec<NameIdx>,
-        level: usize,
+    ImportName {
+        idx: NameIdx,
     },
+    ImportNameless,
     ImportStar,
     ImportFrom {
         idx: NameIdx,
@@ -203,14 +208,16 @@ pub enum Instruction {
     },
     LoadConst {
         /// index into constants vec
-        idx: usize,
+        idx: u32,
     },
     UnaryOperation {
         op: UnaryOperator,
     },
     BinaryOperation {
         op: BinaryOperator,
-        inplace: bool,
+    },
+    BinaryOperationInplace {
+        op: BinaryOperator,
     },
     LoadAttr {
         idx: NameIdx,
@@ -220,11 +227,13 @@ pub enum Instruction {
     },
     Pop,
     Rotate {
-        amount: usize,
+        amount: u32,
     },
     Duplicate,
     GetIter,
-    Continue,
+    Continue {
+        target: Label,
+    },
     Break,
     Jump {
         target: Label,
@@ -247,9 +256,15 @@ pub enum Instruction {
     JumpIfFalseOrPop {
         target: Label,
     },
-    MakeFunction,
-    CallFunction {
-        typ: CallType,
+    MakeFunction(MakeFunctionFlags),
+    CallFunctionPositional {
+        nargs: u32,
+    },
+    CallFunctionKeyword {
+        nargs: u32,
+    },
+    CallFunctionEx {
+        has_kwargs: bool,
     },
     ForIter {
         target: Label,
@@ -259,7 +274,6 @@ pub enum Instruction {
     YieldFrom,
     SetupAnnotation,
     SetupLoop {
-        start: Label,
         end: Label,
     },
 
@@ -292,56 +306,57 @@ pub enum Instruction {
     WithCleanupFinish,
     PopBlock,
     Raise {
-        argc: usize,
+        kind: RaiseKind,
     },
     BuildString {
-        size: usize,
+        size: u32,
     },
     BuildTuple {
-        size: usize,
         unpack: bool,
+        size: u32,
     },
     BuildList {
-        size: usize,
         unpack: bool,
+        size: u32,
     },
     BuildSet {
-        size: usize,
         unpack: bool,
+        size: u32,
     },
     BuildMap {
-        size: usize,
         unpack: bool,
         for_call: bool,
+        size: u32,
     },
     BuildSlice {
-        size: usize,
+        /// whether build a slice with a third step argument
+        step: bool,
     },
     ListAppend {
-        i: usize,
+        i: u32,
     },
     SetAdd {
-        i: usize,
+        i: u32,
     },
     MapAdd {
-        i: usize,
+        i: u32,
     },
 
     PrintExpr,
     LoadBuildClass,
     UnpackSequence {
-        size: usize,
+        size: u32,
     },
     UnpackEx {
-        before: usize,
-        after: usize,
+        before: u8,
+        after: u8,
     },
     FormatValue {
-        conversion: Option<ConversionFlag>,
+        conversion: ConversionFlag,
     },
     PopException,
     Reverse {
-        amount: usize,
+        amount: u32,
     },
     GetAwaitable,
     BeforeAsyncWith,
@@ -355,17 +370,20 @@ pub enum Instruction {
     /// required to support named expressions of Python 3.8 in dict comprehension
     /// today (including Py3.9) only required in dict comprehension.
     MapAddRev {
-        i: usize,
+        i: u32,
     },
 }
 
 use self::Instruction::*;
 
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-pub enum CallType {
-    Positional(usize),
-    Keyword(usize),
-    Ex(bool),
+bitflags! {
+    #[derive(Serialize, Deserialize)]
+    pub struct MakeFunctionFlags: u8 {
+        const CLOSURE = 0x01;
+        const ANNOTATIONS = 0x02;
+        const KW_ONLY_DEFAULTS = 0x04;
+        const DEFAULTS = 0x08;
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
@@ -452,7 +470,7 @@ impl<C: Constant> BorrowedConstant<'_, C> {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, Copy, Clone, PartialEq, Serialize, Deserialize)]
 pub enum ComparisonOperator {
     Greater,
     GreaterOrEqual,
@@ -467,7 +485,7 @@ pub enum ComparisonOperator {
     ExceptionMatch,
 }
 
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, Copy, Clone, PartialEq, Serialize, Deserialize)]
 pub enum BinaryOperator {
     Power,
     Multiply,
@@ -484,7 +502,7 @@ pub enum BinaryOperator {
     Or,
 }
 
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, Copy, Clone, PartialEq, Serialize, Deserialize)]
 pub enum UnaryOperator {
     Not,
     Invert,
@@ -588,39 +606,8 @@ impl<C: Constant> CodeObject<C> {
     pub fn label_targets(&self) -> BTreeSet<Label> {
         let mut label_targets = BTreeSet::new();
         for instruction in &*self.instructions {
-            match instruction {
-                Jump { target: l }
-                | JumpIfTrue { target: l }
-                | JumpIfFalse { target: l }
-                | JumpIfTrueOrPop { target: l }
-                | JumpIfFalseOrPop { target: l }
-                | ForIter { target: l }
-                | SetupFinally { handler: l }
-                | SetupExcept { handler: l }
-                | SetupWith { end: l }
-                | SetupAsyncWith { end: l } => {
-                    label_targets.insert(*l);
-                }
-                SetupLoop { start, end } => {
-                    label_targets.insert(*start);
-                    label_targets.insert(*end);
-                }
-
-                #[rustfmt::skip]
-                Import { .. } | ImportStar | ImportFrom { .. } | LoadFast(_) | LoadNameAny(_)
-                | LoadGlobal(_) | LoadDeref(_) | LoadClassDeref(_) | StoreFast(_) | StoreLocal(_)
-                | StoreGlobal(_) | StoreDeref(_) | DeleteFast(_) | DeleteLocal(_) | DeleteGlobal(_)
-                | DeleteDeref(_) | LoadClosure(_) | Subscript | StoreSubscript | DeleteSubscript
-                | StoreAttr { .. } | DeleteAttr { .. } | LoadConst { .. } | UnaryOperation { .. }
-                | BinaryOperation { .. } | LoadAttr { .. } | CompareOperation { .. } | Pop
-                | Rotate { .. } | Duplicate | GetIter | Continue | Break | MakeFunction
-                | CallFunction { .. } | ReturnValue | YieldValue | YieldFrom | SetupAnnotation
-                | EnterFinally | EndFinally | WithCleanupStart | WithCleanupFinish | PopBlock
-                | Raise { .. } | BuildString { .. } | BuildTuple { .. } | BuildList { .. }
-                | BuildSet { .. } | BuildMap { .. } | BuildSlice { .. } | ListAppend { .. }
-                | SetAdd { .. } | MapAdd { .. } | PrintExpr | LoadBuildClass | UnpackSequence { .. }
-                | UnpackEx { .. } | FormatValue { .. } | PopException | Reverse { .. }
-                | GetAwaitable | BeforeAsyncWith | GetAIter | GetANext | MapAddRev { .. } => {}
+            if let Some(l) = instruction.label_arg() {
+                label_targets.insert(*l);
             }
         }
         label_targets
@@ -635,7 +622,7 @@ impl<C: Constant> CodeObject<C> {
         let label_targets = self.label_targets();
 
         for (offset, instruction) in self.instructions.iter().enumerate() {
-            let arrow = if label_targets.contains(&Label(offset)) {
+            let arrow = if label_targets.contains(&Label(offset as u32)) {
                 ">>"
             } else {
                 "  "
@@ -736,18 +723,21 @@ impl<C: Constant> CodeObject<C> {
 impl CodeObject<ConstantData> {
     /// Load a code object from bytes
     pub fn from_bytes(data: &[u8]) -> Result<Self, Box<dyn std::error::Error>> {
-        let reader = lz_fear::framed::LZ4FrameReader::new(data)?;
-        Ok(bincode::deserialize_from(reader.into_read())?)
+        // TODO: PR to lz4_flex to make it not panic
+        if data.len() < 4 {
+            return Err(
+                std::io::Error::new(std::io::ErrorKind::UnexpectedEof, "bad bytecode").into(),
+            );
+        }
+        let raw_bincode = lz4_flex::decompress_size_prepended(data)?;
+        let data = bincode::deserialize(&raw_bincode)?;
+        Ok(data)
     }
 
     /// Serialize this bytecode to bytes.
     pub fn to_bytes(&self) -> Vec<u8> {
         let data = bincode::serialize(&self).expect("CodeObject is not serializable");
-        let mut out = Vec::new();
-        lz_fear::framed::CompressionSettings::default()
-            .compress_with_size_unchecked(data.as_slice(), &mut out, data.len() as u64)
-            .unwrap();
-        out
+        lz4_flex::compress_prepend_size(&data)
     }
 }
 
@@ -765,6 +755,46 @@ impl<C: Constant> fmt::Display for CodeObject<C> {
 }
 
 impl Instruction {
+    /// Gets the label stored inside this instruction, if it exists
+    #[inline]
+    pub fn label_arg(&self) -> Option<&Label> {
+        match self {
+            Jump { target: l }
+            | JumpIfTrue { target: l }
+            | JumpIfFalse { target: l }
+            | JumpIfTrueOrPop { target: l }
+            | JumpIfFalseOrPop { target: l }
+            | ForIter { target: l }
+            | SetupFinally { handler: l }
+            | SetupExcept { handler: l }
+            | SetupWith { end: l }
+            | SetupAsyncWith { end: l }
+            | SetupLoop { end: l }
+            | Continue { target: l } => Some(l),
+            _ => None,
+        }
+    }
+
+    /// Gets a mutable reference to the label stored inside this instruction, if it exists
+    #[inline]
+    pub fn label_arg_mut(&mut self) -> Option<&mut Label> {
+        match self {
+            Jump { target: l }
+            | JumpIfTrue { target: l }
+            | JumpIfFalse { target: l }
+            | JumpIfTrueOrPop { target: l }
+            | JumpIfFalseOrPop { target: l }
+            | ForIter { target: l }
+            | SetupFinally { handler: l }
+            | SetupExcept { handler: l }
+            | SetupWith { end: l }
+            | SetupAsyncWith { end: l }
+            | SetupLoop { end: l }
+            | Continue { target: l } => Some(l),
+            _ => None,
+        }
+    }
+
     #[allow(clippy::too_many_arguments)]
     fn fmt_dis<C: Constant>(
         &self,
@@ -799,53 +829,41 @@ impl Instruction {
             };
         }
 
-        let cellname = |i: usize| {
+        let varname = |i: u32| varnames[i as usize].as_ref();
+        let name = |i: u32| names[i as usize].as_ref();
+        let cellname = |i: u32| {
             cellvars
-                .get(i)
-                .unwrap_or_else(|| &freevars[i - cellvars.len()])
+                .get(i as usize)
+                .unwrap_or_else(|| &freevars[i as usize - cellvars.len()])
                 .as_ref()
         };
 
         match self {
-            Import {
-                name_idx,
-                symbols_idx,
-                level,
-            } => w!(
-                Import,
-                format!("{:?}", name_idx.map(|idx| names[idx].as_ref())),
-                format!(
-                    "({:?})",
-                    symbols_idx
-                        .iter()
-                        .map(|&idx| names[idx].as_ref())
-                        .format(", ")
-                ),
-                level
-            ),
+            ImportName { idx } => w!(ImportName, name(*idx)),
+            ImportNameless => w!(ImportNameless),
             ImportStar => w!(ImportStar),
-            ImportFrom { idx } => w!(ImportFrom, names[*idx].as_ref()),
-            LoadFast(idx) => w!(LoadFast, *idx, varnames[*idx].as_ref()),
-            LoadNameAny(idx) => w!(LoadNameAny, *idx, names[*idx].as_ref()),
-            LoadGlobal(idx) => w!(LoadGlobal, *idx, names[*idx].as_ref()),
+            ImportFrom { idx } => w!(ImportFrom, name(*idx)),
+            LoadFast(idx) => w!(LoadFast, *idx, varname(*idx)),
+            LoadNameAny(idx) => w!(LoadNameAny, *idx, name(*idx)),
+            LoadGlobal(idx) => w!(LoadGlobal, *idx, name(*idx)),
             LoadDeref(idx) => w!(LoadDeref, *idx, cellname(*idx)),
             LoadClassDeref(idx) => w!(LoadClassDeref, *idx, cellname(*idx)),
-            StoreFast(idx) => w!(StoreFast, *idx, varnames[*idx].as_ref()),
-            StoreLocal(idx) => w!(StoreLocal, *idx, names[*idx].as_ref()),
-            StoreGlobal(idx) => w!(StoreGlobal, *idx, names[*idx].as_ref()),
+            StoreFast(idx) => w!(StoreFast, *idx, varname(*idx)),
+            StoreLocal(idx) => w!(StoreLocal, *idx, name(*idx)),
+            StoreGlobal(idx) => w!(StoreGlobal, *idx, name(*idx)),
             StoreDeref(idx) => w!(StoreDeref, *idx, cellname(*idx)),
-            DeleteFast(idx) => w!(DeleteFast, *idx, varnames[*idx].as_ref()),
-            DeleteLocal(idx) => w!(DeleteLocal, *idx, names[*idx].as_ref()),
-            DeleteGlobal(idx) => w!(DeleteGlobal, *idx, names[*idx].as_ref()),
+            DeleteFast(idx) => w!(DeleteFast, *idx, varname(*idx)),
+            DeleteLocal(idx) => w!(DeleteLocal, *idx, name(*idx)),
+            DeleteGlobal(idx) => w!(DeleteGlobal, *idx, name(*idx)),
             DeleteDeref(idx) => w!(DeleteDeref, *idx, cellname(*idx)),
             LoadClosure(i) => w!(LoadClosure, *i, cellname(*i)),
             Subscript => w!(Subscript),
             StoreSubscript => w!(StoreSubscript),
             DeleteSubscript => w!(DeleteSubscript),
-            StoreAttr { idx } => w!(StoreAttr, names[*idx].as_ref()),
-            DeleteAttr { idx } => w!(DeleteAttr, names[*idx].as_ref()),
+            StoreAttr { idx } => w!(StoreAttr, name(*idx)),
+            DeleteAttr { idx } => w!(DeleteAttr, name(*idx)),
             LoadConst { idx } => {
-                let value = &constants[*idx];
+                let value = &constants[*idx as usize];
                 match value.borrow_constant() {
                     BorrowedConstant::Code { code } if expand_codeobjects => {
                         writeln!(f, "{:20} ({:?}):", "LoadConst", code)?;
@@ -859,29 +877,34 @@ impl Instruction {
                     }
                 }
             }
-            UnaryOperation { op } => w!(UnaryOperation, format!("{:?}", op)),
-            BinaryOperation { op, inplace } => w!(BinaryOperation, format!("{:?}", op), inplace),
-            LoadAttr { idx } => w!(LoadAttr, names[*idx].as_ref()),
-            CompareOperation { op } => w!(CompareOperation, format!("{:?}", op)),
+            UnaryOperation { op } => w!(UnaryOperation, format_args!("{:?}", op)),
+            BinaryOperation { op } => w!(BinaryOperation, format_args!("{:?}", op)),
+            BinaryOperationInplace { op } => {
+                w!(BinaryOperationInplace, format_args!("{:?}", op))
+            }
+            LoadAttr { idx } => w!(LoadAttr, name(*idx)),
+            CompareOperation { op } => w!(CompareOperation, format_args!("{:?}", op)),
             Pop => w!(Pop),
             Rotate { amount } => w!(Rotate, amount),
             Duplicate => w!(Duplicate),
             GetIter => w!(GetIter),
-            Continue => w!(Continue),
+            Continue { target } => w!(Continue, target),
             Break => w!(Break),
             Jump { target } => w!(Jump, target),
             JumpIfTrue { target } => w!(JumpIfTrue, target),
             JumpIfFalse { target } => w!(JumpIfFalse, target),
             JumpIfTrueOrPop { target } => w!(JumpIfTrueOrPop, target),
             JumpIfFalseOrPop { target } => w!(JumpIfFalseOrPop, target),
-            MakeFunction => w!(MakeFunction),
-            CallFunction { typ } => w!(CallFunction, format!("{:?}", typ)),
+            MakeFunction(flags) => w!(MakeFunction, format_args!("{:?}", flags)),
+            CallFunctionPositional { nargs } => w!(CallFunctionPositional, nargs),
+            CallFunctionKeyword { nargs } => w!(CallFunctionKeyword, nargs),
+            CallFunctionEx { has_kwargs } => w!(CallFunctionEx, has_kwargs),
             ForIter { target } => w!(ForIter, target),
             ReturnValue => w!(ReturnValue),
             YieldValue => w!(YieldValue),
             YieldFrom => w!(YieldFrom),
             SetupAnnotation => w!(SetupAnnotation),
-            SetupLoop { start, end } => w!(SetupLoop, start, end),
+            SetupLoop { end } => w!(SetupLoop, end),
             SetupExcept { handler } => w!(SetupExcept, handler),
             SetupFinally { handler } => w!(SetupFinally, handler),
             EnterFinally => w!(EnterFinally),
@@ -892,7 +915,7 @@ impl Instruction {
             BeforeAsyncWith => w!(BeforeAsyncWith),
             SetupAsyncWith { end } => w!(SetupAsyncWith, end),
             PopBlock => w!(PopBlock),
-            Raise { argc } => w!(Raise, argc),
+            Raise { kind } => w!(Raise, format_args!("{:?}", kind)),
             BuildString { size } => w!(BuildString, size),
             BuildTuple { size, unpack } => w!(BuildTuple, size, unpack),
             BuildList { size, unpack } => w!(BuildList, size, unpack),
@@ -902,7 +925,7 @@ impl Instruction {
                 unpack,
                 for_call,
             } => w!(BuildMap, size, unpack, for_call),
-            BuildSlice { size } => w!(BuildSlice, size),
+            BuildSlice { step } => w!(BuildSlice, step),
             ListAppend { i } => w!(ListAppend, i),
             SetAdd { i } => w!(SetAdd, i),
             MapAddRev { i } => w!(MapAddRev, i),
@@ -910,7 +933,7 @@ impl Instruction {
             LoadBuildClass => w!(LoadBuildClass),
             UnpackSequence { size } => w!(UnpackSequence, size),
             UnpackEx { before, after } => w!(UnpackEx, before, after),
-            FormatValue { .. } => w!(FormatValue), // TODO: write conversion
+            FormatValue { conversion } => w!(FormatValue, format_args!("{:?}", conversion)),
             PopException => w!(PopException),
             Reverse { amount } => w!(Reverse, amount),
             GetAwaitable => w!(GetAwaitable),
diff --git a/compiler/Cargo.toml b/compiler/Cargo.toml
index dc44869aa..ba37125e8 100644
--- a/compiler/Cargo.toml
+++ b/compiler/Cargo.toml
@@ -13,6 +13,7 @@ itertools = "0.9"
 rustpython-bytecode = { path = "../bytecode", version = "0.1.1" }
 rustpython-ast = { path = "../ast" }
 num-complex = { version = "0.3", features = ["serde"] }
+num-traits = "0.2"
 log = "0.4"
 arrayvec = "0.5"
 
diff --git a/compiler/src/compile.rs b/compiler/src/compile.rs
index da500a604..0847cab4c 100644
--- a/compiler/src/compile.rs
+++ b/compiler/src/compile.rs
@@ -11,8 +11,9 @@ use crate::symboltable::{make_symbol_table, statements_to_symbol_table, SymbolSc
 use indexmap::IndexSet;
 use itertools::Itertools;
 use num_complex::Complex64;
+use num_traits::ToPrimitive;
 use rustpython_ast as ast;
-use rustpython_bytecode::bytecode::{self, CallType, CodeObject, Instruction, Label};
+use rustpython_bytecode::bytecode::{self, CodeObject, ConstantData, Instruction, Label};
 
 type CompileResult<T> = Result<T, CompileError>;
 
@@ -20,12 +21,12 @@ struct CodeInfo {
     code: CodeObject,
     instructions: Vec<Instruction>,
     locations: Vec<bytecode::Location>,
-    constants: Vec<bytecode::ConstantData>,
+    constants: Vec<ConstantData>,
     name_cache: IndexSet<String>,
     varname_cache: IndexSet<String>,
     cellvar_cache: IndexSet<String>,
     freevar_cache: IndexSet<String>,
-    label_map: Vec<Option<Label>>,
+    label_map: Vec<Label>,
 }
 impl CodeInfo {
     fn finalize_code(self) -> CodeObject {
@@ -72,43 +73,12 @@ impl CodeInfo {
         }
 
         for instruction in &mut *code.instructions {
-            use Instruction::*;
             // this is a little bit hacky, as until now the data stored inside Labels in
             // Instructions is just bookkeeping, but I think it's the best way to do this
-            // XXX: any new instruction that uses a label has to be added here
-            match instruction {
-                Jump { target: l }
-                | JumpIfTrue { target: l }
-                | JumpIfFalse { target: l }
-                | JumpIfTrueOrPop { target: l }
-                | JumpIfFalseOrPop { target: l }
-                | ForIter { target: l }
-                | SetupFinally { handler: l }
-                | SetupExcept { handler: l }
-                | SetupWith { end: l }
-                | SetupAsyncWith { end: l } => {
-                    *l = label_map[l.0].expect("label never set");
-                }
-                SetupLoop { start, end } => {
-                    *start = label_map[start.0].expect("label never set");
-                    *end = label_map[end.0].expect("label never set");
-                }
-
-                #[rustfmt::skip]
-                Import { .. } | ImportStar | ImportFrom { .. } | LoadFast(_) | LoadNameAny(_)
-                | LoadGlobal(_) | LoadDeref(_) | LoadClassDeref(_) | StoreFast(_) | StoreLocal(_)
-                | StoreGlobal(_) | StoreDeref(_) | DeleteFast(_) | DeleteLocal(_) | DeleteGlobal(_)
-                | DeleteDeref(_) | LoadClosure(_) | Subscript | StoreSubscript | DeleteSubscript
-                | StoreAttr { .. } | DeleteAttr { .. } | LoadConst { .. } | UnaryOperation { .. }
-                | BinaryOperation { .. } | LoadAttr { .. } | CompareOperation { .. } | Pop
-                | Rotate { .. } | Duplicate | GetIter | Continue | Break | MakeFunction
-                | CallFunction { .. } | ReturnValue | YieldValue | YieldFrom | SetupAnnotation
-                | EnterFinally | EndFinally | WithCleanupStart | WithCleanupFinish | PopBlock
-                | Raise { .. } | BuildString { .. } | BuildTuple { .. } | BuildList { .. }
-                | BuildSet { .. } | BuildMap { .. } | BuildSlice { .. } | ListAppend { .. }
-                | SetAdd { .. } | MapAdd { .. } | PrintExpr | LoadBuildClass | UnpackSequence { .. }
-                | UnpackEx { .. } | FormatValue { .. } | PopException | Reverse { .. }
-                | GetAwaitable | BeforeAsyncWith | GetAIter | GetANext | MapAddRev { .. } => {}
+            if let Some(l) = instruction.label_arg_mut() {
+                let real_label = label_map[l.0 as usize];
+                debug_assert!(real_label.0 != u32::MAX, "label wasn't set");
+                *l = real_label;
             }
         }
         code
@@ -147,7 +117,7 @@ impl Default for CompileOpts {
 
 #[derive(Debug, Clone, Copy)]
 struct CompileContext {
-    in_loop: bool,
+    loop_data: Option<(Label, Label)>,
     in_class: bool,
     func: FunctionContext,
 }
@@ -160,6 +130,9 @@ enum FunctionContext {
 }
 
 impl CompileContext {
+    fn in_loop(self) -> bool {
+        self.loop_data.is_some()
+    }
     fn in_func(self) -> bool {
         self.func != FunctionContext::NoFunction
     }
@@ -252,7 +225,7 @@ impl Compiler {
             current_qualified_path: None,
             done_with_future_stmts: false,
             ctx: CompileContext {
-                in_loop: false,
+                loop_data: None,
                 in_class: false,
                 func: FunctionContext::NoFunction,
             },
@@ -330,7 +303,7 @@ impl Compiler {
         let cache = cache(self.current_codeinfo());
         cache
             .get_index_of(name)
-            .unwrap_or_else(|| cache.insert_full(name.to_owned()).0)
+            .unwrap_or_else(|| cache.insert_full(name.to_owned()).0) as u32
     }
 
     fn compile_program(
@@ -343,7 +316,7 @@ impl Compiler {
 
         let (statements, doc) = get_doc(&program.statements);
         if let Some(value) = doc {
-            self.emit_constant(bytecode::ConstantData::Str { value });
+            self.emit_constant(ConstantData::Str { value });
             let doc = self.name("__doc__");
             self.emit(Instruction::StoreGlobal(doc))
         }
@@ -357,7 +330,7 @@ impl Compiler {
         assert_eq!(self.code_stack.len(), size_before);
 
         // Emit None at end:
-        self.emit_constant(bytecode::ConstantData::None);
+        self.emit_constant(ConstantData::None);
         self.emit(Instruction::ReturnValue);
         Ok(())
     }
@@ -391,7 +364,7 @@ impl Compiler {
         }
 
         if !emitted_return {
-            self.emit_constant(bytecode::ConstantData::None);
+            self.emit_constant(ConstantData::None);
             self.emit(Instruction::ReturnValue);
         }
 
@@ -497,7 +470,7 @@ impl Compiler {
                 NameUsage::Delete => Instruction::DeleteLocal,
             },
         };
-        self.emit(op(idx));
+        self.emit(op(idx as u32));
     }
 
     fn compile_statement(&mut self, statement: &ast::Statement) -> CompileResult<()> {
@@ -519,12 +492,12 @@ impl Compiler {
             Import { names } => {
                 // import a, b, c as d
                 for name in names {
-                    let name_idx = Some(self.name(&name.symbol));
-                    self.emit(Instruction::Import {
-                        name_idx,
-                        symbols_idx: vec![],
-                        level: 0,
+                    self.emit_constant(ConstantData::Integer {
+                        value: num_traits::Zero::zero(),
                     });
+                    self.emit_constant(ConstantData::None);
+                    let idx = self.name(&name.symbol);
+                    self.emit(Instruction::ImportName { idx });
                     if let Some(alias) = &name.alias {
                         for part in name.symbol.split('.').skip(1) {
                             let idx = self.name(part);
@@ -543,32 +516,43 @@ impl Compiler {
             } => {
                 let import_star = names.iter().any(|n| n.symbol == "*");
 
-                let module_idx = module.as_ref().map(|s| self.name(s));
-
-                if import_star {
+                let from_list = if import_star {
                     if self.ctx.in_func() {
                         return Err(self
                             .error_loc(CompileErrorType::FunctionImportStar, statement.location));
                     }
-                    let star = self.name("*");
+                    vec![ConstantData::Str {
+                        value: "*".to_owned(),
+                    }]
+                } else {
+                    names
+                        .iter()
+                        .map(|n| ConstantData::Str {
+                            value: n.symbol.to_owned(),
+                        })
+                        .collect()
+                };
+
+                let module_idx = module.as_ref().map(|s| self.name(s));
+
+                // from .... import (*fromlist)
+                self.emit_constant(ConstantData::Integer {
+                    value: (*level).into(),
+                });
+                self.emit_constant(ConstantData::Tuple {
+                    elements: from_list,
+                });
+                if let Some(idx) = module_idx {
+                    self.emit(Instruction::ImportName { idx });
+                } else {
+                    self.emit(Instruction::ImportNameless);
+                }
+
+                if import_star {
                     // from .... import *
-                    self.emit(Instruction::Import {
-                        name_idx: module_idx,
-                        symbols_idx: vec![star],
-                        level: *level,
-                    });
                     self.emit(Instruction::ImportStar);
                 } else {
                     // from mod import a, b as c
-                    // First, determine the fromlist (for import lib):
-                    let from_list = names.iter().map(|n| self.name(&n.symbol)).collect();
-
-                    // Load module once:
-                    self.emit(Instruction::Import {
-                        name_idx: module_idx,
-                        symbols_idx: from_list,
-                        level: *level,
-                    });
 
                     for name in names {
                         let idx = self.name(&name.symbol);
@@ -636,7 +620,7 @@ impl Compiler {
                         if is_async {
                             self.emit(Instruction::BeforeAsyncWith);
                             self.emit(Instruction::GetAwaitable);
-                            self.emit_constant(bytecode::ConstantData::None);
+                            self.emit_constant(ConstantData::None);
                             self.emit(Instruction::YieldFrom);
                             self.emit(Instruction::SetupAsyncWith { end: end_label });
                         } else {
@@ -667,7 +651,7 @@ impl Compiler {
 
                     if is_async {
                         self.emit(Instruction::GetAwaitable);
-                        self.emit_constant(bytecode::ConstantData::None);
+                        self.emit_constant(ConstantData::None);
                         self.emit(Instruction::YieldFrom);
                     }
 
@@ -681,23 +665,22 @@ impl Compiler {
                 body,
                 orelse,
             } => self.compile_for(target, iter, body, orelse, *is_async)?,
-            Raise { exception, cause } => match exception {
-                Some(value) => {
-                    self.compile_expression(value)?;
-                    match cause {
-                        Some(cause) => {
-                            self.compile_expression(cause)?;
-                            self.emit(Instruction::Raise { argc: 2 });
-                        }
-                        None => {
-                            self.emit(Instruction::Raise { argc: 1 });
+            Raise { exception, cause } => {
+                let kind = match exception {
+                    Some(value) => {
+                        self.compile_expression(value)?;
+                        match cause {
+                            Some(cause) => {
+                                self.compile_expression(cause)?;
+                                bytecode::RaiseKind::RaiseCause
+                            }
+                            None => bytecode::RaiseKind::Raise,
                         }
                     }
-                }
-                None => {
-                    self.emit(Instruction::Raise { argc: 0 });
-                }
-            },
+                    None => bytecode::RaiseKind::Reraise,
+                };
+                self.emit(Instruction::Raise { kind });
+            }
             Try {
                 body,
                 handlers,
@@ -731,34 +714,34 @@ impl Compiler {
                     match msg {
                         Some(e) => {
                             self.compile_expression(e)?;
-                            self.emit(Instruction::CallFunction {
-                                typ: CallType::Positional(1),
-                            });
+                            self.emit(Instruction::CallFunctionPositional { nargs: 1 });
                         }
                         None => {
-                            self.emit(Instruction::CallFunction {
-                                typ: CallType::Positional(0),
-                            });
+                            self.emit(Instruction::CallFunctionPositional { nargs: 0 });
                         }
                     }
-                    self.emit(Instruction::Raise { argc: 1 });
+                    self.emit(Instruction::Raise {
+                        kind: bytecode::RaiseKind::Raise,
+                    });
                     self.set_label(end_label);
                 }
             }
             Break => {
-                if !self.ctx.in_loop {
+                if !self.ctx.in_loop() {
                     return Err(self.error_loc(CompileErrorType::InvalidBreak, statement.location));
                 }
                 self.emit(Instruction::Break);
             }
-            Continue => {
-                if !self.ctx.in_loop {
+            Continue => match self.ctx.loop_data {
+                Some((start, _)) => {
+                    self.emit(Instruction::Continue { target: start });
+                }
+                None => {
                     return Err(
                         self.error_loc(CompileErrorType::InvalidContinue, statement.location)
                     );
                 }
-                self.emit(Instruction::Continue);
-            }
+            },
             Return { value } => {
                 if !self.ctx.in_func() {
                     return Err(self.error_loc(CompileErrorType::InvalidReturn, statement.location));
@@ -779,7 +762,7 @@ impl Compiler {
                         self.compile_expression(v)?;
                     }
                     None => {
-                        self.emit_constant(bytecode::ConstantData::None);
+                        self.emit_constant(ConstantData::None);
                     }
                 }
 
@@ -845,11 +828,15 @@ impl Compiler {
         Ok(())
     }
 
-    fn enter_function(&mut self, name: &str, args: &ast::Parameters) -> CompileResult<()> {
+    fn enter_function(
+        &mut self,
+        name: &str,
+        args: &ast::Parameters,
+    ) -> CompileResult<bytecode::MakeFunctionFlags> {
         let have_defaults = !args.defaults.is_empty();
         if have_defaults {
             // Construct a tuple:
-            let size = args.defaults.len();
+            let size = args.defaults.len() as u32;
             for element in &args.defaults {
                 self.compile_expression(element)?;
             }
@@ -862,7 +849,7 @@ impl Compiler {
         let mut num_kw_only_defaults = 0;
         for (kw, default) in args.kwonlyargs.iter().zip(&args.kw_defaults) {
             if let Some(default) = default {
-                self.emit_constant(bytecode::ConstantData::Str {
+                self.emit_constant(ConstantData::Str {
                     value: kw.arg.clone(),
                 });
                 self.compile_expression(default)?;
@@ -877,17 +864,17 @@ impl Compiler {
             });
         }
 
-        let mut flags = bytecode::CodeFlags::NEW_LOCALS | bytecode::CodeFlags::IS_OPTIMIZED;
+        let mut funcflags = bytecode::MakeFunctionFlags::empty();
         if have_defaults {
-            flags |= bytecode::CodeFlags::HAS_DEFAULTS;
+            funcflags |= bytecode::MakeFunctionFlags::DEFAULTS;
         }
         if num_kw_only_defaults > 0 {
-            flags |= bytecode::CodeFlags::HAS_KW_ONLY_DEFAULTS;
+            funcflags |= bytecode::MakeFunctionFlags::KW_ONLY_DEFAULTS;
         }
 
         let line_number = self.get_source_line_number();
         self.push_output(CodeObject::new(
-            flags,
+            bytecode::CodeFlags::NEW_LOCALS | bytecode::CodeFlags::IS_OPTIMIZED,
             args.posonlyargs_count,
             args.args.len(),
             args.kwonlyargs.len(),
@@ -914,7 +901,7 @@ impl Compiler {
         compile_varargs(&args.vararg, bytecode::CodeFlags::HAS_VARARGS);
         compile_varargs(&args.kwarg, bytecode::CodeFlags::HAS_VARKEYWORDS);
 
-        Ok(())
+        Ok(funcflags)
     }
 
     fn prepare_decorators(&mut self, decorator_list: &[ast::Expression]) -> CompileResult<()> {
@@ -927,9 +914,7 @@ impl Compiler {
     fn apply_decorators(&mut self, decorator_list: &[ast::Expression]) {
         // Apply decorators:
         for _ in decorator_list {
-            self.emit(Instruction::CallFunction {
-                typ: CallType::Positional(1),
-            });
+            self.emit(Instruction::CallFunctionPositional { nargs: 1 });
         }
     }
 
@@ -1019,7 +1004,9 @@ impl Compiler {
         self.set_label(handler_label);
         // If code flows here, we have an unhandled exception,
         // raise the exception again!
-        self.emit(Instruction::Raise { argc: 0 });
+        self.emit(Instruction::Raise {
+            kind: bytecode::RaiseKind::Reraise,
+        });
 
         // We successfully ran the try block:
         // else:
@@ -1057,13 +1044,13 @@ impl Compiler {
         // Create bytecode for this function:
 
         self.prepare_decorators(decorator_list)?;
-        self.enter_function(name, args)?;
+        let mut funcflags = self.enter_function(name, args)?;
 
         // remember to restore self.ctx.in_loop to the original after the function is compiled
         let prev_ctx = self.ctx;
 
         self.ctx = CompileContext {
-            in_loop: false,
+            loop_data: None,
             in_class: prev_ctx.in_class,
             func: if is_async {
                 FunctionContext::AsyncFunction
@@ -1086,7 +1073,7 @@ impl Compiler {
                 // the last instruction is a ReturnValue already, we don't need to emit it
             }
             _ => {
-                self.emit_constant(bytecode::ConstantData::None);
+                self.emit_constant(ConstantData::None);
                 self.emit(Instruction::ReturnValue);
             }
         }
@@ -1101,7 +1088,7 @@ impl Compiler {
         // Return annotation:
         if let Some(annotation) = returns {
             // key:
-            self.emit_constant(bytecode::ConstantData::Str {
+            self.emit_constant(ConstantData::Str {
                 value: "return".to_owned(),
             });
             // value:
@@ -1111,7 +1098,7 @@ impl Compiler {
 
         let mut visit_arg_annotation = |arg: &ast::Parameter| -> CompileResult<()> {
             if let Some(annotation) = &arg.annotation {
-                self.emit_constant(bytecode::ConstantData::Str {
+                self.emit_constant(ConstantData::Str {
                     value: arg.arg.to_owned(),
                 });
                 self.compile_expression(&annotation)?;
@@ -1133,7 +1120,7 @@ impl Compiler {
         }
 
         if num_annotations > 0 {
-            code.flags |= bytecode::CodeFlags::HAS_ANNOTATIONS;
+            funcflags |= bytecode::MakeFunctionFlags::ANNOTATIONS;
             self.emit(Instruction::BuildMap {
                 size: num_annotations,
                 unpack: false,
@@ -1145,17 +1132,19 @@ impl Compiler {
             code.flags |= bytecode::CodeFlags::IS_COROUTINE;
         }
 
-        self.build_closure(&code);
+        if self.build_closure(&code) {
+            funcflags |= bytecode::MakeFunctionFlags::CLOSURE;
+        }
 
-        self.emit_constant(bytecode::ConstantData::Code {
+        self.emit_constant(ConstantData::Code {
             code: Box::new(code),
         });
-        self.emit_constant(bytecode::ConstantData::Str {
+        self.emit_constant(ConstantData::Str {
             value: qualified_name,
         });
 
         // Turn code object into function object:
-        self.emit(Instruction::MakeFunction);
+        self.emit(Instruction::MakeFunction(funcflags));
 
         self.emit(Instruction::Duplicate);
         self.load_docstring(doc_str);
@@ -1170,32 +1159,34 @@ impl Compiler {
         Ok(())
     }
 
-    fn build_closure(&mut self, code: &CodeObject) {
-        if !code.freevars.is_empty() {
-            for var in &*code.freevars {
-                let table = self.symbol_table_stack.last().unwrap();
-                let symbol = table.lookup(var).unwrap();
-                let parent_code = self.code_stack.last().unwrap();
-                let vars = match symbol.scope {
-                    SymbolScope::Free => &parent_code.freevar_cache,
-                    SymbolScope::Cell => &parent_code.cellvar_cache,
-                    _ if symbol.is_free_class => &parent_code.freevar_cache,
-                    x => unreachable!(
-                        "var {} in a {:?} should be free or cell but it's {:?}",
-                        var, table.typ, x
-                    ),
-                };
-                let mut idx = vars.get_index_of(var).unwrap();
-                if let SymbolScope::Free = symbol.scope {
-                    idx += parent_code.cellvar_cache.len();
-                }
-                self.emit(Instruction::LoadClosure(idx))
-            }
-            self.emit(Instruction::BuildTuple {
-                size: code.freevars.len(),
-                unpack: false,
-            })
+    fn build_closure(&mut self, code: &CodeObject) -> bool {
+        if code.freevars.is_empty() {
+            return false;
         }
+        for var in &*code.freevars {
+            let table = self.symbol_table_stack.last().unwrap();
+            let symbol = table.lookup(var).unwrap();
+            let parent_code = self.code_stack.last().unwrap();
+            let vars = match symbol.scope {
+                SymbolScope::Free => &parent_code.freevar_cache,
+                SymbolScope::Cell => &parent_code.cellvar_cache,
+                _ if symbol.is_free_class => &parent_code.freevar_cache,
+                x => unreachable!(
+                    "var {} in a {:?} should be free or cell but it's {:?}",
+                    var, table.typ, x
+                ),
+            };
+            let mut idx = vars.get_index_of(var).unwrap();
+            if let SymbolScope::Free = symbol.scope {
+                idx += parent_code.cellvar_cache.len();
+            }
+            self.emit(Instruction::LoadClosure(idx as u32))
+        }
+        self.emit(Instruction::BuildTuple {
+            size: code.freevars.len() as u32,
+            unpack: false,
+        });
+        true
     }
 
     fn find_ann(&self, body: &[ast::Statement]) -> bool {
@@ -1269,7 +1260,7 @@ impl Compiler {
         self.ctx = CompileContext {
             func: FunctionContext::NoFunction,
             in_class: true,
-            in_loop: false,
+            loop_data: None,
         };
 
         let qualified_name = self.create_qualified_name(name, "");
@@ -1294,7 +1285,7 @@ impl Compiler {
         self.emit(Instruction::LoadGlobal(dunder_name));
         let dunder_module = self.name("__module__");
         self.emit(Instruction::StoreLocal(dunder_module));
-        self.emit_constant(bytecode::ConstantData::Str {
+        self.emit_constant(ConstantData::Str {
             value: qualified_name.clone(),
         });
         let qualname = self.name("__qualname__");
@@ -1317,12 +1308,12 @@ impl Compiler {
             .position(|var| *var == "__class__");
 
         if let Some(classcell_idx) = classcell_idx {
-            self.emit(Instruction::LoadClosure(classcell_idx));
+            self.emit(Instruction::LoadClosure(classcell_idx as u32));
             self.emit(Instruction::Duplicate);
             let classcell = self.name("__classcell__");
             self.emit(Instruction::StoreLocal(classcell));
         } else {
-            self.emit_constant(bytecode::ConstantData::None);
+            self.emit_constant(ConstantData::None);
         }
 
         self.emit(Instruction::ReturnValue);
@@ -1332,19 +1323,23 @@ impl Compiler {
         self.current_qualified_path = old_qualified_path;
         self.ctx = prev_ctx;
 
-        self.build_closure(&code);
+        let mut funcflags = bytecode::MakeFunctionFlags::empty();
 
-        self.emit_constant(bytecode::ConstantData::Code {
+        if self.build_closure(&code) {
+            funcflags |= bytecode::MakeFunctionFlags::CLOSURE;
+        }
+
+        self.emit_constant(ConstantData::Code {
             code: Box::new(code),
         });
-        self.emit_constant(bytecode::ConstantData::Str {
+        self.emit_constant(ConstantData::Str {
             value: name.to_owned(),
         });
 
         // Turn code object into function object:
-        self.emit(Instruction::MakeFunction);
+        self.emit(Instruction::MakeFunction(funcflags));
 
-        self.emit_constant(bytecode::ConstantData::Str {
+        self.emit_constant(ConstantData::Str {
             value: qualified_name,
         });
 
@@ -1356,7 +1351,7 @@ impl Compiler {
             let mut kwarg_names = vec![];
             for keyword in keywords {
                 if let Some(name) = &keyword.name {
-                    kwarg_names.push(bytecode::ConstantData::Str {
+                    kwarg_names.push(ConstantData::Str {
                         value: name.to_owned(),
                     });
                 } else {
@@ -1366,15 +1361,15 @@ impl Compiler {
                 self.compile_expression(&keyword.value)?;
             }
 
-            self.emit_constant(bytecode::ConstantData::Tuple {
+            self.emit_constant(ConstantData::Tuple {
                 elements: kwarg_names,
             });
-            self.emit(Instruction::CallFunction {
-                typ: CallType::Keyword(2 + keywords.len() + bases.len()),
+            self.emit(Instruction::CallFunctionKeyword {
+                nargs: (2 + keywords.len() + bases.len()) as u32,
             });
         } else {
-            self.emit(Instruction::CallFunction {
-                typ: CallType::Positional(2 + bases.len()),
+            self.emit(Instruction::CallFunctionPositional {
+                nargs: (2 + bases.len()) as u32,
             });
         }
 
@@ -1390,8 +1385,8 @@ impl Compiler {
 
         // Doc string value:
         self.emit_constant(match doc_str {
-            Some(doc) => bytecode::ConstantData::Str { value: doc },
-            None => bytecode::ConstantData::None, // set docstring None if not declared
+            Some(doc) => ConstantData::Str { value: doc },
+            None => ConstantData::None, // set docstring None if not declared
         });
     }
 
@@ -1404,19 +1399,16 @@ impl Compiler {
         let start_label = self.new_label();
         let else_label = self.new_label();
         let end_label = self.new_label();
-        self.emit(Instruction::SetupLoop {
-            start: start_label,
-            end: end_label,
-        });
 
+        self.emit(Instruction::SetupLoop { end: end_label });
         self.set_label(start_label);
 
         self.compile_jump_if(test, false, else_label)?;
 
-        let was_in_loop = self.ctx.in_loop;
-        self.ctx.in_loop = true;
+        let was_in_loop = self.ctx.loop_data;
+        self.ctx.loop_data = Some((start_label, end_label));
         self.compile_statements(body)?;
-        self.ctx.in_loop = was_in_loop;
+        self.ctx.loop_data = was_in_loop;
         self.emit(Instruction::Jump {
             target: start_label,
         });
@@ -1442,10 +1434,7 @@ impl Compiler {
         let else_label = self.new_label();
         let end_label = self.new_label();
 
-        self.emit(Instruction::SetupLoop {
-            start: start_label,
-            end: end_label,
-        });
+        self.emit(Instruction::SetupLoop { end: end_label });
 
         // The thing iterated:
         self.compile_expression(iter)?;
@@ -1461,7 +1450,7 @@ impl Compiler {
                 handler: check_asynciter_label,
             });
             self.emit(Instruction::GetANext);
-            self.emit_constant(bytecode::ConstantData::None);
+            self.emit_constant(ConstantData::None);
             self.emit(Instruction::YieldFrom);
             self.compile_store(target)?;
             self.emit(Instruction::PopBlock);
@@ -1475,13 +1464,15 @@ impl Compiler {
                 op: bytecode::ComparisonOperator::ExceptionMatch,
             });
             self.emit(Instruction::JumpIfTrue { target: else_label });
-            self.emit(Instruction::Raise { argc: 0 });
+            self.emit(Instruction::Raise {
+                kind: bytecode::RaiseKind::Reraise,
+            });
 
-            let was_in_loop = self.ctx.in_loop;
-            self.ctx.in_loop = true;
+            let was_in_loop = self.ctx.loop_data;
+            self.ctx.loop_data = Some((start_label, end_label));
             self.set_label(body_label);
             self.compile_statements(body)?;
-            self.ctx.in_loop = was_in_loop;
+            self.ctx.loop_data = was_in_loop;
         } else {
             // Retrieve Iterator
             self.emit(Instruction::GetIter);
@@ -1492,10 +1483,10 @@ impl Compiler {
             // Start of loop iteration, set targets:
             self.compile_store(target)?;
 
-            let was_in_loop = self.ctx.in_loop;
-            self.ctx.in_loop = true;
+            let was_in_loop = self.ctx.loop_data;
+            self.ctx.loop_data = Some((start_label, end_label));
             self.compile_statements(body)?;
-            self.ctx.in_loop = was_in_loop;
+            self.ctx.loop_data = was_in_loop;
         }
 
         self.emit(Instruction::Jump {
@@ -1610,7 +1601,7 @@ impl Compiler {
             // Store as dict entry in __annotations__ dict:
             let annotations = self.name("__annotations__");
             self.emit(Instruction::LoadNameAny(annotations));
-            self.emit_constant(bytecode::ConstantData::Str {
+            self.emit_constant(ConstantData::Str {
                 value: name.to_owned(),
             });
             self.emit(Instruction::StoreSubscript);
@@ -1647,17 +1638,23 @@ impl Compiler {
                             return Err(self.error(CompileErrorType::MultipleStarArgs));
                         } else {
                             seen_star = true;
-                            self.emit(Instruction::UnpackEx {
-                                before: i,
-                                after: elements.len() - i - 1,
-                            });
+                            let before = i;
+                            let after = elements.len() - i - 1;
+                            let (before, after) = (|| Some((before.to_u8()?, after.to_u8()?)))()
+                                .ok_or_else(|| {
+                                    self.error_loc(
+                                        CompileErrorType::TooManyStarUnpack,
+                                        target.location,
+                                    )
+                                })?;
+                            self.emit(Instruction::UnpackEx { before, after });
                         }
                     }
                 }
 
                 if !seen_star {
                     self.emit(Instruction::UnpackSequence {
-                        size: elements.len(),
+                        size: elements.len() as u32,
                     });
                 }
 
@@ -1683,7 +1680,7 @@ impl Compiler {
     }
 
     fn compile_op(&mut self, op: &ast::Operator, inplace: bool) {
-        let i = match op {
+        let op = match op {
             ast::Operator::Add => bytecode::BinaryOperator::Add,
             ast::Operator::Sub => bytecode::BinaryOperator::Subtract,
             ast::Operator::Mult => bytecode::BinaryOperator::Multiply,
@@ -1698,7 +1695,12 @@ impl Compiler {
             ast::Operator::BitXor => bytecode::BinaryOperator::Xor,
             ast::Operator::BitAnd => bytecode::BinaryOperator::And,
         };
-        self.emit(Instruction::BinaryOperation { op: i, inplace });
+        let ins = if inplace {
+            Instruction::BinaryOperationInplace { op }
+        } else {
+            Instruction::BinaryOperation { op }
+        };
+        self.emit(ins);
     }
 
     /// Implement boolean short circuit evaluation logic.
@@ -1909,18 +1911,18 @@ impl Compiler {
             }
             Number { value } => {
                 let const_value = match value {
-                    ast::Number::Integer { value } => bytecode::ConstantData::Integer {
+                    ast::Number::Integer { value } => ConstantData::Integer {
                         value: value.clone(),
                     },
-                    ast::Number::Float { value } => bytecode::ConstantData::Float { value: *value },
-                    ast::Number::Complex { real, imag } => bytecode::ConstantData::Complex {
+                    ast::Number::Float { value } => ConstantData::Float { value: *value },
+                    ast::Number::Complex { real, imag } => ConstantData::Complex {
                         value: Complex64::new(*real, *imag),
                     },
                 };
                 self.emit_constant(const_value);
             }
             List { elements } => {
-                let size = elements.len();
+                let size = elements.len() as u32;
                 let must_unpack = self.gather_elements(elements)?;
                 self.emit(Instruction::BuildList {
                     size,
@@ -1928,7 +1930,7 @@ impl Compiler {
                 });
             }
             Tuple { elements } => {
-                let size = elements.len();
+                let size = elements.len() as u32;
                 let must_unpack = self.gather_elements(elements)?;
                 self.emit(Instruction::BuildTuple {
                     size,
@@ -1936,7 +1938,7 @@ impl Compiler {
                 });
             }
             Set { elements } => {
-                let size = elements.len();
+                let size = elements.len() as u32;
                 let must_unpack = self.gather_elements(elements)?;
                 self.emit(Instruction::BuildSet {
                     size,
@@ -1947,11 +1949,11 @@ impl Compiler {
                 self.compile_dict(elements)?;
             }
             Slice { elements } => {
-                let size = elements.len();
+                let step = elements.len() >= 3;
                 for element in elements {
                     self.compile_expression(element)?;
                 }
-                self.emit(Instruction::BuildSlice { size });
+                self.emit(Instruction::BuildSlice { step });
             }
             Yield { value } => {
                 if !self.ctx.in_func() {
@@ -1960,7 +1962,7 @@ impl Compiler {
                 self.mark_generator();
                 match value {
                     Some(expression) => self.compile_expression(expression)?,
-                    Option::None => self.emit_constant(bytecode::ConstantData::None),
+                    Option::None => self.emit_constant(ConstantData::None),
                 };
                 self.emit(Instruction::YieldValue);
             }
@@ -1970,7 +1972,7 @@ impl Compiler {
                 }
                 self.compile_expression(value)?;
                 self.emit(Instruction::GetAwaitable);
-                self.emit_constant(bytecode::ConstantData::None);
+                self.emit_constant(ConstantData::None);
                 self.emit(Instruction::YieldFrom);
             }
             YieldFrom { value } => {
@@ -1986,26 +1988,26 @@ impl Compiler {
                 self.mark_generator();
                 self.compile_expression(value)?;
                 self.emit(Instruction::GetIter);
-                self.emit_constant(bytecode::ConstantData::None);
+                self.emit_constant(ConstantData::None);
                 self.emit(Instruction::YieldFrom);
             }
             True => {
-                self.emit_constant(bytecode::ConstantData::Boolean { value: true });
+                self.emit_constant(ConstantData::Boolean { value: true });
             }
             False => {
-                self.emit_constant(bytecode::ConstantData::Boolean { value: false });
+                self.emit_constant(ConstantData::Boolean { value: false });
             }
             ast::ExpressionType::None => {
-                self.emit_constant(bytecode::ConstantData::None);
+                self.emit_constant(ConstantData::None);
             }
             Ellipsis => {
-                self.emit_constant(bytecode::ConstantData::Ellipsis);
+                self.emit_constant(ConstantData::Ellipsis);
             }
             ast::ExpressionType::String { value } => {
                 self.compile_string(value)?;
             }
             Bytes { value } => {
-                self.emit_constant(bytecode::ConstantData::Bytes {
+                self.emit_constant(ConstantData::Bytes {
                     value: value.clone(),
                 });
             }
@@ -2015,23 +2017,25 @@ impl Compiler {
             Lambda { args, body } => {
                 let prev_ctx = self.ctx;
                 self.ctx = CompileContext {
-                    in_loop: false,
+                    loop_data: Option::None,
                     in_class: prev_ctx.in_class,
                     func: FunctionContext::Function,
                 };
 
                 let name = "<lambda>".to_owned();
-                self.enter_function(&name, args)?;
+                let mut funcflags = self.enter_function(&name, args)?;
                 self.compile_expression(body)?;
                 self.emit(Instruction::ReturnValue);
                 let code = self.pop_code_object();
-                self.build_closure(&code);
-                self.emit_constant(bytecode::ConstantData::Code {
+                if self.build_closure(&code) {
+                    funcflags |= bytecode::MakeFunctionFlags::CLOSURE;
+                }
+                self.emit_constant(ConstantData::Code {
                     code: Box::new(code),
                 });
-                self.emit_constant(bytecode::ConstantData::Str { value: name });
+                self.emit_constant(ConstantData::Str { value: name });
                 // Turn code object into function object:
-                self.emit(Instruction::MakeFunction);
+                self.emit(Instruction::MakeFunction(funcflags));
 
                 self.ctx = prev_ctx;
             }
@@ -2076,7 +2080,7 @@ impl Compiler {
                 let mut subsize = 0;
                 for keyword in subkeywords {
                     if let Some(name) = &keyword.name {
-                        self.emit_constant(bytecode::ConstantData::Str {
+                        self.emit_constant(ConstantData::Str {
                             value: name.to_owned(),
                         });
                         self.compile_expression(&keyword.value)?;
@@ -2108,7 +2112,7 @@ impl Compiler {
         keywords: &[ast::Keyword],
     ) -> CompileResult<()> {
         self.compile_expression(function)?;
-        let count = args.len() + keywords.len();
+        let count = (args.len() + keywords.len()) as u32;
 
         // Normal arguments:
         let must_unpack = self.gather_elements(args)?;
@@ -2117,20 +2121,16 @@ impl Compiler {
         if must_unpack || has_double_star {
             // Create a tuple with positional args:
             self.emit(Instruction::BuildTuple {
-                size: args.len(),
+                size: args.len() as u32,
                 unpack: must_unpack,
             });
 
             // Create an optional map with kw-args:
             if !keywords.is_empty() {
                 self.compile_keywords(keywords)?;
-                self.emit(Instruction::CallFunction {
-                    typ: CallType::Ex(true),
-                });
+                self.emit(Instruction::CallFunctionEx { has_kwargs: true });
             } else {
-                self.emit(Instruction::CallFunction {
-                    typ: CallType::Ex(false),
-                });
+                self.emit(Instruction::CallFunctionEx { has_kwargs: false });
             }
         } else {
             // Keyword arguments:
@@ -2138,7 +2138,7 @@ impl Compiler {
                 let mut kwarg_names = vec![];
                 for keyword in keywords {
                     if let Some(name) = &keyword.name {
-                        kwarg_names.push(bytecode::ConstantData::Str {
+                        kwarg_names.push(ConstantData::Str {
                             value: name.to_owned(),
                         });
                     } else {
@@ -2148,16 +2148,12 @@ impl Compiler {
                     self.compile_expression(&keyword.value)?;
                 }
 
-                self.emit_constant(bytecode::ConstantData::Tuple {
+                self.emit_constant(ConstantData::Tuple {
                     elements: kwarg_names,
                 });
-                self.emit(Instruction::CallFunction {
-                    typ: CallType::Keyword(count),
-                });
+                self.emit(Instruction::CallFunctionKeyword { nargs: count });
             } else {
-                self.emit(Instruction::CallFunction {
-                    typ: CallType::Positional(count),
-                });
+                self.emit(Instruction::CallFunctionPositional { nargs: count });
             }
         }
         Ok(())
@@ -2196,7 +2192,7 @@ impl Compiler {
         let prev_ctx = self.ctx;
 
         self.ctx = CompileContext {
-            in_loop: false,
+            loop_data: None,
             in_class: prev_ctx.in_class,
             func: FunctionContext::Function,
         };
@@ -2270,10 +2266,7 @@ impl Compiler {
             let start_label = self.new_label();
             let end_label = self.new_label();
             loop_labels.push((start_label, end_label));
-            self.emit(Instruction::SetupLoop {
-                start: start_label,
-                end: end_label,
-            });
+            self.emit(Instruction::SetupLoop { end: end_label });
             self.set_label(start_label);
             self.emit(Instruction::ForIter { target: end_label });
 
@@ -2307,13 +2300,13 @@ impl Compiler {
             ast::ComprehensionKind::List { element } => {
                 compile_element(element)?;
                 self.emit(Instruction::ListAppend {
-                    i: 1 + generators.len(),
+                    i: (1 + generators.len()) as u32,
                 });
             }
             ast::ComprehensionKind::Set { element } => {
                 compile_element(element)?;
                 self.emit(Instruction::SetAdd {
-                    i: 1 + generators.len(),
+                    i: (1 + generators.len()) as u32,
                 });
             }
             ast::ComprehensionKind::Dict { key, value } => {
@@ -2322,7 +2315,7 @@ impl Compiler {
                 self.compile_expression(value)?;
 
                 self.emit(Instruction::MapAddRev {
-                    i: 1 + generators.len(),
+                    i: (1 + generators.len()) as u32,
                 });
             }
         }
@@ -2346,18 +2339,21 @@ impl Compiler {
 
         self.ctx = prev_ctx;
 
-        self.build_closure(&code);
+        let mut funcflags = bytecode::MakeFunctionFlags::empty();
+        if self.build_closure(&code) {
+            funcflags |= bytecode::MakeFunctionFlags::CLOSURE;
+        }
 
         // List comprehension code:
-        self.emit_constant(bytecode::ConstantData::Code {
+        self.emit_constant(ConstantData::Code {
             code: Box::new(code),
         });
 
         // List comprehension function name:
-        self.emit_constant(bytecode::ConstantData::Str { value: name });
+        self.emit_constant(ConstantData::Str { value: name });
 
         // Turn code object into function object:
-        self.emit(Instruction::MakeFunction);
+        self.emit(Instruction::MakeFunction(funcflags));
 
         // Evaluate iterated item:
         self.compile_expression(&generators[0].iter)?;
@@ -2366,25 +2362,25 @@ impl Compiler {
         self.emit(Instruction::GetIter);
 
         // Call just created <listcomp> function:
-        self.emit(Instruction::CallFunction {
-            typ: CallType::Positional(1),
-        });
+        self.emit(Instruction::CallFunctionPositional { nargs: 1 });
         Ok(())
     }
 
     fn compile_string(&mut self, string: &ast::StringGroup) -> CompileResult<()> {
         if let Some(value) = try_get_constant_string(string) {
-            self.emit_constant(bytecode::ConstantData::Str { value });
+            self.emit_constant(ConstantData::Str { value });
         } else {
             match string {
                 ast::StringGroup::Joined { values } => {
                     for value in values {
                         self.compile_string(value)?;
                     }
-                    self.emit(Instruction::BuildString { size: values.len() })
+                    self.emit(Instruction::BuildString {
+                        size: values.len() as u32,
+                    })
                 }
                 ast::StringGroup::Constant { value } => {
-                    self.emit_constant(bytecode::ConstantData::Str {
+                    self.emit_constant(ConstantData::Str {
                         value: value.to_owned(),
                     });
                 }
@@ -2395,13 +2391,13 @@ impl Compiler {
                 } => {
                     match spec {
                         Some(spec) => self.compile_string(spec)?,
-                        None => self.emit_constant(bytecode::ConstantData::Str {
+                        None => self.emit_constant(ConstantData::Str {
                             value: String::new(),
                         }),
                     };
                     self.compile_expression(value)?;
                     self.emit(Instruction::FormatValue {
-                        conversion: conversion.map(compile_conversion_flag),
+                        conversion: compile_conversion_flag(*conversion),
                     });
                 }
             }
@@ -2440,9 +2436,9 @@ impl Compiler {
         info.locations.push(location);
     }
 
-    fn emit_constant(&mut self, constant: bytecode::ConstantData) {
+    fn emit_constant(&mut self, constant: ConstantData) {
         let info = self.current_codeinfo();
-        let idx = info.constants.len();
+        let idx = info.constants.len() as u32;
         info.constants.push(constant);
         self.emit(Instruction::LoadConst { idx })
     }
@@ -2458,8 +2454,8 @@ impl Compiler {
     // Generate a new label
     fn new_label(&mut self) -> Label {
         let label_map = &mut self.current_codeinfo().label_map;
-        let label = Label(label_map.len());
-        label_map.push(None);
+        let label = Label(label_map.len() as u32);
+        label_map.push(Label(u32::MAX));
         label
     }
 
@@ -2470,10 +2466,10 @@ impl Compiler {
             label_map,
             ..
         } = self.current_codeinfo();
-        let actual_label = Label(instructions.len());
-        let prev_val = std::mem::replace(&mut label_map[label.0], Some(actual_label));
+        let actual_label = Label(instructions.len() as u32);
+        let prev_val = std::mem::replace(&mut label_map[label.0 as usize], actual_label);
         debug_assert!(
-            prev_val.map_or(true, |x| x == actual_label),
+            prev_val.0 == u32::MAX || prev_val == actual_label,
             "double-set a label"
         );
     }
@@ -2537,11 +2533,14 @@ fn compile_location(location: &ast::Location) -> bytecode::Location {
     bytecode::Location::new(location.row(), location.column())
 }
 
-fn compile_conversion_flag(conversion_flag: ast::ConversionFlag) -> bytecode::ConversionFlag {
+fn compile_conversion_flag(
+    conversion_flag: Option<ast::ConversionFlag>,
+) -> bytecode::ConversionFlag {
     match conversion_flag {
-        ast::ConversionFlag::Ascii => bytecode::ConversionFlag::Ascii,
-        ast::ConversionFlag::Repr => bytecode::ConversionFlag::Repr,
-        ast::ConversionFlag::Str => bytecode::ConversionFlag::Str,
+        None => bytecode::ConversionFlag::None,
+        Some(ast::ConversionFlag::Ascii) => bytecode::ConversionFlag::Ascii,
+        Some(ast::ConversionFlag::Repr) => bytecode::ConversionFlag::Repr,
+        Some(ast::ConversionFlag::Str) => bytecode::ConversionFlag::Str,
     }
 }
 
diff --git a/compiler/src/error.rs b/compiler/src/error.rs
index b5b1d866c..f1fa58e5c 100644
--- a/compiler/src/error.rs
+++ b/compiler/src/error.rs
@@ -37,6 +37,7 @@ pub enum CompileErrorType {
     InvalidFuturePlacement,
     InvalidFutureFeature(String),
     FunctionImportStar,
+    TooManyStarUnpack,
 }
 
 impl fmt::Display for CompileErrorType {
@@ -70,6 +71,9 @@ impl fmt::Display for CompileErrorType {
             CompileErrorType::FunctionImportStar => {
                 write!(f, "import * only allowed at module level")
             }
+            CompileErrorType::TooManyStarUnpack => {
+                write!(f, "too many expressions in star-unpacking assignment")
+            }
         }
     }
 }
diff --git a/compiler/src/lib.rs b/compiler/src/lib.rs
index 415ff6134..ab299864e 100644
--- a/compiler/src/lib.rs
+++ b/compiler/src/lib.rs
@@ -1,5 +1,4 @@
-//! Compile a Python AST or source code into bytecode consumable by RustPython or
-//! (eventually) CPython.
+//! Compile a Python AST or source code into bytecode consumable by RustPython.
 #![doc(html_logo_url = "https://raw.githubusercontent.com/RustPython/RustPython/master/logo.png")]
 #![doc(html_root_url = "https://docs.rs/rustpython-compiler/")]
 
diff --git a/jit/src/instructions.rs b/jit/src/instructions.rs
index 9ff9228d4..56ceda39f 100644
--- a/jit/src/instructions.rs
+++ b/jit/src/instructions.rs
@@ -54,7 +54,7 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
         let params = compiler.builder.func.dfg.block_params(entry_block).to_vec();
         for (i, (ty, val)) in arg_types.iter().zip(params).enumerate() {
             compiler
-                .store_variable(i, JitValue::new(val, ty.clone()))
+                .store_variable(i as u32, JitValue::new(val, ty.clone()))
                 .unwrap();
         }
         compiler
@@ -66,8 +66,8 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
         val: JitValue,
     ) -> Result<(), JitCompileError> {
         let builder = &mut self.builder;
-        let local = self.variables[idx].get_or_insert_with(|| {
-            let var = Variable::new(idx);
+        let local = self.variables[idx as usize].get_or_insert_with(|| {
+            let var = Variable::new(idx as usize);
             let local = Local {
                 var,
                 ty: val.ty.clone(),
@@ -119,7 +119,7 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
         let label_targets = bytecode.label_targets();
 
         for (offset, instruction) in bytecode.instructions.iter().enumerate() {
-            let label = Label(offset);
+            let label = Label(offset as u32);
             if label_targets.contains(&label) {
                 let block = self.get_or_create_block(label);
 
@@ -219,7 +219,7 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                 Ok(())
             }
             Instruction::LoadFast(idx) => {
-                let local = self.variables[*idx]
+                let local = self.variables[*idx as usize]
                     .as_ref()
                     .ok_or(JitCompileError::BadBytecode)?;
                 self.stack.push(JitValue {
@@ -232,7 +232,9 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                 let val = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
                 self.store_variable(*idx, val)
             }
-            Instruction::LoadConst { idx } => self.load_const(constants[*idx].borrow_constant()),
+            Instruction::LoadConst { idx } => {
+                self.load_const(constants[*idx as usize].borrow_constant())
+            }
             Instruction::ReturnValue => {
                 let val = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
                 if let Some(ref ty) = self.sig.ret {
@@ -320,7 +322,7 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                     _ => Err(JitCompileError::NotSupported),
                 }
             }
-            Instruction::BinaryOperation { op, .. } => {
+            Instruction::BinaryOperation { op } | Instruction::BinaryOperationInplace { op } => {
                 // the rhs is popped off first
                 let b = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
                 let a = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
diff --git a/jit/tests/common.rs b/jit/tests/common.rs
index 7b5a43468..d064ee771 100644
--- a/jit/tests/common.rs
+++ b/jit/tests/common.rs
@@ -78,13 +78,15 @@ impl StackMachine {
         names: &[String],
     ) -> bool {
         match instruction {
-            Instruction::LoadConst { idx } => self.stack.push(constants[idx].clone().into()),
-            Instruction::LoadNameAny(idx) => {
-                self.stack.push(StackValue::String(names[idx].clone()))
+            Instruction::LoadConst { idx } => {
+                self.stack.push(constants[idx as usize].clone().into())
             }
+            Instruction::LoadNameAny(idx) => self
+                .stack
+                .push(StackValue::String(names[idx as usize].clone())),
             Instruction::StoreLocal(idx) => {
                 self.locals
-                    .insert(names[idx].clone(), self.stack.pop().unwrap());
+                    .insert(names[idx as usize].clone(), self.stack.pop().unwrap());
             }
             Instruction::StoreAttr { .. } => {
                 // Do nothing except throw away the stack values
@@ -104,7 +106,7 @@ impl StackMachine {
                 }
                 self.stack.push(StackValue::Map(map));
             }
-            Instruction::MakeFunction => {
+            Instruction::MakeFunction(_flags) => {
                 let name = if let Some(StackValue::String(name)) = self.stack.pop() {
                     name
                 } else {
@@ -134,7 +136,7 @@ impl StackMachine {
                 let mut values = Vec::new();
 
                 // Pop all values from stack:
-                values.extend(self.stack.drain(self.stack.len() - amount..));
+                values.extend(self.stack.drain(self.stack.len() - amount as usize..));
 
                 // Push top of stack back first:
                 self.stack.push(values.pop().unwrap());
diff --git a/src/lib.rs b/src/lib.rs
index dbfad98b3..492043ee5 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -510,7 +510,7 @@ fn run_rustpython(vm: &VirtualMachine, matches: &ArgMatches) -> PyResult<()> {
     vm.get_attribute(vm.sys_module.clone(), "modules")?
         .set_item("__main__", main_module, vm)?;
 
-    let site_result = vm.import("site", &[], 0);
+    let site_result = vm.import("site", None, 0);
 
     if site_result.is_err() {
         warn!(
@@ -559,7 +559,7 @@ fn run_command(vm: &VirtualMachine, scope: Scope, source: String) -> PyResult<()
 
 fn run_module(vm: &VirtualMachine, module: &str) -> PyResult<()> {
     debug!("Running module {}", module);
-    let runpy = vm.import("runpy", &[], 0)?;
+    let runpy = vm.import("runpy", None, 0)?;
     let run_module_as_main = vm.get_attribute(runpy, "_run_module_as_main")?;
     vm.invoke(&run_module_as_main, (module,))?;
     Ok(())
diff --git a/vm/src/builtins/frame.rs b/vm/src/builtins/frame.rs
index 5248dac61..77bd5d843 100644
--- a/vm/src/builtins/frame.rs
+++ b/vm/src/builtins/frame.rs
@@ -73,7 +73,7 @@ impl FrameRef {
     }
 
     #[pyproperty]
-    fn f_lasti(self) -> usize {
+    fn f_lasti(self) -> u32 {
         self.lasti()
     }
 
diff --git a/vm/src/builtins/module.rs b/vm/src/builtins/module.rs
index 37d0bb638..76ae4e3a3 100644
--- a/vm/src/builtins/module.rs
+++ b/vm/src/builtins/module.rs
@@ -82,7 +82,7 @@ impl PyModule {
 
     #[pymethod(magic)]
     fn repr(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyResult {
-        let importlib = vm.import("_frozen_importlib", &[], 0)?;
+        let importlib = vm.import("_frozen_importlib", None, 0)?;
         let module_repr = vm.get_attribute(importlib, "_module_repr")?;
         vm.invoke(&module_repr, (zelf,))
     }
diff --git a/vm/src/builtins/object.rs b/vm/src/builtins/object.rs
index decb916dd..f5c886b88 100644
--- a/vm/src/builtins/object.rs
+++ b/vm/src/builtins/object.rs
@@ -314,11 +314,11 @@ pub fn init(context: &PyContext) {
 
 fn common_reduce(obj: PyObjectRef, proto: usize, vm: &VirtualMachine) -> PyResult {
     if proto >= 2 {
-        let reducelib = vm.import("__reducelib", &[], 0)?;
+        let reducelib = vm.import("__reducelib", None, 0)?;
         let reduce_2 = vm.get_attribute(reducelib, "reduce_2")?;
         vm.invoke(&reduce_2, (obj,))
     } else {
-        let copyreg = vm.import("copyreg", &[], 0)?;
+        let copyreg = vm.import("copyreg", None, 0)?;
         let reduce_ex = vm.get_attribute(copyreg, "_reduce_ex")?;
         vm.invoke(&reduce_ex, (obj, proto))
     }
diff --git a/vm/src/builtins/pystr.rs b/vm/src/builtins/pystr.rs
index 22787ac23..a57a45975 100644
--- a/vm/src/builtins/pystr.rs
+++ b/vm/src/builtins/pystr.rs
@@ -95,12 +95,14 @@ impl fmt::Display for PyStr {
 }
 
 impl TryIntoRef<PyStr> for String {
+    #[inline]
     fn try_into_ref(self, vm: &VirtualMachine) -> PyResult<PyRef<PyStr>> {
         Ok(PyStr::from(self).into_ref(vm))
     }
 }
 
 impl TryIntoRef<PyStr> for &str {
+    #[inline]
     fn try_into_ref(self, vm: &VirtualMachine) -> PyResult<PyRef<PyStr>> {
         Ok(PyStr::from(self).into_ref(vm))
     }
diff --git a/vm/src/builtins/traceback.rs b/vm/src/builtins/traceback.rs
index 2155fe303..26f5455bc 100644
--- a/vm/src/builtins/traceback.rs
+++ b/vm/src/builtins/traceback.rs
@@ -8,7 +8,7 @@ use crate::vm::VirtualMachine;
 pub struct PyTraceback {
     pub next: Option<PyTracebackRef>, // TODO: Make mutable
     pub frame: FrameRef,
-    pub lasti: usize,
+    pub lasti: u32,
     pub lineno: usize,
 }
 
@@ -22,7 +22,7 @@ impl PyValue for PyTraceback {
 
 #[pyimpl]
 impl PyTraceback {
-    pub fn new(next: Option<PyRef<Self>>, frame: FrameRef, lasti: usize, lineno: usize) -> Self {
+    pub fn new(next: Option<PyRef<Self>>, frame: FrameRef, lasti: u32, lineno: usize) -> Self {
         PyTraceback {
             next,
             frame,
@@ -37,7 +37,7 @@ impl PyTraceback {
     }
 
     #[pyproperty(name = "tb_lasti")]
-    fn lasti(&self) -> usize {
+    fn lasti(&self) -> u32 {
         self.lasti
     }
 
diff --git a/vm/src/builtins/tuple.rs b/vm/src/builtins/tuple.rs
index 74991c69d..c4614881f 100644
--- a/vm/src/builtins/tuple.rs
+++ b/vm/src/builtins/tuple.rs
@@ -317,6 +317,7 @@ impl<T: TransmuteFromObject> TryFromObject for PyTupleTyped<T> {
 
 impl<'a, T: TransmuteFromObject + 'a> BorrowValue<'a> for PyTupleTyped<T> {
     type Borrowed = &'a [T];
+    #[inline]
     fn borrow_value(&'a self) -> Self::Borrowed {
         unsafe { &*(self.tuple.borrow_value() as *const [PyObjectRef] as *const [T]) }
     }
@@ -327,3 +328,17 @@ impl<T: TransmuteFromObject + fmt::Debug> fmt::Debug for PyTupleTyped<T> {
         self.borrow_value().fmt(f)
     }
 }
+
+impl<T: TransmuteFromObject> From<PyTupleTyped<T>> for PyTupleRef {
+    #[inline]
+    fn from(tup: PyTupleTyped<T>) -> Self {
+        tup.tuple
+    }
+}
+
+impl<T: TransmuteFromObject> IntoPyObject for PyTupleTyped<T> {
+    #[inline]
+    fn into_pyobject(self, _vm: &VirtualMachine) -> PyObjectRef {
+        self.tuple.into_object()
+    }
+}
diff --git a/vm/src/frame.rs b/vm/src/frame.rs
index bb749f875..335c7a5a1 100644
--- a/vm/src/frame.rs
+++ b/vm/src/frame.rs
@@ -1,5 +1,5 @@
 use std::fmt;
-use std::sync::atomic::{AtomicUsize, Ordering};
+use std::sync::atomic::{AtomicU32, Ordering};
 
 use indexmap::IndexMap;
 use itertools::Itertools;
@@ -42,7 +42,6 @@ struct Block {
 #[derive(Clone, Debug)]
 enum BlockType {
     Loop {
-        start: bytecode::Label,
         end: bytecode::Label,
     },
     TryExcept {
@@ -77,7 +76,7 @@ enum UnwindReason {
     Break,
 
     /// We are unwinding blocks since we hit a continue statements.
-    Continue,
+    Continue { target: bytecode::Label },
 }
 
 #[derive(Debug)]
@@ -100,7 +99,7 @@ pub struct Frame {
     pub builtins: PyDictRef,
 
     /// index of last instruction ran
-    pub lasti: AtomicUsize,
+    pub lasti: AtomicU32,
     /// tracer function for this frame (usually is None)
     pub trace: PyMutex<PyObjectRef>,
     state: PyMutex<FrameState>,
@@ -187,7 +186,7 @@ impl Frame {
             globals: scope.globals,
             builtins,
             code,
-            lasti: AtomicUsize::new(0),
+            lasti: AtomicU32::new(0),
             state: PyMutex::new(FrameState {
                 stack: Vec::new(),
                 blocks: Vec::new(),
@@ -284,14 +283,14 @@ impl FrameRef {
     }
 
     pub fn current_location(&self) -> bytecode::Location {
-        self.code.locations[self.lasti.load(Ordering::Relaxed) - 1]
+        self.code.locations[self.lasti.load(Ordering::Relaxed) as usize - 1]
     }
 
     pub fn yield_from_target(&self) -> Option<PyObjectRef> {
         self.with_exec(|exec| exec.yield_from_target())
     }
 
-    pub fn lasti(&self) -> usize {
+    pub fn lasti(&self) -> u32 {
         self.lasti.load(Ordering::Relaxed)
     }
 }
@@ -306,7 +305,7 @@ struct ExecutingFrame<'a> {
     globals: &'a PyDictRef,
     builtins: &'a PyDictRef,
     object: &'a FrameRef,
-    lasti: &'a AtomicUsize,
+    lasti: &'a AtomicU32,
     state: &'a mut FrameState,
 }
 
@@ -326,8 +325,7 @@ impl ExecutingFrame<'_> {
         flame_guard!(format!("Frame::run({})", self.code.obj_name));
         // Execute until return or exception:
         loop {
-            let idx = self.lasti.fetch_add(1, Ordering::Relaxed);
-            let loc = self.code.locations[idx];
+            let idx = self.lasti.fetch_add(1, Ordering::Relaxed) as usize;
             let instr = &self.code.instructions[idx];
             let result = self.execute_instruction(instr, vm);
             match result {
@@ -341,6 +339,8 @@ impl ExecutingFrame<'_> {
                     // 2. Add new entry with current execution position (filename, lineno, code_object) to traceback.
                     // 3. Unwind block stack till appropriate handler is found.
 
+                    let loc = self.code.locations[idx];
+
                     let next = exception.traceback();
 
                     let new_traceback =
@@ -365,7 +365,9 @@ impl ExecutingFrame<'_> {
     }
 
     fn yield_from_target(&self) -> Option<PyObjectRef> {
-        if let Some(bytecode::Instruction::YieldFrom) = self.code.instructions.get(self.lasti()) {
+        if let Some(bytecode::Instruction::YieldFrom) =
+            self.code.instructions.get(self.lasti() as usize)
+        {
             Some(self.last_value())
         } else {
             None
@@ -442,23 +444,23 @@ impl ExecutingFrame<'_> {
 
         match instruction {
             bytecode::Instruction::LoadConst { idx } => {
-                self.push_value(self.code.constants[*idx].0.clone());
+                self.push_value(self.code.constants[*idx as usize].0.clone());
                 Ok(None)
             }
-            bytecode::Instruction::Import {
-                name_idx,
-                symbols_idx,
-                level,
-            } => self.import(vm, *name_idx, symbols_idx, *level),
+            bytecode::Instruction::ImportName { idx } => {
+                self.import(vm, Some(self.code.names[*idx as usize].clone()))
+            }
+            bytecode::Instruction::ImportNameless => self.import(vm, None),
             bytecode::Instruction::ImportStar => self.import_star(vm),
             bytecode::Instruction::ImportFrom { idx } => self.import_from(vm, *idx),
             bytecode::Instruction::LoadFast(idx) => {
-                let x = self.fastlocals.lock()[*idx].clone().ok_or_else(|| {
+                let idx = *idx as usize;
+                let x = self.fastlocals.lock()[idx].clone().ok_or_else(|| {
                     vm.new_exception_msg(
                         vm.ctx.exceptions.unbound_local_error.clone(),
                         format!(
                             "local variable '{}' referenced before assignment",
-                            self.code.varnames[*idx]
+                            self.code.varnames[idx]
                         ),
                     )
                 })?;
@@ -466,7 +468,7 @@ impl ExecutingFrame<'_> {
                 Ok(None)
             }
             bytecode::Instruction::LoadNameAny(idx) => {
-                let name = &self.code.names[*idx];
+                let name = &self.code.names[*idx as usize];
                 let x = self.locals.get_item_option(name.clone(), vm)?;
                 let x = match x {
                     Some(x) => x,
@@ -476,13 +478,13 @@ impl ExecutingFrame<'_> {
                 Ok(None)
             }
             bytecode::Instruction::LoadGlobal(idx) => {
-                let name = &self.code.names[*idx];
+                let name = &self.code.names[*idx as usize];
                 let x = self.load_global_or_builtin(name, vm)?;
                 self.push_value(x);
                 Ok(None)
             }
             bytecode::Instruction::LoadDeref(i) => {
-                let i = *i;
+                let i = *i as usize;
                 let x = self.cells_frees[i]
                     .get()
                     .ok_or_else(|| self.unbound_cell_exception(i, vm))?;
@@ -490,7 +492,7 @@ impl ExecutingFrame<'_> {
                 Ok(None)
             }
             bytecode::Instruction::LoadClassDeref(i) => {
-                let i = *i;
+                let i = *i as usize;
                 let name = self.code.freevars[i - self.code.cellvars.len()].clone();
                 let value = if let Some(value) = self.locals.get_item_option(name, vm)? {
                     value
@@ -504,32 +506,32 @@ impl ExecutingFrame<'_> {
             }
             bytecode::Instruction::StoreFast(idx) => {
                 let value = self.pop_value();
-                self.fastlocals.lock()[*idx] = Some(value);
+                self.fastlocals.lock()[*idx as usize] = Some(value);
                 Ok(None)
             }
             bytecode::Instruction::StoreLocal(idx) => {
                 let value = self.pop_value();
                 self.locals
-                    .set_item(self.code.names[*idx].clone(), value, vm)?;
+                    .set_item(self.code.names[*idx as usize].clone(), value, vm)?;
                 Ok(None)
             }
             bytecode::Instruction::StoreGlobal(idx) => {
                 let value = self.pop_value();
                 self.globals
-                    .set_item(self.code.names[*idx].clone(), value, vm)?;
+                    .set_item(self.code.names[*idx as usize].clone(), value, vm)?;
                 Ok(None)
             }
             bytecode::Instruction::StoreDeref(i) => {
                 let value = self.pop_value();
-                self.cells_frees[*i].set(Some(value));
+                self.cells_frees[*i as usize].set(Some(value));
                 Ok(None)
             }
             bytecode::Instruction::DeleteFast(idx) => {
-                self.fastlocals.lock()[*idx] = None;
+                self.fastlocals.lock()[*idx as usize] = None;
                 Ok(None)
             }
             bytecode::Instruction::DeleteLocal(idx) => {
-                let name = &self.code.names[*idx];
+                let name = &self.code.names[*idx as usize];
                 match self.locals.del_item(name.clone(), vm) {
                     Ok(()) => {}
                     Err(e) if e.isinstance(&vm.ctx.exceptions.key_error) => {
@@ -540,7 +542,7 @@ impl ExecutingFrame<'_> {
                 Ok(None)
             }
             bytecode::Instruction::DeleteGlobal(idx) => {
-                let name = &self.code.names[*idx];
+                let name = &self.code.names[*idx as usize];
                 match self.globals.del_item(name.clone(), vm) {
                     Ok(()) => {}
                     Err(e) if e.isinstance(&vm.ctx.exceptions.key_error) => {
@@ -551,11 +553,11 @@ impl ExecutingFrame<'_> {
                 Ok(None)
             }
             bytecode::Instruction::DeleteDeref(i) => {
-                self.cells_frees[*i].set(None);
+                self.cells_frees[*i as usize].set(None);
                 Ok(None)
             }
             bytecode::Instruction::LoadClosure(i) => {
-                let value = self.cells_frees[*i].clone();
+                let value = self.cells_frees[*i as usize].clone();
                 self.push_value(value.into_object());
                 Ok(None)
             }
@@ -577,31 +579,40 @@ impl ExecutingFrame<'_> {
             bytecode::Instruction::Rotate { amount } => self.execute_rotate(*amount),
             bytecode::Instruction::BuildString { size } => {
                 let s = self
-                    .pop_multiple(*size)
-                    .into_iter()
-                    .map(|pyobj| pystr::clone_value(&pyobj))
+                    .pop_multiple(*size as usize)
+                    .as_slice()
+                    .iter()
+                    .map(|pyobj| pystr::borrow_value(&pyobj))
                     .collect::<String>();
                 let str_obj = vm.ctx.new_str(s);
                 self.push_value(str_obj);
                 Ok(None)
             }
             bytecode::Instruction::BuildList { size, unpack } => {
-                let elements = self.get_elements(vm, *size, *unpack)?;
+                let elements = self.get_elements(vm, *size as usize, *unpack)?;
                 let list_obj = vm.ctx.new_list(elements);
                 self.push_value(list_obj);
                 Ok(None)
             }
             bytecode::Instruction::BuildSet { size, unpack } => {
-                let elements = self.get_elements(vm, *size, *unpack)?;
                 let set = vm.ctx.new_set();
-                for item in elements {
-                    set.add(item, vm)?;
+                {
+                    let elements = self.pop_multiple(*size as usize);
+                    if *unpack {
+                        for element in elements {
+                            vm.map_iterable_object(&element, |x| set.add(x, vm))??;
+                        }
+                    } else {
+                        for element in elements {
+                            set.add(element, vm)?;
+                        }
+                    }
                 }
                 self.push_value(set.into_object());
                 Ok(None)
             }
             bytecode::Instruction::BuildTuple { size, unpack } => {
-                let elements = self.get_elements(vm, *size, *unpack)?;
+                let elements = self.get_elements(vm, *size as usize, *unpack)?;
                 let list_obj = vm.ctx.new_tuple(elements);
                 self.push_value(list_obj);
                 Ok(None)
@@ -611,7 +622,7 @@ impl ExecutingFrame<'_> {
                 unpack,
                 for_call,
             } => self.execute_build_map(vm, *size, *unpack, *for_call),
-            bytecode::Instruction::BuildSlice { size } => self.execute_build_slice(vm, *size),
+            bytecode::Instruction::BuildSlice { step } => self.execute_build_slice(vm, *step),
             bytecode::Instruction::ListAppend { i } => {
                 let list_obj = self.nth_value(*i);
                 let item = self.pop_value();
@@ -639,8 +650,9 @@ impl ExecutingFrame<'_> {
                 PyDictRef::try_from_object(vm, dict_obj)?.set_item(key, value, vm)?;
                 Ok(None)
             }
-            bytecode::Instruction::BinaryOperation { ref op, inplace } => {
-                self.execute_binop(vm, op, *inplace)
+            bytecode::Instruction::BinaryOperation { op } => self.execute_binop(vm, *op),
+            bytecode::Instruction::BinaryOperationInplace { op } => {
+                self.execute_binop_inplace(vm, *op)
             }
             bytecode::Instruction::LoadAttr { idx } => self.load_attr(vm, *idx),
             bytecode::Instruction::StoreAttr { idx } => self.store_attr(vm, *idx),
@@ -668,11 +680,8 @@ impl ExecutingFrame<'_> {
                 }
                 Ok(None)
             }
-            bytecode::Instruction::SetupLoop { start, end } => {
-                self.push_block(BlockType::Loop {
-                    start: *start,
-                    end: *end,
-                });
+            bytecode::Instruction::SetupLoop { end } => {
+                self.push_block(BlockType::Loop { end: *end });
                 Ok(None)
             }
             bytecode::Instruction::SetupExcept { handler } => {
@@ -812,8 +821,16 @@ impl ExecutingFrame<'_> {
                 Ok(None)
             }
             bytecode::Instruction::ForIter { target } => self.execute_for_iter(vm, *target),
-            bytecode::Instruction::MakeFunction => self.execute_make_function(vm),
-            bytecode::Instruction::CallFunction { typ } => self.execute_call_function(vm, typ),
+            bytecode::Instruction::MakeFunction(flags) => self.execute_make_function(vm, *flags),
+            bytecode::Instruction::CallFunctionPositional { nargs } => {
+                self.execute_call_function_positional(vm, *nargs)
+            }
+            bytecode::Instruction::CallFunctionKeyword { nargs } => {
+                self.execute_call_function_keyword(vm, *nargs)
+            }
+            bytecode::Instruction::CallFunctionEx { has_kwargs } => {
+                self.execute_call_function_ex(vm, *has_kwargs)
+            }
             bytecode::Instruction::Jump { target } => {
                 self.jump(*target);
                 Ok(None)
@@ -858,10 +875,12 @@ impl ExecutingFrame<'_> {
                 Ok(None)
             }
 
-            bytecode::Instruction::Raise { argc } => self.execute_raise(vm, *argc),
+            bytecode::Instruction::Raise { kind } => self.execute_raise(vm, *kind),
 
             bytecode::Instruction::Break => self.unwind_blocks(vm, UnwindReason::Break),
-            bytecode::Instruction::Continue => self.unwind_blocks(vm, UnwindReason::Continue),
+            bytecode::Instruction::Continue { target } => {
+                self.unwind_blocks(vm, UnwindReason::Continue { target: *target })
+            }
             bytecode::Instruction::PrintExpr => {
                 let expr = self.pop_value();
 
@@ -888,7 +907,7 @@ impl ExecutingFrame<'_> {
                         e
                     }
                 })?;
-                let msg = match elements.len().cmp(size) {
+                let msg = match elements.len().cmp(&(*size as usize)) {
                     std::cmp::Ordering::Equal => {
                         for element in elements.into_iter().rev() {
                             self.push_value(element);
@@ -914,12 +933,13 @@ impl ExecutingFrame<'_> {
                 self.execute_unpack_ex(vm, *before, *after)
             }
             bytecode::Instruction::FormatValue { conversion } => {
-                use bytecode::ConversionFlag::*;
+                use bytecode::ConversionFlag;
+                let value = self.pop_value();
                 let value = match conversion {
-                    Some(Str) => vm.to_str(&self.pop_value())?.into_object(),
-                    Some(Repr) => vm.to_repr(&self.pop_value())?.into_object(),
-                    Some(Ascii) => vm.ctx.new_str(builtins::ascii(self.pop_value(), vm)?),
-                    None => self.pop_value(),
+                    ConversionFlag::Str => vm.to_str(&value)?.into_object(),
+                    ConversionFlag::Repr => vm.to_repr(&value)?.into_object(),
+                    ConversionFlag::Ascii => vm.ctx.new_str(builtins::ascii(value, vm)?),
+                    ConversionFlag::None => value,
                 };
 
                 let spec = self.pop_value();
@@ -938,7 +958,7 @@ impl ExecutingFrame<'_> {
             }
             bytecode::Instruction::Reverse { amount } => {
                 let stack_len = self.state.stack.len();
-                self.state.stack[stack_len - amount..stack_len].reverse();
+                self.state.stack[stack_len - *amount as usize..stack_len].reverse();
                 Ok(None)
             }
         }
@@ -966,27 +986,17 @@ impl ExecutingFrame<'_> {
             }
             Ok(result)
         } else {
-            Ok(elements)
+            Ok(elements.collect())
         }
     }
 
     #[cfg_attr(feature = "flame-it", flame("Frame"))]
-    fn import(
-        &mut self,
-        vm: &VirtualMachine,
-        module: Option<bytecode::NameIdx>,
-        symbols: &[bytecode::NameIdx],
-        level: usize,
-    ) -> FrameResult {
-        let module = match module {
-            Some(idx) => self.code.names[idx].borrow_value(),
-            None => "",
-        };
-        let from_list = symbols
-            .iter()
-            .map(|&idx| self.code.names[idx].clone())
-            .collect::<Vec<_>>();
-        let module = vm.import(&module, &from_list, level)?;
+    fn import(&mut self, vm: &VirtualMachine, module: Option<PyStrRef>) -> FrameResult {
+        let module = module.unwrap_or_else(|| PyStr::from("").into_ref(vm));
+        let from_list = <Option<PyTupleTyped<PyStrRef>>>::try_from_object(vm, self.pop_value())?;
+        let level = usize::try_from_object(vm, self.pop_value())?;
+
+        let module = vm.import(module, from_list, level)?;
 
         self.push_value(module);
         Ok(None)
@@ -995,7 +1005,7 @@ impl ExecutingFrame<'_> {
     #[cfg_attr(feature = "flame-it", flame("Frame"))]
     fn import_from(&mut self, vm: &VirtualMachine, idx: bytecode::NameIdx) -> FrameResult {
         let module = self.last_value();
-        let name = &self.code.names[idx];
+        let name = &self.code.names[idx as usize];
         // Load attribute, and transform any error into import error.
         let obj = vm.get_attribute(module, name.clone()).map_err(|_| {
             vm.new_import_error(format!("cannot import name '{}'", name), name.clone())
@@ -1040,14 +1050,14 @@ impl ExecutingFrame<'_> {
         // First unwind all existing blocks on the block stack:
         while let Some(block) = self.current_block() {
             match block.typ {
-                BlockType::Loop { start, end } => match &reason {
+                BlockType::Loop { end } => match &reason {
                     UnwindReason::Break => {
                         self.pop_block();
                         self.jump(end);
                         return Ok(None);
                     }
-                    UnwindReason::Continue => {
-                        self.jump(start);
+                    UnwindReason::Continue { target } => {
+                        self.jump(*target);
                         return Ok(None);
                     }
                     _ => {
@@ -1094,13 +1104,13 @@ impl ExecutingFrame<'_> {
         match reason {
             UnwindReason::Raising { exception } => Err(exception),
             UnwindReason::Returning { value } => Ok(Some(ExecutionResult::Return(value))),
-            UnwindReason::Break | UnwindReason::Continue => {
+            UnwindReason::Break | UnwindReason::Continue { .. } => {
                 panic!("Internal error: break or continue must occur within a loop block.")
             } // UnwindReason::NoWorries => Ok(None),
         }
     }
 
-    fn execute_rotate(&mut self, amount: usize) -> FrameResult {
+    fn execute_rotate(&mut self, amount: u32) -> FrameResult {
         // Shuffles top of stack amount down
         if amount < 2 {
             panic!("Can only rotate two or more values");
@@ -1150,10 +1160,11 @@ impl ExecutingFrame<'_> {
     fn execute_build_map(
         &mut self,
         vm: &VirtualMachine,
-        size: usize,
+        size: u32,
         unpack: bool,
         for_call: bool,
     ) -> FrameResult {
+        let size = size as usize;
         let map_obj = vm.ctx.new_dict();
         if unpack {
             for obj in self.pop_multiple(size) {
@@ -1176,7 +1187,7 @@ impl ExecutingFrame<'_> {
                 }
             }
         } else {
-            for (key, value) in self.pop_multiple(2 * size).into_iter().tuples() {
+            for (key, value) in self.pop_multiple(2 * size).tuples() {
                 map_obj.set_item(key, value, vm).unwrap();
             }
         }
@@ -1185,14 +1196,8 @@ impl ExecutingFrame<'_> {
         Ok(None)
     }
 
-    fn execute_build_slice(&mut self, vm: &VirtualMachine, size: usize) -> FrameResult {
-        assert!(size == 2 || size == 3);
-
-        let step = if size == 3 {
-            Some(self.pop_value())
-        } else {
-            None
-        };
+    fn execute_build_slice(&mut self, vm: &VirtualMachine, step: bool) -> FrameResult {
+        let step = if step { Some(self.pop_value()) } else { None };
         let stop = self.pop_value();
         let start = self.pop_value();
 
@@ -1206,68 +1211,67 @@ impl ExecutingFrame<'_> {
         Ok(None)
     }
 
-    fn execute_call_function(
-        &mut self,
-        vm: &VirtualMachine,
-        typ: &bytecode::CallType,
-    ) -> FrameResult {
-        let args = match typ {
-            bytecode::CallType::Positional(count) => {
-                let args: Vec<PyObjectRef> = self.pop_multiple(*count);
-                FuncArgs {
-                    args,
-                    kwargs: IndexMap::new(),
-                }
-            }
-            bytecode::CallType::Keyword(count) => {
-                let kwarg_names = self.pop_value();
-                let args: Vec<PyObjectRef> = self.pop_multiple(*count);
-
-                let kwarg_names = vm
-                    .extract_elements(&kwarg_names)?
-                    .iter()
-                    .map(|pyobj| pystr::clone_value(pyobj))
-                    .collect();
-                FuncArgs::with_kwargs_names(args, kwarg_names)
-            }
-            bytecode::CallType::Ex(has_kwargs) => {
-                let kwargs = if *has_kwargs {
-                    let kw_dict: PyDictRef = self.pop_value().downcast().map_err(|_| {
-                        // TODO: check collections.abc.Mapping
-                        vm.new_type_error("Kwargs must be a dict.".to_owned())
-                    })?;
-                    let mut kwargs = IndexMap::new();
-                    for (key, value) in kw_dict.into_iter() {
-                        let key = key.payload_if_subclass::<pystr::PyStr>(vm).ok_or_else(|| {
-                            vm.new_type_error("keywords must be strings".to_owned())
-                        })?;
-                        kwargs.insert(key.borrow_value().to_owned(), value);
-                    }
-                    kwargs
-                } else {
-                    IndexMap::new()
-                };
-                let args = self.pop_value();
-                let args = vm.extract_elements(&args)?;
-                FuncArgs { args, kwargs }
-            }
+    fn execute_call_function_positional(&mut self, vm: &VirtualMachine, nargs: u32) -> FrameResult {
+        let args = FuncArgs {
+            args: self.pop_multiple(nargs as usize).collect(),
+            kwargs: IndexMap::new(),
         };
 
-        // Call function:
-        // eprintln!(
-        //     "calling from {} {:?}",
-        //     self.code.obj_name,
-        //     self.code.locations[self.lasti.load(Ordering::Relaxed)]
-        // );
         let func_ref = self.pop_value();
         let value = vm.invoke(&func_ref, args)?;
         self.push_value(value);
         Ok(None)
     }
 
-    fn execute_raise(&mut self, vm: &VirtualMachine, argc: usize) -> FrameResult {
-        let cause = match argc {
-            2 => {
+    fn execute_call_function_keyword(&mut self, vm: &VirtualMachine, nargs: u32) -> FrameResult {
+        let kwarg_names = self
+            .pop_value()
+            .downcast::<PyTuple>()
+            .expect("kwarg names should be tuple of strings");
+        let args = self.pop_multiple(nargs as usize);
+
+        let kwarg_names = kwarg_names
+            .borrow_value()
+            .iter()
+            .map(|pyobj| pystr::clone_value(pyobj));
+        let args = FuncArgs::with_kwargs_names(args, kwarg_names);
+
+        let func_ref = self.pop_value();
+        let value = vm.invoke(&func_ref, args)?;
+        self.push_value(value);
+        Ok(None)
+    }
+
+    fn execute_call_function_ex(&mut self, vm: &VirtualMachine, has_kwargs: bool) -> FrameResult {
+        let kwargs = if has_kwargs {
+            let kw_dict: PyDictRef = self.pop_value().downcast().map_err(|_| {
+                // TODO: check collections.abc.Mapping
+                vm.new_type_error("Kwargs must be a dict.".to_owned())
+            })?;
+            let mut kwargs = IndexMap::new();
+            for (key, value) in kw_dict.into_iter() {
+                let key = key
+                    .payload_if_subclass::<pystr::PyStr>(vm)
+                    .ok_or_else(|| vm.new_type_error("keywords must be strings".to_owned()))?;
+                kwargs.insert(key.borrow_value().to_owned(), value);
+            }
+            kwargs
+        } else {
+            IndexMap::new()
+        };
+        let args = self.pop_value();
+        let args = vm.extract_elements(&args)?;
+        let args = FuncArgs { args, kwargs };
+
+        let func_ref = self.pop_value();
+        let value = vm.invoke(&func_ref, args)?;
+        self.push_value(value);
+        Ok(None)
+    }
+
+    fn execute_raise(&mut self, vm: &VirtualMachine, kind: bytecode::RaiseKind) -> FrameResult {
+        let cause = match kind {
+            bytecode::RaiseKind::RaiseCause => {
                 let val = self.pop_value();
                 Some(if vm.is_none(&val) {
                     // if the cause arg is none, we clear the cause
@@ -1278,19 +1282,19 @@ impl ExecutingFrame<'_> {
                 })
             }
             // if there's no cause arg, we keep the cause as is
-            _ => None,
+            bytecode::RaiseKind::Raise | bytecode::RaiseKind::Reraise => None,
         };
-        let exception = match argc {
-            0 => vm
+        let exception = match kind {
+            bytecode::RaiseKind::RaiseCause | bytecode::RaiseKind::Raise => {
+                ExceptionCtor::try_from_object(vm, self.pop_value())?.instantiate(vm)?
+            }
+            bytecode::RaiseKind::Reraise => vm
                 .current_exception()
                 .ok_or_else(|| vm.new_runtime_error("No active exception to reraise".to_owned()))?,
-            1 | 2 => ExceptionCtor::try_from_object(vm, self.pop_value())?.instantiate(vm)?,
-            3 => panic!("Not implemented!"),
-            _ => panic!("Invalid parameter for RAISE_VARARGS, must be between 0 to 3"),
         };
-        let context = match argc {
-            0 => None, // We have already got the exception,
-            _ => vm.current_exception(),
+        let context = match kind {
+            bytecode::RaiseKind::RaiseCause | bytecode::RaiseKind::Raise => vm.current_exception(),
+            bytecode::RaiseKind::Reraise => None, // We have already got the current exception
         };
         info!(
             "Exception raised: {:?} with cause: {:?} and context: {:?}",
@@ -1343,12 +1347,8 @@ impl ExecutingFrame<'_> {
         }
     }
 
-    fn execute_unpack_ex(
-        &mut self,
-        vm: &VirtualMachine,
-        before: usize,
-        after: usize,
-    ) -> FrameResult {
+    fn execute_unpack_ex(&mut self, vm: &VirtualMachine, before: u8, after: u8) -> FrameResult {
+        let (before, after) = (before as usize, after as usize);
         let value = self.pop_value();
         let elements = vm.extract_elements::<PyObjectRef>(&value)?;
         let min_expected = before + after;
@@ -1412,7 +1412,11 @@ impl ExecutingFrame<'_> {
             }
         }
     }
-    fn execute_make_function(&mut self, vm: &VirtualMachine) -> FrameResult {
+    fn execute_make_function(
+        &mut self,
+        vm: &VirtualMachine,
+        flags: bytecode::MakeFunctionFlags,
+    ) -> FrameResult {
         let qualified_name = self
             .pop_value()
             .downcast::<PyStr>()
@@ -1422,21 +1426,19 @@ impl ExecutingFrame<'_> {
             .downcast()
             .expect("Second to top value on the stack must be a code object");
 
-        let flags = code_obj.flags;
-
-        let closure = if code_obj.freevars.is_empty() {
-            None
-        } else {
+        let closure = if flags.contains(bytecode::MakeFunctionFlags::CLOSURE) {
             Some(PyTupleTyped::try_from_object(vm, self.pop_value()).unwrap())
+        } else {
+            None
         };
 
-        let annotations = if flags.contains(bytecode::CodeFlags::HAS_ANNOTATIONS) {
+        let annotations = if flags.contains(bytecode::MakeFunctionFlags::ANNOTATIONS) {
             self.pop_value()
         } else {
             vm.ctx.new_dict().into_object()
         };
 
-        let kw_only_defaults = if flags.contains(bytecode::CodeFlags::HAS_KW_ONLY_DEFAULTS) {
+        let kw_only_defaults = if flags.contains(bytecode::MakeFunctionFlags::KW_ONLY_DEFAULTS) {
             Some(
                 self.pop_value()
                     .downcast::<PyDict>()
@@ -1446,7 +1448,7 @@ impl ExecutingFrame<'_> {
             None
         };
 
-        let defaults = if flags.contains(bytecode::CodeFlags::HAS_DEFAULTS) {
+        let defaults = if flags.contains(bytecode::MakeFunctionFlags::DEFAULTS) {
             Some(
                 self.pop_value()
                     .downcast::<PyTuple>()
@@ -1486,47 +1488,50 @@ impl ExecutingFrame<'_> {
     }
 
     #[cfg_attr(feature = "flame-it", flame("Frame"))]
-    fn execute_binop(
+    fn execute_binop(&mut self, vm: &VirtualMachine, op: bytecode::BinaryOperator) -> FrameResult {
+        let b_ref = &self.pop_value();
+        let a_ref = &self.pop_value();
+        let value = match op {
+            bytecode::BinaryOperator::Subtract => vm._sub(a_ref, b_ref),
+            bytecode::BinaryOperator::Add => vm._add(a_ref, b_ref),
+            bytecode::BinaryOperator::Multiply => vm._mul(a_ref, b_ref),
+            bytecode::BinaryOperator::MatrixMultiply => vm._matmul(a_ref, b_ref),
+            bytecode::BinaryOperator::Power => vm._pow(a_ref, b_ref),
+            bytecode::BinaryOperator::Divide => vm._truediv(a_ref, b_ref),
+            bytecode::BinaryOperator::FloorDivide => vm._floordiv(a_ref, b_ref),
+            bytecode::BinaryOperator::Modulo => vm._mod(a_ref, b_ref),
+            bytecode::BinaryOperator::Lshift => vm._lshift(a_ref, b_ref),
+            bytecode::BinaryOperator::Rshift => vm._rshift(a_ref, b_ref),
+            bytecode::BinaryOperator::Xor => vm._xor(a_ref, b_ref),
+            bytecode::BinaryOperator::Or => vm._or(a_ref, b_ref),
+            bytecode::BinaryOperator::And => vm._and(a_ref, b_ref),
+        }?;
+
+        self.push_value(value);
+        Ok(None)
+    }
+    fn execute_binop_inplace(
         &mut self,
         vm: &VirtualMachine,
-        op: &bytecode::BinaryOperator,
-        inplace: bool,
+        op: bytecode::BinaryOperator,
     ) -> FrameResult {
         let b_ref = &self.pop_value();
         let a_ref = &self.pop_value();
-        let value = if inplace {
-            match *op {
-                bytecode::BinaryOperator::Subtract => vm._isub(a_ref, b_ref),
-                bytecode::BinaryOperator::Add => vm._iadd(a_ref, b_ref),
-                bytecode::BinaryOperator::Multiply => vm._imul(a_ref, b_ref),
-                bytecode::BinaryOperator::MatrixMultiply => vm._imatmul(a_ref, b_ref),
-                bytecode::BinaryOperator::Power => vm._ipow(a_ref, b_ref),
-                bytecode::BinaryOperator::Divide => vm._itruediv(a_ref, b_ref),
-                bytecode::BinaryOperator::FloorDivide => vm._ifloordiv(a_ref, b_ref),
-                bytecode::BinaryOperator::Modulo => vm._imod(a_ref, b_ref),
-                bytecode::BinaryOperator::Lshift => vm._ilshift(a_ref, b_ref),
-                bytecode::BinaryOperator::Rshift => vm._irshift(a_ref, b_ref),
-                bytecode::BinaryOperator::Xor => vm._ixor(a_ref, b_ref),
-                bytecode::BinaryOperator::Or => vm._ior(a_ref, b_ref),
-                bytecode::BinaryOperator::And => vm._iand(a_ref, b_ref),
-            }?
-        } else {
-            match *op {
-                bytecode::BinaryOperator::Subtract => vm._sub(a_ref, b_ref),
-                bytecode::BinaryOperator::Add => vm._add(a_ref, b_ref),
-                bytecode::BinaryOperator::Multiply => vm._mul(a_ref, b_ref),
-                bytecode::BinaryOperator::MatrixMultiply => vm._matmul(a_ref, b_ref),
-                bytecode::BinaryOperator::Power => vm._pow(a_ref, b_ref),
-                bytecode::BinaryOperator::Divide => vm._truediv(a_ref, b_ref),
-                bytecode::BinaryOperator::FloorDivide => vm._floordiv(a_ref, b_ref),
-                bytecode::BinaryOperator::Modulo => vm._mod(a_ref, b_ref),
-                bytecode::BinaryOperator::Lshift => vm._lshift(a_ref, b_ref),
-                bytecode::BinaryOperator::Rshift => vm._rshift(a_ref, b_ref),
-                bytecode::BinaryOperator::Xor => vm._xor(a_ref, b_ref),
-                bytecode::BinaryOperator::Or => vm._or(a_ref, b_ref),
-                bytecode::BinaryOperator::And => vm._and(a_ref, b_ref),
-            }?
-        };
+        let value = match op {
+            bytecode::BinaryOperator::Subtract => vm._isub(a_ref, b_ref),
+            bytecode::BinaryOperator::Add => vm._iadd(a_ref, b_ref),
+            bytecode::BinaryOperator::Multiply => vm._imul(a_ref, b_ref),
+            bytecode::BinaryOperator::MatrixMultiply => vm._imatmul(a_ref, b_ref),
+            bytecode::BinaryOperator::Power => vm._ipow(a_ref, b_ref),
+            bytecode::BinaryOperator::Divide => vm._itruediv(a_ref, b_ref),
+            bytecode::BinaryOperator::FloorDivide => vm._ifloordiv(a_ref, b_ref),
+            bytecode::BinaryOperator::Modulo => vm._imod(a_ref, b_ref),
+            bytecode::BinaryOperator::Lshift => vm._ilshift(a_ref, b_ref),
+            bytecode::BinaryOperator::Rshift => vm._irshift(a_ref, b_ref),
+            bytecode::BinaryOperator::Xor => vm._ixor(a_ref, b_ref),
+            bytecode::BinaryOperator::Or => vm._ior(a_ref, b_ref),
+            bytecode::BinaryOperator::And => vm._iand(a_ref, b_ref),
+        }?;
 
         self.push_value(value);
         Ok(None)
@@ -1610,7 +1615,7 @@ impl ExecutingFrame<'_> {
     }
 
     fn load_attr(&mut self, vm: &VirtualMachine, attr: bytecode::NameIdx) -> FrameResult {
-        let attr_name = self.code.names[attr].clone();
+        let attr_name = self.code.names[attr as usize].clone();
         let parent = self.pop_value();
         let obj = vm.get_attribute(parent, attr_name)?;
         self.push_value(obj);
@@ -1618,7 +1623,7 @@ impl ExecutingFrame<'_> {
     }
 
     fn store_attr(&mut self, vm: &VirtualMachine, attr: bytecode::NameIdx) -> FrameResult {
-        let attr_name = self.code.names[attr].clone();
+        let attr_name = self.code.names[attr as usize].clone();
         let parent = self.pop_value();
         let value = self.pop_value();
         vm.set_attr(&parent, attr_name, value)?;
@@ -1626,13 +1631,13 @@ impl ExecutingFrame<'_> {
     }
 
     fn delete_attr(&mut self, vm: &VirtualMachine, attr: bytecode::NameIdx) -> FrameResult {
-        let attr_name = self.code.names[attr].clone().into_object();
+        let attr_name = self.code.names[attr as usize].clone().into_object();
         let parent = self.pop_value();
         vm.del_attr(&parent, attr_name)?;
         Ok(None)
     }
 
-    fn lasti(&self) -> usize {
+    fn lasti(&self) -> u32 {
         // it's okay to make this Relaxed, because we know that we only
         // mutate lasti if the mutex is held, and any other thread that
         // wants to guarantee the value of this will use a Lock anyway
@@ -1667,20 +1672,17 @@ impl ExecutingFrame<'_> {
             .expect("Tried to pop value but there was nothing on the stack")
     }
 
-    fn pop_multiple(&mut self, count: usize) -> Vec<PyObjectRef> {
+    fn pop_multiple(&mut self, count: usize) -> std::vec::Drain<PyObjectRef> {
         let stack_len = self.state.stack.len();
-        self.state
-            .stack
-            .drain(stack_len - count..stack_len)
-            .collect()
+        self.state.stack.drain(stack_len - count..stack_len)
     }
 
     fn last_value(&self) -> PyObjectRef {
         self.state.stack.last().unwrap().clone()
     }
 
-    fn nth_value(&self, depth: usize) -> PyObjectRef {
-        self.state.stack[self.state.stack.len() - depth - 1].clone()
+    fn nth_value(&self, depth: u32) -> PyObjectRef {
+        self.state.stack[self.state.stack.len() - depth as usize - 1].clone()
     }
 }
 
diff --git a/vm/src/function.rs b/vm/src/function.rs
index 19495c772..14465b10a 100644
--- a/vm/src/function.rs
+++ b/vm/src/function.rs
@@ -8,6 +8,7 @@ use crate::pyobject::{
 };
 use crate::vm::VirtualMachine;
 use indexmap::IndexMap;
+use itertools::Itertools;
 use result_like::impl_option_like;
 use std::collections::HashMap;
 use std::marker::PhantomData;
@@ -98,15 +99,24 @@ impl FuncArgs {
         Self { args, kwargs }
     }
 
-    pub fn with_kwargs_names(mut args: Vec<PyObjectRef>, kwarg_names: Vec<String>) -> Self {
+    pub fn with_kwargs_names<A, KW>(mut args: A, kwarg_names: KW) -> Self
+    where
+        A: ExactSizeIterator<Item = PyObjectRef>,
+        KW: ExactSizeIterator<Item = String>,
+    {
         // last `kwarg_names.len()` elements of args in order of appearance in the call signature
-        let kwarg_values = args.drain((args.len() - kwarg_names.len())..);
+        let total_argc = args.len();
+        let kwargc = kwarg_names.len();
+        let posargc = total_argc - kwargc;
 
-        let mut kwargs = IndexMap::new();
-        for (name, value) in kwarg_names.iter().zip(kwarg_values) {
-            kwargs.insert(name.clone(), value);
+        let posargs = args.by_ref().take(posargc).collect();
+
+        let kwargs = kwarg_names.zip_eq(args).collect::<IndexMap<_, _>>();
+
+        FuncArgs {
+            args: posargs,
+            kwargs,
         }
-        FuncArgs { args, kwargs }
     }
 
     pub fn prepend_arg(&mut self, item: PyObjectRef) {
diff --git a/vm/src/import.rs b/vm/src/import.rs
index 550de9ca4..b4d238ce2 100644
--- a/vm/src/import.rs
+++ b/vm/src/import.rs
@@ -36,7 +36,7 @@ pub(crate) fn init_importlib(
             let install_external = vm.get_attribute(importlib, "_install_external_importers")?;
             vm.invoke(&install_external, ())?;
             // Set pyc magic number to commit hash. Should be changed when bytecode will be more stable.
-            let importlib_external = vm.import("_frozen_importlib_external", &[], 0)?;
+            let importlib_external = vm.import("_frozen_importlib_external", None, 0)?;
             let mut magic = get_git_revision().into_bytes();
             magic.truncate(4);
             if magic.len() != 4 {
@@ -44,7 +44,7 @@ pub(crate) fn init_importlib(
             }
             vm.set_attr(&importlib_external, "MAGIC_NUMBER", vm.ctx.new_bytes(magic))?;
             let zipimport_res = (|| -> PyResult<()> {
-                let zipimport = vm.import("zipimport", &[], 0)?;
+                let zipimport = vm.import("zipimport", None, 0)?;
                 let zipimporter = vm.get_attribute(zipimport, "zipimporter")?;
                 let path_hooks = vm.get_attribute(vm.sys_module.clone(), "path_hooks")?;
                 let path_hooks = list::PyListRef::try_from_object(vm, path_hooks)?;
diff --git a/vm/src/pyobject.rs b/vm/src/pyobject.rs
index 15f1484ec..1d3b64c3c 100644
--- a/vm/src/pyobject.rs
+++ b/vm/src/pyobject.rs
@@ -763,6 +763,7 @@ pub trait TryIntoRef<T: PyObjectPayload> {
 }
 
 impl<T: PyObjectPayload> TryIntoRef<T> for PyRef<T> {
+    #[inline]
     fn try_into_ref(self, _vm: &VirtualMachine) -> PyResult<PyRef<T>> {
         Ok(self)
     }
diff --git a/vm/src/pyobjectrc.rs b/vm/src/pyobjectrc.rs
index 3467a5840..e4badd23e 100644
--- a/vm/src/pyobjectrc.rs
+++ b/vm/src/pyobjectrc.rs
@@ -317,7 +317,7 @@ impl Drop for PyObjectRef {
                         Ok(v) => println!("{}", v.to_string()),
                         Err(_) => println!("{}", del_method.class().name),
                     }
-                    let tb_module = vm.import("traceback", &[], 0).unwrap();
+                    let tb_module = vm.import("traceback", None, 0).unwrap();
                     // TODO: set exc traceback
                     let print_stack = vm.get_attribute(tb_module, "print_stack").unwrap();
                     vm.invoke(&print_stack, ()).unwrap();
diff --git a/vm/src/vm.rs b/vm/src/vm.rs
index b6e2f97db..b61728589 100644
--- a/vm/src/vm.rs
+++ b/vm/src/vm.rs
@@ -22,7 +22,7 @@ use crate::builtins::object;
 use crate::builtins::pybool;
 use crate::builtins::pystr::{PyStr, PyStrRef};
 use crate::builtins::pytype::PyTypeRef;
-use crate::builtins::tuple::PyTuple;
+use crate::builtins::tuple::{PyTuple, PyTupleTyped};
 use crate::common::{hash::HashSecret, lock::PyMutex, rc::PyRc};
 #[cfg(feature = "rustpython-compiler")]
 use crate::compile::{self, CompileError, CompileErrorType, CompileOpts};
@@ -511,7 +511,7 @@ impl VirtualMachine {
 
     pub fn try_class(&self, module: &str, class: &str) -> PyResult<PyTypeRef> {
         let class = self
-            .get_attribute(self.import(module, &[], 0)?, class)?
+            .get_attribute(self.import(module, None, 0)?, class)?
             .downcast()
             .expect("not a class");
         Ok(class)
@@ -519,7 +519,7 @@ impl VirtualMachine {
 
     pub fn class(&self, module: &str, class: &str) -> PyTypeRef {
         let module = self
-            .import(module, &[], 0)
+            .import(module, None, 0)
             .unwrap_or_else(|_| panic!("unable to import {}", module));
         let class = self
             .get_attribute(module.clone(), class)
@@ -844,16 +844,35 @@ impl VirtualMachine {
         })
     }
 
-    pub fn import(&self, module: &str, from_list: &[PyStrRef], level: usize) -> PyResult {
+    #[inline]
+    pub fn import(
+        &self,
+        module: impl TryIntoRef<PyStr>,
+        from_list: Option<PyTupleTyped<PyStrRef>>,
+        level: usize,
+    ) -> PyResult {
+        self._import_inner(module.try_into_ref(self)?, from_list, level)
+    }
+
+    fn _import_inner(
+        &self,
+        module: PyStrRef,
+        from_list: Option<PyTupleTyped<PyStrRef>>,
+        level: usize,
+    ) -> PyResult {
         // if the import inputs seem weird, e.g a package import or something, rather than just
         // a straight `import ident`
-        let weird = module.contains('.') || level != 0 || !from_list.is_empty();
+        let weird = module.borrow_value().contains('.')
+            || level != 0
+            || from_list
+                .as_ref()
+                .map_or(false, |x| !x.borrow_value().is_empty());
 
         let cached_module = if weird {
             None
         } else {
             let sys_modules = self.get_attribute(self.sys_module.clone(), "modules")?;
-            sys_modules.get_item(module, self).ok()
+            sys_modules.get_item(module.clone(), self).ok()
         };
 
         match cached_module {
@@ -871,7 +890,7 @@ impl VirtualMachine {
                 let import_func = self
                     .get_attribute(self.builtins.clone(), "__import__")
                     .map_err(|_| {
-                        self.new_import_error("__import__ not found".to_owned(), module)
+                        self.new_import_error("__import__ not found".to_owned(), module.clone())
                     })?;
 
                 let (locals, globals) = if let Some(frame) = self.current_frame() {
@@ -879,9 +898,10 @@ impl VirtualMachine {
                 } else {
                     (None, None)
                 };
-                let from_list = self
-                    .ctx
-                    .new_tuple(from_list.iter().map(|x| x.as_object().clone()).collect());
+                let from_list = match from_list {
+                    Some(tup) => tup.into_pyobject(self),
+                    None => self.ctx.new_tuple(vec![]),
+                };
                 self.invoke(&import_func, (module, globals, locals, from_list, level))
                     .map_err(|exc| import::remove_importlib_frames(self, &exc))
             }
@@ -1287,7 +1307,7 @@ impl VirtualMachine {
         encoding: Option<PyStrRef>,
         errors: Option<PyStrRef>,
     ) -> PyResult {
-        let codecsmodule = self.import("_codecs", &[], 0)?;
+        let codecsmodule = self.import("_codecs", None, 0)?;
         let func = self.get_attribute(codecsmodule, func)?;
         let mut args = vec![obj, encoding.into_pyobject(self)];
         if let Some(errors) = errors {