diff --git a/src/std/net.zr b/src/std/net.zr
index ac3e7f1..61bdfde 100644
--- a/src/std/net.zr
+++ b/src/std/net.zr
@@ -81,8 +81,8 @@ func net.read[s: i64, buffer: ptr, size: i64] : i64
 func net.close[s: i64] : void
     _builtin_syscall(SYS_close, s)
 
-func net.pack_addr[a: u8, b: u8, c: u8, d: u8] : i64
-    return (a as i64 << 24) | (b << 16) | (c << 8) | d
+func net.pack_addr[a: i64, b: i64, c: i64, d: i64] : i64
+    return (a << 24) | (b << 16) | (c << 8) | d
 
 struct net.UDPSocket
     fd: i64
@@ -201,7 +201,7 @@ func net.resolve?[domain: str] : i64
     let query: io.Buffer = net.build_dns_query(domain, DNS_TYPE_A)
 
     // TODO: this probably shouldnt be hardcoded
-    let s: net.UDPSocket = net.create_udp_client?(net.pack_addr(8 as u8, 8 as u8, 8 as u8, 8 as u8), 53)
+    let s: net.UDPSocket = net.create_udp_client?(net.pack_addr(8, 8, 8, 8), 53)
     if err.check()
         return -1
 
@@ -221,6 +221,6 @@ func net.resolve?[domain: str] : i64
 
     pos = pos + 12 // skip name(2), type(2), class(2), ttl(4), rdlength(2)
 
-    let out: i64 = net.pack_addr(pkt->data[pos], pkt->data[pos+1], pkt->data[pos+2], pkt->data[pos+3])
+    let out: i64 = net.pack_addr(pkt->data[pos] as i64, pkt->data[pos+1] as i64, pkt->data[pos+2] as i64, pkt->data[pos+3] as i64)
     net.UDPPacket.free(pkt)
     return out
diff --git a/src/std/std.zr b/src/std/std.zr
index b9afe49..36faf2f 100644
--- a/src/std/std.zr
+++ b/src/std/std.zr
@@ -103,7 +103,7 @@ func mem.alloc?[size: i64] : any
         if cur->free && cur->size >= size
             mem._split_block(cur, size)
             cur->free = false
-            return cur + MEM_BLOCK_SIZE
+            return cur as ptr + MEM_BLOCK_SIZE
         cur = cur->next
     
     let blk: mem.Block = mem._request_space?(size)
@@ -115,7 +115,7 @@ func mem.alloc?[size: i64] : any
     
     mem._split_block(blk, size)
     
-    return blk + MEM_BLOCK_SIZE
+    return blk as ptr + MEM_BLOCK_SIZE
 
 func mem.alloc[size: i64] : any
     return must(mem.alloc?(size))
@@ -335,7 +335,7 @@ func io.read_line[]: str
     if n < 0
         n = 0
     buffer[n] = 0
-    buffer = must(mem.realloc?(buffer, n + 1))
+    buffer = must(mem.realloc?(buffer as ptr, n + 1))
     return buffer
 
 struct io.Buffer
@@ -1001,7 +1001,7 @@ func os.list_directory?[path: str] : Array
                         if name[2] == 0
                             skip = true
                 if !skip
-                    array.push(files, str.make_copy(name))
+                    array.push(files, str.make_copy(name as str))
             pos = pos + len
 
     mem.free(buf)
diff --git a/src/typechecker.rs b/src/typechecker.rs
index 54beae8..2527371 100644
--- a/src/typechecker.rs
+++ b/src/typechecker.rs
@@ -7,14 +7,15 @@ use crate::{
 };
 
 macro_rules! expect_type {
-    ($expr_type:expr, $expected:expr, $loc:expr) => {
-        if $expected != "any" && $expr_type != "any" && $expr_type != $expected {
+    ($expr_type:expr, $expected:expr, $loc:expr) => {{
+        let actual = $expr_type;
+        if $expected != "any" && actual != "any" && actual != $expected {
             return error!(
                 $loc,
-                format!("expected type '{}', got '{}'", $expected, $expr_type)
+                format!("expected type '{}', got '{}'", $expected, actual)
             );
         }
-    };
+    }};
 }
 
 macro_rules! expect_types {
@@ -98,7 +99,7 @@ impl TypeChecker {
                             "unrecognized type: ".to_owned() + &var_type.lexeme
                         );
                     }
-                    expect_type!(actual_type, var_type.lexeme, var_type.loc);
+                    expect_type!(actual_type.clone(), var_type.lexeme, var_type.loc);
 
                     if actual_type == "any" {
                         actual_type = var_type.lexeme.clone();
@@ -288,7 +289,7 @@ impl TypeChecker {
                                 );
                             }
                         };
-                        expect_type!(value_type, *existing_var_type, name.loc);
+                        expect_type!(value_type.clone(), *existing_var_type, name.loc);
                     }
                     Expr::Index {
                         expr,
@@ -297,7 +298,7 @@ impl TypeChecker {
                     } => {
                         expect_types!(self.typecheck_expr(env, expr)?, ["ptr", "str"], bracket.loc);
                         expect_types!(self.typecheck_expr(env, index)?, ["i64", "u8"], bracket.loc);
-                        expect_types!(value_type, ["u8", "i64"], bracket.loc);
+                        expect_types!(value_type.clone(), ["u8", "i64"], bracket.loc);
                     }
                     Expr::MemberAccess { left, field } => {
                         let left_type = self.typecheck_expr(env, left)?;
@@ -323,7 +324,7 @@ impl TypeChecker {
                             }
                         };
 
-                        expect_type!(value_type, f.field_type, field.loc);
+                        expect_type!(value_type.clone(), f.field_type, field.loc);
                     }
                     _ => return error!(&op.loc, "invalid assignment target"),
                 }
@@ -343,11 +344,16 @@ impl TypeChecker {
                     {
                         let fn_type =
                             &self.analyzer.borrow().functions[&callee_name.lexeme].clone();
+                        // its a function (defined/builtin/extern)
                         if let Some(params) = fn_type.params.clone() {
-                            // its a function (defined/builtin/extern)
                             for (i, arg) in args.iter().enumerate() {
                                 expect_type!(self.typecheck_expr(env, arg)?, params[i], paren.loc);
                             }
+                        } else {
+                            // its a variadic function, cant check arg types
+                            for arg in args {
+                                self.typecheck_expr(env, arg)?;
+                            }
                         }
                         Ok(fn_type.return_type.clone())
                     } else {