/map. That command requires you to also have the map in your database. Use change_map test in rcon instead. 
mod foo {
pub fn main() -> i32 {
for (let mut n: i64 = 1; n <= undefined_var; n = n + 1) {
return 0;
}
}
} 
mod foo {
struct Owo {
field: i32
}
pub fn main() -> i32 {
let owo: Owo = Owo {
field: 11,
};
let a: &Owo = &owo;
let b: &i32 = a as &i32;
return *b;
}
}
I would call it a feature in my lang
uint8_t* and int32_t* even though they are both of type pointer?
mod foo {
pub fn main() -> i32 {
for (let mut n: i64 = 1; n <= undefined_var; n = n + 1) {
return 0;
}
}
} SomeClass *pIdk = pSomeParentClass
mod foo {
pub fn main() -> i32 {
for (let mut n: i64 = 1; n <= undefined_var; n = n + 1) {
return 0;
}
}
} 
SomeClass *pIdk = pSomeParentClass 
sudo pacman -S --needed base-devel cmake curl ffmpeg freetype2 git glew glslang gmock libnotify libpng opusfile python rust sdl2 spirv-tools sqlite vulkan-headers vulkan-icd-loader wavpack x264 
mod vec {
extern fn malloc(size: u64) -> *mut u8;
extern fn realloc(ptr: *mut u8, size: u64) -> *mut u8;
#[intrinsic = "sizeof"]
fn sizeof<T>() -> u64;
struct Vec<T> {
ptr: *mut T,
len: u64,
cap: u64,
}
impl<T> Vec<T> {
pub fn new(type_size: u64) -> Vec<T> {
let vec: Vec<T> = Vec::<T> {
ptr: malloc(sizeof::<T>() * 32) as *mut T,
len: 0,
cap: 32,
};
return vec;
}
pub fn push(&mut self, value: T) {
let type_size: u64 = sizeof::<T>();
if self.len <= self.cap {
let new_cap: u64 = self.cap * 2;
self.ptr = realloc(self.ptr as *mut u8, type_size * new_cap) as *mut T;
self.cap = new_cap;
}
let target_ptr: *mut T = (self.ptr + (self.len * type_size)) as *mut T;
*target_ptr = value;
self.len = self.len + 1;
}
pub fn get(&self, at: u64) -> &T {
// todo: bounds check
let target_ptr: *mut T = (self.ptr + (at * sizeof::<T>())) as *mut T;
return target_ptr as &T;
}
}
fn main() -> i32 {
let type_size: u64 = 4;
let mut vec: Vec<i32> = Vec::<i32>#new(type_size);
vec.push(2);
vec.push(3);
vec.push(4);
vec.push(5);
let pushed: &i32 = vec.get(2);
return *pushed;
}
}
@MilkeeyCat type_size in new fn
polymorphic i think it's some rocket science 
int64_t main() {
int64_t a = 1 + 2;
int64_t b = 3 + 4;
return b - a;
}
.section .text
.global main
main:
.L0:
mov r15, 1
add r15, 2
mov r14, 3
add r14, 4
mov rax, r14
sub rax, r15
ret int64_t main() {
int64_t a = 1 + 2;
int64_t b = 3 + 4;
return b - a;
}
.section .text
.global main
main:
.L0:
mov r15, 1
add r15, 2
mov r14, 3
add r14, 4
mov rax, r14
sub rax, r15
ret 
2
