#include implemented! (neos)

[Mr Flibble]

Hi!

The semantic concept "source.package.import" (basically #include) of neos
my universal compiler that can compile any programming language now folds! \o/

Sample session:

neos 1.0.0.0 ED-209
]schema neoscript
Loading schema 'neoscript'...
Language: Default neoGFX scripting language
Version: 1.0.0
Copyright (C) 2019 Leigh Johnston
neoscript]load examples/neoscript/fibonacci.neo
neoscript]compile
Compilation time: 99.234ms
neoscript]list
File 'examples/neoscript/fibonacci.neo':
-- neoscript example: Fibonacci

using neos.string;
using neos.stream;

import fn to_string(x : i32) -> string;
import fn to_integer(s : string) -> i32;
import proc input(s : out string);
import proc print(s : in string);

-- functions are pure
def fn add(x, y : i32) -> i32
{
return x + y;
}
def fn fib(x : i32) -> i32
{
if (x < 2)
return 1;
else
return add(fib(x-1), fib(x-2));
}

-- procedures are impure
def proc main()
s : string;
{
print("Enter a positive "
"integer: ");
input(s);
print("Fibonacci(" + s + ") = " + to_string(fib(to_integer(s))) + "\n");
}
File 'packages/neoscript/neos.string.neo':
-- neoscript package: string

import fn to_string(x : i32) -> string;
import fn to_integer(s : string) -> i32;


File 'packages/neoscript/neos.stream.neo':
-- neoscript package: stream

import proc input(s : out string);
import proc print(s : in string);

neoscript]trace 2
neoscript]compile
prefold: <3: line 3, col 6> language.keyword ()
prefold: <4: line 3, col 7> string.utf8.character.alpha (n)
prefold: <5: line 3, col 8> string.utf8.character.alpha (e)
prefold: <5: line 3, col 9> string.utf8.character.alpha (o)
prefold: <5: line 3, col 10> string.utf8.character.alpha (s)
prefold: <5: line 3, col 11> string.utf8.character.period (.)
prefold: <6: line 3, col 12> string.utf8.character.alpha (s)
prefold: <7: line 3, col 13> string.utf8.character.alpha (t)
prefold: <7: line 3, col 14> string.utf8.character.alpha (r)
prefold: <7: line 3, col 15> string.utf8.character.alpha (i)
prefold: <7: line 3, col 16> string.utf8.character.alpha (n)
prefold: <7: line 3, col 17> string.utf8.character.alpha (g)
prefold: <4: line 3, col 18> string.utf8 ()
prefold: <4: line 3, col 18> source.package.name ()
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8(g)
folding: string.utf8(g) <- string.utf8.character.alpha()
folded: string.utf8(g) <- string.utf8.character.alpha() = string.utf8(gn)
folding: string.utf8(gn) <- string.utf8.character.alpha()
folded: string.utf8(gn) <- string.utf8.character.alpha() = string.utf8(gni)
folding: string.utf8(gni) <- string.utf8.character.alpha()
folded: string.utf8(gni) <- string.utf8.character.alpha() = string.utf8(gnir)
folding: string.utf8(gnir) <- string.utf8.character.alpha()
folded: string.utf8(gnir) <- string.utf8.character.alpha() =
string.utf8(gnirt)
folding: string.utf8(gnirt) <- string.utf8.character.alpha()
folded: string.utf8(gnirt) <- string.utf8.character.alpha() =
string.utf8(gnirts)
folding: string.utf8(gnirts) <- string.utf8.character.period()
folded: string.utf8(gnirts) <- string.utf8.character.period() =
string.utf8(gnirts.)
folding: string.utf8(gnirts.) <- string.utf8.character.alpha()
folded: string.utf8(gnirts.) <- string.utf8.character.alpha() =
string.utf8(gnirts.s)
folding: string.utf8(gnirts.s) <- string.utf8.character.alpha()
folded: string.utf8(gnirts.s) <- string.utf8.character.alpha() =
string.utf8(gnirts.so)
folding: string.utf8(gnirts.so) <- string.utf8.character.alpha()
folded: string.utf8(gnirts.so) <- string.utf8.character.alpha() =
string.utf8(gnirts.soe)
folding: string.utf8(gnirts.soe) <- string.utf8.character.alpha()
folded: string.utf8(gnirts.soe) <- string.utf8.character.alpha() =
string.utf8(gnirts.soen)
folding: source.package.name() <- string.utf8(gnirts.soen)
folded: source.package.name() <- string.utf8(gnirts.soen) =
source.package.name(neos.string)
prefold: <3: line 3, col 18> source.package.import ()
folding: source.package.import() <- source.package.name(neos.string)
folded: source.package.import() <- source.package.name(neos.string) =
source.package.import(neos.string)
folding: source.package.import(neos.string) <-
source.package.import(neos.string)
prefold: <3: line 3, col 7> language.keyword ()
prefold: <4: line 3, col 10> language.keyword ()
prefold: <5: line 3, col 11> string.utf8.character.alpha (t)
prefold: <6: line 3, col 12> string.utf8.character.alpha (o)
prefold: <6: line 3, col 13> string.utf8.character.underscore (_)
prefold: <6: line 3, col 14> string.utf8.character.alpha (s)
prefold: <6: line 3, col 15> string.utf8.character.alpha (t)
prefold: <6: line 3, col 16> string.utf8.character.alpha (r)
prefold: <6: line 3, col 17> string.utf8.character.alpha (i)
prefold: <6: line 3, col 18> string.utf8.character.alpha (n)
prefold: <6: line 3, col 19> string.utf8.character.alpha (g)
prefold: <5: line 3, col 20> string.utf8 ()
prefold: <5: line 3, col 20> language.identifier ()
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8(g)
folding: string.utf8(g) <- string.utf8.character.alpha()
folded: string.utf8(g) <- string.utf8.character.alpha() = string.utf8(gn)
folding: string.utf8(gn) <- string.utf8.character.alpha()
folded: string.utf8(gn) <- string.utf8.character.alpha() = string.utf8(gni)
folding: string.utf8(gni) <- string.utf8.character.alpha()
folded: string.utf8(gni) <- string.utf8.character.alpha() = string.utf8(gnir)
folding: string.utf8(gnir) <- string.utf8.character.alpha()
folded: string.utf8(gnir) <- string.utf8.character.alpha() =
string.utf8(gnirt)
folding: string.utf8(gnirt) <- string.utf8.character.alpha()
folded: string.utf8(gnirt) <- string.utf8.character.alpha() =
string.utf8(gnirts)
folding: string.utf8(gnirts) <- string.utf8.character.underscore()
folded: string.utf8(gnirts) <- string.utf8.character.underscore() =
string.utf8(gnirts_)
folding: string.utf8(gnirts_) <- string.utf8.character.alpha()
folded: string.utf8(gnirts_) <- string.utf8.character.alpha() =
string.utf8(gnirts_o)
folding: string.utf8(gnirts_o) <- string.utf8.character.alpha()
folded: string.utf8(gnirts_o) <- string.utf8.character.alpha() =
string.utf8(gnirts_ot)
folding: language.identifier() <- string.utf8(gnirts_ot)
folded: language.identifier() <- string.utf8(gnirts_ot) =
language.identifier(to_string)
prefold: <10: line 3, col 21> string.utf8.character.alpha (x)
prefold: <10: line 3, col 22> string.utf8 ()
prefold: <10: line 3, col 22> language.identifier ()
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8(x)
folding: language.identifier() <- string.utf8(x)
folded: language.identifier() <- string.utf8(x) = language.identifier(x)
prefold: <9: line 3, col 22> language.function.parameter ()
prefold: <11: line 3, col 28> language.type.i32 ()
prefold: <7: line 3, col 28> language.function.parameters ()
prefold: <10: line 3, col 39> language.type.string ()
prefold: <9: line 3, col 39> language.function.return ()
prefold: <4: line 3, col 39> language.function.signature ()
prefold: <4: line 3, col 40> language.function.import ()
prefold: <3: line 4, col 7> language.keyword ()
prefold: <4: line 4, col 10> language.keyword ()
prefold: <5: line 4, col 11> string.utf8.character.alpha (t)
prefold: <6: line 4, col 12> string.utf8.character.alpha (o)
prefold: <6: line 4, col 13> string.utf8.character.underscore (_)
prefold: <6: line 4, col 14> string.utf8.character.alpha (i)
prefold: <6: line 4, col 15> string.utf8.character.alpha (n)
prefold: <6: line 4, col 16> string.utf8.character.alpha (t)
prefold: <6: line 4, col 17> string.utf8.character.alpha (e)
prefold: <6: line 4, col 18> string.utf8.character.alpha (g)
prefold: <6: line 4, col 19> string.utf8.character.alpha (e)
prefold: <6: line 4, col 20> string.utf8.character.alpha (r)
prefold: <5: line 4, col 21> string.utf8 ()
prefold: <5: line 4, col 21> language.identifier ()
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8(r)
folding: string.utf8(r) <- string.utf8.character.alpha()
folded: string.utf8(r) <- string.utf8.character.alpha() = string.utf8(re)
folding: string.utf8(re) <- string.utf8.character.alpha()
folded: string.utf8(re) <- string.utf8.character.alpha() = string.utf8(reg)
folding: string.utf8(reg) <- string.utf8.character.alpha()
folded: string.utf8(reg) <- string.utf8.character.alpha() = string.utf8(rege)
folding: string.utf8(rege) <- string.utf8.character.alpha()
folded: string.utf8(rege) <- string.utf8.character.alpha() =
string.utf8(reget)
folding: string.utf8(reget) <- string.utf8.character.alpha()
folded: string.utf8(reget) <- string.utf8.character.alpha() =
string.utf8(regetn)
folding: string.utf8(regetn) <- string.utf8.character.alpha()
folded: string.utf8(regetn) <- string.utf8.character.alpha() =
string.utf8(regetni)
folding: string.utf8(regetni) <- string.utf8.character.underscore()
folded: string.utf8(regetni) <- string.utf8.character.underscore() =
string.utf8(regetni_)
folding: string.utf8(regetni_) <- string.utf8.character.alpha()
folded: string.utf8(regetni_) <- string.utf8.character.alpha() =
string.utf8(regetni_o)
folding: string.utf8(regetni_o) <- string.utf8.character.alpha()
folded: string.utf8(regetni_o) <- string.utf8.character.alpha() =
string.utf8(regetni_ot)
folding: language.identifier() <- string.utf8(regetni_ot)
folded: language.identifier() <- string.utf8(regetni_ot) =
language.identifier(to_integer)
prefold: <10: line 4, col 22> string.utf8.character.alpha (s)
prefold: <10: line 4, col 23> string.utf8 ()
prefold: <10: line 4, col 23> language.identifier ()
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8(s)
folding: language.identifier() <- string.utf8(s)
folded: language.identifier() <- string.utf8(s) = language.identifier(s)
prefold: <9: line 4, col 23> language.function.parameter ()
prefold: <11: line 4, col 32> language.type.string ()
prefold: <7: line 4, col 32> language.function.parameters ()
prefold: <10: line 4, col 40> language.type.i32 ()
prefold: <9: line 4, col 40> language.function.return ()
prefold: <4: line 4, col 40> language.function.signature ()
prefold: <4: line 4, col 41> language.function.import ()
folded: source.package.import(neos.string) <-
source.package.import(neos.string) = ()
prefold: <3: line 4, col 6> language.keyword ()
prefold: <4: line 4, col 7> string.utf8.character.alpha (n)
prefold: <5: line 4, col 8> string.utf8.character.alpha (e)
prefold: <5: line 4, col 9> string.utf8.character.alpha (o)
prefold: <5: line 4, col 10> string.utf8.character.alpha (s)
prefold: <5: line 4, col 11> string.utf8.character.period (.)
prefold: <6: line 4, col 12> string.utf8.character.alpha (s)
prefold: <7: line 4, col 13> string.utf8.character.alpha (t)
prefold: <7: line 4, col 14> string.utf8.character.alpha (r)
prefold: <7: line 4, col 15> string.utf8.character.alpha (e)
prefold: <7: line 4, col 16> string.utf8.character.alpha (a)
prefold: <7: line 4, col 17> string.utf8.character.alpha (m)
prefold: <4: line 4, col 18> string.utf8 ()
prefold: <4: line 4, col 18> source.package.name ()
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8(m)
folding: string.utf8(m) <- string.utf8.character.alpha()
folded: string.utf8(m) <- string.utf8.character.alpha() = string.utf8(ma)
folding: string.utf8(ma) <- string.utf8.character.alpha()
folded: string.utf8(ma) <- string.utf8.character.alpha() = string.utf8(mae)
folding: string.utf8(mae) <- string.utf8.character.alpha()
folded: string.utf8(mae) <- string.utf8.character.alpha() = string.utf8(maer)
folding: string.utf8(maer) <- string.utf8.character.alpha()
folded: string.utf8(maer) <- string.utf8.character.alpha() =
string.utf8(maert)
folding: string.utf8(maert) <- string.utf8.character.alpha()
folded: string.utf8(maert) <- string.utf8.character.alpha() =
string.utf8(maerts)
folding: string.utf8(maerts) <- string.utf8.character.period()
folded: string.utf8(maerts) <- string.utf8.character.period() =
string.utf8(maerts.)
folding: string.utf8(maerts.) <- string.utf8.character.alpha()
folded: string.utf8(maerts.) <- string.utf8.character.alpha() =
string.utf8(maerts.s)
folding: string.utf8(maerts.s) <- string.utf8.character.alpha()
folded: string.utf8(maerts.s) <- string.utf8.character.alpha() =
string.utf8(maerts.so)
folding: string.utf8(maerts.so) <- string.utf8.character.alpha()
folded: string.utf8(maerts.so) <- string.utf8.character.alpha() =
string.utf8(maerts.soe)
folding: string.utf8(maerts.soe) <- string.utf8.character.alpha()
folded: string.utf8(maerts.soe) <- string.utf8.character.alpha() =
string.utf8(maerts.soen)
folding: source.package.name() <- string.utf8(maerts.soen)
folded: source.package.name() <- string.utf8(maerts.soen) =
source.package.name(neos.stream)
prefold: <3: line 4, col 18> source.package.import ()
folding: source.package.import() <- source.package.name(neos.stream)
folded: source.package.import() <- source.package.name(neos.stream) =
source.package.import(neos.stream)
folding: source.package.import(neos.stream) <-
source.package.import(neos.stream)
prefold: <3: line 3, col 7> language.keyword ()
prefold: <4: line 3, col 12> language.keyword ()
prefold: <5: line 3, col 13> string.utf8.character.alpha (i)
prefold: <6: line 3, col 14> string.utf8.character.alpha (n)
prefold: <6: line 3, col 15> string.utf8.character.alpha (p)
prefold: <6: line 3, col 16> string.utf8.character.alpha (u)
prefold: <6: line 3, col 17> string.utf8.character.alpha (t)
prefold: <5: line 3, col 18> string.utf8 ()
prefold: <5: line 3, col 18> language.identifier ()
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8(t)
folding: string.utf8(t) <- string.utf8.character.alpha()
folded: string.utf8(t) <- string.utf8.character.alpha() = string.utf8(tu)
folding: string.utf8(tu) <- string.utf8.character.alpha()
folded: string.utf8(tu) <- string.utf8.character.alpha() = string.utf8(tup)
folding: string.utf8(tup) <- string.utf8.character.alpha()
folded: string.utf8(tup) <- string.utf8.character.alpha() = string.utf8(tupn)
folding: string.utf8(tupn) <- string.utf8.character.alpha()
folded: string.utf8(tupn) <- string.utf8.character.alpha() =
string.utf8(tupni)
folding: language.identifier() <- string.utf8(tupni)
folded: language.identifier() <- string.utf8(tupni) =
language.identifier(input)
prefold: <10: line 3, col 19> string.utf8.character.alpha (s)
prefold: <10: line 3, col 20> string.utf8 ()
prefold: <10: line 3, col 20> language.identifier ()
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8(s)
folding: language.identifier() <- string.utf8(s)
folded: language.identifier() <- string.utf8(s) = language.identifier(s)
prefold: <9: line 3, col 20> language.function.parameter ()
prefold: <11: line 3, col 26> language.keyword ()
prefold: <10: line 3, col 26> language.function.parameter.direction.out ()
prefold: <12: line 3, col 33> language.type.string ()
prefold: <7: line 3, col 33> language.function.parameters ()
prefold: <4: line 3, col 34> language.function.signature ()
prefold: <4: line 3, col 35> language.function.import ()
prefold: <3: line 4, col 7> language.keyword ()
prefold: <4: line 4, col 12> language.keyword ()
prefold: <5: line 4, col 13> string.utf8.character.alpha (p)
prefold: <6: line 4, col 14> string.utf8.character.alpha (r)
prefold: <6: line 4, col 15> string.utf8.character.alpha (i)
prefold: <6: line 4, col 16> string.utf8.character.alpha (n)
prefold: <6: line 4, col 17> string.utf8.character.alpha (t)
prefold: <5: line 4, col 18> string.utf8 ()
prefold: <5: line 4, col 18> language.identifier ()
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8(t)
folding: string.utf8(t) <- string.utf8.character.alpha()
folded: string.utf8(t) <- string.utf8.character.alpha() = string.utf8(tn)
folding: string.utf8(tn) <- string.utf8.character.alpha()
folded: string.utf8(tn) <- string.utf8.character.alpha() = string.utf8(tni)
folding: string.utf8(tni) <- string.utf8.character.alpha()
folded: string.utf8(tni) <- string.utf8.character.alpha() = string.utf8(tnir)
folding: string.utf8(tnir) <- string.utf8.character.alpha()
folded: string.utf8(tnir) <- string.utf8.character.alpha() =
string.utf8(tnirp)
folding: language.identifier() <- string.utf8(tnirp)
folded: language.identifier() <- string.utf8(tnirp) =
language.identifier(print)
prefold: <10: line 4, col 19> string.utf8.character.alpha (s)
prefold: <10: line 4, col 20> string.utf8 ()
prefold: <10: line 4, col 20> language.identifier ()
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8(s)
folding: language.identifier() <- string.utf8(s)
folded: language.identifier() <- string.utf8(s) = language.identifier(s)
prefold: <9: line 4, col 20> language.function.parameter ()
prefold: <11: line 4, col 25> language.keyword ()
prefold: <10: line 4, col 25> language.function.parameter.direction.in ()
prefold: <12: line 4, col 32> language.type.string ()
prefold: <7: line 4, col 32> language.function.parameters ()
prefold: <4: line 4, col 33> language.function.signature ()
prefold: <4: line 4, col 34> language.function.import ()
folded: source.package.import(neos.stream) <-
source.package.import(neos.stream) = ()
prefold: <3: line 6, col 7> language.keyword ()
prefold: <4: line 6, col 10> language.keyword ()
prefold: <5: line 6, col 11> string.utf8.character.alpha (t)
prefold: <6: line 6, col 12> string.utf8.character.alpha (o)
prefold: <6: line 6, col 13> string.utf8.character.underscore (_)
prefold: <6: line 6, col 14> string.utf8.character.alpha (s)
prefold: <6: line 6, col 15> string.utf8.character.alpha (t)
prefold: <6: line 6, col 16> string.utf8.character.alpha (r)
prefold: <6: line 6, col 17> string.utf8.character.alpha (i)
prefold: <6: line 6, col 18> string.utf8.character.alpha (n)
prefold: <6: line 6, col 19> string.utf8.character.alpha (g)
prefold: <5: line 6, col 20> string.utf8 ()
prefold: <5: line 6, col 20> language.identifier ()
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8(g)
folding: string.utf8(g) <- string.utf8.character.alpha()
folded: string.utf8(g) <- string.utf8.character.alpha() = string.utf8(gn)
folding: string.utf8(gn) <- string.utf8.character.alpha()
folded: string.utf8(gn) <- string.utf8.character.alpha() = string.utf8(gni)
folding: string.utf8(gni) <- string.utf8.character.alpha()
folded: string.utf8(gni) <- string.utf8.character.alpha() = string.utf8(gnir)
folding: string.utf8(gnir) <- string.utf8.character.alpha()
folded: string.utf8(gnir) <- string.utf8.character.alpha() =
string.utf8(gnirt)
folding: string.utf8(gnirt) <- string.utf8.character.alpha()
folded: string.utf8(gnirt) <- string.utf8.character.alpha() =
string.utf8(gnirts)
folding: string.utf8(gnirts) <- string.utf8.character.underscore()
folded: string.utf8(gnirts) <- string.utf8.character.underscore() =
string.utf8(gnirts_)
folding: string.utf8(gnirts_) <- string.utf8.character.alpha()
folded: string.utf8(gnirts_) <- string.utf8.character.alpha() =
string.utf8(gnirts_o)
folding: string.utf8(gnirts_o) <- string.utf8.character.alpha()
folded: string.utf8(gnirts_o) <- string.utf8.character.alpha() =
string.utf8(gnirts_ot)
folding: language.identifier() <- string.utf8(gnirts_ot)
folded: language.identifier() <- string.utf8(gnirts_ot) =
language.identifier(to_string)
prefold: <10: line 6, col 21> string.utf8.character.alpha (x)
prefold: <10: line 6, col 22> string.utf8 ()
prefold: <10: line 6, col 22> language.identifier ()
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8(x)
folding: language.identifier() <- string.utf8(x)
folded: language.identifier() <- string.utf8(x) = language.identifier(x)
prefold: <9: line 6, col 22> language.function.parameter ()
prefold: <11: line 6, col 28> language.type.i32 ()
prefold: <7: line 6, col 28> language.function.parameters ()
prefold: <10: line 6, col 39> language.type.string ()
prefold: <9: line 6, col 39> language.function.return ()
prefold: <4: line 6, col 39> language.function.signature ()
prefold: <4: line 6, col 40> language.function.import ()
prefold: <3: line 7, col 7> language.keyword ()
prefold: <4: line 7, col 10> language.keyword ()
prefold: <5: line 7, col 11> string.utf8.character.alpha (t)
prefold: <6: line 7, col 12> string.utf8.character.alpha (o)
prefold: <6: line 7, col 13> string.utf8.character.underscore (_)
prefold: <6: line 7, col 14> string.utf8.character.alpha (i)
prefold: <6: line 7, col 15> string.utf8.character.alpha (n)
prefold: <6: line 7, col 16> string.utf8.character.alpha (t)
prefold: <6: line 7, col 17> string.utf8.character.alpha (e)
prefold: <6: line 7, col 18> string.utf8.character.alpha (g)
prefold: <6: line 7, col 19> string.utf8.character.alpha (e)
prefold: <6: line 7, col 20> string.utf8.character.alpha (r)
prefold: <5: line 7, col 21> string.utf8 ()
prefold: <5: line 7, col 21> language.identifier ()
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8(r)
folding: string.utf8(r) <- string.utf8.character.alpha()
folded: string.utf8(r) <- string.utf8.character.alpha() = string.utf8(re)
folding: string.utf8(re) <- string.utf8.character.alpha()
folded: string.utf8(re) <- string.utf8.character.alpha() = string.utf8(reg)
folding: string.utf8(reg) <- string.utf8.character.alpha()
folded: string.utf8(reg) <- string.utf8.character.alpha() = string.utf8(rege)
folding: string.utf8(rege) <- string.utf8.character.alpha()
folded: string.utf8(rege) <- string.utf8.character.alpha() =
string.utf8(reget)
folding: string.utf8(reget) <- string.utf8.character.alpha()
folded: string.utf8(reget) <- string.utf8.character.alpha() =
string.utf8(regetn)
folding: string.utf8(regetn) <- string.utf8.character.alpha()
folded: string.utf8(regetn) <- string.utf8.character.alpha() =
string.utf8(regetni)
folding: string.utf8(regetni) <- string.utf8.character.underscore()
folded: string.utf8(regetni) <- string.utf8.character.underscore() =
string.utf8(regetni_)
folding: string.utf8(regetni_) <- string.utf8.character.alpha()
folded: string.utf8(regetni_) <- string.utf8.character.alpha() =
string.utf8(regetni_o)
folding: string.utf8(regetni_o) <- string.utf8.character.alpha()
folded: string.utf8(regetni_o) <- string.utf8.character.alpha() =
string.utf8(regetni_ot)
folding: language.identifier() <- string.utf8(regetni_ot)
folded: language.identifier() <- string.utf8(regetni_ot) =
language.identifier(to_integer)
prefold: <10: line 7, col 22> string.utf8.character.alpha (s)
prefold: <10: line 7, col 23> string.utf8 ()
prefold: <10: line 7, col 23> language.identifier ()
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8(s)
folding: language.identifier() <- string.utf8(s)
folded: language.identifier() <- string.utf8(s) = language.identifier(s)
prefold: <9: line 7, col 23> language.function.parameter ()
prefold: <11: line 7, col 32> language.type.string ()
prefold: <7: line 7, col 32> language.function.parameters ()
prefold: <10: line 7, col 40> language.type.i32 ()
prefold: <9: line 7, col 40> language.function.return ()
prefold: <4: line 7, col 40> language.function.signature ()
prefold: <4: line 7, col 41> language.function.import ()
prefold: <3: line 8, col 7> language.keyword ()
prefold: <4: line 8, col 12> language.keyword ()
prefold: <5: line 8, col 13> string.utf8.character.alpha (i)
prefold: <6: line 8, col 14> string.utf8.character.alpha (n)
prefold: <6: line 8, col 15> string.utf8.character.alpha (p)
prefold: <6: line 8, col 16> string.utf8.character.alpha (u)
prefold: <6: line 8, col 17> string.utf8.character.alpha (t)
prefold: <5: line 8, col 18> string.utf8 ()
prefold: <5: line 8, col 18> language.identifier ()
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8(t)
folding: string.utf8(t) <- string.utf8.character.alpha()
folded: string.utf8(t) <- string.utf8.character.alpha() = string.utf8(tu)
folding: string.utf8(tu) <- string.utf8.character.alpha()
folded: string.utf8(tu) <- string.utf8.character.alpha() = string.utf8(tup)
folding: string.utf8(tup) <- string.utf8.character.alpha()
folded: string.utf8(tup) <- string.utf8.character.alpha() = string.utf8(tupn)
folding: string.utf8(tupn) <- string.utf8.character.alpha()
folded: string.utf8(tupn) <- string.utf8.character.alpha() =
string.utf8(tupni)
folding: language.identifier() <- string.utf8(tupni)
folded: language.identifier() <- string.utf8(tupni) =
language.identifier(input)
prefold: <10: line 8, col 19> string.utf8.character.alpha (s)
prefold: <10: line 8, col 20> string.utf8 ()
prefold: <10: line 8, col 20> language.identifier ()
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8(s)
folding: language.identifier() <- string.utf8(s)
folded: language.identifier() <- string.utf8(s) = language.identifier(s)
prefold: <9: line 8, col 20> language.function.parameter ()
prefold: <11: line 8, col 26> language.keyword ()
prefold: <10: line 8, col 26> language.function.parameter.direction.out ()
prefold: <12: line 8, col 33> language.type.string ()
prefold: <7: line 8, col 33> language.function.parameters ()
prefold: <4: line 8, col 34> language.function.signature ()
prefold: <4: line 8, col 35> language.function.import ()
prefold: <3: line 9, col 7> language.keyword ()
prefold: <4: line 9, col 12> language.keyword ()
prefold: <5: line 9, col 13> string.utf8.character.alpha (p)
prefold: <6: line 9, col 14> string.utf8.character.alpha (r)
prefold: <6: line 9, col 15> string.utf8.character.alpha (i)
prefold: <6: line 9, col 16> string.utf8.character.alpha (n)
prefold: <6: line 9, col 17> string.utf8.character.alpha (t)
prefold: <5: line 9, col 18> string.utf8 ()
prefold: <5: line 9, col 18> language.identifier ()
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8(t)
folding: string.utf8(t) <- string.utf8.character.alpha()
folded: string.utf8(t) <- string.utf8.character.alpha() = string.utf8(tn)
folding: string.utf8(tn) <- string.utf8.character.alpha()
folded: string.utf8(tn) <- string.utf8.character.alpha() = string.utf8(tni)
folding: string.utf8(tni) <- string.utf8.character.alpha()
folded: string.utf8(tni) <- string.utf8.character.alpha() = string.utf8(tnir)
folding: string.utf8(tnir) <- string.utf8.character.alpha()
folded: string.utf8(tnir) <- string.utf8.character.alpha() =
string.utf8(tnirp)
folding: language.identifier() <- string.utf8(tnirp)
folded: language.identifier() <- string.utf8(tnirp) =
language.identifier(print)
prefold: <10: line 9, col 19> string.utf8.character.alpha (s)
prefold: <10: line 9, col 20> string.utf8 ()
prefold: <10: line 9, col 20> language.identifier ()
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8(s)
folding: language.identifier() <- string.utf8(s)
folded: language.identifier() <- string.utf8(s) = language.identifier(s)
prefold: <9: line 9, col 20> language.function.parameter ()
prefold: <11: line 9, col 25> language.keyword ()
prefold: <10: line 9, col 25> language.function.parameter.direction.in ()
prefold: <12: line 9, col 32> language.type.string ()
prefold: <7: line 9, col 32> language.function.parameters ()
prefold: <4: line 9, col 33> language.function.signature ()
prefold: <4: line 9, col 34> language.function.import ()
prefold: <3: line 12, col 4> language.keyword ()
prefold: <4: line 12, col 7> language.keyword ()
prefold: <5: line 12, col 8> string.utf8.character.alpha (a)
prefold: <6: line 12, col 9> string.utf8.character.alpha (d)
prefold: <6: line 12, col 10> string.utf8.character.alpha (d)
prefold: <5: line 12, col 11> string.utf8 ()
prefold: <5: line 12, col 11> language.identifier ()
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8(d)
folding: string.utf8(d) <- string.utf8.character.alpha()
folded: string.utf8(d) <- string.utf8.character.alpha() = string.utf8(dd)
folding: string.utf8(dd) <- string.utf8.character.alpha()
folded: string.utf8(dd) <- string.utf8.character.alpha() = string.utf8(dda)
folding: language.identifier() <- string.utf8(dda)
folded: language.identifier() <- string.utf8(dda) = language.identifier(add)
prefold: <10: line 12, col 12> string.utf8.character.alpha (x)
prefold: <10: line 12, col 13> string.utf8 ()
prefold: <10: line 12, col 13> language.identifier ()
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8(x)
folding: language.identifier() <- string.utf8(x)
folded: language.identifier() <- string.utf8(x) = language.identifier(x)
prefold: <9: line 12, col 13> language.function.parameter ()
prefold: <12: line 12, col 15> string.utf8.character.alpha (y)
prefold: <12: line 12, col 16> string.utf8 ()
prefold: <12: line 12, col 16> language.identifier ()
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8(y)
folding: language.identifier() <- string.utf8(y)
folded: language.identifier() <- string.utf8(y) = language.identifier(y)
prefold: <11: line 12, col 16> language.function.parameter ()
prefold: <13: line 12, col 22> language.type.i32 ()
prefold: <7: line 12, col 22> language.function.parameters ()
prefold: <10: line 12, col 30> language.type.i32 ()
prefold: <9: line 12, col 30> language.function.return ()
prefold: <4: line 12, col 30> language.function.signature ()
prefold: <8: line 14, col 11> language.keyword ()
prefold: <14: line 14, col 12> string.utf8.character.alpha (x)
prefold: <14: line 14, col 13> string.utf8 ()
prefold: <14: line 14, col 13> language.identifier ()
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8(x)
folding: language.identifier() <- string.utf8(x)
folded: language.identifier() <- string.utf8(x) = language.identifier(x)
prefold: <13: line 14, col 13> math.expression.operand ()
prefold: <16: line 14, col 16> string.utf8.character.alpha (y)
prefold: <16: line 14, col 17> string.utf8 ()
prefold: <16: line 14, col 17> language.identifier ()
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8(y)
folding: language.identifier() <- string.utf8(y)
folded: language.identifier() <- string.utf8(y) = language.identifier(y)
prefold: <15: line 14, col 17> math.expression.operand ()
prefold: <11: line 14, col 15> math.operator.add ()
prefold: <10: line 14, col 17> math.expression ()
prefold: <9: line 14, col 17> language.expression ()
prefold: <9: line 14, col 18> language.function.return ()
prefold: <7: line 14, col 18> language.statement ()
prefold: <5: line 15, col 2> language.function.scope ()
prefold: <4: line 15, col 2> language.function ()
prefold: <3: line 16, col 4> language.keyword ()
prefold: <4: line 16, col 7> language.keyword ()
prefold: <5: line 16, col 8> string.utf8.character.alpha (f)
prefold: <6: line 16, col 9> string.utf8.character.alpha (i)
prefold: <6: line 16, col 10> string.utf8.character.alpha (b)
prefold: <5: line 16, col 11> string.utf8 ()
prefold: <5: line 16, col 11> language.identifier ()
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8(b)
folding: string.utf8(b) <- string.utf8.character.alpha()
folded: string.utf8(b) <- string.utf8.character.alpha() = string.utf8(bi)
folding: string.utf8(bi) <- string.utf8.character.alpha()
folded: string.utf8(bi) <- string.utf8.character.alpha() = string.utf8(bif)
folding: language.identifier() <- string.utf8(bif)
folded: language.identifier() <- string.utf8(bif) = language.identifier(fib)
prefold: <10: line 16, col 12> string.utf8.character.alpha (x)
prefold: <10: line 16, col 13> string.utf8 ()
prefold: <10: line 16, col 13> language.identifier ()
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8(x)
folding: language.identifier() <- string.utf8(x)
folded: language.identifier() <- string.utf8(x) = language.identifier(x)
prefold: <9: line 16, col 13> language.function.parameter ()
prefold: <11: line 16, col 19> language.type.i32 ()
prefold: <7: line 16, col 19> language.function.parameters ()
prefold: <10: line 16, col 27> language.type.i32 ()
prefold: <9: line 16, col 27> language.function.return ()
prefold: <4: line 16, col 27> language.function.signature ()
prefold: <8: line 18, col 7> language.keyword ()
prefold: <17: line 18, col 9> string.utf8.character.alpha (x)
prefold: <17: line 18, col 10> string.utf8 ()
prefold: <17: line 18, col 10> language.identifier ()
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8(x)
folding: language.identifier() <- string.utf8(x)
folded: language.identifier() <- string.utf8(x) = language.identifier(x)
prefold: <16: line 18, col 10> math.expression.operand ()
prefold: <13: line 18, col 11> math.expression ()
prefold: <12: line 18, col 11> boolean.expression.operand ()
prefold: <18: line 18, col 13> math.universal.number.digit (2)
prefold: <18: line 18, col 14> math.universal.number ()
prefold: <18: line 18, col 14> math.expression.operand ()
prefold: <15: line 18, col 14> math.expression ()
prefold: <14: line 18, col 14> boolean.expression.operand ()
prefold: <12: line 18, col 12> boolean.operator.relational.lessthan ()
prefold: <10: line 18, col 14> boolean.expression ()
prefold: <13: line 19, col 15> language.keyword ()
prefold: <18: line 19, col 16> math.universal.number.digit (1)
prefold: <18: line 19, col 17> math.universal.number ()
prefold: <18: line 19, col 17> math.expression.operand ()
prefold: <15: line 19, col 17> math.expression ()
prefold: <14: line 19, col 17> language.expression ()
prefold: <14: line 19, col 18> language.function.return ()
prefold: <12: line 19, col 18> language.statement ()
prefold: <11: line 19, col 18> logic.operator.if ()
prefold: <14: line 20, col 9> language.keyword ()
prefold: <16: line 21, col 15> language.keyword ()
prefold: <23: line 21, col 16> string.utf8.character.alpha (a)
prefold: <24: line 21, col 17> string.utf8.character.alpha (d)
prefold: <24: line 21, col 18> string.utf8.character.alpha (d)
prefold: <23: line 21, col 19> string.utf8 ()
prefold: <23: line 21, col 19> language.identifier ()
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8(d)
folding: string.utf8(d) <- string.utf8.character.alpha()
folded: string.utf8(d) <- string.utf8.character.alpha() = string.utf8(dd)
folding: string.utf8(dd) <- string.utf8.character.alpha()
folded: string.utf8(dd) <- string.utf8.character.alpha() = string.utf8(dda)
folding: language.identifier() <- string.utf8(dda)
folded: language.identifier() <- string.utf8(dda) = language.identifier(add)
prefold: <32: line 21, col 20> string.utf8.character.alpha (f)
prefold: <33: line 21, col 21> string.utf8.character.alpha (i)
prefold: <33: line 21, col 22> string.utf8.character.alpha (b)
prefold: <32: line 21, col 23> string.utf8 ()
prefold: <32: line 21, col 23> language.identifier ()
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8(b)
folding: string.utf8(b) <- string.utf8.character.alpha()
folded: string.utf8(b) <- string.utf8.character.alpha() = string.utf8(bi)
folding: string.utf8(bi) <- string.utf8.character.alpha()
folded: string.utf8(bi) <- string.utf8.character.alpha() = string.utf8(bif)
folding: language.identifier() <- string.utf8(bif)
folded: language.identifier() <- string.utf8(bif) = language.identifier(fib)
prefold: <40: line 21, col 24> string.utf8.character.alpha (x)
prefold: <40: line 21, col 25> string.utf8 ()
prefold: <40: line 21, col 25> language.identifier ()
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8(x)
folding: language.identifier() <- string.utf8(x)
folded: language.identifier() <- string.utf8(x) = language.identifier(x)
prefold: <39: line 21, col 25> math.expression.operand ()
prefold: <41: line 21, col 26> math.universal.number.digit (1)
prefold: <41: line 21, col 27> math.universal.number ()
prefold: <41: line 21, col 27> math.expression.operand ()
prefold: <37: line 21, col 26> math.operator.subtract ()
prefold: <36: line 21, col 27> math.expression ()
prefold: <35: line 21, col 27> language.function.argument ()
prefold: <34: line 21, col 28> language.function.call ()
prefold: <30: line 21, col 28> math.expression.operand ()
prefold: <27: line 21, col 28> math.expression ()
prefold: <26: line 21, col 28> language.function.argument ()
prefold: <35: line 21, col 30> string.utf8.character.alpha (f)
prefold: <36: line 21, col 31> string.utf8.character.alpha (i)
prefold: <36: line 21, col 32> string.utf8.character.alpha (b)
prefold: <35: line 21, col 33> string.utf8 ()
prefold: <35: line 21, col 33> language.identifier ()
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8(b)
folding: string.utf8(b) <- string.utf8.character.alpha()
folded: string.utf8(b) <- string.utf8.character.alpha() = string.utf8(bi)
folding: string.utf8(bi) <- string.utf8.character.alpha()
folded: string.utf8(bi) <- string.utf8.character.alpha() = string.utf8(bif)
folding: language.identifier() <- string.utf8(bif)
folded: language.identifier() <- string.utf8(bif) = language.identifier(fib)
prefold: <43: line 21, col 34> string.utf8.character.alpha (x)
prefold: <43: line 21, col 35> string.utf8 ()
prefold: <43: line 21, col 35> language.identifier ()
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8(x)
folding: language.identifier() <- string.utf8(x)
folded: language.identifier() <- string.utf8(x) = language.identifier(x)
prefold: <42: line 21, col 35> math.expression.operand ()
prefold: <44: line 21, col 36> math.universal.number.digit (2)
prefold: <44: line 21, col 37> math.universal.number ()
prefold: <44: line 21, col 37> math.expression.operand ()
prefold: <40: line 21, col 36> math.operator.subtract ()
prefold: <39: line 21, col 37> math.expression ()
prefold: <38: line 21, col 37> language.function.argument ()
prefold: <37: line 21, col 38> language.function.call ()
prefold: <33: line 21, col 38> math.expression.operand ()
prefold: <30: line 21, col 38> math.expression ()
prefold: <29: line 21, col 38> language.function.argument ()
prefold: <25: line 21, col 39> language.function.call ()
prefold: <21: line 21, col 39> math.expression.operand ()
prefold: <18: line 21, col 39> math.expression ()
prefold: <17: line 21, col 39> language.expression ()
prefold: <17: line 21, col 40> language.function.return ()
prefold: <15: line 21, col 40> language.statement ()
prefold: <14: line 21, col 40> logic.operator.else ()
prefold: <7: line 21, col 40> language.statement ()
prefold: <5: line 22, col 2> language.function.scope ()
prefold: <4: line 22, col 2> language.function ()
prefold: <3: line 25, col 4> language.keyword ()
prefold: <4: line 25, col 9> language.keyword ()
prefold: <5: line 25, col 10> string.utf8.character.alpha (m)
prefold: <6: line 25, col 11> string.utf8.character.alpha (a)
prefold: <6: line 25, col 12> string.utf8.character.alpha (i)
prefold: <6: line 25, col 13> string.utf8.character.alpha (n)
prefold: <5: line 25, col 14> string.utf8 ()
prefold: <5: line 25, col 14> language.identifier ()
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8(n)
folding: string.utf8(n) <- string.utf8.character.alpha()
folded: string.utf8(n) <- string.utf8.character.alpha() = string.utf8(ni)
folding: string.utf8(ni) <- string.utf8.character.alpha()
folded: string.utf8(ni) <- string.utf8.character.alpha() = string.utf8(nia)
folding: string.utf8(nia) <- string.utf8.character.alpha()
folded: string.utf8(nia) <- string.utf8.character.alpha() = string.utf8(niam)
folding: language.identifier() <- string.utf8(niam)
folded: language.identifier() <- string.utf8(niam) = language.identifier(main)
prefold: <4: line 25, col 16> language.function.signature ()
prefold: <8: line 26, col 5> string.utf8.character.alpha (s)
prefold: <8: line 26, col 6> string.utf8 ()
prefold: <8: line 26, col 6> language.identifier ()
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8(s)
folding: language.identifier() <- string.utf8(s)
folded: language.identifier() <- string.utf8(s) = language.identifier(s)
prefold: <7: line 26, col 6> language.function.local ()
prefold: <9: line 26, col 15> language.type.string ()
prefold: <5: line 26, col 16> language.function.locals ()
prefold: <5: line 27, col 1> language.function.locals ()
prefold: <15: line 28, col 5> string.utf8.character.alpha (p)
prefold: <16: line 28, col 6> string.utf8.character.alpha (r)
prefold: <16: line 28, col 7> string.utf8.character.alpha (i)
prefold: <16: line 28, col 8> string.utf8.character.alpha (n)
prefold: <16: line 28, col 9> string.utf8.character.alpha (t)
prefold: <15: line 28, col 10> string.utf8 ()
prefold: <15: line 28, col 10> language.identifier ()
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8(t)
folding: string.utf8(t) <- string.utf8.character.alpha()
folded: string.utf8(t) <- string.utf8.character.alpha() = string.utf8(tn)
folding: string.utf8(tn) <- string.utf8.character.alpha()
folded: string.utf8(tn) <- string.utf8.character.alpha() = string.utf8(tni)
folding: string.utf8(tni) <- string.utf8.character.alpha()
folded: string.utf8(tni) <- string.utf8.character.alpha() = string.utf8(tnir)
folding: string.utf8(tnir) <- string.utf8.character.alpha()
folded: string.utf8(tnir) <- string.utf8.character.alpha() =
string.utf8(tnirp)
folding: language.identifier() <- string.utf8(tnirp)
folded: language.identifier() <- string.utf8(tnirp) =
language.identifier(print)
prefold: <24: line 28, col 12> string.utf8.character (E)
prefold: <24: line 28, col 13> string.utf8.character (n)
prefold: <24: line 28, col 14> string.utf8.character (t)
prefold: <24: line 28, col 15> string.utf8.character (e)
prefold: <24: line 28, col 16> string.utf8.character (r)
prefold: <24: line 28, col 17> string.utf8.character ( )
prefold: <24: line 28, col 18> string.utf8.character (a)
prefold: <24: line 28, col 19> string.utf8.character ( )
prefold: <24: line 28, col 20> string.utf8.character (p)
prefold: <24: line 28, col 21> string.utf8.character (o)
prefold: <24: line 28, col 22> string.utf8.character (s)
prefold: <24: line 28, col 23> string.utf8.character (i)
prefold: <24: line 28, col 24> string.utf8.character (t)
prefold: <24: line 28, col 25> string.utf8.character (i)
prefold: <24: line 28, col 26> string.utf8.character (v)
prefold: <24: line 28, col 27> string.utf8.character (e)
prefold: <24: line 28, col 28> string.utf8.character ( )
prefold: <27: line 29, col 14> string.utf8.character (i)
prefold: <27: line 29, col 15> string.utf8.character (n)
prefold: <27: line 29, col 16> string.utf8.character (t)
prefold: <27: line 29, col 17> string.utf8.character (e)
prefold: <27: line 29, col 18> string.utf8.character (g)
prefold: <27: line 29, col 19> string.utf8.character (e)
prefold: <27: line 29, col 20> string.utf8.character (r)
prefold: <27: line 29, col 21> string.utf8.character (:)
prefold: <27: line 29, col 22> string.utf8.character ( )
prefold: <23: line 29, col 24> string.utf8 ()
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8( )
folding: string.utf8( ) <- string.utf8.character.alpha()
folded: string.utf8( ) <- string.utf8.character.alpha() = string.utf8( :)
folding: string.utf8( :) <- string.utf8.character.alpha()
folded: string.utf8( :) <- string.utf8.character.alpha() = string.utf8( :r)
folding: string.utf8( :r) <- string.utf8.character.alpha()
folded: string.utf8( :r) <- string.utf8.character.alpha() = string.utf8( :re)
folding: string.utf8( :re) <- string.utf8.character.alpha()
folded: string.utf8( :re) <- string.utf8.character.alpha() = string.utf8(
:reg)
folding: string.utf8( :reg) <- string.utf8.character.alpha()
folded: string.utf8( :reg) <- string.utf8.character.alpha() = string.utf8(
:rege)
folding: string.utf8( :rege) <- string.utf8.character.alpha()
folded: string.utf8( :rege) <- string.utf8.character.alpha() =
string.utf8( :reget)
folding: string.utf8( :reget) <- string.utf8.character.alpha()
folded: string.utf8( :reget) <- string.utf8.character.alpha() =
string.utf8( :regetn)
folding: string.utf8( :regetn) <- string.utf8.character.alpha()
folded: string.utf8( :regetn) <- string.utf8.character.alpha() =
string.utf8( :regetni)
folding: string.utf8( :regetni) <- string.utf8.character.alpha()
folded: string.utf8( :regetni) <- string.utf8.character.alpha() =
string.utf8( :regetni )
folding: string.utf8( :regetni ) <- string.utf8.character.alpha()
folded: string.utf8( :regetni ) <- string.utf8.character.alpha() =
string.utf8( :regetni e)
folding: string.utf8( :regetni e) <- string.utf8.character.alpha()
folded: string.utf8( :regetni e) <- string.utf8.character.alpha() =
string.utf8( :regetni ev)
folding: string.utf8( :regetni ev) <- string.utf8.character.alpha()
folded: string.utf8( :regetni ev) <- string.utf8.character.alpha() =
string.utf8( :regetni evi)
folding: string.utf8( :regetni evi) <- string.utf8.character.alpha()
folded: string.utf8( :regetni evi) <- string.utf8.character.alpha() =
string.utf8( :regetni evit)
folding: string.utf8( :regetni evit) <- string.utf8.character.alpha()
folded: string.utf8( :regetni evit) <- string.utf8.character.alpha() =
string.utf8( :regetni eviti)
folding: string.utf8( :regetni eviti) <- string.utf8.character.alpha()
folded: string.utf8( :regetni eviti) <- string.utf8.character.alpha() =
string.utf8( :regetni evitis)
folding: string.utf8( :regetni evitis) <- string.utf8.character.alpha()
folded: string.utf8( :regetni evitis) <- string.utf8.character.alpha() =
string.utf8( :regetni evitiso)
folding: string.utf8( :regetni evitiso) <- string.utf8.character.alpha()
folded: string.utf8( :regetni evitiso) <- string.utf8.character.alpha() =
string.utf8( :regetni evitisop)
folding: string.utf8( :regetni evitisop) <- string.utf8.character.alpha()
folded: string.utf8( :regetni evitisop) <- string.utf8.character.alpha() =
string.utf8( :regetni evitisop )
folding: string.utf8( :regetni evitisop ) <- string.utf8.character.alpha()
folded: string.utf8( :regetni evitisop ) <- string.utf8.character.alpha()
= string.utf8( :regetni evitisop a)
folding: string.utf8( :regetni evitisop a) <- string.utf8.character.alpha()
folded: string.utf8( :regetni evitisop a) <- string.utf8.character.alpha()
= string.utf8( :regetni evitisop a )
folding: string.utf8( :regetni evitisop a ) <- string.utf8.character.alpha()
folded: string.utf8( :regetni evitisop a ) <-
string.utf8.character.alpha() = string.utf8( :regetni evitisop a r)
folding: string.utf8( :regetni evitisop a r) <- string.utf8.character.alpha()
folded: string.utf8( :regetni evitisop a r) <-
string.utf8.character.alpha() = string.utf8( :regetni evitisop a re)
folding: string.utf8( :regetni evitisop a re) <- string.utf8.character.alpha()
folded: string.utf8( :regetni evitisop a re) <-
string.utf8.character.alpha() = string.utf8( :regetni evitisop a ret)
folding: string.utf8( :regetni evitisop a ret) <-
string.utf8.character.alpha()
folded: string.utf8( :regetni evitisop a ret) <-
string.utf8.character.alpha() = string.utf8( :regetni evitisop a retn)
folding: string.utf8( :regetni evitisop a retn) <-
string.utf8.character.alpha()
folded: string.utf8( :regetni evitisop a retn) <-
string.utf8.character.alpha() = string.utf8( :regetni evitisop a retnE)
folding: string.utf8( :regetni evitisop a retnE) <- string.utf8( :regetni
evitisop a retnE)
folded: string.utf8( :regetni evitisop a retnE) <- string.utf8( :regetni
evitisop a retnE) = string.utf8(Enter a positive integer: )
prefold: <22: line 29, col 24> math.expression.operand ()
prefold: <19: line 29, col 24> math.expression ()
prefold: <18: line 29, col 24> language.function.argument ()
prefold: <17: line 29, col 25> language.function.call ()
prefold: <13: line 29, col 25> math.expression.operand ()
prefold: <10: line 29, col 25> math.expression ()
prefold: <9: line 29, col 25> language.expression ()
prefold: <8: line 29, col 25> language.statement ()
prefold: <9: line 29, col 26> language.function.return ()
prefold: <8: line 29, col 26> language.statement ()
prefold: <15: line 30, col 5> string.utf8.character.alpha (i)
prefold: <16: line 30, col 6> string.utf8.character.alpha (n)
prefold: <16: line 30, col 7> string.utf8.character.alpha (p)
prefold: <16: line 30, col 8> string.utf8.character.alpha (u)
prefold: <16: line 30, col 9> string.utf8.character.alpha (t)
prefold: <15: line 30, col 10> string.utf8 ()
prefold: <15: line 30, col 10> language.identifier ()
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8(t)
folding: string.utf8(t) <- string.utf8.character.alpha()
folded: string.utf8(t) <- string.utf8.character.alpha() = string.utf8(tu)
folding: string.utf8(tu) <- string.utf8.character.alpha()
folded: string.utf8(tu) <- string.utf8.character.alpha() = string.utf8(tup)
folding: string.utf8(tup) <- string.utf8.character.alpha()
folded: string.utf8(tup) <- string.utf8.character.alpha() = string.utf8(tupn)
folding: string.utf8(tupn) <- string.utf8.character.alpha()
folded: string.utf8(tupn) <- string.utf8.character.alpha() =
string.utf8(tupni)
folding: language.identifier() <- string.utf8(tupni)
folded: language.identifier() <- string.utf8(tupni) =
language.identifier(input)
prefold: <23: line 30, col 11> string.utf8.character.alpha (s)
prefold: <23: line 30, col 12> string.utf8 ()
prefold: <23: line 30, col 12> language.identifier ()
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8(s)
folding: language.identifier() <- string.utf8(s)
folded: language.identifier() <- string.utf8(s) = language.identifier(s)
prefold: <22: line 30, col 12> math.expression.operand ()
prefold: <19: line 30, col 12> math.expression ()
prefold: <18: line 30, col 12> language.function.argument ()
prefold: <17: line 30, col 13> language.function.call ()
prefold: <13: line 30, col 13> math.expression.operand ()
prefold: <10: line 30, col 13> math.expression ()
prefold: <9: line 30, col 13> language.expression ()
prefold: <8: line 30, col 13> language.statement ()
prefold: <9: line 30, col 14> language.function.return ()
prefold: <8: line 30, col 14> language.statement ()
prefold: <15: line 31, col 5> string.utf8.character.alpha (p)
prefold: <16: line 31, col 6> string.utf8.character.alpha (r)
prefold: <16: line 31, col 7> string.utf8.character.alpha (i)
prefold: <16: line 31, col 8> string.utf8.character.alpha (n)
prefold: <16: line 31, col 9> string.utf8.character.alpha (t)
prefold: <15: line 31, col 10> string.utf8 ()
prefold: <15: line 31, col 10> language.identifier ()
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8(t)
folding: string.utf8(t) <- string.utf8.character.alpha()
folded: string.utf8(t) <- string.utf8.character.alpha() = string.utf8(tn)
folding: string.utf8(tn) <- string.utf8.character.alpha()
folded: string.utf8(tn) <- string.utf8.character.alpha() = string.utf8(tni)
folding: string.utf8(tni) <- string.utf8.character.alpha()
folded: string.utf8(tni) <- string.utf8.character.alpha() = string.utf8(tnir)
folding: string.utf8(tnir) <- string.utf8.character.alpha()
folded: string.utf8(tnir) <- string.utf8.character.alpha() =
string.utf8(tnirp)
folding: language.identifier() <- string.utf8(tnirp)
folded: language.identifier() <- string.utf8(tnirp) =
language.identifier(print)
prefold: <24: line 31, col 12> string.utf8.character (F)
prefold: <24: line 31, col 13> string.utf8.character (i)
prefold: <24: line 31, col 14> string.utf8.character (b)
prefold: <24: line 31, col 15> string.utf8.character (o)
prefold: <24: line 31, col 16> string.utf8.character (n)
prefold: <24: line 31, col 17> string.utf8.character (a)
prefold: <24: line 31, col 18> string.utf8.character (c)
prefold: <24: line 31, col 19> string.utf8.character (c)
prefold: <24: line 31, col 20> string.utf8.character (i)
prefold: <24: line 31, col 21> string.utf8.character (()
prefold: <23: line 31, col 24> string.utf8 ()
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8(()
folding: string.utf8(() <- string.utf8.character.alpha()
folded: string.utf8(() <- string.utf8.character.alpha() = string.utf8((i)
folding: string.utf8((i) <- string.utf8.character.alpha()
folded: string.utf8((i) <- string.utf8.character.alpha() = string.utf8((ic)
folding: string.utf8((ic) <- string.utf8.character.alpha()
folded: string.utf8((ic) <- string.utf8.character.alpha() = string.utf8((icc)
folding: string.utf8((icc) <- string.utf8.character.alpha()
folded: string.utf8((icc) <- string.utf8.character.alpha() =
string.utf8((icca)
folding: string.utf8((icca) <- string.utf8.character.alpha()
folded: string.utf8((icca) <- string.utf8.character.alpha() =
string.utf8((iccan)
folding: string.utf8((iccan) <- string.utf8.character.alpha()
folded: string.utf8((iccan) <- string.utf8.character.alpha() =
string.utf8((iccano)
folding: string.utf8((iccano) <- string.utf8.character.alpha()
folded: string.utf8((iccano) <- string.utf8.character.alpha() =
string.utf8((iccanob)
folding: string.utf8((iccanob) <- string.utf8.character.alpha()
folded: string.utf8((iccanob) <- string.utf8.character.alpha() =
string.utf8((iccanobi)
folding: string.utf8((iccanobi) <- string.utf8.character.alpha()
folded: string.utf8((iccanobi) <- string.utf8.character.alpha() =
string.utf8((iccanobiF)
folding: string.utf8((iccanobiF) <- string.utf8((iccanobiF)
folded: string.utf8((iccanobiF) <- string.utf8((iccanobiF) =
string.utf8(Fibonacci()
prefold: <22: line 31, col 24> math.expression.operand ()
prefold: <25: line 31, col 26> string.utf8.character.alpha (s)
prefold: <25: line 31, col 27> string.utf8 ()
prefold: <25: line 31, col 27> language.identifier ()
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8(s)
folding: language.identifier() <- string.utf8(s)
folded: language.identifier() <- string.utf8(s) = language.identifier(s)
prefold: <24: line 31, col 27> math.expression.operand ()
prefold: <20: line 31, col 25> math.operator.add ()
prefold: <28: line 31, col 31> string.utf8.character ())
prefold: <28: line 31, col 32> string.utf8.character ( )
prefold: <28: line 31, col 33> string.utf8.character (=)
prefold: <28: line 31, col 34> string.utf8.character ( )
prefold: <27: line 31, col 37> string.utf8 ()
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8( )
folding: string.utf8( ) <- string.utf8.character.alpha()
folded: string.utf8( ) <- string.utf8.character.alpha() = string.utf8( =)
folding: string.utf8( =) <- string.utf8.character.alpha()
folded: string.utf8( =) <- string.utf8.character.alpha() = string.utf8( = )
folding: string.utf8( = ) <- string.utf8.character.alpha()
folded: string.utf8( = ) <- string.utf8.character.alpha() = string.utf8( = ))
folding: string.utf8( = )) <- string.utf8( = ))
folded: string.utf8( = )) <- string.utf8( = )) = string.utf8() = )
prefold: <26: line 31, col 37> math.expression.operand ()
prefold: <22: line 31, col 29> math.operator.add ()
prefold: <30: line 31, col 39> string.utf8.character.alpha (t)
prefold: <31: line 31, col 40> string.utf8.character.alpha (o)
prefold: <31: line 31, col 41> string.utf8.character.underscore (_)
prefold: <31: line 31, col 42> string.utf8.character.alpha (s)
prefold: <31: line 31, col 43> string.utf8.character.alpha (t)
prefold: <31: line 31, col 44> string.utf8.character.alpha (r)
prefold: <31: line 31, col 45> string.utf8.character.alpha (i)
prefold: <31: line 31, col 46> string.utf8.character.alpha (n)
prefold: <31: line 31, col 47> string.utf8.character.alpha (g)
prefold: <30: line 31, col 48> string.utf8 ()
prefold: <30: line 31, col 48> language.identifier ()
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8(g)
folding: string.utf8(g) <- string.utf8.character.alpha()
folded: string.utf8(g) <- string.utf8.character.alpha() = string.utf8(gn)
folding: string.utf8(gn) <- string.utf8.character.alpha()
folded: string.utf8(gn) <- string.utf8.character.alpha() = string.utf8(gni)
folding: string.utf8(gni) <- string.utf8.character.alpha()
folded: string.utf8(gni) <- string.utf8.character.alpha() = string.utf8(gnir)
folding: string.utf8(gnir) <- string.utf8.character.alpha()
folded: string.utf8(gnir) <- string.utf8.character.alpha() =
string.utf8(gnirt)
folding: string.utf8(gnirt) <- string.utf8.character.alpha()
folded: string.utf8(gnirt) <- string.utf8.character.alpha() =
string.utf8(gnirts)
folding: string.utf8(gnirts) <- string.utf8.character.underscore()
folded: string.utf8(gnirts) <- string.utf8.character.underscore() =
string.utf8(gnirts_)
folding: string.utf8(gnirts_) <- string.utf8.character.alpha()
folded: string.utf8(gnirts_) <- string.utf8.character.alpha() =
string.utf8(gnirts_o)
folding: string.utf8(gnirts_o) <- string.utf8.character.alpha()
folded: string.utf8(gnirts_o) <- string.utf8.character.alpha() =
string.utf8(gnirts_ot)
folding: language.identifier() <- string.utf8(gnirts_ot)
folded: language.identifier() <- string.utf8(gnirts_ot) =
language.identifier(to_string)
prefold: <39: line 31, col 49> string.utf8.character.alpha (f)
prefold: <40: line 31, col 50> string.utf8.character.alpha (i)
prefold: <40: line 31, col 51> string.utf8.character.alpha (b)
prefold: <39: line 31, col 52> string.utf8 ()
prefold: <39: line 31, col 52> language.identifier ()
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8(b)
folding: string.utf8(b) <- string.utf8.character.alpha()
folded: string.utf8(b) <- string.utf8.character.alpha() = string.utf8(bi)
folding: string.utf8(bi) <- string.utf8.character.alpha()
folded: string.utf8(bi) <- string.utf8.character.alpha() = string.utf8(bif)
folding: language.identifier() <- string.utf8(bif)
folded: language.identifier() <- string.utf8(bif) = language.identifier(fib)
prefold: <48: line 31, col 53> string.utf8.character.alpha (t)
prefold: <49: line 31, col 54> string.utf8.character.alpha (o)
prefold: <49: line 31, col 55> string.utf8.character.underscore (_)
prefold: <49: line 31, col 56> string.utf8.character.alpha (i)
prefold: <49: line 31, col 57> string.utf8.character.alpha (n)
prefold: <49: line 31, col 58> string.utf8.character.alpha (t)
prefold: <49: line 31, col 59> string.utf8.character.alpha (e)
prefold: <49: line 31, col 60> string.utf8.character.alpha (g)
prefold: <49: line 31, col 61> string.utf8.character.alpha (e)
prefold: <49: line 31, col 62> string.utf8.character.alpha (r)
prefold: <48: line 31, col 63> string.utf8 ()
prefold: <48: line 31, col 63> language.identifier ()
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8(r)
folding: string.utf8(r) <- string.utf8.character.alpha()
folded: string.utf8(r) <- string.utf8.character.alpha() = string.utf8(re)
folding: string.utf8(re) <- string.utf8.character.alpha()
folded: string.utf8(re) <- string.utf8.character.alpha() = string.utf8(reg)
folding: string.utf8(reg) <- string.utf8.character.alpha()
folded: string.utf8(reg) <- string.utf8.character.alpha() = string.utf8(rege)
folding: string.utf8(rege) <- string.utf8.character.alpha()
folded: string.utf8(rege) <- string.utf8.character.alpha() =
string.utf8(reget)
folding: string.utf8(reget) <- string.utf8.character.alpha()
folded: string.utf8(reget) <- string.utf8.character.alpha() =
string.utf8(regetn)
folding: string.utf8(regetn) <- string.utf8.character.alpha()
folded: string.utf8(regetn) <- string.utf8.character.alpha() =
string.utf8(regetni)
folding: string.utf8(regetni) <- string.utf8.character.underscore()
folded: string.utf8(regetni) <- string.utf8.character.underscore() =
string.utf8(regetni_)
folding: string.utf8(regetni_) <- string.utf8.character.alpha()
folded: string.utf8(regetni_) <- string.utf8.character.alpha() =
string.utf8(regetni_o)
folding: string.utf8(regetni_o) <- string.utf8.character.alpha()
folded: string.utf8(regetni_o) <- string.utf8.character.alpha() =
string.utf8(regetni_ot)
folding: language.identifier() <- string.utf8(regetni_ot)
folded: language.identifier() <- string.utf8(regetni_ot) =
language.identifier(to_integer)
prefold: <56: line 31, col 64> string.utf8.character.alpha (s)
prefold: <56: line 31, col 65> string.utf8 ()
prefold: <56: line 31, col 65> language.identifier ()
folding: string.utf8() <- string.utf8.character.alpha()
folded: string.utf8() <- string.utf8.character.alpha() = string.utf8(s)
folding: language.identifier() <- string.utf8(s)
folded: language.identifier() <- string.utf8(s) = language.identifier(s)
prefold: <55: line 31, col 65> math.expression.operand ()
prefold: <52: line 31, col 65> math.expression ()
prefold: <51: line 31, col 65> language.function.argument ()
prefold: <50: line 31, col 66> language.function.call ()
prefold: <46: line 31, col 66> math.expression.operand ()
prefold: <43: line 31, col 66> math.expression ()
prefold: <42: line 31, col 66> language.function.argument ()
prefold: <41: line 31, col 67> language.function.call ()
prefold: <37: line 31, col 67> math.expression.operand ()
prefold: <34: line 31, col 67> math.expression ()
prefold: <33: line 31, col 67> language.function.argument ()
prefold: <32: line 31, col 68> language.function.call ()
prefold: <28: line 31, col 68> math.expression.operand ()
prefold: <24: line 31, col 38> math.operator.add ()
prefold: <34: line 31, col 74> string.utf8.character.LF ()
prefold: <31: line 31, col 75> string.utf8 ()
folding: string.utf8() <- string.utf8.character.LF()
folded: string.utf8() <- string.utf8.character.LF() = string.utf8( )
folding: string.utf8( ) <- string.utf8( )
folded: string.utf8( ) <- string.utf8( ) = string.utf8( )
prefold: <30: line 31, col 75> math.expression.operand ()
prefold: <26: line 31, col 70> math.operator.add ()
prefold: <19: line 31, col 75> math.expression ()
prefold: <18: line 31, col 75> language.function.argument ()
prefold: <17: line 31, col 76> language.function.call ()
prefold: <13: line 31, col 76> math.expression.operand ()
prefold: <10: line 31, col 76> math.expression ()
prefold: <9: line 31, col 76> language.expression ()
prefold: <8: line 31, col 76> language.statement ()
prefold: <9: line 31, col 77> language.function.return ()
prefold: <8: line 31, col 77> language.statement ()
prefold: <6: line 32, col 2> language.function.scope ()
prefold: <5: line 32, col 2> language.function ()
Compilation time: 704.515ms
neoscript]

/Flibble

--
"Talking snakes with legs changed into snakes." - Rick C. Hodgin

“You won’t burn in hell. But be nice anyway.” – Ricky Gervais

“I see Atheists are fighting and killing each other again, over who
doesn’t believe in any God the most. Oh, no..wait.. that never happens.” –
Ricky Gervais

"Suppose it's all true, and you walk up to the pearly gates, and are
confronted by God," Bryne asked on his show The Meaning of Life. "What
will Stephen Fry say to him, her, or it?"
"I'd say, bone cancer in children? What's that about?" Fry replied.
"How dare you? How dare you create a world to which there is such misery
that is not our fault. It's not right, it's utterly, utterly evil."
"Why should I respect a capricious, mean-minded, stupid God who creates a
world that is so full of injustice and pain. That's what I would say."