SYMBOL INDEX (1165 symbols across 98 files)

FILE: benchmarks/Dict/dict_c.c
  function main (line 8) | int main(int argc, char *argv[])

FILE: benchmarks/Dict/dict_cello.c
  function main (line 10) | int main(int argc, char *argv[]) {

FILE: benchmarks/Dict/dict_cpp.cpp
  type eqstr (line 9) | struct eqstr {
  type std (line 15) | namespace std {
    type hash<const char *> (line 17) | struct hash<const char *> : public std::unary_function<const char *, s...
  function main (line 32) | int main(int argc, char *argv[])

FILE: benchmarks/Dict/dict_cs.cs
  class dict_v1 (line 4) | class dict_v1 {
    method Main (line 5) | static void Main() {

FILE: benchmarks/Dict/dict_go.go
  function main (line 10) | func main() {

FILE: benchmarks/Dict/dict_java.java
  class dict_java (line 4) | class dict_java {
    method main (line 5) | public static void main(String[] args) {

FILE: benchmarks/Dict/dict_javascript.js
  function processLine (line 4) | function processLine (l) {

FILE: benchmarks/Dict/dict_python.py
  function count_duplicates (line 3) | def count_duplicates(lines):

FILE: benchmarks/GC/gc_c.c
  function create_objects (line 3) | static void create_objects(int depth) {
  function main (line 34) | int main(int argc, char** argv) {

FILE: benchmarks/GC/gc_cello.c
  function create_objects (line 3) | static void create_objects(int depth) {
  function main (line 34) | int main(int argc, char** argv) {

FILE: benchmarks/GC/gc_cpp.cpp
  class Int (line 3) | class Int {
    method Int (line 6) | Int() : i(0) {}
  function create_objects (line 9) | static void create_objects(int depth) {
  function main (line 40) | int main(int argc, char** argv) {

FILE: benchmarks/GC/gc_java.java
  class gc_java (line 1) | public final class gc_java {
    class Int (line 3) | final public static class Int {
      method Int (line 5) | Int(int x) {
    method create_objects (line 10) | public static void create_objects(int depth) {
    method main (line 41) | public static void main(String[] args) {

FILE: benchmarks/GC/gc_javascript.js
  function Int (line 2) | function Int() {
  function create_objects (line 6) | function create_objects(depth) {

FILE: benchmarks/GC/gc_python.py
  class Int (line 2) | class Int:
  function create_objects (line 5) | def create_objects(depth):

FILE: benchmarks/GC/gc_ruby.rb
  class Int (line 2) | class Int
  function create_objects (line 5) | def create_objects(depth)

FILE: benchmarks/List/list_c.c
  function main (line 5) | int main(int argc, char** argv) {

FILE: benchmarks/List/list_cello.c
  function main (line 3) | int main(int argc, char** argv) {

FILE: benchmarks/List/list_cpp.cpp
  function main (line 4) | int main(int argc, char** argv) {

FILE: benchmarks/List/list_java.java
  class list_java (line 5) | class list_java {
    method main (line 6) | public static void main(String[] args) {

FILE: benchmarks/Map/map_c.c
  type elem_t (line 4) | typedef struct {
  function main (line 15) | int main(int argc, char *argv[])

FILE: benchmarks/Map/map_cello.c
  function main (line 10) | int main(int argc, char *argv[]) {

FILE: benchmarks/Map/map_cpp.cpp
  type eqstr (line 9) | struct eqstr {
  function main (line 20) | int main(int argc, char *argv[])

FILE: benchmarks/Map/map_cs.cs
  class dict_v1 (line 4) | class dict_v1 {
    method Main (line 5) | static void Main() {

FILE: benchmarks/Map/map_go.go
  function main (line 10) | func main() {

FILE: benchmarks/Map/map_java.java
  class map_java (line 4) | class map_java {
    method main (line 5) | public static void main(String[] args) {

FILE: benchmarks/Map/map_javascript.js
  function processLine (line 7) | function processLine (l) {

FILE: benchmarks/Map/map_python.py
  function count_duplicates (line 4) | def count_duplicates(lines):

FILE: benchmarks/Matmul/matmul_c.c
  function mm_destroy (line 15) | void mm_destroy(int n, double **m)
  function main (line 52) | int main(int argc, char *argv[])

FILE: benchmarks/Matmul/matmul_cello.c
  type Matrix (line 3) | struct Matrix {
  function Matrix_New (line 8) | static void Matrix_New(var self, var args) {
  function Matrix_Del (line 17) | static void Matrix_Del(var self) {
  type Matrix (line 25) | struct Matrix
  type Matrix (line 26) | struct Matrix
  function var (line 36) | static var Matrix_Mul(var m0, var m1) {
  function main (line 60) | int main(int argc, char *argv[]) {

FILE: benchmarks/Matmul/matmul_cpp.cpp
  class Matrix (line 3) | class Matrix {
  function Matrix (line 27) | static Matrix* Matrix_Gen(int n) {
  function Matrix (line 38) | static Matrix* Matrix_Mul(Matrix* m0, Matrix* m1) {
  function main (line 62) | int main(int argc, char *argv[]) {

FILE: benchmarks/Matmul/matmul_cs.cs
  class matmul_v1 (line 8) | class matmul_v1 {
    method matgen (line 9) | public double[,] matgen(int n) {
    method matmul (line 17) | public double[,] matmul(double[,] a, double[,] b) {
    method Main (line 33) | public static void Main(String[] args) {

FILE: benchmarks/Matmul/matmul_dart.dart
  function mat_transpose (line 3) | mat_transpose(a)
  function mat_mul (line 14) | mat_mul(a, b)
  function inner_loop (line 16) | inner_loop(t, n, ai, c)
  function mat_gen (line 35) | mat_gen(int n)
  function main (line 47) | main()

FILE: benchmarks/Matmul/matmul_go.go
  function matgen (line 9) | func matgen(n int) [][]float64 {
  function matmul (line 21) | func matmul(a [][]float64, b [][]float64) [][]float64 {
  function main (line 46) | func main() {

FILE: benchmarks/Matmul/matmul_java.java
  class matmul_java (line 3) | class matmul_java {
    method matgen (line 4) | public double[][] matgen(int n) {
    method matmul (line 12) | public double[][] matmul(double[][] a, double[][] b) {
    method main (line 28) | public static void main(String[] args) {

FILE: benchmarks/Matmul/matmul_javascript.js
  function matgen (line 30) | function matgen(n) {

FILE: benchmarks/Matmul/matmul_python.py
  function matmul (line 7) | def matmul(a, b): # FIXME: no error checking
  function main (line 20) | def main():

FILE: benchmarks/Matmul/matmul_ruby.rb
  function matmul (line 6) | def matmul(a, b)
  function matgen (line 32) | def matgen(n)

FILE: benchmarks/Nbodies/nbodies_c.c
  type Body (line 10) | struct Body {
  function Body_Offset_Momentum (line 16) | static void Body_Offset_Momentum(struct Body* b, double px, double py, d...
  function Bodies_Advance (line 22) | static void Bodies_Advance(struct Body* bodies, size_t nbodies, double d...
  function Bodies_Energy (line 58) | static double Bodies_Energy(struct Body* bodies, size_t nbodies) {
  function main (line 91) | int main(int argc, char** argv) {

FILE: benchmarks/Nbodies/nbodies_cello.c
  type Body (line 6) | struct Body {
  function Body_Offset_Momentum (line 12) | static void Body_Offset_Momentum(struct Body* self, double px, double py...
  function Bodies_Advance (line 20) | static void Bodies_Advance(var bodies, double dt) {
  function Bodies_Energy (line 58) | static double Bodies_Energy(var bodies) {
  function main (line 92) | int main(int argc, char** argv) {

FILE: benchmarks/Nbodies/nbodies_cpp.cpp
  class Body (line 10) | class Body {
    method Body (line 14) | Body(double  x, double  y, double  z,
    method Offset_Momentum (line 22) | void Offset_Momentum(double px, double py, double pz) {
  function Bodies_Advance (line 30) | static void Bodies_Advance(std::vector<Body*> bodies, double dt) {
  function Bodies_Energy (line 65) | static double Bodies_Energy(std::vector<Body*> bodies) {
  function main (line 98) | int main(int argc, char** argv) {

FILE: benchmarks/Nbodies/nbodies_java.java
  class nbodies_java (line 1) | public final class nbodies_java {
    method main (line 2) | public static void main(String[] args) {
  class NBodySystem (line 11) | final class NBodySystem {
    method NBodySystem (line 14) | public NBodySystem(){
    method advance (line 34) | public void advance(double dt) {
    method energy (line 64) | public double energy(){
  class Body (line 90) | final class Body {
    method Body (line 97) | public Body(){}
    method jupiter (line 99) | static Body jupiter(){
    method saturn (line 111) | static Body saturn(){
    method uranus (line 123) | static Body uranus(){
    method neptune (line 135) | static Body neptune(){
    method sun (line 147) | static Body sun(){
    method offsetMomentum (line 153) | Body offsetMomentum(double px, double py, double pz){

FILE: benchmarks/Nbodies/nbodies_javascript.js
  function body_offset_momentum (line 47) | function body_offset_momentum(b, px, py, pz) {
  function bodies_new (line 54) | function bodies_new() {
  function bodies_advance (line 74) | function bodies_advance(bodies, dt) {
  function bodies_energy (line 111) | function bodies_energy(bodies) {

FILE: benchmarks/Nbodies/nbodies_python.py
  class Body (line 12) | class Body:
    method __init__ (line 14) | def __init__(self, x, y, z, vx, vy, vz, mass):
  function body_offset_momentum (line 72) | def body_offset_momentum(b, px, py, pz):
  function bodies_new (line 78) | def bodies_new():
  function bodies_advance (line 98) | def bodies_advance(bodies, dt):
  function bodies_energy (line 130) | def bodies_energy(bodies):

FILE: benchmarks/Nbodies/nbodies_ruby.rb
  class Planet (line 4) | class Planet
    method initialize (line 7) | def initialize(x, y, z, vx, vy, vz, mass)
    method move_from_i (line 13) | def move_from_i(bodies, nbodies, dt, i)
  function energy (line 39) | def energy(bodies)
  function offset_momentum (line 58) | def offset_momentum(bodies)

FILE: benchmarks/Sudoku/sudoku_c.c
  type sdaux_t (line 80) | typedef struct {
  function sdaux_t (line 86) | sdaux_t *sd_genmat()
  function sd_update (line 107) | static inline int sd_update(const sdaux_t *aux, int8_t sr[729], uint8_t ...
  function sd_solve (line 133) | int sd_solve(const sdaux_t *aux, const char *_s)
  function main (line 179) | int main()

FILE: benchmarks/Sudoku/sudoku_cello.c
  type Sudoku (line 3) | struct Sudoku {
  function Sudoku_New (line 8) | static void Sudoku_New(var self, var args) {
  function Sudoku_Update (line 30) | static int Sudoku_Update(
  function Sudoku_Solve (line 58) | static int Sudoku_Solve(struct Sudoku* aux, const char *_s) {
  function main (line 103) | int main(int argc, char** argv) {

FILE: benchmarks/Sudoku/sudoku_cpp.cpp
  class sdaux_t (line 80) | class sdaux_t {
  function main (line 181) | int main()

FILE: benchmarks/Sudoku/sudoku_cs.cs
  class sudoku_v1 (line 3) | class sudoku_v1 {
    method genmat (line 5) | public void genmat() {
    method sd_update (line 25) | private int sd_update(int[] sr, int[] sc, int r, int v) {
    method solve (line 50) | public int solve(String _s) {
    method Main (line 98) | public static void Main(String[] args) {

FILE: benchmarks/Sudoku/sudoku_dart.dart
  class Sudoku (line 5) | class Sudoku {
  function main (line 98) | main()

FILE: benchmarks/Sudoku/sudoku_go.go
  type sdaux_t (line 9) | type sdaux_t struct
  function sd_genmat (line 14) | func sd_genmat() *sdaux_t {
  function sd_update_forward (line 42) | func sd_update_forward(aux *sdaux_t, sr []int8, sc []uint8, r uint16) int {
  function sd_update_revert (line 66) | func sd_update_revert(aux *sdaux_t, sr []int8, sc []uint8, r uint16) {
  function sd_solve (line 84) | func sd_solve(aux *sdaux_t, _s []byte) int {
  function main (line 161) | func main() {

FILE: benchmarks/Sudoku/sudoku_java.java
  class sudoku_java (line 3) | class sudoku_java {
    method genmat (line 5) | public void genmat() {
    method sd_update (line 25) | private int sd_update(int[] sr, int[] sc, int r, int v) {
    method solve (line 51) | public int solve(String _s) {
    method main (line 99) | public static void main(String[] args) throws Exception {

FILE: benchmarks/Sudoku/sudoku_javascript.js
  function Sudoku (line 1) | function Sudoku() {
  function processLine (line 90) | function processLine (l) {

FILE: benchmarks/Sudoku/sudoku_python.py
  function sd_genmat (line 8) | def sd_genmat():
  function sd_update (line 16) | def sd_update(R, C, sr, sc, r, v):
  function sd_solve (line 37) | def sd_solve(R, C, s):

FILE: benchmarks/Sudoku/sudoku_ruby.rb
  function sd_genmat (line 1) | def sd_genmat()
  function sd_update (line 21) | def sd_update(mr, mc, sr, sc, r, v)
  function sd_solve (line 56) | def sd_solve(mr, mc, s)

FILE: benchmarks/ext/cleantxt.c
  function main (line 5) | int main(int argc, char *argv[])

FILE: benchmarks/ext/genint.c
  function main (line 7) | int main(int argc, char *argv[])

FILE: benchmarks/ext/kbtree.h
  type kbnode_t (line 35) | typedef struct {
  type __kbstack_t (line 327) | typedef struct {

FILE: benchmarks/ext/khash.h
  type khint32_t (line 106) | typedef unsigned int khint32_t;
  type khint32_t (line 108) | typedef unsigned long khint32_t;
  type khint64_t (line 112) | typedef unsigned long khint64_t;
  type khint64_t (line 114) | typedef unsigned long long khint64_t;
  type khint32_t (line 121) | typedef khint32_t khint_t;
  type khint_t (line 122) | typedef khint_t khiter_t;
  function khint_t (line 336) | static inline khint_t __ac_X31_hash_string(const char *s)

FILE: benchmarks/ext/regexp9.c
  function chartorune (line 74) | int
  function Rune (line 130) | Rune*
  function _renewmatch (line 182) | static void
  function Relist (line 203) | static Relist*
  function Relist (line 235) | static Relist*
  function Relist (line 261) | static Relist*
  type Node (line 297) | typedef
  function rcerror (line 332) | static	void
  function Reinst (line 340) | static	Reinst*
  function operand (line 349) | static	void
  function operator (line 367) | static	void
  function regerr2 (line 387) | static	void
  function cant (line 399) | static	void
  function pushand (line 408) | static	void
  function pushator (line 418) | static	void
  function Node (line 427) | static	Node*
  function popator (line 440) | static	int
  function evaluntil (line 449) | static	void
  function Reprog (line 514) | static	Reprog*
  function dumpstack (line 566) | static	void
  function dump (line 579) | static	void
  function Reclass (line 607) | static	Reclass*
  function nextc (line 615) | static	int
  function lex (line 632) | static	int
  function bldcclass (line 671) | static int
  function Reprog (line 757) | static	Reprog*
  function Reprog (line 825) | extern	Reprog*
  function Reprog (line 831) | extern	Reprog*
  function Reprog (line 837) | extern	Reprog*
  function regexec1 (line 852) | static int
  function regexec2 (line 998) | static int
  function regexec9 (line 1029) | extern int
  function regsub9 (line 1079) | extern	void
  function regerror9 (line 1143) | void
  function rregexec1 (line 1164) | static int
  function rregexec2 (line 1304) | static int
  function rregexec9 (line 1323) | extern int
  function rregsub9 (line 1373) | extern	void

FILE: benchmarks/ext/regexp9.h
  type Rune (line 8) | typedef unsigned short Rune;
  type Resub (line 10) | typedef struct Resub		Resub;
  type Reclass (line 11) | typedef struct Reclass		Reclass;
  type Reinst (line 12) | typedef struct Reinst		Reinst;
  type Reprog (line 13) | typedef struct Reprog		Reprog;
  type Resub (line 38) | struct Resub{
  type Reclass (line 54) | struct Reclass{
  type Reinst (line 62) | struct Reinst{
  type Reprog (line 79) | struct Reprog{
  type uchar (line 111) | typedef unsigned char uchar;
  type Resublist (line 115) | typedef struct Resublist	Resublist;
  type Resublist (line 116) | struct	Resublist
  type Relist (line 158) | typedef struct Relist	Relist;
  type Relist (line 159) | struct Relist
  type Reljunk (line 164) | typedef struct Reljunk	Reljunk;
  type Reljunk (line 165) | struct	Reljunk

FILE: examples/cello_world.c
  function main (line 3) | int main(int argc, char** argv) {

FILE: examples/help.c
  function main (line 3) | int main(int argc, char** argv) {

FILE: examples/iteration.c
  function main (line 3) | int main(int argc, char** argv) {

FILE: examples/newtype.c
  type ExampleType (line 7) | struct ExampleType {
  function ExampleType_New (line 12) | static void ExampleType_New(var self, var args) {
  function ExampleType_Cmp (line 18) | static int ExampleType_Cmp(var self, var obj) {
  function main (line 24) | int main(int argc, char** argv) {

FILE: examples/object.c
  type Point (line 4) | struct Point {
  function main (line 11) | int main(int argc, char** argv) {

FILE: examples/ranges.c
  function main (line 3) | int main(int argc, char** argv) {

FILE: examples/table.c
  function main (line 3) | int main(int argc, char** argv) {

FILE: examples/threads.c
  function var (line 4) | var say_hello(var args) {
  function main (line 11) | int main(int argc, char** argv) {

FILE: include/Cello.h
  type Header (line 228) | struct Header {
  type Type (line 238) | struct Type {
  type Ref (line 244) | struct Ref {
  type Box (line 248) | struct Box {
  type Int (line 252) | struct Int {
  type Float (line 256) | struct Float {
  type String (line 260) | struct String {
  type Tuple (line 264) | struct Tuple {
  type Range (line 268) | struct Range {
  type Slice (line 275) | struct Slice {
  type Zip (line 280) | struct Zip {
  type Filter (line 285) | struct Filter {
  type Map (line 290) | struct Map {
  type File (line 296) | struct File {
  type Process (line 300) | struct Process {
  type Function (line 304) | struct Function {
  type Example (line 343) | struct Example {
  type Method (line 348) | struct Method {
  type Doc (line 354) | struct Doc {
  type Help (line 363) | struct Help {
  type Cast (line 367) | struct Cast {
  type Size (line 371) | struct Size {
  type Alloc (line 375) | struct Alloc {
  type New (line 380) | struct New {
  type Copy (line 385) | struct Copy {
  type Assign (line 389) | struct Assign {
  type Swap (line 393) | struct Swap {
  type Cmp (line 397) | struct Cmp {
  type Hash (line 401) | struct Hash {
  type Len (line 405) | struct Len {
  type Push (line 409) | struct Push {
  type Concat (line 416) | struct Concat {
  type Get (line 421) | struct Get {
  type Iter (line 430) | struct Iter {
  type Sort (line 438) | struct Sort {
  type Resize (line 442) | struct Resize {
  type C_Str (line 446) | struct C_Str {
  type C_Int (line 450) | struct C_Int {
  type C_Float (line 454) | struct C_Float {
  type Stream (line 458) | struct Stream {
  type Pointer (line 469) | struct Pointer {
  type Call (line 474) | struct Call {
  type Format (line 478) | struct Format {
  type Show (line 483) | struct Show {
  type Current (line 488) | struct Current {
  type Start (line 492) | struct Start {
  type Lock (line 499) | struct Lock {
  type Mark (line 505) | struct Mark {
  type Header (line 546) | struct Header

FILE: src/Alloc.c
  type Header (line 3) | struct Header
  type Header (line 4) | struct Header
  type Header (line 4) | struct Header
  function var (line 7) | var header_init(var head, var type, int alloc) {
  type Example (line 56) | struct Example
  type Example (line 58) | struct Example
  type Method (line 77) | struct Method
  type Method (line 79) | struct Method
  function var (line 127) | static var alloc_by(var type, int method) {
  function var (line 162) | var alloc(var type)      { return alloc_by(type, ALLOC_STANDARD); }
  function var (line 163) | var alloc_raw(var type)  { return alloc_by(type, ALLOC_RAW); }
  function var (line 164) | var alloc_root(var type) { return alloc_by(type, ALLOC_ROOT); }
  function dealloc (line 166) | void dealloc(var self) {
  function dealloc_raw (line 209) | void dealloc_raw(var self)  { dealloc(self); }
  function dealloc_root (line 210) | void dealloc_root(var self) { dealloc(self); }
  type Example (line 254) | struct Example
  type Example (line 256) | struct Example
  type Method (line 273) | struct Method
  type Method (line 275) | struct Method
  function var (line 317) | var construct_with(var self, var args) {
  function var (line 327) | var destruct(var self) {
  function var (line 335) | var new_with(var type, var args) {
  function var (line 339) | var new_raw_with(var type, var args) {
  function var (line 343) | var new_root_with(var type, var args) {
  function del_by (line 347) | static void del_by(var self, int method) {
  function del (line 364) | void del(var self) { del_by(self, ALLOC_STANDARD); }
  function del_raw (line 365) | void del_raw(var self) { del_by(self, ALLOC_RAW); }
  function del_root (line 366) | void del_root(var self) { del_by(self, ALLOC_ROOT); }
  type Example (line 402) | struct Example
  type Example (line 404) | struct Example
  type Method (line 419) | struct Method
  type Method (line 421) | struct Method
  function var (line 437) | var copy(var self) {

FILE: src/Array.c
  type Example (line 30) | struct Example
  type Example (line 32) | struct Example
  type Array (line 80) | struct Array {
  function Array_Step (line 88) | static size_t Array_Step(struct Array* a) {
  function var (line 92) | static var Array_Item(struct Array* a, size_t i) {
  function Array_Alloc (line 96) | static void Array_Alloc(struct Array* a, size_t i) {
  function Array_Size_Round (line 102) | static size_t Array_Size_Round(size_t s) {
  function Array_New (line 106) | static void Array_New(var self, var args) {
  function Array_Del (line 134) | static void Array_Del(var self) {
  function Array_Clear (line 146) | static void Array_Clear(var self) {
  function Array_Assign (line 161) | static void Array_Assign(var self, var obj) {
  function Array_Reserve_More (line 205) | static void Array_Reserve_More(struct Array* a) {
  function Array_Concat (line 219) | static void Array_Concat(var self, var obj) {
  function Array_Cmp (line 240) | static int Array_Cmp(var self, var obj) {
  function Array_Hash (line 259) | static uint64_t Array_Hash(var self) {
  function Array_Len (line 270) | static size_t Array_Len(var self) {
  function Array_Mem (line 275) | static bool Array_Mem(var self, var obj) {
  function Array_Reserve_Less (line 285) | static void Array_Reserve_Less(struct Array* a) {
  function Array_Pop_At (line 292) | static void Array_Pop_At(var self, var key) {
  function Array_Rem (line 316) | static void Array_Rem(var self, var obj) {
  function Array_Push (line 327) | static void Array_Push(var self, var obj) {
  function Array_Push_At (line 335) | static void Array_Push_At(var self, var obj, var key) {
  function Array_Pop (line 359) | static void Array_Pop(var self) {
  function var (line 376) | static var Array_Get(var self, var key) {
  function Array_Set (line 392) | static void Array_Set(var self, var key, var val) {
  function var (line 409) | static var Array_Iter_Init(var self) {
  function var (line 415) | static var Array_Iter_Next(var self, var curr) {
  function var (line 424) | static var Array_Iter_Last(var self) {
  function var (line 430) | static var Array_Iter_Prev(var self, var curr) {
  function var (line 439) | static var Array_Iter_Type(var self) {
  function Array_Sort_Partition (line 444) | static size_t Array_Sort_Partition(
  function Array_Sort_Part (line 463) | static void Array_Sort_Part(struct Array* a, int64_t l, int64_t r, bool(...
  function Array_Sort_By (line 471) | static void Array_Sort_By(var self, bool(*f)(var,var)) {
  function Array_Show (line 475) | static int Array_Show(var self, var output, int pos) {
  function Array_Resize (line 485) | static void Array_Resize(var self, size_t n) {
  function Array_Mark (line 509) | static void Array_Mark(var self, var gc, void(*f)(var,void*)) {

FILE: src/Assign.c
  type Example (line 35) | struct Example
  type Example (line 37) | struct Example
  type Method (line 56) | struct Method
  type Method (line 58) | struct Method
  function var (line 75) | var assign(var self, var obj) {
  type Example (line 120) | struct Example
  type Example (line 122) | struct Example
  type Method (line 138) | struct Method
  type Method (line 140) | struct Method
  function memswap (line 156) | static void memswap(void* p0, void* p1, size_t s) {
  function swap (line 165) | void swap(var self, var obj) {

FILE: src/Cmp.c
  type Example (line 42) | struct Example
  type Example (line 44) | struct Example
  type Method (line 75) | struct Method
  type Method (line 77) | struct Method
  function cmp (line 120) | int cmp(var self, var obj) {
  function eq (line 134) | bool  eq(var self, var obj) { return cmp(self, obj) is 0; }
  function neq (line 135) | bool neq(var self, var obj) { return not eq(self, obj); }
  function gt (line 136) | bool  gt(var self, var obj) { return cmp(self, obj) > 0; }
  function lt (line 137) | bool  lt(var self, var obj) { return cmp(self, obj) < 0; }
  function ge (line 138) | bool  ge(var self, var obj) { return not lt(self, obj); }
  function le (line 139) | bool  le(var self, var obj) { return not gt(self, obj); }
  type Example (line 163) | struct Example
  type Example (line 165) | struct Example
  type Method (line 180) | struct Method
  type Method (line 182) | struct Method
  function sort (line 202) | void sort(var self) {
  function sort_by (line 206) | void sort_by(var self, bool(*f)(var,var)) {

FILE: src/Concat.c
  type Example (line 26) | struct Example
  type Example (line 28) | struct Example
  type Method (line 47) | struct Method
  type Method (line 49) | struct Method
  function append (line 69) | void append(var self, var obj) {
  function concat (line 73) | void concat(var self, var obj) {

FILE: src/Doc.c
  type Method (line 45) | struct Method
  type Method (line 47) | struct Method
  type Example (line 70) | struct Example
  type Example (line 72) | struct Example
  type Doc (line 90) | struct Doc
  type Method (line 130) | struct Method
  type Method (line 132) | struct Method
  type Example (line 145) | struct Example
  type Example (line 147) | struct Example
  function help_to (line 163) | int help_to(var out, int pos, var self) {
  function help (line 167) | void help(var self) {

FILE: src/Exception.c
  type Exception (line 28) | struct Exception {
  type Method (line 65) | struct Method
  type Method (line 67) | struct Method
  type Example (line 100) | struct Example
  type Example (line 102) | struct Example
  function Exception_New (line 121) | static void Exception_New(var self, var args) {
  function Exception_Del (line 131) | static void Exception_Del(var self) {
  function Exception_Assign (line 137) | static void Exception_Assign(var self, var obj) {
  function var (line 147) | static var Exception_Current(void) {
  function Exception_Signal (line 151) | static void Exception_Signal(int sig) {
  function jmp_buf (line 162) | static jmp_buf* Exception_Buffer(struct Exception* e) {
  function Exception_Len (line 170) | static size_t Exception_Len(var self) {
  function Exception_Running (line 175) | static bool Exception_Running(var self) {
  function Exception_Backtrace (line 183) | static void Exception_Backtrace(void) {
  function Exception_Backtrace (line 204) | static void Exception_Backtrace(void) {
  function Exception_Backtrace (line 308) | static void Exception_Backtrace(void) {}
  function Exception_Backtrace (line 314) | static void Exception_Backtrace(void) {}
  function Exception_Error (line 318) | static void Exception_Error(struct Exception* e)  {
  function Exception_Show (line 333) | static int Exception_Show(var self, var out, int pos) {
  function exception_signals (line 350) | void exception_signals(void) {
  function exception_try (line 359) | void exception_try(jmp_buf* env) {
  function var (line 370) | var exception_throw(var obj, const char* fmt, var args) {
  function var (line 387) | var exception_catch(var args) {
  function exception_try_end (line 416) | void exception_try_end(void) {
  function exception_try_fail (line 425) | void exception_try_fail(void) {

FILE: src/File.c
  type Example (line 31) | struct Example
  type Example (line 33) | struct Example
  type Method (line 52) | struct Method
  type Method (line 54) | struct Method
  function var (line 98) | var sopen(var self, var resource, var options) {
  function sclose (line 102) | void sclose(var self) {
  function sseek (line 106) | void sseek(var self, int64_t pos, int origin) {
  function stell (line 110) | int64_t stell(var self) {
  function sflush (line 114) | void sflush(var self) {
  function seof (line 118) | bool seof(var self) {
  function sread (line 122) | size_t sread(var self, void* output, size_t size) {
  function swrite (line 126) | size_t swrite(var self, void* input, size_t size) {
  type Example (line 151) | struct Example
  type Example (line 153) | struct Example
  function File_New (line 187) | static void File_New(var self, var args) {
  function File_Del (line 194) | static void File_Del(var self) {
  function var (line 199) | static var File_Open(var self, var filename, var access) {
  function File_Close (line 213) | static void File_Close(var self) {
  function File_Seek (line 224) | static void File_Seek(var self, int64_t pos, int origin) {
  function File_Tell (line 238) | static int64_t File_Tell(var self) {
  function File_Flush (line 253) | static void File_Flush(var self) {
  function File_EOF (line 267) | static bool File_EOF(var self) {
  function File_Read (line 277) | static size_t File_Read(var self, void* output, size_t size) {
  function File_Write (line 293) | static size_t File_Write(var self, void* input, size_t size) {
  function File_Format_To (line 308) | static int File_Format_To(var self, int pos, const char* fmt, va_list va) {
  function File_Format_From (line 318) | static int File_Format_From(var self, int pos, const char* fmt, va_list ...
  type Example (line 363) | struct Example
  type Example (line 365) | struct Example
  function Process_New (line 385) | static void Process_New(var self, var args) {
  function Process_Del (line 391) | static void Process_Del(var self) {
  function var (line 396) | static var Process_Open(var self, var filename, var access) {
  function Process_Close (line 410) | static void Process_Close(var self) {
  function Process_Seek (line 421) | static void Process_Seek(var self, int64_t pos, int origin) {
  function Process_Tell (line 435) | static int64_t Process_Tell(var self) {
  function Process_Flush (line 450) | static void Process_Flush(var self) {
  function Process_EOF (line 464) | static bool Process_EOF(var self) {
  function Process_Read (line 474) | static size_t Process_Read(var self, void* output, size_t size) {
  function Process_Write (line 490) | static size_t Process_Write(var self, void* input, size_t size) {
  function Process_Format_To (line 505) | static int Process_Format_To(var self, int pos, const char* fmt, va_list...
  function Process_Format_From (line 515) | static int Process_Format_From(var self, int pos, const char* fmt, va_li...

FILE: src/Function.c
  type Example (line 23) | struct Example
  type Example (line 25) | struct Example
  type Method (line 45) | struct Method
  type Method (line 47) | struct Method
  function var (line 64) | var call_with(var self, var args) {
  type Example (line 85) | struct Example
  type Example (line 87) | struct Example
  function var (line 132) | static var Function_Call(var self, var args) {

FILE: src/GC.c
  type Method (line 32) | struct Method
  type Method (line 34) | struct Method
  function mark (line 50) | void mark(var self, var gc, void(*f)(var,void*)) {
  type Example (line 90) | struct Example
  type Example (line 92) | struct Example
  type GCEntry (line 108) | struct GCEntry {
  type GC (line 115) | struct GC {
  function GC_Probe (line 128) | static uint64_t GC_Probe(struct GC* gc, uint64_t i, uint64_t h) {
  function GC_Ideal_Size (line 138) | static size_t GC_Ideal_Size(size_t size) {
  type GC (line 149) | struct GC
  function GC_Rehash (line 151) | static void GC_Rehash(struct GC* gc, size_t new_size) {
  function GC_Resize_More (line 176) | static void GC_Resize_More(struct GC* gc) {
  function GC_Resize_Less (line 182) | static void GC_Resize_Less(struct GC* gc) {
  function GC_Hash (line 188) | static uint64_t GC_Hash(var ptr) {
  function GC_Set_Ptr (line 192) | static void GC_Set_Ptr(struct GC* gc, var ptr, bool root) {
  function GC_Mem_Ptr (line 219) | static bool GC_Mem_Ptr(struct GC* gc, var ptr) {
  function GC_Rem_Ptr (line 235) | static void GC_Rem_Ptr(struct GC* gc, var ptr) {
  type GC (line 280) | struct GC
  function GC_Mark_And_Recurse (line 282) | static void GC_Mark_And_Recurse(void* _gc, void* ptr) {
  function GC_Recurse (line 288) | static void GC_Recurse(struct GC* gc, var ptr) {
  type GC (line 310) | struct GC
  function GC_Mark_Item (line 312) | static void GC_Mark_Item(void* _gc, void* ptr) {
  function GC_Mark_Stack (line 339) | static void CELLO_NASAN GC_Mark_Stack(struct GC* gc) {
  function GC_Mark_Stack_Fake (line 361) | static void GC_Mark_Stack_Fake(struct GC* gc) { }
  function GC_Mark (line 363) | void GC_Mark(struct GC* gc) {
  function GC_Show (line 399) | static int GC_Show(var self, var out, int pos) {
  function GC_Sweep (line 418) | void GC_Sweep(struct GC* gc) {
  function var (line 478) | static var GC_Current(void) {
  function GC_New (line 482) | static void GC_New(var self, var args) {
  function GC_Del (line 494) | static void GC_Del(var self) {
  function GC_Set (line 502) | static void GC_Set(var self, var key, var val) {
  function GC_Rem (line 516) | static void GC_Rem(var self, var key) {
  function GC_Mem (line 524) | static bool GC_Mem(var self, var key) {
  function GC_Start (line 528) | static void GC_Start(var self) {
  function GC_Stop (line 533) | static void GC_Stop(var self) {
  function GC_Running (line 538) | static bool GC_Running(var self) {
  function Cello_Exit (line 553) | void Cello_Exit(void) {

FILE: src/Get.c
  type Example (line 32) | struct Example
  type Example (line 34) | struct Example
  type Method (line 65) | struct Method
  type Method (line 67) | struct Method
  function var (line 103) | var get(var self, var key) {
  function set (line 107) | void set(var self, var key, var val) {
  function mem (line 111) | bool mem(var self, var key) {
  function rem (line 115) | void rem(var self, var key) {
  function var (line 119) | var key_type(var self) {
  function var (line 123) | var val_type(var self) {

FILE: src/Hash.c
  type Example (line 35) | struct Example
  type Example (line 37) | struct Example
  type Method (line 56) | struct Method
  type Method (line 58) | struct Method
  function hash_data (line 79) | uint64_t hash_data(const void* data, size_t size) {
  function hash (line 118) | uint64_t hash(var self) {

FILE: src/Iter.c
  type Example (line 36) | struct Example
  type Example (line 38) | struct Example
  type Method (line 64) | struct Method
  type Method (line 66) | struct Method
  function var (line 98) | var iter_init(var self) {
  function var (line 102) | var iter_next(var self, var curr) {
  function var (line 106) | var iter_last(var self) {
  function var (line 110) | var iter_prev(var self, var curr) {
  function var (line 114) | var iter_type(var self) {
  type Example (line 148) | struct Example
  type Example (line 150) | struct Example
  type Method (line 179) | struct Method
  type Method (line 181) | struct Method
  function var (line 192) | var range_stack(var self, var args) {
  function Range_New (line 228) | static void Range_New(var self, var args) {
  function Range_Del (line 234) | static void Range_Del(var self) {
  function Range_Assign (line 239) | static void Range_Assign(var self, var obj) {
  function Range_Cmp (line 248) | static int Range_Cmp(var self, var obj) {
  function var (line 254) | static var Range_Iter_Init(var self) {
  function var (line 265) | static var Range_Iter_Last(var self) {
  function var (line 276) | static var Range_Iter_Next(var self, var curr) {
  function var (line 286) | static var Range_Iter_Prev(var self, var curr) {
  function var (line 296) | static var Range_Iter_Type(var self) {
  function Range_Len (line 300) | static size_t Range_Len(var self) {
  function var (line 308) | static var Range_Get(var self, var key) {
  function Range_Mem (line 335) | static bool Range_Mem(var self, var key) {
  function Range_Show (line 349) | static int Range_Show(var self, var output, int pos) {
  type Example (line 401) | struct Example
  type Example (line 403) | struct Example
  type Method (line 435) | struct Method
  type Method (line 437) | struct Method
  function Slice_Arg (line 453) | static int64_t Slice_Arg(int part, size_t n, var arg) {
  function var (line 472) | var slice_stack(var self, var args) {
  function Slice_New (line 517) | static void Slice_New(var self, var args) {
  function Slice_Del (line 523) | static void Slice_Del(var self) {
  function Slice_Assign (line 528) | static void Slice_Assign(var self, var obj) {
  function Slice_Cmp (line 535) | static int Slice_Cmp(var self, var obj) {
  function var (line 543) | static var Slice_Iter_Init(var self) {
  function var (line 566) | static var Slice_Iter_Next(var self, var curr) {
  function var (line 585) | static var Slice_Iter_Type(var self) {
  function var (line 590) | static var Slice_Iter_Last(var self) {
  function var (line 613) | static var Slice_Iter_Prev(var self, var curr) {
  function Slice_Len (line 632) | static size_t Slice_Len(var self) {
  function var (line 637) | static var Slice_Get(var self, var key) {
  function Slice_Mem (line 642) | static bool Slice_Mem(var self, var key) {
  function Slice_Show (line 651) | static int Slice_Show(var self, var output, int pos) {
  type Example (line 703) | struct Example
  type Example (line 705) | struct Example
  type Method (line 727) | struct Method
  type Method (line 729) | struct Method
  function var (line 744) | var zip_stack(var self) {
  function Zip_New (line 755) | static void Zip_New(var self, var args) {
  function Zip_Del (line 765) | static void Zip_Del(var self) {
  function Zip_Assign (line 771) | static void Zip_Assign(var self, var obj) {
  function var (line 778) | static var Zip_Iter_Init(var self) {
  function var (line 792) | static var Zip_Iter_Last(var self) {
  function var (line 806) | static var Zip_Iter_Next(var self, var curr) {
  function var (line 820) | static var Zip_Iter_Prev(var self, var curr) {
  function var (line 834) | static var Zip_Iter_Type(var self) {
  function Zip_Len (line 838) | static size_t Zip_Len(var self) {
  function var (line 852) | static var Zip_Get(var self, var key) {
  function Zip_Mem (line 865) | static bool Zip_Mem(var self, var key) {
  function var (line 884) | var enumerate_stack(var self) {
  type Example (line 915) | struct Example
  type Example (line 917) | struct Example
  type Method (line 949) | struct Method
  type Method (line 951) | struct Method
  function Filter_New (line 963) | static void Filter_New(var self, var args) {
  function var (line 969) | static var Filter_Iter_Init(var self) {
  function var (line 982) | static var Filter_Iter_Last(var self) {
  function var (line 995) | static var Filter_Iter_Next(var self, var curr) {
  function var (line 1008) | static var Filter_Iter_Prev(var self, var curr) {
  function var (line 1021) | static var Filter_Iter_Type(var self) {
  function Filter_Mem (line 1026) | static bool Filter_Mem(var self, var key) {
  type Method (line 1077) | struct Method
  type Method (line 1079) | struct Method
  type Example (line 1091) | struct Example
  type Example (line 1093) | struct Example
  function Map_New (line 1124) | static void Map_New(var self, var args) {
  function var (line 1130) | static var Map_Iter_Init(var self) {
  function var (line 1140) | static var Map_Iter_Last(var self) {
  function var (line 1150) | static var Map_Iter_Next(var self, var curr) {
  function var (line 1160) | static var Map_Iter_Prev(var self, var curr) {
  function Map_Len (line 1170) | static size_t Map_Len(var self) {
  function var (line 1175) | static var Map_Get(var self, var key) {
  function Map_Mem (line 1185) | static bool Map_Mem(var self, var key) {
  function var (line 1192) | static var Map_Call(var self, var args) {

FILE: src/Len.c
  type Example (line 25) | struct Example
  type Example (line 27) | struct Example
  type Method (line 41) | struct Method
  type Method (line 43) | struct Method
  function len (line 59) | size_t len(var self) {
  function empty (line 63) | bool empty(var self) {

FILE: src/List.c
  type Example (line 29) | struct Example
  type Example (line 31) | struct Example
  type List (line 80) | struct List {
  function var (line 88) | static var List_Alloc(struct List* l) {
  function List_Free (line 101) | static void List_Free(struct List* l, var self) {
  function var (line 105) | static var* List_Next(struct List* l, var self) {
  function var (line 109) | static var* List_Prev(struct List* l, var self) {
  function var (line 113) | static var List_At(struct List* l, int64_t i) {
  function List_New (line 142) | static void List_New(var self, var args) {
  function List_Clear (line 158) | static void List_Clear(var self) {
  function List_Del (line 172) | static void List_Del(var self) {
  function List_Assign (line 177) | static void List_Assign(var self, var obj) {
  function List_Concat (line 192) | static void List_Concat(var self, var obj) {
  function List_Cmp (line 201) | static int List_Cmp(var self, var obj) {
  function List_Hash (line 220) | static uint64_t List_Hash(var self) {
  function List_Len (line 233) | static size_t List_Len(var self) {
  function List_Mem (line 238) | static bool List_Mem(var self, var obj) {
  function List_Unlink (line 248) | static void List_Unlink(struct List* l, var item) {
  function List_Link (line 268) | static void List_Link(struct List* l, var item, var prev, var next) {
  function List_Pop_At (line 275) | static void List_Pop_At(var self, var key) {
  function List_Rem (line 287) | static void List_Rem(var self, var obj) {
  function List_Push (line 304) | static void List_Push(var self, var obj) {
  function List_Push_At (line 312) | static void List_Push_At(var self, var obj, var key) {
  function List_Pop (line 328) | static void List_Pop(var self) {
  function var (line 346) | static var List_Get(var self, var key) {
  function List_Set (line 351) | static void List_Set(var self, var key, var val) {
  function var (line 356) | static var List_Iter_Init(var self) {
  function var (line 362) | static var List_Iter_Next(var self, var curr) {
  function var (line 368) | static var List_Iter_Last(var self) {
  function var (line 374) | static var List_Iter_Prev(var self, var curr) {
  function var (line 380) | static var List_Iter_Type(var self) {
  function List_Show (line 385) | static int List_Show(var self, var output, int pos) {
  function List_Resize (line 397) | static void List_Resize(var self, size_t n) {
  function List_Mark (line 421) | static void List_Mark(var self, var gc, void(*f)(var,void*)) {

FILE: src/Num.c
  type Example (line 24) | struct Example
  type Example (line 26) | struct Example
  type Method (line 38) | struct Method
  type Method (line 40) | struct Method
  type Example (line 77) | struct Example
  type Example (line 79) | struct Example
  type Method (line 91) | struct Method
  type Method (line 93) | struct Method
  function c_int (line 109) | int64_t c_int(var self) {
  function c_float (line 118) | double c_float(var self) {
  type Example (line 146) | struct Example
  type Example (line 148) | struct Example
  function Int_Assign (line 165) | static void Int_Assign(var self, var obj) {
  function Int_C_Int (line 170) | static int64_t Int_C_Int(var self) {
  function Int_Cmp (line 175) | static int Int_Cmp(var self, var obj) {
  function Int_Hash (line 179) | static uint64_t Int_Hash(var self) {
  function Int_Show (line 183) | static int Int_Show(var self, var output, int pos) {
  function Int_Look (line 187) | static int Int_Look(var self, var input, int pos) {
  type Example (line 219) | struct Example
  type Example (line 221) | struct Example
  function Float_Assign (line 238) | static void Float_Assign(var self, var obj) {
  function Float_C_Float (line 243) | static double Float_C_Float(var self) {
  function Float_Cmp (line 248) | static int Float_Cmp(var self, var obj) {
  function Float_Hash (line 258) | static uint64_t Float_Hash(var self) {
  function Float_Show (line 264) | int Float_Show(var self, var output, int pos) {
  function Float_Look (line 268) | int Float_Look(var self, var input, int pos) {

FILE: src/Pointer.c
  type Example (line 26) | struct Example
  type Example (line 28) | struct Example
  type Method (line 46) | struct Method
  type Method (line 48) | struct Method
  function ref (line 68) | void ref(var self, var item) {
  function var (line 72) | var deref(var self) {
  type Example (line 99) | struct Example
  type Example (line 101) | struct Example
  function Ref_Assign (line 132) | static void Ref_Assign(var self, var obj) {
  function Ref_Ref (line 141) | static void Ref_Ref(var self, var val) {
  function var (line 146) | static var Ref_Deref(var self) {
  type Example (line 188) | struct Example
  type Example (line 190) | struct Example
  function Box_New (line 233) | static void Box_New(var self, var args) {
  function Box_Del (line 237) | static void Box_Del(var self) {
  function Box_Assign (line 243) | static void Box_Assign(var self, var obj) {
  function Box_Show (line 252) | static int Box_Show(var self, var output, int pos) {
  function Box_Ref (line 256) | static void Box_Ref(var self, var val) {
  function var (line 261) | static var Box_Deref(var self) {

FILE: src/Push.c
  type Example (line 30) | struct Example
  type Example (line 32) | struct Example
  type Method (line 56) | struct Method
  type Method (line 58) | struct Method
  function push (line 86) | void push(var self, var val) { method(self, Push, push, val); }
  function push_at (line 87) | void push_at(var self, var val, var i) { method(self, Push, push_at, val...
  function pop (line 88) | void pop(var self) { method(self, Push, pop); }
  function pop_at (line 89) | void pop_at(var self, var i) { method(self, Push, pop_at, i); }

FILE: src/Resize.c
  type Method (line 28) | struct Method
  type Method (line 30) | struct Method
  type Example (line 42) | struct Example
  type Example (line 44) | struct Example
  function resize (line 68) | void resize(var self, size_t n) {

FILE: src/Show.c
  type Example (line 33) | struct Example
  type Example (line 35) | struct Example
  type Method (line 48) | struct Method
  type Method (line 50) | struct Method
  function format_to_va (line 72) | int format_to_va(var self, int pos, const char* fmt, va_list va) {
  function format_from_va (line 76) | int format_from_va(var self, int pos, const char* fmt, va_list va) {
  function format_to (line 80) | int format_to(var self, int pos, const char* fmt, ...) {
  function format_from (line 88) | int format_from(var self, int pos, const char* fmt, ...) {
  type Example (line 136) | struct Example
  type Example (line 138) | struct Example
  type Method (line 173) | struct Method
  type Method (line 175) | struct Method
  function show (line 217) | int show(var self) {
  function show_to (line 221) | int show_to(var self, var out, int pos) {
  function print_with (line 235) | int print_with(const char* fmt, var args) {
  function println_with (line 239) | int println_with(const char* fmt, var args) {
  function print_to_with (line 246) | int print_to_with(var out, int pos, const char* fmt, var args) {
  function look (line 337) | int look(var self) {
  function look_from (line 341) | int look_from(var self, var input, int pos) {
  function scan_with (line 345) | int scan_with(const char* fmt, var args) {
  function scanln_with (line 349) | int scanln_with(const char* fmt, var args) {
  function scan_from_with (line 356) | int scan_from_with(var input, int pos, const char* fmt, var args) {

FILE: src/Start.c
  type Example (line 33) | struct Example
  type Example (line 35) | struct Example
  type Method (line 55) | struct Method
  type Method (line 57) | struct Method
  function start (line 88) | void start(var self) {
  function stop (line 92) | void stop(var self) {
  function join (line 96) | void join(var self) {
  function running (line 100) | bool running(var self) {
  function var (line 104) | var start_in(var self) {
  function var (line 112) | var stop_in(var self) {

FILE: src/String.c
  type Example (line 24) | struct Example
  type Example (line 26) | struct Example
  type Method (line 38) | struct Method
  type Method (line 40) | struct Method
  type String (line 59) | struct String
  type Example (line 89) | struct Example
  type Example (line 91) | struct Example
  function String_New (line 126) | static void String_New(var self, var args) {
  function String_Del (line 141) | static void String_Del(var self) {
  function String_Assign (line 154) | static void String_Assign(var self, var obj) {
  type String (line 177) | struct String
  function String_Cmp (line 181) | static int String_Cmp(var self, var obj) {
  function String_Len (line 185) | static size_t String_Len(var self) {
  function String_Clear (line 190) | static void String_Clear(var self) {
  function String_Mem (line 211) | static bool String_Mem(var self, var obj) {
  function String_Rem (line 221) | static void String_Rem(var self, var obj) {
  function String_Hash (line 233) | static uint64_t String_Hash(var self) {
  function String_Concat (line 238) | static void String_Concat(var self, var obj) {
  function String_Resize (line 259) | static void String_Resize(var self, size_t n) {
  function String_Format_To (line 286) | static int String_Format_To(var self, int pos, const char* fmt, va_list ...
  function String_Format_From (line 371) | static int String_Format_From(var self, int pos, const char* fmt, va_lis...
  function String_Show (line 376) | static int String_Show(var self, var out, int pos) {
  function String_Look (line 400) | static int String_Look(var self, var input, int pos) {

FILE: src/Table.c
  type Example (line 26) | struct Example
  type Example (line 28) | struct Example
  type Table (line 67) | struct Table {
  function Table_Ideal_Size (line 94) | static size_t Table_Ideal_Size(size_t size) {
  function Table_Step (line 105) | static size_t Table_Step(struct Table* t) {
  function Table_Key_Hash (line 112) | static uint64_t Table_Key_Hash(struct Table* t, uint64_t i) {
  function var (line 116) | static var Table_Key(struct Table* t, uint64_t i) {
  function var (line 122) | static var Table_Val(struct Table* t, uint64_t i) {
  function Table_Probe (line 130) | static uint64_t Table_Probe(struct Table* t, uint64_t i, uint64_t h) {
  function Table_Size_Round (line 141) | static size_t Table_Size_Round(size_t s) {
  function Table_New (line 145) | static void Table_New(var self, var args) {
  function Table_Del (line 185) | static void Table_Del(var self) {
  function var (line 201) | static var Table_Key_Type(var self) {
  function var (line 206) | static var Table_Val_Type(var self) {
  function Table_Clear (line 211) | static void Table_Clear(var self) {
  function Table_Assign (line 229) | static void Table_Assign(var self, var obj) {
  function Table_Cmp (line 270) | static int Table_Cmp(var self, var obj) {
  function Table_Hash (line 294) | static uint64_t Table_Hash(var self) {
  function Table_Len (line 308) | static size_t Table_Len(var self) {
  function Table_Swapspace_Hash (line 313) | static uint64_t Table_Swapspace_Hash(struct Table* t, var space) {
  function var (line 317) | static var Table_Swapspace_Key(struct Table* t, var space) {
  function var (line 321) | static var Table_Swapspace_Val(struct Table* t, var space) {
  function Table_Set_Move (line 326) | static void Table_Set_Move(var self, var key, var val, bool move) {
  function Table_Rehash (line 398) | static void Table_Rehash(struct Table* t, size_t new_size) {
  function Table_Resize_More (line 431) | static void Table_Resize_More(struct Table* t) {
  function Table_Resize_Less (line 437) | static void Table_Resize_Less(struct Table* t) {
  function Table_Mem (line 443) | static bool Table_Mem(var self, var key) {
  function Table_Rem (line 469) | static void Table_Rem(var self, var key) {
  function var (line 520) | static var Table_Get(var self, var key) {
  function Table_Set (line 553) | static void Table_Set(var self, var key, var val) {
  function var (line 558) | static var Table_Iter_Init(var self) {
  function var (line 571) | static var Table_Iter_Next(var self, var curr) {
  function var (line 588) | static var Table_Iter_Last(var self) {
  function var (line 606) | static var Table_Iter_Prev(var self, var curr) {
  function var (line 623) | static var Table_Iter_Type(var self) {
  function Table_Show (line 628) | static int Table_Show(var self, var output, int pos) {
  function Table_Resize (line 646) | static void Table_Resize(var self, size_t n) {
  function Table_Mark (line 665) | static void Table_Mark(var self, var gc, void(*f)(var,void*)) {

FILE: src/Thread.c
  type Example (line 29) | struct Example
  type Example (line 31) | struct Example
  type Method (line 45) | struct Method
  type Method (line 47) | struct Method
  function var (line 63) | var current(var type) {
  type Thread (line 67) | struct Thread {
  type Example (line 100) | struct Example
  type Example (line 102) | struct Example
  function Thread_New (line 153) | static void Thread_New(var self, var args) {
  function Thread_Del (line 162) | static void Thread_Del(var self) {
  function Thread_C_Int (line 173) | static int64_t Thread_C_Int(var self) {
  function Thread_Assign (line 190) | static void Thread_Assign(var self, var obj) {
  function Thread_Cmp (line 198) | static int Thread_Cmp(var self, var obj) {
  function Thread_Hash (line 202) | static uint64_t Thread_Hash(var self) {
  function Thread_TLS_Key_Create (line 212) | static void Thread_TLS_Key_Create(void) {
  function Thread_TLS_Key_Delete (line 215) | static void Thread_TLS_Key_Delete(void) {
  function var (line 219) | static var Thread_Init_Run(var self) {
  function Thread_TLS_Key_Create (line 249) | static void Thread_TLS_Key_Create(void) {
  function Thread_TLS_Key_Delete (line 252) | static void Thread_TLS_Key_Delete(void) {
  function DWORD (line 256) | static DWORD Thread_Init_Run(var self) {
  function var (line 284) | static var Thread_Call(var self, var args) {
  function Thread_Main_Del (line 346) | static void Thread_Main_Del(void) {
  function var (line 351) | static var Thread_Current(void) {
  function Thread_Start (line 405) | static void Thread_Start(var self) {
  function Thread_Stop (line 409) | static void Thread_Stop(var self) {
  function Thread_Join (line 424) | static void Thread_Join(var self) {
  function Thread_Running (line 439) | static bool Thread_Running(var self) {
  function var (line 444) | static var Thread_Get(var self, var key) {
  function Thread_Set (line 449) | static void Thread_Set(var self, var key, var val) {
  function Thread_Mem (line 454) | static bool Thread_Mem(var self, var key) {
  function Thread_Rem (line 459) | static void Thread_Rem(var self, var key) {
  function var (line 464) | static var Thread_Key_Type(var self) {
  function var (line 469) | static var Thread_Val_Type(var self) {
  function Thread_Mark (line 474) | static void Thread_Mark(var self, var gc, void(*f)(var,void*)) {
  type Method (line 518) | struct Method
  type Method (line 520) | struct Method
  type Example (line 540) | struct Example
  type Example (line 542) | struct Example
  function lock (line 561) | void lock(var self) {
  function unlock (line 565) | void unlock(var self) {
  function trylock (line 569) | bool trylock(var self) {
  type Mutex (line 573) | struct Mutex {
  type Example (line 595) | struct Example
  type Example (line 597) | struct Example
  function Mutex_New (line 611) | static void Mutex_New(var self, var args) {
  function Mutex_Del (line 620) | static void Mutex_Del(var self) {
  function Mutex_Lock (line 629) | static void Mutex_Lock(var self) {
  function Mutex_Trylock (line 647) | static bool Mutex_Trylock(var self) {
  function Mutex_Unlock (line 664) | static void Mutex_Unlock(var self) {

FILE: src/Tree.c
  type Example (line 26) | struct Example
  type Example (line 28) | struct Example
  type Tree (line 67) | struct Tree {
  type Tree (line 76) | struct Tree
  function var (line 78) | static var* Tree_Left(struct Tree* m, var node) {
  function var (line 82) | static var* Tree_Right(struct Tree* m, var node) {
  function var (line 86) | static var Tree_Get_Parent(struct Tree* m, var node) {
  function Tree_Set_Parent (line 91) | static void Tree_Set_Parent(struct Tree* m, var node, var ptr) {
  function var (line 99) | static var Tree_Key(struct Tree* m, var node) {
  function var (line 103) | static var Tree_Val(struct Tree* m, var node) {
  function Tree_Set_Color (line 109) | static void Tree_Set_Color(struct Tree* m, var node, bool col) {
  function Tree_Get_Color (line 118) | static bool Tree_Get_Color(struct Tree* m, var node) {
  function Tree_Set_Black (line 124) | static void Tree_Set_Black(struct Tree* m, var node) {
  function Tree_Set_Red (line 128) | static void Tree_Set_Red(struct Tree* m, var node) {
  function Tree_Is_Red (line 132) | static bool Tree_Is_Red(struct Tree* m, var node) {
  function Tree_Is_Black (line 136) | static bool Tree_Is_Black(struct Tree* m, var node) {
  function var (line 140) | static var Tree_Alloc(struct Tree* m) {
  function Tree_New (line 167) | static void Tree_New(var self, var args) {
  function Tree_Clear_Entry (line 190) | static void Tree_Clear_Entry(struct Tree* m, var node) {
  function Tree_Clear (line 200) | static void Tree_Clear(var self) {
  function Tree_Del (line 207) | static void Tree_Del(var self) {
  function Tree_Assign (line 212) | static void Tree_Assign(var self, var obj) {
  function Tree_Cmp (line 230) | static int Tree_Cmp(var self, var obj) {
  function Tree_Hash (line 254) | static uint64_t Tree_Hash(var self) {
  function Tree_Len (line 268) | static size_t Tree_Len(var self) {
  function Tree_Mem (line 273) | static bool Tree_Mem(var self, var key) {
  function var (line 287) | static var Tree_Get(var self, var key) {
  function var (line 301) | static var Tree_Key_Type(var self) {
  function var (line 306) | static var Tree_Val_Type(var self) {
  function var (line 311) | static var Tree_Maximum(struct Tree* m, var node) {
  function var (line 318) | static var Tree_Sibling(struct Tree* m, var node) {
  function var (line 331) | static var Tree_Grandparent(struct Tree* m, var node) {
  function var (line 339) | static var Tree_Uncle(struct Tree* m, var node) {
  function Tree_Replace (line 349) | void Tree_Replace(struct Tree* m, var oldn, var newn) {
  function Tree_Rotate_Left (line 364) | static void Tree_Rotate_Left(struct Tree* m, var node) {
  function Tree_Rotate_Right (line 375) | static void Tree_Rotate_Right(struct Tree* m, var node) {
  function Tree_Set_Fix (line 386) | static void Tree_Set_Fix(struct Tree* m, var node) {
  function Tree_Set (line 435) | static void Tree_Set(var self, var key, var val) {
  function Tree_Rem_Fix (line 498) | static void Tree_Rem_Fix(struct Tree* m, var node) {
  function Tree_Rem (line 573) | static void Tree_Rem(var self, var key) {
  function var (line 625) | static var Tree_Iter_Init(var self) {
  function var (line 635) | static var Tree_Iter_Next(var self, var curr) {
  function var (line 661) | static var Tree_Iter_Last(var self) {
  function var (line 671) | static var Tree_Iter_Prev(var self, var curr) {
  function var (line 697) | static var Tree_Iter_Type(var self) {
  function Tree_Show (line 702) | static int Tree_Show(var self, var output, int pos) {
  function Tree_Mark (line 720) | static void Tree_Mark(var self, var gc, void(*f)(var,void*)) {
  function Tree_Resize (line 734) | static void Tree_Resize(var self, size_t n) {

FILE: src/Tuple.c
  type Example (line 40) | struct Example
  type Example (line 42) | struct Example
  type Method (line 61) | struct Method
  type Method (line 63) | struct Method
  function Tuple_New (line 74) | static void Tuple_New(var self, var args) {
  function Tuple_Del (line 93) | static void Tuple_Del(var self) {
  function Tuple_Assign (line 108) | static void Tuple_Assign(var self, var obj) {
  function Tuple_Len (line 146) | static size_t Tuple_Len(var self) {
  function var (line 153) | static var Tuple_Iter_Init(var self) {
  function var (line 158) | static var Tuple_Iter_Next(var self, var curr) {
  function var (line 168) | static var Tuple_Iter_Last(var self) {
  function var (line 173) | static var Tuple_Iter_Prev(var self, var curr) {
  function var (line 184) | static var Tuple_Get(var self, var key) {
  function Tuple_Set (line 202) | static void Tuple_Set(var self, var key, var val) {
  function Tuple_Mem (line 221) | static bool Tuple_Mem(var self, var item) {
  function Tuple_Rem (line 230) | static void Tuple_Rem(var self, var item) {
  function Tuple_Show (line 242) | static int Tuple_Show(var self, var output, int pos) {
  function Tuple_Push (line 254) | static void Tuple_Push(var self, var obj) {
  function Tuple_Pop (line 279) | static void Tuple_Pop(var self) {
  function Tuple_Push_At (line 303) | static void Tuple_Push_At(var self, var obj, var key) {
  function Tuple_Pop_At (line 340) | static void Tuple_Pop_At(var self, var key) {
  function Tuple_Concat (line 368) | static void Tuple_Concat(var self, var obj) {
  function Tuple_Resize (line 399) | static void Tuple_Resize(var self, size_t n) {
  function Tuple_Mark (line 422) | static void Tuple_Mark(var self, var gc, void(*f)(var,void*)) {
  function Tuple_Swap (line 431) | static void Tuple_Swap(struct Tuple* t, size_t i, size_t j) {
  function Tuple_Sort_Partition (line 437) | static size_t Tuple_Sort_Partition(
  function Tuple_Sort_Part (line 455) | static void Tuple_Sort_Part(
  function Tuple_Sort_By (line 464) | static void Tuple_Sort_By(var self, bool(*f)(var,var)) {
  function Tuple_Cmp (line 468) | static int Tuple_Cmp(var self, var obj) {
  function Tuple_Hash (line 490) | static uint64_t Tuple_Hash(var self) {

FILE: src/Type.c
  type Example (line 26) | struct Example
  type Example (line 28) | struct Example
  type Method (line 41) | struct Method
  type Method (line 43) | struct Method
  function var (line 59) | var cast(var self, var type) {
  type Example (line 99) | struct Example
  type Example (line 101) | struct Example
  type Method (line 119) | struct Method
  type Method (line 121) | struct Method
  function var (line 161) | static var Type_Alloc(void) {
  function Type_New (line 178) | static void Type_New(var self, var args) {
  type Type (line 210) | struct Type
  function Type_Builtin_Size (line 214) | static size_t Type_Builtin_Size(struct Type* t) {
  function Type_Show (line 218) | static int Type_Show(var self, var output, int pos) {
  function Type_Cmp (line 222) | static int Type_Cmp(var self, var obj) {
  function Type_Hash (line 227) | static uint64_t Type_Hash(var self) {
  function Type_Assign (line 236) | static void Type_Assign(var self, var obj) {
  function var (line 240) | static var Type_Copy(var self) {
  function print_indent (line 244) | static int print_indent(var out, int pos, const char* str) {
  function Type_Help_To (line 254) | static int Type_Help_To(var self, var out, int pos) {
  function var (line 319) | static var Type_Scan(var self, var cls) {
  function Type_Implements (line 345) | static bool Type_Implements(var self, var cls) {
  function type_implements (line 349) | bool type_implements(var self, var cls) {
  function var (line 355) | static var Type_Method_At_Offset(
  function var (line 382) | var type_method_at_offset(
  function Type_Implements_Method_At_Offset (line 387) | static bool Type_Implements_Method_At_Offset(var self, var cls, size_t o...
  function type_implements_method_at_offset (line 395) | bool type_implements_method_at_offset(var self, var cls, size_t offset) {
  function var (line 434) | static var Type_Instance(var self, var cls) {
  function var (line 453) | var type_instance(var self, var cls) {
  function var (line 457) | static var Type_Of(var self) {
  function var (line 497) | var type_of(var self) {
  function var (line 501) | var instance(var self, var cls) {
  function implements (line 505) | bool implements(var self, var cls) {
  function var (line 509) | var method_at_offset(
  function implements_method_at_offset (line 514) | bool implements_method_at_offset(var self, var cls, size_t offset) {
  type Example (line 544) | struct Example
  type Example (line 546) | struct Example
  type Method (line 559) | struct Method
  type Method (line 561) | struct Method
  function size (line 576) | size_t size(var type) {

FILE: tests/ptest.c
  function pt_color (line 59) | static void pt_color(int color) {
  function pt_color (line 95) | static void pt_color(int color) {
  function pt_assert_run (line 111) | void pt_assert_run(
  function ptest_signal (line 130) | static void ptest_signal(int sig) {
  function pt_title_case (line 161) | static void pt_title_case(char* output, const char* input) {
  type test_t (line 188) | typedef struct {
  function pt_add_test (line 200) | void pt_add_test(void (*func)(void), const char* name, const char* suite) {
  function pt_add_suite (line 233) | void pt_add_suite(void (*func)(void)) {
  function pt_run (line 243) | int pt_run(void) {

FILE: tests/test.c
  function PT_FUNC (line 6) | PT_FUNC(test_array_new) {
  function PT_FUNC (line 30) | PT_FUNC(test_array_assign) {
  function PT_FUNC (line 59) | PT_FUNC(test_array_concat) {
  function PT_FUNC (line 81) | PT_FUNC(test_array_cmp) {
  function PT_FUNC (line 96) | PT_FUNC(test_array_get) {
  function PT_FUNC (line 145) | PT_FUNC(test_array_hash) {
  function PT_FUNC (line 155) | PT_FUNC(test_array_iter) {
  function PT_FUNC (line 196) | PT_FUNC(test_array_len) {
  function PT_FUNC (line 214) | PT_FUNC(test_array_push) {
  function PT_FUNC (line 272) | PT_FUNC(test_array_resize) {
  function PT_FUNC (line 291) | PT_FUNC(test_array_show) {
  function PT_FUNC (line 301) | PT_FUNC(test_array_sort) {
  function PT_SUITE (line 328) | PT_SUITE(suite_array) {
  function PT_FUNC (line 345) | PT_FUNC(test_box_new) {
  function PT_FUNC (line 358) | PT_FUNC(test_box_assign) {
  function PT_FUNC (line 370) | PT_FUNC(test_box_pointer) {
  function PT_FUNC (line 385) | PT_FUNC(test_box_show) {
  function PT_SUITE (line 396) | PT_SUITE(suite_box) {
  function PT_FUNC (line 405) | PT_FUNC(test_file_format) {
  function PT_FUNC (line 415) | PT_FUNC(test_file_new) {
  function PT_FUNC (line 429) | PT_FUNC(test_file_start) {
  function PT_FUNC (line 442) | PT_FUNC(test_file_stream) {
  function PT_SUITE (line 462) | PT_SUITE(suite_file) {
  function PT_FUNC (line 471) | PT_FUNC(test_float_assign) {
  function PT_FUNC (line 495) | PT_FUNC(test_float_c_float) {
  function PT_FUNC (line 505) | PT_FUNC(test_float_cmp) {
  function PT_FUNC (line 527) | PT_FUNC(test_float_hash) {
  function PT_FUNC (line 541) | PT_FUNC(test_float_show) {
  function PT_SUITE (line 558) | PT_SUITE(suite_float) {
  function var (line 568) | var greater_than_two(var x) {
  function var (line 572) | var mem_hello(var x) {
  function PT_FUNC (line 576) | PT_FUNC(test_filter_get) {
  function PT_FUNC (line 590) | PT_FUNC(test_filter_iter) {
  function PT_FUNC (line 606) | PT_FUNC(test_filter_new) {
  function PT_SUITE (line 621) | PT_SUITE(suite_filter) {
  function var (line 629) | var return_fst(var args) {
  function var (line 633) | var return_snd(var args) {
  function PT_FUNC (line 638) | PT_FUNC(test_function_call) {
  function PT_SUITE (line 645) | PT_SUITE(suite_function) {
  function PT_FUNC (line 651) | PT_FUNC(test_int_assign) {
  function PT_FUNC (line 675) | PT_FUNC(test_int_c_int) {
  function PT_FUNC (line 684) | PT_FUNC(test_int_cmp) {
  function PT_FUNC (line 701) | PT_FUNC(test_int_hash) {
  function PT_FUNC (line 710) | PT_FUNC(test_int_show) {
  function PT_SUITE (line 727) | PT_SUITE(suite_int) {
  function PT_FUNC (line 737) | PT_FUNC(test_list_new) {
  function PT_FUNC (line 761) | PT_FUNC(test_list_assign) {
  function PT_FUNC (line 790) | PT_FUNC(test_list_concat) {
  function PT_FUNC (line 812) | PT_FUNC(test_list_cmp) {
  function PT_FUNC (line 827) | PT_FUNC(test_list_get) {
  function PT_FUNC (line 876) | PT_FUNC(test_list_hash) {
  function PT_FUNC (line 886) | PT_FUNC(test_list_iter) {
  function PT_FUNC (line 927) | PT_FUNC(test_list_len) {
  function PT_FUNC (line 945) | PT_FUNC(test_list_push) {
  function PT_FUNC (line 1003) | PT_FUNC(test_list_resize) {
  function PT_FUNC (line 1022) | PT_FUNC(test_list_show) {
  function PT_SUITE (line 1033) | PT_SUITE(suite_list) {
  function var (line 1049) | var convert_to_int(var x) {
  function var (line 1055) | var assert_value(var x) {
  function PT_FUNC (line 1060) | PT_FUNC(test_map_call) {
  function PT_FUNC (line 1067) | PT_FUNC(test_map_get) {
  function PT_FUNC (line 1084) | PT_FUNC(test_map_iter) {
  function PT_FUNC (line 1091) | PT_FUNC(test_map_len) {
  function PT_FUNC (line 1103) | PT_FUNC(test_map_new) {
  function PT_SUITE (line 1121) | PT_SUITE(suite_map) {
  function var (line 1131) | static var increment(var args) {
  function var (line 1140) | static var increment2(var args) {
  function PT_FUNC (line 1149) | PT_FUNC(test_mutex_lock) {
  function PT_FUNC (line 1176) | PT_FUNC(test_mutex_new) {
  function PT_FUNC (line 1186) | PT_FUNC(test_mutex_start) {
  function PT_SUITE (line 1213) | PT_SUITE(suite_mutex) {
  function PT_FUNC (line 1221) | PT_FUNC(test_range_assign) {
  function PT_FUNC (line 1233) | PT_FUNC(test_range_cmp) {
  function PT_FUNC (line 1253) | PT_FUNC(test_range_get) {
  function PT_FUNC (line 1277) | PT_FUNC(test_range_iter) {
  function PT_FUNC (line 1306) | PT_FUNC(test_range_len) {
  function PT_FUNC (line 1318) | PT_FUNC(test_range_new) {
  function PT_FUNC (line 1323) | PT_FUNC(test_range_show) {
  function PT_SUITE (line 1334) | PT_SUITE(suite_range) {
  function PT_FUNC (line 1346) | PT_FUNC(test_ref_assign) {
  function PT_FUNC (line 1358) | PT_FUNC(test_ref_pointer) {
  function PT_SUITE (line 1373) | PT_SUITE(suite_ref) {
  function PT_FUNC (line 1380) | PT_FUNC(test_slice_assign) {
  function PT_FUNC (line 1395) | PT_FUNC(test_slice_cmp) {
  function PT_FUNC (line 1410) | PT_FUNC(test_slice_get) {
  function PT_FUNC (line 1457) | PT_FUNC(test_slice_iter) {
  function PT_FUNC (line 1480) | PT_FUNC(test_slice_len) {
  function PT_FUNC (line 1495) | PT_FUNC(test_slice_new) {
  function PT_SUITE (line 1506) | PT_SUITE(suite_slice) {
  function PT_FUNC (line 1517) | PT_FUNC(test_string_assign) {
  function PT_FUNC (line 1531) | PT_FUNC(test_string_c_str) {
  function PT_FUNC (line 1541) | PT_FUNC(test_string_cmp) {
  function PT_FUNC (line 1558) | PT_FUNC(test_string_concat) {
  function PT_FUNC (line 1576) | PT_FUNC(test_string_format) {
  function PT_FUNC (line 1594) | PT_FUNC(test_string_get) {
  function PT_FUNC (line 1617) | PT_FUNC(test_string_hash) {
  function PT_FUNC (line 1629) | PT_FUNC(test_string_len) {
  function PT_FUNC (line 1639) | PT_FUNC(test_string_new) {
  function PT_FUNC (line 1663) | PT_FUNC(test_string_resize) {
  function PT_FUNC (line 1683) | PT_FUNC(test_string_show) {
  function PT_SUITE (line 1703) | PT_SUITE(suite_string) {
  function PT_FUNC (line 1719) | PT_FUNC(test_table_assign) {
  function PT_FUNC (line 1744) | PT_FUNC(test_table_cmp) {
  function PT_FUNC (line 1774) | PT_FUNC(test_table_get) {
  function PT_FUNC (line 1836) | PT_FUNC(test_table_hash) {
  function PT_FUNC (line 1850) | PT_FUNC(test_table_iter) {
  function PT_FUNC (line 1870) | PT_FUNC(test_table_len) {
  function PT_FUNC (line 1882) | PT_FUNC(test_table_new) {
  function PT_FUNC (line 1938) | PT_FUNC(test_table_resize) {
  function PT_FUNC (line 1959) | PT_FUNC(test_table_show) {
  function PT_FUNC (line 1973) | PT_FUNC(test_table_rehash) {
  function PT_SUITE (line 1997) | PT_SUITE(suite_table) {
  function PT_FUNC (line 2012) | PT_FUNC(test_thread_c_int) {
  function var (line 2020) | static var set_value(var args) {
  function PT_FUNC (line 2025) | PT_FUNC(test_thread_call) {
  function PT_FUNC (line 2039) | PT_FUNC(test_thread_cmp) {
  function PT_FUNC (line 2045) | PT_FUNC(test_thread_current) {
  function PT_FUNC (line 2050) | PT_FUNC(test_thread_get) {
  function PT_FUNC (line 2060) | PT_FUNC(test_thread_hash) {
  function PT_FUNC (line 2068) | PT_FUNC(test_thread_new) {
  function PT_FUNC (line 2073) | PT_FUNC(test_thread_start) {
  function cello_sleep (line 2087) | void cello_sleep(int ms) {
  function var (line 2095) | static var exception_sleep(var args) {
  function PT_FUNC (line 2103) | PT_FUNC(test_thread_exception) {
  function PT_SUITE (line 2116) | PT_SUITE(suite_thread) {
  function PT_FUNC (line 2130) | PT_FUNC(test_tree_assign) {
  function PT_FUNC (line 2155) | PT_FUNC(test_tree_resize) {
  function PT_FUNC (line 2172) | PT_FUNC(test_tree_cmp) {
  function PT_FUNC (line 2202) | PT_FUNC(test_tree_get) {
  function PT_FUNC (line 2274) | PT_FUNC(test_tree_hash) {
  function PT_FUNC (line 2288) | PT_FUNC(test_tree_iter) {
  function PT_FUNC (line 2308) | PT_FUNC(test_tree_len) {
  function PT_FUNC (line 2320) | PT_FUNC(test_tree_new) {
  function PT_FUNC (line 2366) | PT_FUNC(test_tree_show) {
  function PT_SUITE (line 2380) | PT_SUITE(suite_tree) {
  function PT_FUNC (line 2394) | PT_FUNC(test_tuple_assign) {
  function PT_FUNC (line 2419) | PT_FUNC(test_tuple_resize) {
  function PT_FUNC (line 2431) | PT_FUNC(test_tuple_cmp) {
  function PT_FUNC (line 2442) | PT_FUNC(test_tuple_concat) {
  function PT_FUNC (line 2457) | PT_FUNC(test_tuple_get) {
  function PT_FUNC (line 2486) | PT_FUNC(test_tuple_hash) {
  function PT_FUNC (line 2495) | PT_FUNC(test_tuple_iter) {
  function PT_FUNC (line 2507) | PT_FUNC(test_tuple_len) {
  function PT_FUNC (line 2519) | PT_FUNC(test_tuple_new) {
  function PT_FUNC (line 2527) | PT_FUNC(test_tuple_push) {
  function PT_FUNC (line 2549) | PT_FUNC(test_tuple_show) {
  function PT_FUNC (line 2560) | PT_FUNC(test_tuple_sort) {
  function PT_SUITE (line 2578) | PT_SUITE(suite_tuple) {
  type TestType (line 2597) | struct TestType {
  function TestType_New (line 2601) | static void TestType_New(var self, var args) {
  function TestType_Cmp (line 2606) | static int TestType_Cmp(var self, var obj) {
  function PT_FUNC (line 2612) | PT_FUNC(test_type_new) {
  function PT_FUNC (line 2642) | PT_FUNC(test_type_c_str) {
  function PT_FUNC (line 2649) | PT_FUNC(test_type_cmp) {
  function PT_FUNC (line 2654) | PT_FUNC(test_type_hash) {
  function PT_FUNC (line 2660) | PT_FUNC(test_type_help) {
  function catch (line 2664) | catch(e) { }
  function catch (line 2665) | catch(e) { }
  function catch (line 2666) | catch(e) { }
  function catch (line 2667) | catch(e) { }
  function catch (line 2668) | catch(e) { }
  function catch (line 2669) | catch(e) { }
  function PT_FUNC (line 2673) | PT_FUNC(test_type_show) {
  function PT_SUITE (line 2684) | PT_SUITE(suite_type) {
  function PT_FUNC (line 2695) | PT_FUNC(test_zip_get) {
  function PT_FUNC (line 2709) | PT_FUNC(test_zip_iter) {
  function PT_FUNC (line 2734) | PT_FUNC(test_zip_len) {
  function PT_FUNC (line 2748) | PT_FUNC(test_zip_new) {
  function PT_SUITE (line 2762) | PT_SUITE(suite_zip) {
  function exception_divide (line 2775) | static int exception_divide(int x, int y) {
  function PT_FUNC (line 2784) | PT_FUNC(test_exception_throw) {
  function PT_FUNC (line 2798) | PT_FUNC(test_exception_catch) {
  function catch (line 2818) | catch (e) {
  function PT_FUNC (line 2830) | PT_FUNC(test_exception_catch_all) {
  function PT_FUNC (line 2853) | PT_FUNC(test_exception_catch_outer) {
  function catch (line 2871) | catch (e) {
  function PT_SUITE (line 2882) | PT_SUITE(suite_exception) {
  function main (line 2891) | int main(int argc, char** argv) {