// A real example:// Reading a line of user input requires a heap allocator because// in theory the input length is unbounded. In practice though,// the input is almost always a short search query or path that// fits in well under 1kb.//// stackFallback puts a fixed-size buffer on the stack and only// hits the heap when the input overflows it. The common case// costs zero heap allocations. The rare long input still works// because the allocator silently upgrades to the heap.
var stack_fallback = std.heap.stackFallback(256, heap_allocator);const alloc = stack_fallback.get();const line =try reader.readUntilDelimiterAlloc(alloc,'\n',4096);defer alloc.free(line);

pub const TaggedClass =  enum(u3) {    ns_atom =  0,    ns_string =  1,    ns_number =  2,    ns_date =  3,};
pub const ObjcTaggedPointer =  packed struct {
    is_tagged :  bool =  true,
    class : TaggedClass,
    payload :  u60,
    pub fn ns_number(n :  u60) ObjcTaggedPointer {       return. {          .class =.ns_number, .payload = n       };
  }
pub fn from_raw(raw :  u64) ObjcTaggedPointer {    return @bitCast(raw);}
pub fn raw(self : ObjcTaggedPointer)  u64 {
  return @bitCast(self);
}
pub fn is_ns_number(self : ObjcTaggedPointer)  bool{
  return self.is_tagged  and self.class  == .ns_number;
}};

pub struct ObjcTaggedPointer(u64);
impl ObjcTaggedPointer{
  const TAG_MASK : u64 = 0b1;
  const CLASS_MASK : u64 = 0b1110;
  const CLASS_SHIFT : u64 = 1;
  const PAYLOAD_SHIFT : u64 = 4;
  const CLASS_NS_ATOM : u64 = 0;
  const CLASS_NS_STRING : u64 = 1;
  const CLASS_NS_NUMBER : u64 = 2;
  const CLASS_NS_DATE : u64 = 3;
  pub fn ns_number(: u64)->Self  {
        Self(
          (n  << Self ::PAYLOAD_SHIFT)
              | (Self ::CLASS_NS_NUMBER  << Self ::CLASS_SHIFT)
              | Self ::TAG_MASK,
          )
  }
  pub fn is_ns_number(self)->bool{
            self.0 & Self ::TAG_MASK  != 0
        && (self.0 & Self ::CLASS_MASK) >> Self ::CLASS_SHIFT  == Self ::CLASS_NS_NUMBER  }}

fn ArrayList(comptime T :  type)  type{  return struct  {
        items : [] T,
        capacity :  usize,
        allocator : Allocator,
    };}
const IntList =  ArrayList(i32);

use euclid :: {  point2, vec2, Point2D, Translation2D, Vector2D};
struct WorldSpace;
struct ScreenSpace;
type WorldPoint = Point2DWorldSpace>;
type WorldVector = Vector2DWorldSpace>;
type ScreenPoint = Point2DScreenSpace>;
fn main(){
  let player : WorldPoint = point2(10 .0, 20 .0);  let movement : WorldVector = vec2(5 .0, 0 .0);
  // Allowed: point + vector in the same space.  let moved_player  = player  + movement;
  // Allowed: explicitly convert from world space to screen space.  let world_to_screen = Translation2D ::WorldSpace, ScreenSpace>::new (100 .0, 50 .0);
  let player_on_screen : ScreenPoint = world_to_screen.transform_point(moved_player);
  // Disallowed: can't mix coordinate spaces.  let bad : ScreenPoint = player;}