sn.printf.net

Rebar Releases and Being Wrong

This is an entry I wrote during the Bay Area Erlang Factory 2012, not long before R15B01 came out. Back at then, I found the time to discuss a few things with fellow Erlang programmers. One of them was related to a patch to Reltool that someone submitted while before. This was a fix made to make things simpler for Erlang programmers wanting to generate releases using rebar.

In your usual Erlang project using rebar, the structure is usually based under a clean OTP Application directory structure:

ebin/
src/
include/
priv/

There is also a bunch of other optional directories, including priv/, logs/, and deps/. The deps/ is specifically the default directory for dependencies downloaded at build-time.

This way of doing things works very, very well when it comes to writing OTP Applications. As long as anyone respects that structure, getting any app as a dependency should never hurt.

There is however, an insidious extension to this done when transforming an OTP Application into a release. When people generate release, their directory structure might now look a bit like this:

ebin/
src/
include/
priv/
deps/
rel/

The rel/ directory is where the release will be built. That one will contain a release configuration file, that references to a directory with libraries is usually found. The line of configuration is precisely {lib_dirs, ["../deps/"]}. You can already see where there might be a problem — the src/ directory is getting ignored.

How Can we fix this?

Many rebar users fix this issue in two common ways:

• Writing plugins or extending rebar to move, copy or simlink their top-level directories inside deps/
• Adding the line {lib_dirs, ["../deps/", "../../"]} to the configuration instead of the one above

The problem with this (especially the second approach) is that it's badly using a standard that has existed in OTP for a long, long while. The idea is that Erlang works with the basic concept of a LIB_DIRS environment variable. That variable should point to one or more directory that contains a bunch of application directories:

./
 - some_app/
   - src/
   - ebin/
 - other_app/
   - src/
   - ebin/
   - priv/

Putting that directory in LIB_DIRS will make it visible to the Erlang VM. When you put that directory in the configuration for a release ({lib_dirs, [Dirs]}), Reltool (the OTP release-building tool that is called by rebar) gets these variables to be part of its places to search.

Setting the directory to ../../ is a bad idea, because it basically makes the release building take into account all the directories on the same level as the one you're currently developing. This can have unexpected effects when you put that one first and you might have conflicting versions of libraries in deps/ and the directory itself; one of the two versions will be picked, and you might not be sure which.

The patch I mentioned earlier basically solved the issue by allowing the following to be placed in application requirements: {app, foo, [{incl_cond, include}, {lib_dir, ".."}]}. This patch basically lets you keep the OTP Application structure and turn it into a release without needing the messy hacks. I might be out of touch, but I can't understand why the OTP team would accept this patch. It is basically officializing a workaround for people using OTP tools in a way it wasn't intended.

There are two actual solutions that work to build releases, and they involve using a proper directory structure:

• All your OTP Applications have their own repository. You then make an additional directory that does nothing but fetch all dependencies to create a release
• You put your own OTP applications inside a custom directory (say apps/) and the dependencies in a second one (deps/). You then include these two directories in lib_dirs.

That's it, really. It's not very hard to do, and it works fine with all the regular OTP stuff. You use a proper release directory structure for releases, and you can keep using a proper OTP Application structure for OTP Applications. I do not understand why the fix had to make it upstream to OTP when its main use is to transform an OTP Application structure in something compatible with releases, especially since this need is mostly a quirk of how default values in rebar and community standards that emerged from its use pushed a lot of people to do things wrong (arguably). I would have prefered for people in general to fix their repositories rather than forcing the OTP team to fix their (non-broken) tool to accomodate them there.

I guess in the end it's kind of irrelevant; the fix in no way keeps me from doing what I was doing before, after all.

RTB: Where Erlang BLOOMs

I'm still on my way back from the Bay Area Erlang Factory 2012 (in fact I finished this post after coming back entirely), in San Francisco, and I've been starting to see a bunch of twitter posts regarding people posting their slides online. Although it is a good idea, I tend to view my slides as pure visual support, and the animations don't show up very well in a static PDF, so I thought I'd do a quick transcript of the main ideas that were at work in my talk, Real Time Bidding: Where Erlang BLOOMs, as brought to you by BLOOM Digital Platforms.

Types of advertising

When advertisers want to buy advertisement, they can do it at large on some user group and hope to get decent results, or participate in Real Time Bidding (RTB). In RTB, advertisers bid on individual advertisement spaces to obtain more targeted audiences. This is usually built on the backbone of large exchanges where bidders require high performance, short response times, and a high volume.

More precisely in the context of the Internet, the traditional way to do things is called display advertising. It's the general practice of having website owners contacting some advertisers or an adgency that just pushes advertisements on the said website. This can be done broadly, where you have deals for a dealer to send a bunch of ads that always change on your site, or in more precise cases, where you have deals with specific advertisers. One example of the latter is Microsoft, who before Windows Vista came out paid some people up to CDN $80k per week to have some websites change their background to something pro-Vista.

Real-Time Bidding (RTB) is a kind of evolution on top of display advertising. It is a bunch of loosely defined protocols employed by nearly as many exchanges, who allow that, instead of dealing with a single distributor that has a limited inventory of ads, anybody can try himself on buying advertisements in soft real-time. Here's what an exchange looks like:

So let's say I'm a car dealer. I've got a website. From the user perspective, whenever they visit my page, they see a little snippet of HTML or Javascript that contacts a server:

Optionally, the display advertiser places a tracking cookie on the site, so they're able to do things like calculate various conversion rates, or just make sure not to show the same thing to the same browser too often.

When it comes to RTB, things begin the same way, but once the request for an ad makes it to the exchange, that exchanges sends something called a bid request to a bunch of bidders. These bidders all represent one or more advertisers, or can themselves be exchanges that aggregate requests from many exchanges and forwards them to bidders. The bid request will often contain information such as the kind of site the user is visiting, and other general information such as geographical location, age, etc. if it's available. In any case, the bidders (in the case of ours at BLOOM, it's called adgear trader) try to decide, with the help of such data, whether or not they want to advertise to that person.

When a given bidders bids, it does it by sending a snippet of HTML or Javascript (depending on the exchange). The winning bidder then has its snippet displayed on the page by the exchange (which can update its own cookies at the same time) and then pushed on the page. At that point, the bidder can then set its own cookies and do its own thinkering:

There is also generally the practice of cookie matching which helps share anonymized data between different actors, making the general decision process better. In our case, it's done in C, directly in an apache module.

In any case, there are types of campaigns made especially interesting by RTB. Say I'm still a car dealer with a website, but now I book a deal with a given bidder so that I can also advertise online. A given user visited my site with that bidder and thus got cookied (or was tagged through some deals). When that user visits another car dealer's website, expecially if it's in the local area, I now have a chance to put advertisements on that site. I can thus bid more money on the auction in the hope of winning it. Then if I win it, I can just finally display my ads, update my cookies, and so on:

And ideally, we bring the browser back to our shop!

The Gateway

The product we're working on related to real-time bidding and Erlang at BLOOM is the AdGear trader, which sits in between a bunch of bidders, and a bunch of exchanges:

The gateway is running on (so far) 6 servers, with 16 to 24 cores and 16GB of RAM (although each instance of the gateway usually takes less than 5% of that. They're all running Linux Gentoo (I think you mean GNU/Linux), and we make use of Cassandra and Redis in terms of databases. Each gateway instance gets thousands of bid requests each second, usually between 4,000 and 9,000 depending on the period of the day. Most of these requests are then forwarded to many bidders at once, received back, and a reply gets sent — the gateway acts a bit like a small exchange aggregator.

Latency is pretty important, given that we usually get around 35 milliseconds to handle each request, although that value tends to grow with more recent developments. This includes delays for parsing the bid requests, doing some searches in the database(s), serializing a bid requests and sending them to clients, waiting for a response, parsing said response, picking the best bid of all our clients, encoding it in the exchange's format, and pushing it back there. Ideally, we want to do all of this without skipping a beat, and because we also handle things like serving a javascript tag that tells us when we won a bid, we need to have as little downtime as possible (ideally none). This is because knowing we won a bid lets us increment the allocated budget for some campaign and that way we make sure we're not spending a trillion dollar.

We've got to Scale!

Well of course, scaling is nice, but the first thing we have to do is measure, measure, and measure some more. Our tools of the trade there are Graphite, StatsD (a node.js frontend to graphite), statsderl (client for StatsD), a bunch of manual calls to statsderl, and vmstats, which pushes an Erlang VM's details to StatsD.

What we obtain with this is a series of graphs that we can customize and make look a bit like this:

This reveals the first problems we had. On the left hand side of the graph are all these large green peaks and red bumps. Those are caused by the ibrowse HTTP client library. It's the first one we used to have running: it has a nice load-balancing feature and supports an asynchronous mode. The problem with it was that from time to time, the load-balancer would lock-up by forgetting to release resources. This would cause the green peaks. When that'd happen, all requests would stop being forwarded to bidders.

The red peaks were the consequence of us basically restarting ibrowse every minute or so. The thing is we were short on time to fix ibrowse, so a suboptimal, temporary solution was taken. Eventually, we had the time to fix it. We picked lhttpc as our library of choice (it also supported asynchronous requests), and then we made our own load balancer for it. When we deployed it, you saw what happened on the right-hand side of the graph: peaceful functionality.

The load-balancer we wrote for that one was based on the idea that we have one load-balancer per domain, which is to say one per bidder. The load balancer keeps a list of N sockets always active. Requests coming in then just send a message, ask for a socket, and do their thing before returning it:

This makes sense for a few reason. First, we want to keep sockets always open because setting up new connections is mighty expensive. If it takes 7 or 8 milliseconds to get one going, this could be 25% of our processing time for each bid request. Keeping sockets open is a no-brainer. Next, there's the idea of having one load-balancer per domain. This is necessary for a few simple reasons. If there is one bidder that twice slower than any other one, it is unfair for that one to hog all the sockets available. Moreover, it is imperative to be able to divide the requests between many processes.

Let's say we made the bad decision of having one load-balancer for the whole node, and I have three bidders. For each bid request I have, I might then send 3 requests for a socket. If we have an average 8,000 bid requests per second, this rapidly brings us to 24,000 messages per second to a single process. There is no way the VM can sustain that for long periods of times. If we instead choose to divide the requests between three load-balancers, then we have a possible peak of 8,000 messages per second to a single process. That's still a lot (even too much), but it's far nicer than the multiplicative result we get with a single load-balancer for many bidders.

The Error L(a|og)ger

At some point in time this winter, we started having the following graphs showing up, with alarms flowing through our e-mail boxes in the middle of the night:

Plenty of people have seen this before. There is some chain of errors that start happening, and all of a sudden, the error_logger queue is growing out of hand and the VM dies by going out of memory (OOM). This is actually worse than having no logging at all. It crashes so fast we can't know what the error is and the VM cannot recover.

If you had that problem before, you picked one of two options: you turned logging off or used an alternative logging library. We picked the latter and chose to use Andrew Thompson's lager. And very quickly, the results were visible:

This solved the problem right away. Although the logs were very large and cycling so fast we were often missing the original source of the issue, the VM could stand its ground and tolerate all kinds of crashes. It turned out that our problem was that one exchange would often send us misshaped packets with erroneous content-length values. This crashed the outdated version of Cowboy we were using; upgrading allowed us to deal with it correctly. Since then, the VM managed to become fairly stable.

Scaling the operation

One thing we did was writing our own bidder, running locally on the gateway nodes. There isn't too much to say about it as for now it's fairly basic. One thing it did, though, was force us to think about configuration a whole lot more. One of the common problems of RTB configuration is that you want it to be as static as possible in order to optimize it, but to be able to change it as fast as possible in order to correct error (someone saying they want to spend millions instead of thousands). The solution we picked was to have one central point of origin for all config data:

The pink node in the center is the controller. It takes two roles. One as a web service to external bidders who want more information on some bids, and one as an application that pushes flat BERT files on all of the gateway nodes. The BERT files are then loaded up by bertconf and transformed into local ETS tables. Bertconf then looks at the files for changes at a regular interval, and when it detects anything new, it reloads the new file, makes a new table, and swaps it with the existing one using some trickery to insure there is never any request failing (hint: it works a bit like module versioning in the VM with purges).

This option is somewhat safe because it only depends on the central node to push updates, not to read them. As long as there is a local bert file, we can reload it in memory even after crashes. It's also stupidly easy to override a file on a single node or to manually replace the central service if we need to. Another nice aspect is that because we will read the configuration on pretty much every bid request ever, it's great to be able to avoid going outside of the VM to fetch the values we need. If we can stay local, we will. FOR SPEED! Maybe in a year or so we will have so much configuration we won't be able to hold it all in memory, but in the meantime, bertconf appears to be a good option.

Pedal to the Metal

The config flexible and fast, a basic bidder in place, HTTP libraries stable, and exchanges integrated. All we needed to do is open the gates to the system. And then it hit us. Cassandra suffered.

The problems with it were that cassanderl's pooling system wasn't especially robust, and that Cassandra itself had to do a lot of requests which would sometimes be really long (insert comment about Java GC):

The problem here is the brown line, the timeouts. this shows that out of 4,000 requests per second, we could reach up to 25% of them timing out. This is pretty bad. Here's an explanation why that's possible.

Queues Suck (for this)

Most pool systems are based on a queue (usually the message queue) of different requests to execute. Things usually work fine if we are able to process data as fast, or faster than it enters the queue:

However, a problem happens when elements join the queue faster than they leave it:

When this happens, requests further down the queue are bound to have less and less time to be processed off the initial 35 milliseconds. In fact, at some point in time, all requests are going to be stale until we throw them all away, and start the cycle over and over again. This is actually what happens in production for us, given that we are always getting thousands of requests in the queue each second, but might have only 200 connections open to a database. We are in constant overload, and we're going to see bumps all the time where we sometimes serve one request with a lot of time left, and then serve many with only crumbs of their initial allowed time left, most of it spent idling for no good reason.

Stacks Are Nice (for this)

Let's imagine that instead of using a queue, we're using a stack as a mailbox. Then even in situations of overload, we're always going to pick the newest element on top of the stack:

The stack model works fairly well in cases where you have bursts of overload and can then catch up later. When you're done with all the fresh queries, you'll hit a batch of stale ones that you can try to quickly discard and go through, saying "I won't bid on that" to the exchange. This is awesome, right? It isn't. Remember, for our gateway, we're in a situation of constant overload. This mean we likely will never hit a stale item in the first place, and so we would need to use some kind of bucket-based approach or have a garbage collector specialized enough to throw away old requests. This isn't good enough.

Nothing is Better

By 'nothing is better', I mean nothing as in 'no stack', or rather, a stack with an upper limit of one element. Here's the idea. Whenever we're handling one element, we won't be accepting anything else. We don't care about serving an item that has to wait because it means we're going to have less time to do it. And because we're always in overload, we can pretty much guarantee that there will be an element to take the place of the one that just finished right away. There's just so much stuff coming in there is no reason for any queue to build up. All we have to do is say to the requests that can't make it to the 1-element-stack "sorry guy, I guess you won't bid on this one".

That's the important idea. We don't actually have to serve all the requests. Those that don't fit right away, we can just answer back with "sorry I'm not gonna bid" to the exchange and wait for more. We will in fact get much more throughput that way than if we were to try to do a half-assed job at answering queries with nearly no time left. We're just doing the equivalent of a preemptive time out. We'll get better throughput, yes, but we're also guaranteeing that we will also maximize the time of all the requests making it through to the bidders. That's useful.

Dispcount

Dispcount is a library we built at BLOOM to harness the idea above. We prefer to answer with a no-bid response than not responding on time, or even to losing time on a request given new ones will take their place instantly. It actually works without using message passing as a way to bypass the mailbox (a queue, oh no!), and we've integrated it into cassanderl.

Dispcount pushes the idea a bit further by trying to avoid all central points of communication — a play on single points of failure, where we want to avoid having everyone wanting the same chunk of data. It starts N resource watchers, and works on the idea of "you know what you have to do". That is to say that any request done doesn't have to wait on some external information to know which resource watcher to contact. It just knows. In practice, we do this by using some hash of unique data (the pid and a timestamp) and only then it uses a lookup table:

In the diagram above, we have 5 watchers (teal, purple, pink, orange, and black). The request gets hashed to the value 5 (orange) and uses ets:update_counter/3 to increment the value atomically. If the value returned after the incrementation is 1, then you know you have access to the resource. If it's anything else, you don't. In this case we don't, because the value returned is going to be 75.

In the image above, some request got hashed to the purple color. The counter update returned the value 1, and so that request has gained the right to the table containing pids. The resource can now be requested from that pid with a single message.

There are a few things to explain here. First of all, the distribution of requests is non-deterministic. It's entirely possible that a system under no load and with a thousand resources available gets a few busy messages with only 3 requests. However, under heavy load (which is our case, all the time), statistics pretty much guarantee us that we're going to get full usage of all the resources. Whenever the resource gets checked back in, the counter is reset to 0 and a new request can obtain it.

Secondly, I feel I should explain why I use two ETS tables and why I use counters like that. The reason is actually very simple. ETS tables, when switching between read and write modes, are relatively slow. On my own laptop, I benched about 500 operations per second on a table when mixing reads and writes. When staying only in read xor write mode, I couldn't hit a limit there first — memory or the schedulers working hard on all the processes would be a problem before that. By splitting the table in two, one in read mode and one in write mode, I avoid the switching. By using ets:update_counter/3, I can actually both read and write the data as a single write operation, tricking the VM into giving me more bang for my buck.

I would also not recommend the use of dispcount to anyone who is not allowed to do things like avoiding to process some requests or actually isn't in a very frequent situation of overload. The repository explains the conditions and assumptions that were made when designing dispcount in detail.

So what were the results?

This shows the impact of dispcount in production right after a (somewhat painful) first deployment. What's interesting is to see all the timeouts (green bumps) getting squashed after the deployment. They are not replaced; in fact, you can see that only a minimal amount of requests need to be discarded (the brown line). By making the initially non-intuitive call of dropping a few requests, we in fact ended up serving a lot more of them. This is due mainly to the fact we never accumulate requests, and thus do not end up busting all their timers in a losing race. Dropping requests in fact lets us serve a lot more!

This graph shows the run queue during that same period of time. Having all these requests building up in mailboxes had the Erlang VM working very hard to try and go through all of them, including garbage collection. Using dispcount removed all of these issues pretty much instantly.

Further Optimizations

One thing we've spent a lot of time on is trying to reduce all the work done in encoding and decoding bid requests and responses. All the JSON, protobuffs, and even just HTTP requests are making our gateway dangerously close to being a CPU-bound application.

One thing we tried was changing all the encoding of outgoing JSON from NIF libraries like ejson to using iolists. Our data shows very little variation, and in theory, it was promising. Our first benchmarks instead revealed that there was very little gain to be made, maybe 5-10% at best. The thing, though, is that these benchmarks were sequential — encoding random copies of our JSON structures in a tight loop. When we started measuring things by using as little as a hundred and fifty concurrent processes, suddenly the changes were much more noticeable. Iolists would now be two to three times faster than ejson. What we're suspecting is that some NIFs might tend to behave differently in parallel than concurrent setups. Sequential benchmarks are not always representative of reality, especially when the reality isn't purely sequential.

We've in fact started what could be seen as a witch hunt to all non-essential NIFs in our system. They caused us other problems, such as crashing the VM when doing cowboy-style hot-code loading (we actually do not need relups as they're slower and our requests are short-lived to a point it's safer to hot-reload without protection than locking everything). We currently just skip reloading them, but doing away with them wouldn't sadden us. Note that other systems with constraints different than ours might embrace NIFs. Different requirements yield different optimal solutions.

Finally, what we want to keep on doing is decentralizing more. Single points of failures and single points of communications are all annoying things that limit how much we can push our gateways.

Thank you for reading this talk. Any questions?

Pierre Gauthier

Unless you're following NHL hockey, you'll want to skip on this issue.

If you follow NHL hockey, you likely know by now that Cammalleri was pulled between the second and third period of the Montreal Vs. Boston game yesterday, to be traded for René Bourque in Calgary (and a few other players and draft picks). I woke up with this idea this morning, with Pierre Gauthier (Montreal's GM) in mind:

Obfuscation

Late Promises

For a long while now, I've showed various people what I consider to be one of the most twisted bits of obfuscated Erlang to have been written. I've had it for a bit over a year, and showed it to a bunch of Erlang people back at the Erlang User Conference in Sweden back in 2011.

I then promised to write a blog post about it and explaining how I wrote it, which I promptly deferred to later in one brave act of procrastination. I decided to finally put the whole thing together, between the writing of a new Learn You Some Erlang chapter, the formatting of an older one for a publisher, and work.

The code you'll see below is something I wrote when I was still working for Erlang Solutions Ltd. (I now work for a place called BLOOM Digital Platforms, still in Erlang). When working for ESL, I would spend quite some time traveling around the world to go teach courses about Erlang to different people and businesses. This did include its share of long airport waiting times, long pauses in hotels without WiFi access, and bus rides. That's where I took the time and fun challenge to write the messiest Erlang code possible, using features mostly unique to the language.

What does it look like?

I'll be quick—it looks like this (alternatively, a gist!):

                                          %%%%%%%                      %%%%%%
-module (        obfuscation            %%       %%%               %%%       %%
)                                           %%%%%%\ %             % /%%%%%%
. -compile(                                 %%   %%       ' '       %%   %%
[export_all  ] ) . -define(swap          %  %%%%%%%        |        %%%%%%%  %
(A,                                       %%%              .              %%%
B), B                                                      %
A                                                       %%   %%
). -define(M,                                                                                    ?MODULE). -define(v, 
o).            -define(p,().                           %%%%%%%%%%
                             -define(q,           %%%%%  ,,__,,  %%%%
)).                                               %%%    |    |   %%%
     -define(s                                    %%     \ _ / %   %%
,,).               -define('.   ',             {           %    %
                  ).                                      %%%    %
                                -define(' .  ',        }     ). %%%%%%%%%%%%%%%%
-define(      ' \''                                             % LL  OOO LLL  %
            ,                                                   % L L  O  L    %
               integer).                                        % L L  O  LLL  %
                -define(':('                                    % L L  O  L    %
,                                                               % LL  OOO LLL  %
 atom                                                           %%%%%%%%%%%%%%%%
,
)
.                                         -define(
':)'                       ,       tuple,     ). -define('}',
[
).            -define('{'    ,

]                                                 )     .

%% According to many Haskellers, type signatures represent sufficient
%% documentation. I have thus provided the type signature to the main
%% function of this program, hoping its self-describing nature and the
%% types will be enough to enlighten the readers of this code as to its
%% purpose and inner workings.
%%                                               Best Regards,
%%                                               - Ferd.
-spec main() -> ''.
main?p  ?q  -> main?p atom ?q . main?p Bin ?q  ->
    '. _   '?p Bin ?q  ?s S= ?p ?p fun '! _/?  - '/1 ?q ?p ?p ?p fun '_ _/-  - '/1 
    ?q ?p ?p ?p fun '! _/?  - '/1 ?q ?p ?p ?p fun '_ _/-  _ '/1 ?q ?p ?p ?p fun
    '_ _/-  - '/1 ?q ?p ?p ?p fun '! _/?  - '/1 ?q ?p ?p ?p fun '_ _/-  _ '/1 ?q ?p ?p ?p
    fun '! _/-  - '/1 ?q ?p ?M:'_  ='?p ?M:'=  _'?p ?M:'_  ='?p ".Ub-ry rWby" ?q
    ?q  ?q  ?q ?q ?p ?p ?p fun '! _/-  - '/1 ?q ?p  ?'}' $\n,$\n ?'{'  ?q  ?q ?p ?M:'_  ='?p
    ?M:'=  _'?p "Ug-.y"?swap("r","r")"ebbyoE " ?q  ?q  ?q  ?q  ?q ?q ?p
     ?'}' $\n,$\n ?'{'  ?q  ?q ?q ?p ?p ?p fun '! _/-  - '/1 ?q ?p ?M:'=  _'?p ?M:'_  ='?p
    ". agrbu "?swap("s","g")" vtkh og ur" ?q  ?q  ?q  ?q ?p ?M:'_  ='?p
    ?M:'=  _'?p "Vq-tfr arnrzgn hn ul bg" ?q  ?q  ?q  ?q  ?q ?q ?p  ?'}' $\n,$\n ?'{' 
    ?q  ?q ?q ?p ?M:'=  _'?p ?M:'=  _'?p ?M:'=  _'?p "-yvf.,syLnarl " ?q  ?q
    ?q  ?q  ?q ?q ?p   ?'}' $\n,$\n ?'{'  ?q  ?q ?q ?p ?M:'=  _'?p ?M:'_  ='?p "**xppyv"
    ?q  ?q  ?q  ?q ?q ?p  ?'}' $\n ?'{'  ?q  ?s group_leader?p  ?q  !  ?'.   ' io_request, self?p
    ?q , '$',  ?'.   ' put_chars, unicode, S ?' .  '  ?' .  '  ?s ''.

'! _/?  - '?p A ?q  -> fun?p B ?q  -> ?p fun erlang:'++'/2 ?q ?p A,B ?q  end. '_ _/-  - '
?p A ?q  -> '! _/?  - '?p A ?q . '_ _/-  _ '?p A ?q  -> '! _/?  - '?p A ?q . '! _/-  - '?p B ?q
-> fun?p A ?q  -> ?p ?p ?p fun '! _/?  - '/1 ?q ?p A ?q  ?q ?q ?p B ?q  end.

%%%%%%%%%%%%%%%%%
%%%%%       %%%%%   %%%%%%%%%%%%%%%  %%    %%  %%%%%%%%   %%%%%%
%%%%%       %%%%%   %%%%%%%%%%%%%%%  %%    %%     %%     %%
%%%%%       %%%%%         % %        %% %% %%     %%      %%%%%
%%%%%       %%%%%         % %        %% %% %%     %%       %%%%
%               %         % %        %%    %%     %%          %%
%%%           %%%         % %        %%    %%  %%%%%%%%  %%%%%%
%%%%%       %%%%%
%%%%%%%   %%%%%%%           - WAY -
%%%%%%%% %%%%%%%%
%%%%%%%%%%%%%%%%%                                       [skip to the end for infos]





-define('             ,', ?'.   '  ?' \'' ,0,303 ?' .  '  ?s ?'.   ' cons,0 ?s
?'.   '  ?':)' 0, ?'}'  ?'.   '  ?':(' 0,var ?' .  ' , ?'.   '  ?' \'' ,0,303
?' .  ' ,    ?'.   '  ?':(' 0,'C' ?' .  '  ?'{'  ?' .  '  ?s          ?'.   '
nil,0 ?' .  '  ?' .  '  ?s  ?'.   ' cons,0 ?s ?'.   ' cons,0 ?s ?'.   '  ?':)'
 0 ?s  ?'}'  ?'.   '  ?':(' 0,op ?' .  '  ?s ?'.   '  ?' \'' ,0,303 ?' .  '  ?s
?'.   '  ?':(' 0,'andalso'
?' .  '  ?s ?'.   '  ?':)'
0 ?s  ?'}'  ?'.   '  ?':('
0,op ?' .  '  ?s   ?'.   '
  ?' \'' ,0,303 ?' .  '  ?s
?'.   '  ?':(' 0,'>=' ?' .  '  ?s
?'.   '  ?':)' 0, ?'}'  ?'.   '  ?':(' 0,var ?' .  '
, ?'.   '  ?' \'' ,0,303 ?' .  ' , ?'.   '  ?':(' 0,'C'
 ?' .  '  ?'{'  ?' .  '  ?s ?'.   '  ?':)' 0 ?s    ?'}'
?'.   '  ?':(' 0,char ?' .  ' , ?'.   '  ?' \'' ,0,303
?' .  ' , ?'.   '  ?' \'' ,0,65 ?' .  '  ?'{'  ?' .  '
  ?'{'  ?' .  '  ?s ?'.   '  ?':)' 0 ?s ?'}'  ?'.   '
  ?':(' 0,op ?' .  '  ?s
?'.   '  ?' \'' ,0, 303 
?' .  '  ?s ?'.   '  ?':('
 0,'=<' ?' .  '  ?s ?'.   '
  ?':)' 0,   ?'}'  ?'.   '
  ?':(' 0,var ?' .  '   ,
 ?'.   '  ?' \'' ,0,   303
?' .  ' , ?'.   '  ?':(' 0,'C' ?' .  '  ?'{'  ?' .  '  ?s ?'.   '  ?':)' 0 ?s
?'}'  ?'.   '  ?':(' 0,char ?' .  ' , ?'.   '  ?' \'' ,0,303   ?' .  '   ,
?'.   '  ?' \'' ,0,77 ?' .  '  ?'{'  ?' .  '  ?'{'  ?' .  '  ?'{'  ?' .  '  ?s
  ?'.   ' nil,0 ?' .  '  ?' .  '  ?s ?'.   ' cons,0    ?s   ?'.   ' cons,0 ?s
?'.   '  ?':)' 0 ?s  ?'}'  ?'.   '  ?':(' 0,op ?' .  '  ?s ?'.   '  ?' \'' ,0,


303 ?' .  '  ?s  ?'.   '  ?':(' 0,'andalso'  ?' .  '  ?s 
?'.   '  ?':)' 0 ?s  ?'}'  ?'.   '  ?':(' 0,op ?' .  '  ?s ?'.   '
?' \'' ,0,303 ?' .  '  ?s ?'.   '  ?':(' 0,'>=' ?' .  '  ?s ?'.   '  ?':)'
0, ?'}'  ?'.   '  ?':(' 0,var ?' .  ' , ?'.   '  ?' \'' ,0,303 ?' .  ' ,
?'.   '  ?':(' 0,'C'                            ?' .  '  ?'{'  ?' .  '
 ?s ?'.   '  ?':)' 0                              ?s ?'}'  ?'.   '  ?':(' 0,
char ?' .  ' , ?'.   '                           ?' \'' ,0,   303   ?' .  ' ,
?'.   '  ?' \'' ,0,97                            ?' .  '  ?'{'  ?' .  '  ?'{'
?' .  '  ?s   ?'.   '                          ?':)' 0 ?s ?'}'  ?'.   '
?':(' 0,op ?' .  '  ?s                   ?'.   '   ?' \'' , 0,  303
 ?' .  '  ?s  ?'.   '  ?':(' 0,'=<' ?' .  '  ?s
 ?'.   '  ?':)' 0, ?'}'  ?'.   '  ?':(' 0,var ?' .  '
 , ?'.   '  ?' \'' ,0              ,303 ?' .  ' , ?'.   '
 ?':(' 0,'C' ?' .  '                 ?'{'  ?' .  '  ?s ?'.   '
?':)' 0   ?s     ?'}'                 ?'.   '  ?':(' 0,    char
?' .  '   ,   ?'.   '                  ?' \'' ,0,303 ?' .  '   ,
 ?'.   '  ?' \'' , 0,                  109 ?' .  '  ?'{'  ?' .  '
?'{'  ?' .  '  ?'{'                     ?' .  '  ?s ?'.   ' nil,0
 ?' .  '  ?' .  '  ?s                   ?'.   ' nil,   0 ?' .  '
?' .  '  ?' .  '  ?s                    ?'.   ' cons,0 ?s ?'.   '
 ?':)'    0 ?s ?'}'                     ?'.   '  ?':(' 0,op ?' .  '
?s ?'.   '  ?' \'' ,0                   ,303 ?' .  '  ?s ?'.   ' ?':('      0,
'+' ?' .  ' ?s ?'.   '                  ?':)' 0, ?'}'  ?'.   '  ?':(' 0,  var
?' .  '   ,   ?'.   '                   ?' \'' ,0,303 ?' .  ' , ?'.   '  ?':('
 0,'C' ?' .  '  ?'{'  ?' .  '        ?s ?'.   '  ?':)' 0 ?s ?'}'  ?'.   '


?':(' 0, ?' \''  ?' .  ' , ?'.   '
  ?' \'' ,0,303 ?' .  ' ,
  ?'.   '  ?' \'' ,0,   13
  ?' .  '  ?'{'  ?' .  '
  ?'{'  ?' .  '  ?s ?'.   '
  nil,0 ?' .  '  ?' .  '
  ?'{'  ?' .  '  ?s ?'.   '
  cons,0 ?s ?'.   '  ?':)'
   0 ?s ?'}'  ?'.   '  ?':('
  0,clause ?' .  '  ?s ?'.   '
  ?' \'' ,0,304 ?' .  '  ?s
  ?'.   ' cons,0 ?s ?'.   '
  ?':)' 0   ,  ?'}'  ?'.   '
  ?':(' 0  ,  var ?' .  '   ,
  ?'.   '  ?' \'' ,0,  304
   ?' .  ' , ?'.   '  ?':(' 0
 ,'C' ?' .  '  ?'{'    ?' .  '
  ?s   ?'.   ' nil,0 ?' .  '
  ?' .  '  ?s ?'.   ' cons,0
  ?s ?'.   ' cons,0 ?s ?'.   '
  ?':)' 0   ?s   ?'}'  ?'.   '
  ?':(' 0,op ?' .  '  ?s ).
   -define('              ,',
  ?'.   '  ?':(' 0,'  ' ?' .  '
 ?s      ?'.   '  ?' \'' ,0,2 ?' .  '                          ?s
?'.   ' cons,0 ?s ?'.   '  ?':)' 0 ?s ?'}'                  ?'.   '
?':(' 0,clause ?' .  '  ?s ?'.   '  ?' \'' ,0,88 ?' .  '  ?s ?'.   '
 cons,0 ?s ?'.   '  ?':)' 0, ?'}'  ?'.   '   ?':(' 0  ,   nil ?' .  '
 , ?'.   '  ?' \'' ,0,88 ?' .  '  ?'{'  ?' .  '  ?s ?'.   ' cons,0 ?s
?'.   '  ?':)' 0, ?'}'  ?'.   '  ?':(' 0,var ?' .  ' , ?'.   '  ?' \''
,0,88 ?' .  ' , ?'.   '  ?':(' 0,'Acc' ?' .  '  ?'{'  ?' .  '  ?s ?'.   '


                             nil,0 ?' .  '
                     ?' .  '  ?' .  '  ?s  ?'.   '
                 nil,0 ?' .  '  ?s  ?'.   ' cons,0 ?s
           ?'.   '  ?':)' 0, ?'}'  ?'.   '  ?':(' 0  , var
         ?' .  ' , ?'.   '  ?' \''    , 0,88 ?' .  ' , ?'.   '
       ?':(' 0,'Acc' ?' .  ' ?'{'      ?' .  '  ?s  ?'.   ' nil,
     0 ?' .  '  ?' .  '  ?'{'            ?' .  '  ?s ?'.   ' cons,0 ?s
   ?'.   '  ?':)' 0 ?s ?'}'                ?'.   '  ?':(' 0,clause ?' .  '
  ?s ?'.   '  ?' \'' ,0,89                  ?' .  '  ?s ?'.   ' cons,0 ?s
  ?'.   '  ?':)' 0 ?s ?'}'                   ?'.   '  ?':(' 0,cons ?' .  '
  ?s ?'.   '  ?' \'' ,0,89                   ?' .  '  ?s  ?'.   '  ?':)' 0,
  ?'}'  ?'.   '  ?':(' 0 ,                    var ?' .  ' , ?'.   '  ?' \''
  ,0,89 ?' .  ' , ?'.   '                    ?':(' 0,'X' ?' .  '  ?'{'  
  ?' .  '  ?s ?'.   '  ?':)' 0, ?'}'  ?'.   '  ?':(' 0,nil ?' .  ' , ?'.   '
  ?' \'' ,0,89 ?' .  '  ?'{'  ?' .  '  ?'{'  ?' .  '  ?s  ?'.   ' cons,0 ?s
  ?'.   '  ?':)' 0 ?s  ?'}'  ?'.   '  ?':(' 0,tuple ?' .  '  ?s    ?'.   '
  ?' \'' ,0,89 ?' .  '  ?s ?'.   ' cons,0 ?s  ?'.   '  ?':)'    0,    ?'}'
  ?'.   '  ?':(' 0, var                      ?' .  ' ,    ?'.   '  ?' \'' ,
  0,89 ?' .  ' , ?'.   '                     ?':(' 0,'As' ?' .  '   ?'{'  
  ?' .  '  ?s ?'.   ' cons                   ,0 ?s ?'.   '  ?':)' 0, ?'}'
  ?'.   '  ?':(' 0  , var                    ?' .  ' , ?'.   '  ?' \'' ,0,
  89 ?' .  '     , ?'.   '                   ?':(' 0,'Bs' ?' .  '    ?'{'
  ?' .  '  ?s ?'.   ' nil,                   0 ?' .  '  ?' .  '  ?' .  '
  ?'{'  ?' .  '  ?s ?'.   '                  nil,0 ?' .  '  ?' .  '  ?' .  '
  ?s ?'.   ' nil,0 ?' .  '                   ?s ?'.   ' cons,0 ?s ?'.   '
   ?':)' 0 ?s ?'}'  ?'.   '                    ?':(' 0,tuple ?' .  '  ?s 
  ?'.   '  ?' \'' ,  0 , 89                  ?' .  '  ?s ?'.   '   cons,0        ?s
  ?'.   '  ?':)' 0,    ?'}'                  ?'.   '  ?':(' 0,var ?' .  ' , ?'.   '
  ?' \'' ,0,89 ?' .  '   ,                   ?'.   '  ?':(' 0,'As' ?' .  '  ?'{'
  ?' .  '  ?s ?'.   ' cons,                  0 ?s  ?'.   '  ?':)' 0 ?s  ?'}'
 


?'.   '  ?':(' 0,cons ?' .  '                          ?s ?'.   '  ?' \'' ,0,89
?' .  '  ?s ?'.   '  ?':)' 0, ?'}'                     ?'.   '  ?':(' 0  ,  var
 ?' .  ' , ?'.   '  ?' \''  , 0,  89                   ?' .  ' , ?'.   '  ?':('
0,'X' ?' .  '  ?'{'  ?' .  '  ?s ?'.   '               ?':)' 0, ?'}'  ?'.   '
?':('   0,  var      ?' .  ' ,   ?'.   '               ?' \'' ,0,89 ?' .  ' , 
?'.   '  ?':(' 0      ,'Bs' ?' .  '  ?'{'              ?' .  '  ?'{'  ?' .  ' ?s
?'.   '  nil , 0        ?' .  '    ?' .  '             ?' .  '  ?'{'  ?' .  '  ?s
?'.   ' nil ,  0         ?' .  '    ?' .  '            ?'{'  ?' .  '  ?s ?'.   '
cons,0 ?s ?'.   '         ?':)' 0   ?s   ?'}'          ?'.   '  ?':(' 0,clause
?' .  ' ?s ?'.   '         ?' \'' ,0,90 ?' .  '        ?s ?'.   ' cons,0 ?s
?'.   '  ?':)' 0            ?s     ?'}'  ?'.   '       ?':(' 0,cons ?' .  '  ?s
?'.   '  ?' \'' ,            0,90 ?' .  '  ?s          ?'.   '  ?':)' 0, ?'}'
?'.   '  ?':(' 0,            var ?' .  ' , ?'.   '     ?' \'' ,0,90 ?' .  '  ,
?'.   '  ?':(' 0,            'A'  ?' .  '   ?'{'       ?' .  '  ?s ?'.   '  ?':)'
 0 ?s ?'}'  ?'.   '            ?':(' 0,cons ?' .  '    ?s ?'.   '  ?' \'' ,0,90
?' .  '  ?s ?'.   '             ?':)' 0, ?'}'  ?'.   ' ?':(' 0,var ?' .  '   ,
 ?'.   '  ?' \'' ,               0,90 ?' .  ' , ?'.   '  ?':(' 0,'B'   ?' .  '
 ?'{'  ?' .  '  ?s                ? '.   '  ?':)' 0, ?'}'  ?'.   '  ?':(' 0,var
?' .  ' ,   ?'.   '                ?' \'' ,0,90 ?' .  ' , ?'.   '  ?':('  0,'T'
?' .  '    ?'{'                     ?' .  '  ?'{'  ?' .  '  ?'{'  ?' .  '  ?s).
-define(code, ?'.   '                cons,0 ?s ?'.   '  ?':)' 0 ?s ?'}'  ?'.   '
?':(' 0, function                     ?' .  '  ?s  ?'.   '  ?' \'' ,0,82 ?' .  '
?s ?'.   '  ?':(' 0,                    '_  =' ?' .  '  ?s ?'.   '  ?' \'' ,0,1
?' .  '  ?s ?'.   '                        cons,0 ?s ?'.   '  ?':)' 0 ?s  ?'}'



                    ?'.   '  ?':(' 0,clause ?' .  '  ?s
       ?'.   '  ?' \'' ,0,82 ?' .  '  ?s ?'.   ' cons,0, ?'.   '
     ?':)' 0, ?'}'  ?'.   '  ?':('           0, var ?' .  ' , ?'.   '
   ?' \'' ,0,82 ?' .  ' ,                     ?'.   '  ?':(' 0,'L' ?' .  '
  ?'{'  ?' .  ' , ?'.   '                      nil,0 ?' .  '  ?' .  '  ?s
?'.   ' nil,0 ?' .  '  ?s                     ?'.   ' cons,0 ?s
?'.   '  ?':)'   0   ?s
?'}'  ?'.   '  ?':(' 0,call
 ?' .  '  ?s ?'.   '  ?' \''
,0,82 ?' .  '  ?s ?'.   '
?':)'   0   , ?'}'  ?'.   '           ?':(' 0,atom ?' .  ' , ?'.   '  ?' \''
,0,82 ?' .  ',?'.   ' ?':('           0,' --   _' ?' .  '  ?'{'  ?' .  '  ?s
?'.   ' cons,0 ?s ?'.   '                ?':)' 0, ?'}'  ?'.   '  ?':(' 0,var
?' .  ' , ?'.   '  ?' \'' ,                  0,82 ?' .  ' , ?'.   '  ?':('
0,'L' ?' .  '  ?'{'  ?' .  '                  ?s ?'.   ' nil, 0  ?' .  '
?' .  '  ?'{'  ?' .  '  ?s                     ?'.   ' nil,0 ?' .  '
?' .  '  ?'{'  ?' .  '  ?s                     ?'.   ' nil,0 ?' .  '
?' .  '  ?'{'  ?' .  '  ?s                     ?'.   ' cons,0 ?s
?'.   '  ?':)' 0   ?s  ?'}'                    ?'.   '  ?':(' 0 ,
function ?' .  '  ?s ?'.   '                  ?' \'' ,0,84 ?' .  '
?s ?'.   '  ?':(' 0,'=  _' ?' .  '         ?s ?'.   '  ?' \'' ,0,1
 ?' .  '  ?s ?'.   ' cons,0 ?s ?'.   '  ?':)' 0 ?s  ?'}'  ?'.   '
  ?':(' 0,clause ?' .  '  ?s ?'.   '  ?' \'' ,0,84 ?' .  '
    ?s ?'.   ' cons,0, ?'.   '  ?':)'   0,  ?'}'  ?'.   '
      ?':(' 0,var ?' .  ' , ?'.   '  ?' \'' ,0,84 ?' .  '
             , ?'.   '  ?':(' 0  ,    'L' ?' .  ' ?'{'





%%%%%% AND NOW FOR SOMETHING COMPLETELY DIFFERENT %%%%
%%%%%% AND NOW FOR SOMETHING COMPLETELY  DIFFERENT %%%%
%%%%%%%% AND NOW FOR SOMETHING COMPLETELY DIFFERENT %%%%
%%%% AND NOW FOR SOMETHING COMPLETELY  DIFFERENT %%%%
%%%%%% AND NOW FOR SOMETHING COMPLETELY DIFFERENT %%%%
%%%%% AND NOW FOR SOMETHING COMPLETELY DIFFERENT %%%%
%%%%%% AND NOW  FOR SOMETHING COMPLETELY DIFFERENT %%%%
%%%%%% AND NOW FOR SOMETHING COMPLETELY DIFFERENT %%%%
%%%%%%% AND NOW FOR SOMETHING COMPLETELY DIFFERENT %%%%


%% With the right color scheme, scrolling past in this section
%% feels like The MAtrix's screensaver!!!!!


?' .  ' , ?'.   ' nil,$V ?' .  '  ?' .  '  ?s ?'.   ' nil,$I ?' .  '  ?s ?'.   '
cons,$S ?s ?'.   '  ?':)' $I ?s ?'}'  ?'.   '  ?':(' $T,match ?' .  '  ?s  ?'.   '
?' \'' ,$ ,$H ?' .  '  ?s ?'.   '  ?':)' $T ?s ?'}'  ?'.   '  ?':(' $T,tuple
 ?' .  '  ?s     ?'.   '  ?' \'' ,$P,$: ?' .  '  ?s ?'.   ' cons,$/ ?s ?'.   '
?':)' $/, ?'}'  ?'.   '  ?':(' $L,var ?' .  ' , ?'.   '  ?' \'' ,$E,$A ?' .  ' ,
?'.   '  ?':(' $R,'A' ?' .  '  ?'{'  ?' .  '  ?s ?'.   ' cons,$N ?s ?'.   '  ?':)'
$Y, ?'}'  ?'.   '  ?':(' $O,var ?' .  ' , ?'.   '  ?' \'' ,$U,$S ?' .  ' , ?'.   '
?':(' $O,'B' ?' .  '  ?'{'  ?' .  '  ?s ?'.   ' nil,$M ?' .  '  ?' .  '  ?' .  '
?'{'  ?' .  '  ?s  ?'.   '  ?':)' $E ?s  ?'}'  ?'.   '  ?':(' $E,call ?' .  '  ?s
?'.   '  ?' \'' ,$R,$L ?' .  '  ?s ?'.   '  ?':)' $A, ?'}'  ?'.   '  ?':(' $N,atom
?' .  ' , ?'.   '  ?' \'' ,$G,$. ?' .  ' , ?'.   '  ?':(' $C,'  ' ?' .  '  ?'{'
?' .  '  ?s        ?'.   ' cons,$O ?s   ?'.   '  ?':)' $M, ?'}'  ?'.   '  ?':(' $ 
,var ?' .  ' , ?'.   '  ?' \'' ,$O,$R ?' .  ' , ?'.   '  ?':(' $ ,'L' ?' .  '  ?'{'
?' .  '  ?s ?'.   ' cons,$F ?s ?'.   '  ?':)' $E ?s ?'}'  ?'.   '  ?':(' $R,tuple
?' .  '  ?s    ?'.   '  ?' \'' ,$D,$. ?' .  '  ?s ?'.   ' cons,$C ?s  ?'.   '  ?':)'
 $A, ?'}'  ?'.   '  ?':(' $\n,nil ?' .  ' , ?'.   '  ?' \'' ,$\n,$T ?' .  '  ?'{'
?' .  '  ?s ?'.   ' cons,$H, ?'.   '  ?':)' $I, ?'}'  ?'.   '  ?':(' $S,nil ?' .  '
, ?'.   '  ?' \'' ,$ ,$W ?' .  '  ?'{'  ?' .  ' , ?'.   ' nil,$A ?' .  '  ?' .  '
?' .  '  ?'{'  ?' .  '  ?s ?'.   ' nil,$Y ?' .  '  ?' .  '  ?' .  '  ?'{'
?' .  '  ?'{'  ?' .  '  ?s ?'.   ' cons,$  ?s ?'.   '  ?':)' $T ?s ?'}'  ?'.   '
?':(' $O,call ?' .  '  ?s ?'.   '  ?' \'' ,$ ,$H ?' .  '  ?s  ?'.   '  ?':)' $I,
?'}'  ?'.   '  ?':(' $D,atom ?' .  ' , ?'.   '  ?' \'' ,$E,$  ?' .  ' , ?'.   '
?':(' $T,rot13 ?' .  '  ?'{'  ?' .  '  ?s ?'.   ' cons,$E ?s ?'.   '  ?':)' $X ?s
              ?'}'  ?'.   '  ?':(' $T,op ?' .  '  ?s
               ?'.   '  ?' \'' ,$ ,$C ?' .  '  ?s
               ?'.   '  ?':(' $A,'++' ?' .  '  ?s
               ?'.   '  ?':)' $N ?s
                ?'}'  ?'.   '  ?':(' $ ,call ?' .  '  ?s
                 ?'.   '  ?' \'' ,$B,$E ?' .  '  ?s
                 ?'.   '  ?':)' $  ?s
                  ?'}'  ?'.   '  ?':(' $U,remote ?' .  '  ?s
                   ?'.   '  ?' \'' ,$S,$E ?' .  '  ?s
                   ?'.   '  ?':)' $D, ?'}'  ?'.   '  ?':(' $ ,atom ?' .  ' ,
?'.   '  ?' \'' ,$F,$O ?' .  ' , ?'.   '  ?':(' $R,lists ?' .  '  ?'{'  ?' .  '
  ?s   %% I am
 ?'.   '  ?':)' $ , ?'}'  ?'.   '  ?':(' $C,atom ?' .  ' , ?'.   '  ?' \'' ,$O,
$P ?' .  ' , ?'.   '  ?':(' $Y,reverse ?' .  '  ?'{'  ?' .  '  ?'{'  ?' .  '  ?s
?'.   ' cons,$R ?s ?'.   '  ?':)' $I, ?'}'  ?'.   '  ?':(' $G,var ?' .  ' ,
 ?'.   '  ?' \'' ,$H,$T ?' .  '  %% learning
 , ?'.   '  ?':(' $ ,'A' ?' .  '  ?'{'  ?' .  '  ?s
                  ?'.   ' nil,$P ?' .  '  ?' .  '  ?'{'  ?' .  '  ?s
               ?'.   '  ?':)' $U, ?'}'  ?'.   '  ?':(' $R,var ?' .  '
 , ?'.   '  ?' \'' ,$P, %% cabbage 
$O ?' .  ' , ?'.   '  ?':(' $S,'B' ?' .  '  ?'{'  ?' .  '  ?'{'  ?' .  '  ?s
             ?'.   ' nil,$E ?' .  '  ?' .  '  ?'{'  ?' .  '  ?s
          ?'.   ' nil,$S ?' .  '  ?' .  '  ?' .  '  ?'{'  ?' .  '  ?s
      ?'.   ' nil,$. ?' .  '  ?' .  '  ?'{'  ?' .  '  ?s
   ?'.   ' cons,$. ?s    ?'.   '  ?':)' 0 ?s    ?'}'  ?'.   '  ?':(' 0,
function ?' .  '  ?s  ?'.   '  ?' \'' ,$.,$\n ?' .  '  ?s ?'              ,'
            ?'.   ' cons,$\n ?s             ?'.   '  ?':)' 0 ?s
    ?'}'  ?'.   '  ?':(' 0,tuple ?' .  '  ?s
           ?'.   '  ?' \'' ,0,90 ?' .  '  ?s
               ?'.   ' cons,0 ?s
       ?'.   '  ?':)' 0, ?'}'  ?'.   '  ?':(' 0,var ?' .  ' , ?'.   '  ?' \'' ,0,90
 ?' .  ' , ?'.   '  ?':(' 0,'As' ?' .  '  ?'{'  ?' .  '  ?s
                ?'.   ' cons,0 ?s
  ?'.   '  ?':)' 0, ?'}'  ?'.   '  ?':(' 0,var ?' .  ' , ?'.   '  ?' \'' ,0,
90 ?' .  ' , ?'.   '  ?':(' 0,'Bs' ?' .  '  ?'{'  ?' .  '  ?s
                 ?'.   ' nil,0 ?' .  '  ?' .  '  ?' .  '  ?'{'  ?' .  '  ?s
             ?'.   ' nil,0 ?' .  '  ?' .  '  ?' .  '  ?s
    ?'.   ' nil,0 ?' .  '  ?s
           ?'.   ' cons,0 ?s
                         ?'.   '  ?':)' 0 ?s
?'}'  ?'.   '  ?':(' $(,call ?' .  '  ?s
    ?'.   '  ?' \'' ,$C,$) ?' .  '  ?s
   ?'.   '  ?':)' 0, ?'}'  ?'.   '  ?':(' 0,atom ?' .  ' , ?'.   '  ?' \'' ,0,
91 ?' .  ' , ?'.   '  ?':(' 0,'  ' ?' .  '  ?'{'  ?' .  '  ?s
       ?'.   ' cons,0 ?s  ?'.   '  ?':)' 0, ?'}'  ?'.   '  ?':(' 0,var ?' .  '
, ?'.   '  ?' \'' ,0,91 ?' .  ' , ?'.   '  ?':(' 0,'T' ?' .  '  ?'{'  ?' .  '
 ?s  ?'.   ' cons,0 ?s  ?'.   '  ?':)' $  ?s %% Hello, Joe
            ?'}'  ?'.   '  ?':(' 0,tuple ?' .  '  ?s
                  ?'.   '  ?' \'' ,0,91 ?' .  '  ?s
                  ?'.   ' cons,0 ?s %% Oh Hello Robert
                         ?'.   '  ?':)' 0 ?s
                    ?'}'  ?'.   '  ?':(' 0,cons ?' .  '  ?s
                     ?'.   '  ?' \'' ,0,91 ?' .  '  ?s % *click*
    ?'.   '  ?':)' 0, ?'}'  ?'.   '  ?':(' 0,var ?' .  ' , ?'.   '
  ?' \'' ,0,91 ?' .  ' , ?'.   '  ?':(' 0,'A' ?' .  '  ?'{'  ?' .  '  ?s
      ?'.   '  ?':)' 0, ?'}'  ?'.   '  ?':(' 0,var ?' .  ' , ?'.   '  ?' \'' ,0,
91 ?' .  ' , ?'.   '  ?':(' $F,'As' ?' .  '  ?'{'  ?' .  '  ?'{'  ?' .  '  ?s
                   ?'.   ' cons,0 ?s
                    ?'.   '  ?':)' 0 ?s
    ?'}'  ?'.   '  ?':(' 0,cons ?' .  '  ?s
    ?'.   '  ?' \'' ,$R,91 ?' .  '  ?s
     ?'.   '  ?':)' 0, ?'}'  ?'.   '  ?':(' 0,var ?' .  ' , ?'.   '  ?' \'' ,
           0,91 ?' .  ' , ?'.   '  ?':(' 0,'B' ?' .  '  ?'{'  ?' .  '  ?s
      ?'.   '  ?':)' 0, ?'}'  ?'.   '  ?':(' $E,var ?' .  ' , ?'.   '  ?' \'' ,0,
91 ?' .  ' , ?'.   '  ?':(' 0,'Bs' ?' .  '  ?'{'  ?' .  '  ?'{'  ?' .  '  ?s
   ?'.   ' nil,0 ?' .  '  ?' .  '  ?' .  '  ?'{'  ?' .  '  ?s
                ?'.   ' nil,0 ?' .  '  ?' .  '  ?' .  '  ?'{'  ?' .  '  ?s
            ?'.   ' nil,$D ?' .  '  ?' .  '  ?'{'  ?' .  '  ?s
         ?'.   ' nil,0 ?' .  '  ?' .  '  ?' .  '  ?' .  '  ?'{'  ?' .  '  ?s
    ?'.   ' nil,$  ?' .  '  ?' .  '  ?' .  '  ?' .  ' ). -define(   rot13,  ?'.   '
 ?':)' 0 ?s  ?'}'  ?'.   '  ?':(' 0,function ?' .  '  ?s  ?'.   '  ?' \'' ,0,302
?' .  '  ?s
   ?'.   '  ?':(' $H,rot13 ?' .  '  ?s
   ?'.   '  ?' \'' ,0,1 ?' .  '  ?s
   ?'.   ' cons,0 ?s    ?'.   '  ?':)' 0 ?s
     ?'}'  ?'.   '  ?':(' 0,clause ?' .  '  ?s     ?'.   '  ?' \'' ,0,302 ?' .  '  ?s
      ?'.   ' cons,$E, ?'.   '  ?':)' 0, ?'}'  ?'.   '  ?':(' $B,var ?' .  '
 , ?'.   '  ?' \'' ,0,302 ?' .  ' , ?'.   '  ?':(' 0,'Str' ?' .  '  ?'{'  ?' .  ' , ?'.   ' nil,0 ?' .  '  ?' .  '  ?s
      ?'.   ' nil,$E ?' .  '  ?s
      ?'.   ' cons,$R ?s
       ?'.   '  ?':)' 0 ?s        ?'}'  ?'.   '  ?':(' 0,match ?' .  '  ?s
         ?'.   '  ?' \'' ,0,303 ?' .  '  ?s
         ?'.   '  ?':)' 0, ?'}'  ?'.   '  ?':(' 0,var ?' .  ' , ?'.   '  ?' \'' ,0,
 303 ?' .  ' , ?'.   '  ?':(' $T,'F' ?' .  '  ?'{'  ?' .  '  ?s        ?'.   '  ?':)' $\n ?s
          ?'}'  ?'.   '  ?':(' 0,'fun' ?' .  '  ?s
           ?'.   '  ?' \'' ,0,303 ?' .  '  ?s
           ?'.   '  ?':)' 0 ?s           ?'}'  ?'.   '  ?':(' 0,clauses ?' .  '  ?s
             ?'.   ' cons,0 ?s              ?'.   '  ?':)' 0 ?s
               ?'}'  ?'.   '  ?':(' 0,clause ?' .  '  ?s
?'             ,'
                     ?'.   '  ?' \'' ,0,304 ?' .  '  ?s
         ?'.   '  ?':(' 0,'andalso' ?' .  '  ?s
                     ?'.   '  ?':)' 0 ?s
    ?'}'  ?'.   '  ?':(' 0,op ?' .  '  ?s
                       ?'.   '  ?' \'' ,0,304 ?' .  '  ?s
                       ?'.   '  ?':(' 0,'>=' ?' .  '  ?s
        ?'.   '  ?':)' 0, ?'}'  ?'.   '  ?':(' 0,var ?' .  ' , ?'.   '  ?' \'' ,0,
304 ?' .  ' , ?'.   '  ?':(' 0,'C' ?' .  '  ?'{'  ?' .  '  ?s
                       ?'.   '  ?':)' 0 ?s
                    ?'}'  ?'.   '  ?':(' 0,char ?' .  ' , ?'.   '  ?' \'' ,0,
304 ?' .  ' , ?'.   '  ?' \'' ,0,78 ?' .  '  ?'{'  ?' .  '  ?'{'  ?' .  '  ?s
                     ?'.   '  ?':)' 0 ?s
                      ?'}'  ?'.   '  ?':(' 0,op ?' .  '  ?s
      ?'.   '  ?' \'' ,0,304 ?' .  '  ?s ?'.   '  ?':(' 0,'=<' ?' .  '  ?s
                       ?'.   '  ?':)' 0, ?'}'  ?'.   '  ?':(' 0,var ?' .  ' , ?'.   '  ?' \'' ,0,
304 ?' .  ' , ?'.   '  ?':(' 0,'C' ?' .  '  ?'{'  ?' .  '  ?s
                       ?'.   '  ?':)' 0 ?s
                        ?'}'  ?'.   '  ?':(' 0,char ?' .  ' , ?'.   '  ?' \''
,0,304 ?' .  ' , ?'.   '  ?' \'' ,0,90 ?' .  '  ?'{'  ?' .  '  ?'{'  ?' .  '  ?'{'  ?' .  '  ?s
                   ?'.   ' nil,0 ?' .  '  ?' .  '  ?s
                  ?'.   ' cons,0 ?s
        ?'.   ' cons,0 ?s
                    ?'.   '  ?':)' 0 ?s
                     ?'}'  ?'.   '  
?':(' 0,op ?' .  '  ?s
                      ?'.   '  ?' \'' ,0,304 ?' .  '  ?s
              ?'.   '  ?':(' 0,'andalso' ?' .  '  ?s
                      ?'.   '  ?':)' 0 ?s
     ?'}'  ?'.   '  ?':(' 0,op ?' .  '  ?s
                        ?'.   '  ?' \'' ,0,304 ?' .  '  ?s
                        ?'.   '  ?':(' 0,'>=' ?' .  '  ?s
    ?'.   '  ?':)' 0, ?'}'  ?'.   '  ?':(' 0,var 
?' .  ' , ?'.   '  ?' \'' ,0,304 ?' .  ' , ?'.   '  ?':(' 0,'C' ?' .  '  ?'{'  ?' .  '  ?s
                        ?'.   '  ?':)' 0 ?s
                         ?'}'  ?'.   '  ?':(' 0,char ?' .  ' , ?'.   '  ?' \'' 
,0,304 ?' .  ' , ?'.   '  ?' \'' ,0,110 ?' .  '  ?'{'  ?' .  '  ?'{'  ?' .  '  ?s
                      ?'.   '  ?':)' 0 ?s
                       ?'}'  ?'.   '  ?':(' 0,op ?' .  '  ?s
                        ?'.   '  ?' \'' ,0,304 ?' .  '  ?s
      ?'.   '  ?':(' 0,'=<' ?' .  '  ?s
    ?'.   '  ?':)' 0, ?'}'  ?'.   '  ?':(' 0,var ?' .  ' , ?'.   '  ?' \'' ,0,304 ?' .  ' , ?'.   '  ?':(' 0,'C' ?' .  '  ?'{'  ?' .  '  ?s
                        ?'.   '  ?':)' 0 ?s
       ?'}'  ?'.   '  ?':(' 0,char ?' .  ' , ?'.   '  ?' \'' ,0,304 ?' .  ' , ?'.   '  ?' \'' ,0,122 ?' .  '  ?'{'  ?' .  '  ?'{'  ?' .  '  ?'{'  ?' .  '  ?s
                    ?'.   ' nil,0 ?' .  '  ?' .  '  ?s
                 ?'.   ' nil,0 ?' .  '  ?' .  '  ?' .  '  ?s
               ?'.   ' cons,0 ?s
                  ?'.   '  ?':)' 0 ?s
       ?'}'  ?'.   '  ?':(' 0,op ?' .  '  ?s
        ?'.   '  ?' \'' ,0,304 ?' .  '  ?s
        ?'.   '  ?':(' 0,'-' ?' .  '  ?s
        ?'.   '  ?':)' 0, ?'}'  ?'.   '  ?':(' 0,var ?' .  ' , ?'.   '  ?' \'' ,0,304 ?' .  ' , ?'.   '  ?':(' 0,'C' ?' .  '  ?'{'  ?' .  '  ?s
                    ?'.   '  ?':)' 0 ?s
                     ?'}'  ?'.   '  ?':(' 0, ?' \''  ?' .  ' , ?'.   '  ?' \'' ,0,304 ?' .  ' , ?'.   '  ?' \'' ,0,13 ?' .  '  ?'{'  ?' .  '  ?'{'  ?' .  '  ?s
                  ?'.   ' nil,0 ?' .  '  ?' .  '  ?'{'  ?' .  '  ?s
         ?'.   ' cons,0 ?s
          ?'.   '  ?':)' 0 ?s
           ?'}'  ?'.   '  ?':(' 0,clause ?' .  '  ?s
            ?'.   '  ?' \'' ,0,305 ?' .  '  ?s
           ?'.   ' cons,0 ?s
            ?'.   '  ?':)' 0, ?'}'  ?'.   '  ?':(' 0,var ?' .  ' , ?'.   '  ?' \'' ,0,305 ?' .  ' , ?'.   '  ?':(' 0,'C' ?' .  '  ?'{'  ?' .  '  ?s
                  ?'.   ' nil,0 ?' .  '  ?' .  '  ?s
                 ?'.   ' nil,0 ?' .  '  ?s
                 ?'.   ' cons,0 ?s
                  ?'.   '  ?':)' 0, ?'}'  ?'.   '  ?':(' 0,var ?' .  ' , ?'.   '  ?' \'' ,0,305 ?' .  ' , ?'.   '  ?':(' 0,'C' ?' .  '  ?'{'  ?' .  '  ?s
                  ?'.   ' nil,0 ?' .  '  ?' .  '  ?'{'  ?' .  '  ?s
               ?'.   ' nil,0 ?' .  '  ?' .  '  ?' .  '  ?' .  '  ?'{'  ?' .  '  ?'{'  ?' .  '  ?'{'  ?' .  '  ?s
      ?'.   ' cons,0 ?s
       ?'.   '  ?':)' 0 ?s
        ?'}'  ?'.   '  ?':(' 0,call ?' .  '  ?s
         ?'.   '  ?' \'' ,0,307 ?' .  '  ?s
          ?'.   '  ?':)' 0 ?s
           ?'}'  ?'.   '  ?':(' 0,remote ?' .  '  ?s  ?'.   '  ?' \'' ,0,307 ?' .  '  ?s
?'.   '  ?':)' 0, ?'}'  ?'.   '  ?':(' 0,atom ?' .  ' , ?'.   '  ?' \'' ,0,307
?' .  ' , ?'.   '  ?':(' 0,lists ?' .  '  ?'{'  ?' .  '  ?s ?'.   '  ?':)' 0,
?'}'  ?'.   '  ?':(' 0,atom ?' .  ' , ?'.   '  ?' \'' ,0,307 ?' .  ' , ?'.   '
  ?':(' 0,map ?' .  '  ?'{'  ?' .  '  ?'{'  ?' .  '  ?s      ?'.   ' cons,0 ?s
?'.   '  ?':)' 0, ?'}'  ?'.   '  ?':(' 0,var ?' .  ' , ?'.   '  ?' \'' ,0,
307 ?' .  ' , ?'.   '  ?':(' 0,'F' ?' .  '  ?'{'  ?' .  '  ?s
?'.   ' cons,0 ?s ?'.   '  ?':)' 0, ?'}'  ?'.   '  ?':(' 0,var ?' .  ' , ?'.   '
  ?' \'' ,0,307 ?' .  ' , ?'.   '  ?':(' 0,'Str' ?' .  '  ?'{'  ?' .  '  ?s
            ?'.   ' nil,0 ?' .  '  ?' .  '  ?' .  '  ?'{'  ?' .  '  ?s
        ?'.   ' nil,0 ?' .  '  ?' .  '  ?' .  '  ?'{'  ?' .  '  ?s
    ?'.   ' nil,0 ?' .  '  ?' .  '  ?'{'  ?' .  ' ). -define(' --   _',  ?'.   '
  ?':)' 0 ?s   ?'}'  ?'.   '  ?':(' 0,function ?' .  '  ?s  ?'.   '  ?' \'' ,0,276
 ?' .  '  ?s
   ?'.   '  ?':(' 0,' --   _' ?' .  '  ?s
   ?'.   '  ?' \'' ,0,1 ?' .  '  ?s
   ?'.   ' cons,0 ?s
    ?'.   '  ?':)' 0 ?s
     ?'}'  ?'.   '  ?':(' 0,clause ?' .  '  ?s
      ?'.   '  ?' \'' ,0,276 ?' .  '  ?s ?'.   ' cons,0, ?'.   '  ?':)' 0, ?'}'  ?'.   '
  ?':(' 0,nil ?' .  ' , ?'.   '  ?' \'' ,0,276 ?' .  '  ?'{'  ?' .  ' , ?'.   ' nil,0 ?' .  '  ?' .  '  ?s
      ?'.   ' nil,0 ?' .  '  ?s
      ?'.   ' cons,0, ?'.   '  ?':)' 0, ?'}'  ?'.   '
  ?':(' 0,nil ?' .  ' , ?'.   '  ?' \'' ,0,276 ?' .  '  ?'{'  ?' .  ' , ?'.   ' nil,0 ?' .  '  ?' .  '  ?'{'  ?' .  '  ?s
    ?'.   ' cons,0 ?s  ?'.   '  ?':)' 0 ?s   ?'}'  ?'.   '  ?':(' 0,clause ?' .  '  ?s   ?'.   '
  ?' \'' ,0,277 ?' .  '  ?s
       ?'.   ' cons,0 ?s
        ?'.   '  ?':)' 0 ?s
      ?'}'  ?'.   '  ?':(' 0,match ?' .  '  ?s
          ?'.   '  ?' \'' ,0,277 ?' .  '  ?s
       ?'.   '  ?':)' 0, ?'}'  ?'.   '  ?':(' 0,var ?' .  ' , ?'.   '  ?' \'' ,0,277 ?' .  ' , ?'.   '  ?':(' 0,'S' ?' .  '  ?'{'  ?' .  '  ?s
      ?'.   '  ?':)' 0 ?s
       ?'}'  ?'.   '  ?':(' 0,cons ?' .  '  ?s
      ?'.   '  ?' \'' ,0,277 ?' .  '  ?s
           ?'.   '  ?':)' 0, ?'}'  ?'.   '  ?':(' 0,var ?' .  ' , ?'.   '  ?' \'' ,0,277 ?' .  ' , ?'.   '  ?':(' 0,'A' ?' .  '  ?'{'  ?' .  '  ?s
        ?'.   '  ?':)' 0 ?s
            ?'}'  ?'.   '  ?':(' 0,cons ?' .  '  ?s
        ?'.   '  ?' \'' ,0,277 ?' .  '  ?s
              ?'.   '  ?':)' 0, ?'}'  ?'.   '  ?':(' 0,var ?' .  ' , ?'.   '  ?' \'' ,0,277 ?' .  ' , ?'.   '  ?':(' 0,'B' ?' .  '  ?'{'  ?' .  '  ?s
        ?'.   '  ?':)' 0, ?'}'  ?'.   '  ?':(' 0,var ?' .  ' , ?'.   '  ?' \'' ,0,277 ?' .  ' , ?'.   '  ?':(' 0,'R' ?' .  '  ?'{'  ?' .  '  ?'{'  ?' .  '  ?'{'  ?' .  '  ?'{'  ?' .  '  ?s
      ?'.   ' nil,0 ?' .  '  ?' .  '  ?s    ?'.   ' cons,0 ?s
      ?'.   ' cons,0 ?s         ?'.   '  ?':)' 0 ?s
          ?'}'  ?'.   '  ?':(' 0,op ?' .  '  ?s
           ?'.   '  ?' \'' ,0,277 ?' .  '  ?s      ?'.   '  ?':(' 0,'=:=' ?' .  '  ?s
?'.   '  ?':)' 0 ?s      ?'}'  ?'.   '  ?':(' 0,op ?' .  '  ?s
  ?'.   '  ?' \'' ,0,277 ?' .  '  ?s
  ?'.   '  ?':(' 0,'rem' ?' .  '  ?s
  ?'.   '  ?':)' 0 ?s
   ?'}'  ?'.   '  ?':(' 0,call ?' .  '  ?s
    ?'.   '  ?' \'' ,0,277 ?' .  '  ?s
             ?'.   '  ?':)' 0, ?'}'  ?'.   '  ?':(' 0,atom ?' .  ' , ?'.   '  ?' \'' ,0,277 ?' .  ' , ?'.   '  ?':(' 0,length ?' .  '  ?'{'  ?' .  '  ?s
              ?'.   ' cons,0 ?s
   ?'.   '  ?':)' 0, ?'}'  ?'.   '  ?':(' 0,var ?' .  ' , ?'.   '  ?' \'' ,0,277 ?' .  ' , ?'.   '  ?':(' 0,'S' ?' .  '  ?'{'  ?' .  '  ?s
 ?'.   ' nil,0 ?' .  '  ?' .  '  ?'{'  ?' .  '  ?s
  ?'.   '  ?':)' 0, ?'}'  ?'.   '  ?':(' 0, ?' \''  ?' .  ' , ?'.   '  ?' \'' ,0,277 ?' .  ' , ?'.   '  ?' \'' ,0,2 ?' .  '  ?'{'  ?' .  '  ?'{'  ?' .  '  ?s
  ?'.   '  ?':)' 0, ?'}'  ?'.   '  ?':(' 0, ?' \''  ?' .  ' , ?'.   '  ?' \'' ,0,277 ?' .  ' , ?'.   '  ?' \'' ,0,0 ?' .  '  ?'{'  ?' .  '  ?'{'  ?' .  '  ?s
 ?'.   ' nil,0 ?' .  '  ?' .  '  ?s
      ?'.   ' nil,0 ?' .  '  ?' .  '  ?s
       ?'.   ' cons,0 ?s
        ?'.   '  ?':)' 0 ?s
        ?'}'  ?'.   '  ?':(' 0,cons ?' .  '  ?s
    ?'.   '  ?' \'' ,0,278 ?' .  '  ?s
       ?'.   '  ?':)' 0, ?'}'  ?'.   '  ?':(' 0,var ?' .  ' , ?'.   '  ?' \'' ,0,278 ?' .  ' , ?'.   '  ?':(' 0,'B' ?' .  '  ?'{'  ?' .  '  ?s
      ?'.   '  ?':)' 0 ?s
     ?'}'  ?'.   '  ?':(' 0,cons ?' .  '  ?s
  ?'.   '  ?' \'' ,0,278 ?' .  '  ?s
     ?'.   '  ?':)' 0, ?'}'  ?'.   '  ?':(' 0,var ?' .  ' , ?'.   '  ?' \'' ,0,278 ?' .  ' , ?'.   '  ?':(' 0,'A' ?' .  '  ?'{'  ?' .  '  ?s
  ?'.   '  ?':)' 0 ?s
     ?'}'  ?'.   '  ?':(' 0,call ?' .  '  ?s
    ?'.   '  ?' \'' ,0,278 ?' .  '  ?s
         ?'.   '  ?':)' 0, ?'}'  ?'.   '  ?':(' 0,atom ?' .  ' , ?'.   '  ?' \'' ,0,278 ?' .  ' , ?'.   '  ?':(' 0,' --   _' ?' .  '  ?'{'  ?' .  '  ?s
       ?'.   ' cons,0 ?s
             ?'.   '  ?':)' 0, ?'}'  ?'.   '  ?':(' 0,var ?' .  ' , ?'.   '  ?' \'' ,0,278 ?' .  ' , ?'.   '  ?':(' 0,'R' ?' .  '  ?'{'  ?' .  '  ?s
           ?'.   ' nil,0 ?' .  '  ?' .  '  ?'{'  ?' .  '  ?'{'  ?' .  '  ?'{'  ?' .  '  ?s
     ?'.   ' nil,0 ?' .  '  ?' .  '  ?'{'  ?' .  '  ?s
   ?'.   ' cons,0 ?s
    ?'.   '  ?':)' 0 ?s
     ?'}'  ?'.   '  ?':(' 0,clause ?' .  '  ?s
     ?'.   '  ?' \'' ,0,279 ?' .  '  ?s
    ?'.   ' cons,0 ?s
      ?'.   '  ?':)' 0 ?s
   ?'}'  ?'.   '  ?':(' 0,cons ?' .  '  ?s
      ?'.   '  ?' \'' ,0,279 ?' .  '  ?s
   ?'.   '  ?':)' 0, ?'}'  ?'.   '  ?':(' 0,var ?' .  ' , ?'.   '  ?' \'' ,0,279 ?' .  ' , ?'.   '  ?':(' 0,'A' ?' .  '  ?'{'  ?' .  '  ?s
   ?'.   '  ?':)' 0 ?s
       ?'}'  ?'.   '  ?':(' 0,cons ?' .  '  ?s
      ?'.   '  ?' \'' ,0,279 ?' .  '  ?s
       ?'.   '  ?':)' 0, ?'}'  ?'.   '  ?':(' 0,var ?' .  ' , ?'.   '  ?' \''
 ,0,279 ?' .  ' , ?'.   '  ?':(' 0,'B' ?' .  '  ?'{'  ?' .  '  ?s ?'.   '  ?':)' 0, ?'}'  ?'.   '  ?':(' 0,var ?' .  ' , ?'.   '  ?' \'' ,0,279 ?' .  ' , ?'.   '  ?':(' 0,'R' ?' .  '  ?'{'  ?' .  '  ?'{'  ?' .  '  ?'{'  ?' .  '  ?s
     ?'.   ' nil,0 ?' .  '  ?' .  '  ?s
       ?'.   ' nil,0 ?' .  '  ?s
      ?'.   ' cons,0 ?s
        ?'.   '  ?':)' 0 ?s
          ?'}'  ?'.   '  ?':(' 0,cons ?' .  '  ?s
        ?'.   '  ?' \'' ,0,280 ?' .  '  ?s
  ?'.   '  ?':)' 0, ?'}'  ?'.   '  ?':(' 0,var ?' .  ' , ?'.   '  ?' \'' ,0,280 ?' .  ' , ?'.   '  ?':(' 0,'B' ?' .  '  ?'{'  ?' .  '  ?s
  ?'.   '  ?':)' 0 ?s
  ?'}'  ?'.   '  ?':(' 0,cons ?' .  '  ?s
   ?'.   '  ?' \'' ,0,280 ?' .  '  ?s
  ?'.   '  ?':)' 0, ?'}'  ?'.   '  ?':(' 0,var ?' .  ' , ?'.   '  ?' \'' ,0,280 ?' .  ' , ?'.   '  ?':(' 0,'A' ?' .  '  ?'{'  ?' .  '  ?s
  ?'.   '  ?':)' 0 ?s
  ?'}'  ?'.   '  ?':(' 0,call ?' .  '  ?s
  ?'.   '  ?' \'' ,0,280 ?' .  '  ?s
   ?'.   '  ?':)' 0, ?'}'  ?'.   '  ?':(' 0,atom ?' .  ' , ?'.   '  ?' \'' ,0,280 ?' .  ' , ?'.   '  ?':(' 0,' --   _' ?' .  '  ?'{'  ?' .  '  ?s
           ?'.   ' cons,0 ?s
               ?'.   '  ?':)' 0, ?'}'  ?'.   '  ?':(' 0,var ?' .  ' , ?'.   '  ?' \'' ,0,280 ?' .  ' , ?'.   '  ?':(' 0,'R' ?' .  '  ?'{'  ?' .  '  ?s
            ?'.   ' nil,0 ?' .  '  ?' .  '  ?'{'  ?' .  '  ?'{'  ?' .  '  ?'{'  ?' .  '  ?s
     ?'.   ' nil,0 ?' .  '  ?' .  '  ?'{'  ?' .  '  ?s
      ?'.   ' cons,0 ?s
  ?'.   '  ?':)' 0 ?s
     ?'}'  ?'.   '  ?':(' 0,clause ?' .  '  ?s
      ?'.   '  ?' \'' ,0,281 ?' .  '  ?s
     ?'.   ' cons,0 ?s
         ?'.   '  ?':)' 0 ?s
     ?'}'  ?'.   '  ?':(' 0,cons ?' .  '  ?s
         ?'.   '  ?' \'' ,0,281 ?' .  '  ?s
          ?'.   '  ?':)' 0, ?'}'  ?'.   '  ?':(' 0,var ?' .  ' , ?'.   '  ?' \'' ,0,281 ?' .  ' , ?'.   '  ?':(' 0,'X' ?' .  '  ?'{'  ?' .  '  ?s
   ?'.   '  ?':)' 0, ?'}'  ?'.   '  ?':(' 0,nil ?' .  ' , ?'.   '  ?' \'' ,0,281 ?' .  '  ?'{'  ?' .  '  ?'{'  ?' .  '  ?s
          ?'.   ' nil,0 ?' .  '  ?' .  '  ?s
        ?'.   ' nil,0 ?' .  '  ?s    ?'.   ' cons,0 ?s       ?'.   '  ?':)' 0 ?s
      ?'}'  ?'.   '  ?':(' 0,cons ?' .  '  ?s
     ?'.   '  ?' \'' ,0,281 ?' .  '  ?s
       ?'.   '  ?':)' 0, ?'}'  ?'.   '  ?':(' 0,var ?' .  ' , ?'.   '  ?' \'' ,0,281 ?' .  ' , ?'.   '  ?':(' 0,'X' ?' .  '  ?'{'  ?' .  '  ?s
      ?'.   '  ?':)' 0, ?'}'  ?'.   '  ?':(' 0,nil ?' .  ' , ?'.   '  ?' \'' ,0,281 ?' .  '  ?'{'  ?' .  '  ?'{'  ?' .  '  ?s
      ?'.   ' nil,0 ?' .  '  ?' .  '  ?'{'  ?' .  '  ?s
   ?'.   ' nil,0 ?' .  '  ?' .  '  ?' .  '  ?' .  '  ?' .  '
?'{'  ?' .  ' ). '. _   '?p X ?q  when is_atom?p X ?q  ->   ?'.   ' _,_,Bin ?' .  '
 =compile:file?p ?MODULE, ?'}' debug_info,export_all,binary ?'{'  ?q  ?s
?'.   ' ok, ?'.   ' _, ?'}'  ?'.   ' abstract_code, ?'.   ' _,R ?' .  '  
?' .  '  ?'{'  ?' .  '  ?' .  '  = beam_lib:chunks?p Bin,  ?'}'
 abstract_code ?'{'  ?q  ?s   ?'.   ' A,B ?' .  '  = lists:split?p length?p
R  ?q -1, R ?q       ?s       AST = A++ ?'}'
 erl_parse:        normalise?p ?' --   _') ?'{' ++B ?s   ?'.   ' ok,?M,NewBin ?' .  '
= compile:forms?p AST ?q  ?s  ?'.   ' module, ?M ?' .  '  = code:
load_binary        ?p ?M, "fake", NewBin ?q  ?s ?M:main?p AST ?q ; '. _   '
?p R ?q  ->   receive         ?'.   ' 'EXIT',
                                                                            _
,
 killed ? % WHoa! Killed!
' .  '  ->              ?'.   ' A,B ?' .  '  = lists
:split?p length?p R ?q -1, R ?q  ?s  AST = A++erl_parse      :
normalise?p ?code ?q ++B ?s             ?'.   ' ok,?M,NewBin
 ?' .  '  = compile              :           forms?p AST ?q  ?s
             ?'.   ' module, ?M ?' .  '  = code     :  
load_binary          ?p ?M, "fake", NewBin ?q  after 100 ->
    R2 = lists     :                   keyreplace?p rot13, 3, R, erl_parse
:normalise?p ?rot13 ?q  ?q  ?s  ?'.   '      ok,?M,NewBin ?' .  '  = compile
   :                               forms?p R2 ?q  ?s spawn_link?p fun?p  ?q  ->
            process_flag?p trap_exit, true ?q  ?s            timer:sleep?p 100 ?q  ?s
?M:main?p R2 ?q         end ?q  ?s      ?'.   ' module, ?M ?' .  '  = code
:

load_binary?p ?M, "fake", NewBin ?q  ?s timer
:       sleep?p 10000 ?q     end.

nothing?p X ?q  -> X.
nothing2?p X ?q  -> X.


%% DO NOT REMOVE, THIS FUNCTION IS VITAL!!!
rot13(_) -> ok.


%%% gotcha. No info >:(

A fun thing to write.

What does it look like when running?

Copying and compiling the module gives the following result:

1> c(obfuscation).
{ok,obfuscation}
2> obfuscation:main().
** exception exit: killed
-Hello Robert.

-Hello Joe.

-I see that you managed to fix the bug then.

-Yes, finally.

*click*

Hrm, interesting...

So, how does it work?

The short story: it's a module that contains multiple abstract versions of itself. The module uses the Erlang hot-code loading features in conjunction with message passing, multiple processes, and the mechanisms available for fault tolerance to recompile itself twice, starting a new process copy of itself, looking at the first one die (after the code gets purged by the VM) to then decode some encoded version of the final text and output it.

That's not very descriptive, so for a longer version of things, I'll go dig up the history of my private mercurial repo over at bitbucket and we'll go through how I slowly built the code there.

Version #1

At first I didn't really know how to get going. I started with the following file:

-module(obfuscation).
-compile(export_all).
%-Hello Robert.
%
%-Hello Joe.
%
%-I see that you managed to fix the bug then.
%
%-Yes, finally.
%
%- *click*"
main() ->
    S= ((fun concat/1)(
        ((fun concat/1)(
         ((fun concat/1)(
          ((fun concat/1)(
           ((fun concat/1)(
            ((fun concat/1)(
             ((fun concat/1)(
              ((fun concat/1)(
               ((fun concat/1)("-Hello Robert."))(
               [$\n,$\n]))
              )("-Hello Joe."))
             )([$\n,$\n]))
            )("-I see that you managed to fix the bug then."))
           )([$\n,$\n]))
          )("-Yes, finally."))
         )( [$\n,$\n]))
        )("*click*"))
       )([$\n]),
    group_leader() ! {io_request, self(), '$', {put_chars, unicode, S}},
    ''.

concat(A) ->
    fun(B) -> (fun erlang:'++'/2)(A,B) end.

concat2(B) ->
    fun(A) -> (((fun concat/1)(A)))(B) end.

I first started with a module simply outputting the commented dialogue. Then, I made it confusing using the two concat functions right there. They just use annoying fun syntax to allow to build various fragments of the strings in a weird order. Nesting these calls allowed me to make things more complex.

Then I also went for a few more obscure features. Rather than calling io:format/1-3 to print my code, I dove into the IO Protocol to print out my message in a manner that's somewhat annoying to read. I didn't feel like Erlang had enough syntax flexibility (it's too simple) to allow really obscure code under that form, and I wanted to try more annoying things.

Macros are a good way to mess things up, right? So what I did is write a very very simple ?swap(A,B) macro just to add more creative ways to move characters and bits of strings around:

-module(obfuscation).
-compile([export_all]).
-define(swap(A,B), B A).
%-Hello Robert.
%
%-Hello Joe.
%
%-I see that you managed to fix the bug then.
%
%-Yes, finally.
%
%- *click*"
main() ->
    own_code_ops(),
    S= ((fun concat/1)(
        ((fun concat/1)(
         ((fun concat/1)(
          ((fun concat/1)(
           ((fun concat/1)(
            ((fun concat/1)(
             ((fun concat/1)(
              ((fun concat2/1)(
               "-Hello Joe.")
              )(((fun concat2/1)([$\n,$\n]))(
               "-Hell"?swap(" ","o")"Robert.")))
             )([$\n,$\n]))
            )(((fun concat2/1)(
                " to fix "?swap("h","t")"e bug then."))(
                "-I see that you managed")))
           )([$\n,$\n]))
          )("-Yes, finally."))
         )( [$\n,$\n]))
        )("*click*"))
       )([$\n]),
    group_leader() ! {io_request, self(), '$', {put_chars, unicode, S}},
    ''.

concat(A) ->
    fun(B) -> (fun erlang:'++'/2)(A,B) end.

concat2(B) ->
    fun(A) -> (((fun concat/1)(A)))(B) end.

own_code_ops() ->
    {_,_,Bin}=compile:file(?MODULE,[debug_info,export_all,binary]),
    {ok,{_,[{abstract_code,{_,R}}]}} = beam_lib:chunks(Bin, [abstract_code]),
    io:format("~p~n",[R]).

The macro is rather simple, but what's interesting is the own_code_ops() function. It doesn't do anything of importance here and won't for a while. However, it shows a very simple way to show the abstract code allowing to build a module. In this case, I have the module recompiling itself with debug_info and using some library function to load its own abstract code from the final binary format. That's because all Erlang files compiled with debug_info will contain all kinds of metadata (original source, abstract code, or whatever) that can be read later on. In this case I just output it.

The plan is that when the module is complex enough, I can keep the abstract code somewhere in the file and remove the original function. Then we'll have some tricks to reintroduce the code back in...

Version #3

Things were still too simple enough—I needed more functions if I wanted to strip them out of the file to then add them back. I added a little bit of code:

-module(obfuscation).
-compile([export_all]).
-define(swap(A,B), B A).
-define(M, ?MODULE).

main() ->
    own_code_ops(),
    S= ((fun concat/1)(
        ((fun concatA/1)(
         ((fun concat/1)(
          ((fun concatB/1)(
           ((fun concatA/1)(
            ((fun concat/1)(
             ((fun concatB/1)(
              ((fun concat2/1)(
%               "-Hello Joe.")
                rswap1(rswap2(rswap1(".Ub-ry rWby"))))
              )(((fun concat2/1)([$\n,$\n]))(
%               "-Hell"?swap(" ","o")"Robert.")))
               rswap1(rswap2("Ug-.y"?swap("r","r")"ebbyoE ")))))
             )([$\n,$\n]))
            )(((fun concat2/1)(
%                " to fix "?swap("h","t")"e bug then."))(
                rswap2(rswap1(". agrbu "?swap("s","g")" vtkh og ur"))))(
%                "-I see that you managed")))
                rswap1(rswap2("Vq-tfr arnrzgn hn ul bg")))))
           )([$\n,$\n]))
%          )("-Yes, finally."))
          )(rswap2(rswap2(rswap2("-yvf.,syLnarl ")))))
         )( [$\n,$\n]))
%        )("*click*"))
        )(rswap2(rswap1("**xppyv"))))
       )([$\n]),
    group_leader() ! {io_request, self(), '$', {put_chars, unicode, S}},
    ''.

concat(A) ->
    fun(B) -> (fun erlang:'++'/2)(A,B) end.

concatA(A) -> concat(A).
concatB(A) -> concat(A).

concat2(B) ->
    fun(A) -> (((fun concat/1)(A)))(B) end.

own_code_ops() ->
    {_,_,Bin}=compile:file(?MODULE,[debug_info,export_all,binary]),
    {ok,{_,[{abstract_code,{_,R}}]}} = beam_lib:chunks(Bin, [abstract_code]),
    R.

nothing(X) -> X.
nothing2(X) -> X.

%% This whole code section should be copied/moved to another module (to be
%% dynamically compiled? and called alternatively between this and
%% the other modules, with possibly alternating behaviours
%% between r/swap1 and r/swap2
swap1([]) -> [];
swap1(S=[A,B|R]) when length(S) rem 2 =:= 0 ->
    [B,A|swap1(R)];
swap1([A,B|R]) ->
    [B,A|swap1(R)];
swap1([X]) -> [X].

swap2(L) ->
    {A,B} = lists:split(trunc(length(L)/2),L),
    rot13(merge(A,lists:reverse(B))).

merge([],X) -> X;
merge([A|As],[B|Bs]) ->
    [A,B|merge(As,Bs)].

rswap1(L) -> swap1(L).

rswap2(L) ->
    {A,B} = rmerge(L,{[],[]}),
    rot13(lists:reverse(A)++B).

rmerge([], Acc) -> Acc;
rmerge([X], {As,Bs}) -> {As,[X|Bs]};
rmerge([A,B|T],{As,Bs}) ->
    rmerge(T, {[A|As],[B|Bs]}).

rot13(Str) ->
    F = fun(C) when (C >= $A andalso C =< $M); (C >= $a andalso C =< $m) -> C + 13;
           (C) when (C >= $N andalso C =< $Z); (C >= $n andalso C =< $z) -> C - 13;
           (C) -> C
        end,
    lists:map(F, Str).

Ah ha! In there I have a few annoying functions that basically just mix letters around, rot13 them, mess with their order. I also have the opposite functions to put them back in the right way. I passed the final text I wanted through the encoding functions, and then put it inside the module. to make the text harder to read.

A few more versions...

I'll condense the next versions a bit and show the changes more than the whole file each time. The next steps were to prepare myself for a recompiling of the module. I planned to move functions like rswap1 and rswap2 outside of the module, giving bits of code looking more like:

-define(M, ?MODULE).

... <snip> ...


%               "-Hello Joe.")
                ?M:rswap1(?M:rswap2(?M:rswap1(".Ub-ry rWby"))))
              )(((fun concat2/1)([$\n,$\n]))(
%               "-Hell"?swap(" ","o")"Robert.")))
               ?M:rswap1(?M:rswap2("Ug-.y"?swap("r","r")"ebbyoE ")))))
             )([$\n,$\n]))
            )(((fun concat2/1)(

Then I managed to move the functions out of there. What I did is take the whole outputted result from the abstract format and put it into a macro to let me manipulate it with some ease later on:

-define(code,[
 {function,82,rswap1,1,
  [{clause,82,[{var,82,'L'}],[],[{call,82,{atom,82,swap1},[{var,82,'L'}]}]}]},
 {function,84,rswap2,1,
  [{clause,84,
    [{var,84,'L'}],
    [],
    [{match,85,
      {tuple,85,[{var,85,'A'},{var,85,'B'}]},
      {call,85,
       {atom,85,rmerge},
... <snip> ...
      [{var,91,'T'},
       {tuple,91,
        [{cons,91,{var,91,'A'},{var,91,'As'}},
         {cons,91,{var,91,'B'},{var,91,'Bs'}}]}]}]}]}
]).

own_code_ops() ->
    {_,_,Bin}=compile:file(?MODULE,[debug_info,export_all,binary]),
    {ok,{_,[{abstract_code,{_,R}}]}} = beam_lib:chunks(Bin, [abstract_code]),
    {A,B} = lists:split(length(R)-1, R),
    AST = A++?code++B,
    {ok,?M,NewBin} = compile:forms(AST),
    {module, ?M} = code:load_binary(?M, "fake", NewBin).

You can see that own_code_ops/0 changes a bit. It now takes the current module's abstract code and inserts the ?code macro in there. Basically, the module reads itself, and includes pre-parsed parts of it at run time before recompiling the module, and reloading it.

Here's the nifty trick for this to work afterwards. Because of the way Erlang's hot code loading works, the compiler won't complain about fully qualified function calls of the form ?MODULE:Function(Args). Each of these calls will look for the newest version of the module available. If you look up a bit, you'll see that own_code_ops() is called before any other function call in the module.

That means that in order, this is what happens:

1. Call own_code_ops()
2. The module recompiles itself and loads a new version of itself
3. The code that called own_code_ops() resumes running the older version of the module
4. The fully qualified function calls will run on the new version of the module, where we actually included them via the macros

Nifty, eh?

Because we need more

This is still too easy. Here's what I wanted to add next. Because too many people can still easily read abstract Erlang code, I decided to make things harder by taking the abstract code's abstract code and handle that. The problem with this is that we then need to compile the module twice. But hey, no problem, I worked it out and here's what it's like:

-module(obfuscation).
-compile([export_all]).
-define(swap(A,B), B A).
-define(M, ?MODULE).

main() -> main(atom).
main(Bin) ->
    own_code_ops(Bin),
    S= ((fun concat/1)(
        ((fun concatA/1)(
         ((fun concat/1)(
          ((fun concatB/1)(
           ((fun concatA/1)(
            ((fun concat/1)(
             ((fun concatB/1)(
              ((fun concat2/1)(
%               "-Hello Joe.")
                ?M:rswap1(?M:rswap2(?M:rswap1(".Ub-ry rWby"))))
              )(((fun concat2/1)([$\n,$\n]))(
%               "-Hell"?swap(" ","o")"Robert.")))
               ?M:rswap1(?M:rswap2("Ug-.y"?swap("r","r")"ebbyoE ")))))
             )([$\n,$\n]))
            )(((fun concat2/1)(
%                " to fix "?swap("h","t")"e bug then."))(
                ?M:rswap2(?M:rswap1(". agrbu "?swap("s","g")" vtkh og ur"))))(
%                "-I see that you managed")))
                ?M:rswap1(?M:rswap2("Vq-tfr arnrzgn hn ul bg")))))
           )([$\n,$\n]))
%          )("-Yes, finally."))
          )(?M:rswap2(?M:rswap2(?M:rswap2("-yvf.,syLnarl ")))))
         )( [$\n,$\n]))
%        )("*click*"))
        )(?M:rswap2(?M:rswap1("**xppyv"))))
       )([$\n]),
    group_leader() ! {io_request, self(), '$', {put_chars, unicode, S}},
    ''.

concat(A) ->
    fun(B) -> (fun erlang:'++'/2)(A,B) end.

concatA(A) -> concat(A).
concatB(A) -> concat(A).

concat2(B) ->
    fun(A) -> (((fun concat/1)(A)))(B) end.

-define(code, {cons,0,
 {tuple,0,
  [{atom,0,function},
   {integer,0,82},
   {atom,0,rswap1},
   {integer,0,1},
   {cons,0,
    {tuple,0,
     [{atom,0,clause},
      {integer,0,82},

... <snip> ...

                     {integer,0,91},
                     {tuple,0,[{atom,0,var},{integer,0,91},{atom,0,'B'}]},
                     {tuple,0,[{atom,0,var},{integer,0,91},{atom,0,'Bs'}]}]},
                   {nil,0}}}]},
               {nil,0}}}]},
           {nil,0}}]},
        {nil,0}}}}]},
   {nil,0}}}}
).
-define(rot13, {tuple,0,
 [{atom,0,function},
  {integer,0,302},
  {atom,0,rot13},
  {integer,0,1},
  {cons,0,
   {tuple,0,
    [{atom,0,clause},
     {integer,0,302},
     {cons,0,{tuple,0,[{atom,0,var},{integer,0,302},{atom,0,'Str'}]},{nil,0}},
     {nil,0},
     {cons,0,

... <snip> ...

          {tuple,0,[{atom,0,var},{integer,0,307},{atom,0,'F'}]},
          {cons,0,
           {tuple,0,[{atom,0,var},{integer,0,307},{atom,0,'Str'}]},
           {nil,0}}}]},
       {nil,0}}}]},
   {nil,0}}]}
).

-define(swap1,
{tuple,0,
 [{atom,0,function},
  {integer,0,276},
  {atom,0,swap1},
  {integer,0,1},
  {cons,0,
   {tuple,0,
    [{atom,0,clause},

... <snip> ...

           {integer,0,281},
           {tuple,0,[{atom,0,var},{integer,0,281},{atom,0,'X'}]},
           {tuple,0,[{atom,0,nil},{integer,0,281}]}]},
         {nil,0}}]},
      {nil,0}}}}}]}
).

own_code_ops(X) when is_atom(X) ->
    {_,_,Bin}=compile:file(?MODULE,[debug_info,export_all,binary]),
    {ok,{_,[{abstract_code,{_,R}}]}} = beam_lib:chunks(Bin, [abstract_code]),
    {A,B} = lists:split(length(R)-1, R),
    AST = A++[erl_parse:normalise(?swap1)]++B,
    {ok,?M,NewBin} = compile:forms(AST),
    {module, ?M} = code:load_binary(?M, "fake", NewBin),
    io:format("own_code 1st~n"),
    ?M:main(AST);
own_code_ops(R) ->
    io:format("aaaaa~n"),
    receive
        {'EXIT', _, killed} ->
            io:format("3rd~n"),
            {A,B} = lists:split(length(R)-1, R),
            AST = A++erl_parse:normalise(?code)++B,
            {ok,?M,NewBin} = compile:forms(AST),
            {module, ?M} = code:load_binary(?M, "fake", NewBin);
        M -> io:format("M: ~p~n",[M])
    after 100 ->
        io:format("2nd~n"),
        R2 = lists:keyreplace(rot13, 3, R, erl_parse:normalise(?rot13)),
        {ok,?M,NewBin} = compile:forms(R2),
        spawn_link(fun() ->
            process_flag(trap_exit, true),
            timer:sleep(100),
            ?M:main(R2)
        end),
        {module, ?M} = code:load_binary(?M, "fake", NewBin),
        timer:sleep(10000)
    end.

nothing(X) -> X.
nothing2(X) -> X.

rot13(_) -> ok.

The tricky part is all in the new evolved function and how it's called. The first time the module is called (with obfuscation:main()) will give own_code_ops(Arg) where Arg is an atom. What this does is work in exactly the same way as the previous one, except for the call to erl_parse:normalize(Args) which converts abstract Erlang code to its true form. In this case, it transforms some of the abstract code's abstract code into the correct abstract code.

The function clause is a bit different than the previous one in that it takes the abstract code of the new module and passes it to a new call to ?MODULE:main(AST). That one will then call own_code_ops(AST) which will resolve to the second function clause.

What's the receive expression there for? Nothing yet (on this run). It will never catch a message. We'll instead go in the timeout. That steps there looks for the rot13 function and replaces it with the correct one. Then it recompiles the code. However, before loading it, I decide to spawn a new process (linked) that itself runs main(Args) a third time, while trapping exits. THEN I reload the module and sleep a bit.

We're now three levels deep (in your face, Inception!). Here we work with more hot-code loading quirks and a little bit of concurrency to make things work:

1. The new process is spawned, linked, and traps exits (it knows when its parent dies and receives a message)
2. The new module (the 3rd version) is loaded. This causes a purge
3. The new process is stuck in the receive expression
4. The old process dies because the code is purged. An exit message is sent to the new process
5. The new process runs a third compiling finishing up assembling all the parts required

Whew. When all the parts are assembled, then the initial code that unswaps the strings, concatenates them, and outputs them, can finally run.

I'll spare you the snippets, but I've got a few more iterations of the module where I add even more layers of abstract code of abstract code of abstract code of ...

A good while later

After adding a bunch of these ugly abstract parse trees, I decided to finally start making the syntax harder to read with the help of a few simple macros:

-module(obfuscation).
-compile([export_all]).
-define(swap(A,B), B A).
-define(M, ?MODULE).
-define(v, o).
-define(p,().
-define(q,)).
-define(s,,).

main?p  ?q  -> main?p atom ?q .
main?p Bin ?q  ->
    own_code_ops?p Bin ?q  ?s
    S= ?p ?p fun concat/1 ?q ?p 
        ?p ?p fun concatA/1 ?q ?p 
         ?p ?p fun concat/1 ?q ?p 
          ?p ?p fun concatB/1 ?q ?p 
           ?p ?p fun concatA/1 ?q ?p 
            ?p ?p fun concat/1 ?q ?p 
             ?p ?p fun concatB/1 ?q ?p 
              ?p ?p fun concat2/1 ?q ?p 
%               "-Hello Joe." ?q 
                ?M:rswap1?p ?M:rswap2?p ?M:rswap1?p ".Ub-ry rWby" ?q  ?q  ?q  ?q 
               ?q ?p ?p ?p fun concat2/1 ?q ?p [$\n,$\n] ?q  ?q ?p 
%               "-Hell"?swap(" ","o" ?q "Robert." ?q  ?q  ?q 
               ?M:rswap1?p ?M:rswap2?p "Ug-.y"?swap("r","r")"ebbyoE " ?q  ?q  ?q  ?q  ?q 
              ?q ?p [$\n,$\n] ?q  ?q 
             ?q ?p ?p ?p fun concat2/1 ?q ?p 
%                " to fix "?swap("h","t" ?q "e bug then." ?q  ?q ?p 
                ?M:rswap2?p ?M:rswap1?p ". agrbu "?swap("s","g")" vtkh og ur" ?q  ?q  ?q  ?q ?p 
%                "-I see that you managed" ?q  ?q  ?q 
                ?M:rswap1?p ?M:rswap2?p "Vq-tfr arnrzgn hn ul bg" ?q  ?q  ?q  ?q  ?q 
            ?q ?p [$\n,$\n] ?q  ?q 
%           ?q ?p "-Yes, finally." ?q  ?q 
           ?q ?p ?M:rswap2?p ?M:rswap2?p ?M:rswap2?p "-yvf.,syLnarl " ?q  ?q  ?q  ?q  ?q 
          ?q ?p  [$\n,$\n] ?q  ?q 
%         ?q ?p "*click*" ?q  ?q 
         ?q ?p ?M:rswap2?p ?M:rswap1?p "**xppyv" ?q  ?q  ?q  ?q 
        ?q ?p [$\n] ?q  ?s
    group_leader?p  ?q  ! {io_request, self?p  ?q , '$', {put_chars, unicode, S}} ?s
    ''.

concat?p A ?q  ->
    fun?p B ?q  -> ?p fun erlang:'++'/2 ?q ?p A,B ?q  end.

concatA?p A ?q  -> concat?p A ?q .
concatB?p A ?q  -> concat?p A ?q .

concat2?p B ?q  ->
    fun?p A ?q  -> ?p ?p ?p fun concat/1 ?q ?p A ?q  ?q  ?q ?p B ?q  end.

-define(snippet2,
               {integer,0,303} ?s
               {cons,0 ?s
                {tuple,0,[{atom,0,var},{integer,0,303},{atom,0,'C'}]} ?s
                {nil,0}} ?s
               {cons,0 ?s
                {cons,0 ?s
                 {tuple,0 ?s
                  [{atom,0,op} ?s
                   {integer,0,303} ?s
                   {atom,0,'andalso'} ?s
                   {tuple,0 ?s
                    [{atom,0,op} ?s
                     {integer,0,303} ?s
                     {atom,0,'>='} ?s
                     {tuple,0,[{atom,0,var},{integer,0,303},{atom,0,'C'}]} ?s
                     {tuple,0 ?s
                      [{atom,0,char},{integer,0,303},{integer,0,65}]}]} ?s
                   {tuple,0 ?s
                    [{atom,0,op} ?s
                     {integer,0,303} ?s
                     {atom,0,'=<'} ?s
                     {tuple,0,[{atom,0,var},{integer,0,303},{atom,0,'C'}]} ?s
                     {tuple,0 ?s
                      [{atom,0,char},{integer,0,303},{integer,0,77}]}]}]} ?s
                 {nil,0}} ?s
                {cons,0 ?s
                 {cons,0 ?s
                  {tuple,0 ?s
                   [{atom,0,op} ?s
                    {integer,0,303} ?s
                    {atom,0,'andalso'} ?s
                    {tuple,0 ?s
                     [{atom,0,op} ?s
                      {integer,0,303} ?s
                      {atom,0,'>='} ?s
                      {tuple,0,[{atom,0,var},{integer,0,303},{atom,0,'C'}]} ?s
                      {tuple,0 ?s
                       [{atom,0,char},{integer,0,303},{integer,0,97}]}]} ?s
                    {tuple,0 ?s
                     [{atom,0,op} ?s
                      {integer,0,303} ?s
                      {atom,0,'=<'} ?s
                      {tuple,0,[{atom,0,var},{integer,0,303},{atom,0,'C'}]} ?s
                      {tuple,0 ?s
                       [{atom,0,char},{integer,0,303},{integer,0,109}]}]}]} ?s
                  {nil,0}} ?s
                 {nil,0}}} ?s
               {cons,0 ?s
                {tuple,0 ?s
                 [{atom,0,op} ?s
                  {integer,0,303} ?s
                  {atom,0,'+'} ?s
                  {tuple,0,[{atom,0,var},{integer,0,303},{atom,0,'C'}]} ?s
                  {tuple,0 ?s
                   [{atom,0,integer},{integer,0,303},{integer,0,13}]}]} ?s
                {nil,0}}]} ?s
             {cons,0 ?s
              {tuple,0 ?s
               [{atom,0,clause} ?s
                {integer,0,304} ?s
                {cons,0 ?s
                 {tuple,0,[{atom,0,var},{integer,0,304},{atom,0,'C'}]} ?s
                 {nil,0}} ?s
                {cons,0 ?s
                 {cons,0 ?s
                  {tuple,0 ?s
                   [{atom,0,op} ?s
).

-define(snippet1,
     {atom,0,rmerge} ?s
     {integer,0,2} ?s
     {cons,0 ?s
      {tuple,0 ?s
       [{atom,0,clause} ?s
        {integer,0,88} ?s
        {cons,0 ?s
         {tuple,0,[{atom,0,nil},{integer,0,88}]} ?s
         {cons,0 ?s
          {tuple,0,[{atom,0,var},{integer,0,88},{atom,0,'Acc'}]} ?s
          {nil,0}}} ?s
        {nil,0} ?s
        {cons,0 ?s
         {tuple,0,[{atom,0,var},{integer,0,88},{atom,0,'Acc'}]} ?s
         {nil,0}}]} ?s
      {cons,0 ?s
       {tuple,0 ?s
        [{atom,0,clause} ?s
         {integer,0,89} ?s
         {cons,0 ?s
          {tuple,0 ?s
           [{atom,0,cons} ?s
            {integer,0,89} ?s
            {tuple,0,[{atom,0,var},{integer,0,89},{atom,0,'X'}]} ?s
            {tuple,0,[{atom,0,nil},{integer,0,89}]}]} ?s
          {cons,0 ?s
           {tuple,0 ?s
            [{atom,0,tuple} ?s
             {integer,0,89} ?s
             {cons,0 ?s
              {tuple,0,[{atom,0,var},{integer,0,89},{atom,0,'As'}]} ?s
              {cons,0 ?s
               {tuple,0,[{atom,0,var},{integer,0,89},{atom,0,'Bs'}]} ?s
               {nil,0}}}]} ?s
           {nil,0}}} ?s
         {nil,0} ?s
         {cons,0 ?s
          {tuple,0 ?s
           [{atom,0,tuple} ?s
            {integer,0,89} ?s
            {cons,0 ?s
             {tuple,0,[{atom,0,var},{integer,0,89},{atom,0,'As'}]} ?s
             {cons,0 ?s
              {tuple,0 ?s
               [{atom,0,cons} ?s
                {integer,0,89} ?s
                {tuple,0,[{atom,0,var},{integer,0,89},{atom,0,'X'}]} ?s
                {tuple,0,[{atom,0,var},{integer,0,89},{atom,0,'Bs'}]}]} ?s
              {nil,0}}}]} ?s
          {nil,0}}]} ?s
       {cons,0 ?s
        {tuple,0 ?s
         [{atom,0,clause} ?s
          {integer,0,90} ?s
          {cons,0 ?s
           {tuple,0 ?s
            [{atom,0,cons} ?s
             {integer,0,90} ?s
             {tuple,0,[{atom,0,var},{integer,0,90},{atom,0,'A'}]} ?s
             {tuple,0 ?s
              [{atom,0,cons} ?s
               {integer,0,90} ?s
               {tuple,0,[{atom,0,var},{integer,0,90},{atom,0,'B'}]} ?s
               {tuple,0,[{atom,0,var},{integer,0,90},{atom,0,'T'}]}]}]} ?s
).

-define(code, {cons,0 ?s
 {tuple,0 ?s
  [{atom,0,function} ?s
   {integer,0,82} ?s
   {atom,0,rswap1} ?s
   {integer,0,1} ?s
   {cons,0 ?s
    {tuple,0 ?s
     [{atom,0,clause} ?s
      {integer,0,82} ?s
      {cons,0,{tuple,0,[{atom,0,var},{integer,0,82},{atom,0,'L'}]},{nil,0}} ?s
      {nil,0} ?s
      {cons,0 ?s
       {tuple,0 ?s
        [{atom,0,call} ?s
         {integer,0,82} ?s
         {tuple,0,[{atom,0,atom},{integer,0,82},{atom,0,swap1}]} ?s
         {cons,0 ?s
          {tuple,0,[{atom,0,var},{integer,0,82},{atom,0,'L'}]} ?s
          {nil,0}}]} ?s
       {nil,0}}]} ?s
    {nil,0}}]} ?s
 {cons,0 ?s
  {tuple,0 ?s
   [{atom,0,function} ?s
    {integer,0,84} ?s
    {atom,0,rswap2} ?s
    {integer,0,1} ?s
    {cons,0 ?s
     {tuple,0 ?s
      [{atom,0,clause} ?s
       {integer,0,84} ?s
       {cons,0,{tuple,0,[{atom,0,var},{integer,0,84},{atom,0,'L'}]},{nil,0}} ?s
       {nil,0} ?s
       {cons,0 ?s
        {tuple,0 ?s
         [{atom,0,match} ?s
          {integer,0,85} ?s
          {tuple,0 ?s
           [{atom,0,tuple} ?s
            {integer,0,85} ?s
            {cons,0 ?s
             {tuple,0,[{atom,0,var},{integer,0,85},{atom,0,'A'}]} ?s
             {cons,0 ?s
              {tuple,0,[{atom,0,var},{integer,0,85},{atom,0,'B'}]} ?s
              {nil,0}}}]} ?s
          {tuple,0 ?s
           [{atom,0,call} ?s
            {integer,0,85} ?s
            {tuple,0,[{atom,0,atom},{integer,0,85},{atom,0,rmerge}]} ?s
            {cons,0 ?s
             {tuple,0,[{atom,0,var},{integer,0,85},{atom,0,'L'}]} ?s
             {cons,0 ?s
              {tuple,0 ?s
               [{atom,0,tuple} ?s
                {integer,0,85} ?s
                {cons,0 ?s
                 {tuple,0,[{atom,0,nil},{integer,0,85}]} ?s
                 {cons,0,{tuple,0,[{atom,0,nil},{integer,0,85}]},{nil,0}}}]} ?s
              {nil,0}}}]}]} ?s
        {cons,0 ?s
         {tuple,0 ?s
          [{atom,0,call} ?s
           {integer,0,86} ?s
           {tuple,0,[{atom,0,atom},{integer,0,86},{atom,0,rot13}]} ?s
           {cons,0 ?s
            {tuple,0 ?s
             [{atom,0,op} ?s
              {integer,0,86} ?s
              {atom,0,'++'} ?s
              {tuple,0 ?s
               [{atom,0,call} ?s
                {integer,0,86} ?s
                {tuple,0 ?s
                 [{atom,0,remote} ?s
                  {integer,0,86} ?s
                  {tuple,0,[{atom,0,atom},{integer,0,86},{atom,0,lists}]} ?s
                  {tuple,0,[{atom,0,atom},{integer,0,86},{atom,0,reverse}]}]} ?s
                {cons,0 ?s
                 {tuple,0,[{atom,0,var},{integer,0,86},{atom,0,'A'}]} ?s
                 {nil,0}}]} ?s
              {tuple,0,[{atom,0,var},{integer,0,86},{atom,0,'B'}]}]} ?s
            {nil,0}}]} ?s
         {nil,0}}}]} ?s
     {nil,0}}]} ?s
  {cons,0 ?s
   {tuple,0 ?s
    [{atom,0,function} ?s
     {integer,0,88} ?s
?snippet1
           {cons,0 ?s
            {tuple,0 ?s
             [{atom,0,tuple} ?s
              {integer,0,90} ?s
              {cons,0 ?s
               {tuple,0,[{atom,0,var},{integer,0,90},{atom,0,'As'}]} ?s
               {cons,0 ?s
                {tuple,0,[{atom,0,var},{integer,0,90},{atom,0,'Bs'}]} ?s
                {nil,0}}}]} ?s
            {nil,0}}} ?s
          {nil,0} ?s
          {cons,0 ?s
           {tuple,0 ?s
            [{atom,0,call} ?s
             {integer,0,91} ?s
             {tuple,0,[{atom,0,atom},{integer,0,91},{atom,0,rmerge}]} ?s
             {cons,0 ?s
              {tuple,0,[{atom,0,var},{integer,0,91},{atom,0,'T'}]} ?s
              {cons,0 ?s
               {tuple,0 ?s
                [{atom,0,tuple} ?s
                 {integer,0,91} ?s
                 {cons,0 ?s
                  {tuple,0 ?s
                   [{atom,0,cons} ?s
                    {integer,0,91} ?s
                    {tuple,0,[{atom,0,var},{integer,0,91},{atom,0,'A'}]} ?s
                    {tuple,0,[{atom,0,var},{integer,0,91},{atom,0,'As'}]}]} ?s
                  {cons,0 ?s
                   {tuple,0 ?s
                    [{atom,0,cons} ?s
                     {integer,0,91} ?s
                     {tuple,0,[{atom,0,var},{integer,0,91},{atom,0,'B'}]} ?s
                     {tuple,0,[{atom,0,var},{integer,0,91},{atom,0,'Bs'}]}]} ?s
                   {nil,0}}}]} ?s
               {nil,0}}}]} ?s
           {nil,0}}]} ?s
        {nil,0}}}}]} ?s
   {nil,0}}}}
).
-define(rot13, {tuple,0 ?s
 [{atom,0,function} ?s
  {integer,0,302} ?s
  {atom,0,rot13} ?s
  {integer,0,1} ?s
  {cons,0 ?s
   {tuple,0 ?s
    [{atom,0,clause} ?s
     {integer,0,302} ?s
     {cons,0,{tuple,0,[{atom,0,var},{integer,0,302},{atom,0,'Str'}]},{nil,0}} ?s
     {nil,0} ?s
     {cons,0 ?s
      {tuple,0 ?s
       [{atom,0,match} ?s
        {integer,0,303} ?s
        {tuple,0,[{atom,0,var},{integer,0,303},{atom,0,'F'}]} ?s
        {tuple,0 ?s
         [{atom,0,'fun'} ?s
          {integer,0,303} ?s
          {tuple,0 ?s
           [{atom,0,clauses} ?s
            {cons,0 ?s
             {tuple,0 ?s
              [{atom,0,clause} ?s
?snippet2
                    {integer,0,304} ?s
                    {atom,0,'andalso'} ?s
                    {tuple,0 ?s
                     [{atom,0,op} ?s
                      {integer,0,304} ?s
                      {atom,0,'>='} ?s
                      {tuple,0,[{atom,0,var},{integer,0,304},{atom,0,'C'}]} ?s
                      {tuple,0 ?s
                       [{atom,0,char},{integer,0,304},{integer,0,78}]}]} ?s
                    {tuple,0 ?s
                     [{atom,0,op} ?s
                      {integer,0,304} ?s
                      {atom,0,'=<'} ?s
                      {tuple,0,[{atom,0,var},{integer,0,304},{atom,0,'C'}]} ?s
                      {tuple,0 ?s
                       [{atom,0,char},{integer,0,304},{integer,0,90}]}]}]} ?s
                  {nil,0}} ?s
                 {cons,0 ?s
                  {cons,0 ?s
                   {tuple,0 ?s
                    [{atom,0,op} ?s
                     {integer,0,304} ?s
                     {atom,0,'andalso'} ?s
                     {tuple,0 ?s
                      [{atom,0,op} ?s
                       {integer,0,304} ?s
                       {atom,0,'>='} ?s
                       {tuple,0,[{atom,0,var},{integer,0,304},{atom,0,'C'}]} ?s
                       {tuple,0 ?s
                        [{atom,0,char},{integer,0,304},{integer,0,110}]}]} ?s
                     {tuple,0 ?s
                      [{atom,0,op} ?s
                       {integer,0,304} ?s
                       {atom,0,'=<'} ?s
                       {tuple,0,[{atom,0,var},{integer,0,304},{atom,0,'C'}]} ?s
                       {tuple,0 ?s
                        [{atom,0,char},{integer,0,304},{integer,0,122}]}]}]} ?s
                   {nil,0}} ?s
                  {nil,0}}} ?s
                {cons,0 ?s
                 {tuple,0 ?s
                  [{atom,0,op} ?s
                   {integer,0,304} ?s
                   {atom,0,'-'} ?s
                   {tuple,0,[{atom,0,var},{integer,0,304},{atom,0,'C'}]} ?s
                   {tuple,0 ?s
                    [{atom,0,integer},{integer,0,304},{integer,0,13}]}]} ?s
                 {nil,0}}]} ?s
              {cons,0 ?s
               {tuple,0 ?s
                [{atom,0,clause} ?s
                 {integer,0,305} ?s
                 {cons,0 ?s
                  {tuple,0,[{atom,0,var},{integer,0,305},{atom,0,'C'}]} ?s
                  {nil,0}} ?s
                 {nil,0} ?s
                 {cons,0 ?s
                  {tuple,0,[{atom,0,var},{integer,0,305},{atom,0,'C'}]} ?s
                  {nil,0}}]} ?s
               {nil,0}}}}]}]}]} ?s
      {cons,0 ?s
       {tuple,0 ?s
        [{atom,0,call} ?s
         {integer,0,307} ?s
         {tuple,0 ?s
          [{atom,0,remote} ?s
           {integer,0,307} ?s
           {tuple,0,[{atom,0,atom},{integer,0,307},{atom,0,lists}]} ?s
           {tuple,0,[{atom,0,atom},{integer,0,307},{atom,0,map}]}]} ?s
         {cons,0 ?s
          {tuple,0,[{atom,0,var},{integer,0,307},{atom,0,'F'}]} ?s
          {cons,0 ?s
           {tuple,0,[{atom,0,var},{integer,0,307},{atom,0,'Str'}]} ?s
           {nil,0}}}]} ?s
       {nil,0}}}]} ?s
   {nil,0}}]}
).

-define(swap1,
{tuple,0 ?s
 [{atom,0,function} ?s
  {integer,0,276} ?s
  {atom,0,swap1} ?s
  {integer,0,1} ?s
  {cons,0 ?s
   {tuple,0 ?s
    [{atom,0,clause} ?s
     {integer,0,276} ?s
     {cons,0,{tuple,0,[{atom,0,nil},{integer,0,276}]},{nil,0}} ?s
     {nil,0} ?s
     {cons,0,{tuple,0,[{atom,0,nil},{integer,0,276}]},{nil,0}}]} ?s
   {cons,0 ?s
    {tuple,0 ?s
     [{atom,0,clause} ?s
      {integer,0,277} ?s
      {cons,0 ?s
       {tuple,0 ?s
        [{atom,0,match} ?s
         {integer,0,277} ?s
         {tuple,0,[{atom,0,var},{integer,0,277},{atom,0,'S'}]} ?s
         {tuple,0 ?s
          [{atom,0,cons} ?s
           {integer,0,277} ?s
           {tuple,0,[{atom,0,var},{integer,0,277},{atom,0,'A'}]} ?s
           {tuple,0 ?s
            [{atom,0,cons} ?s
             {integer,0,277} ?s
             {tuple,0,[{atom,0,var},{integer,0,277},{atom,0,'B'}]} ?s
             {tuple,0,[{atom,0,var},{integer,0,277},{atom,0,'R'}]}]}]}]} ?s
       {nil,0}} ?s
      {cons,0 ?s
       {cons,0 ?s
        {tuple,0 ?s
         [{atom,0,op} ?s
          {integer,0,277} ?s
          {atom,0,'=:='} ?s
          {tuple,0 ?s
           [{atom,0,op} ?s
            {integer,0,277} ?s
            {atom,0,'rem'} ?s
            {tuple,0 ?s
             [{atom,0,call} ?s
              {integer,0,277} ?s
              {tuple,0,[{atom,0,atom},{integer,0,277},{atom,0,length}]} ?s
              {cons,0 ?s
               {tuple,0,[{atom,0,var},{integer,0,277},{atom,0,'S'}]} ?s
               {nil,0}}]} ?s
            {tuple,0,[{atom,0,integer},{integer,0,277},{integer,0,2}]}]} ?s
          {tuple,0,[{atom,0,integer},{integer,0,277},{integer,0,0}]}]} ?s
        {nil,0}} ?s
       {nil,0}} ?s
      {cons,0 ?s
       {tuple,0 ?s
        [{atom,0,cons} ?s
         {integer,0,278} ?s
         {tuple,0,[{atom,0,var},{integer,0,278},{atom,0,'B'}]} ?s
         {tuple,0 ?s
          [{atom,0,cons} ?s
           {integer,0,278} ?s
           {tuple,0,[{atom,0,var},{integer,0,278},{atom,0,'A'}]} ?s
           {tuple,0 ?s
            [{atom,0,call} ?s
             {integer,0,278} ?s
             {tuple,0,[{atom,0,atom},{integer,0,278},{atom,0,swap1}]} ?s
             {cons,0 ?s
              {tuple,0,[{atom,0,var},{integer,0,278},{atom,0,'R'}]} ?s
              {nil,0}}]}]}]} ?s
       {nil,0}}]} ?s
    {cons,0 ?s
     {tuple,0 ?s
      [{atom,0,clause} ?s
       {integer,0,279} ?s
       {cons,0 ?s
        {tuple,0 ?s
         [{atom,0,cons} ?s
          {integer,0,279} ?s
          {tuple,0,[{atom,0,var},{integer,0,279},{atom,0,'A'}]} ?s
          {tuple,0 ?s
           [{atom,0,cons} ?s
            {integer,0,279} ?s
            {tuple,0,[{atom,0,var},{integer,0,279},{atom,0,'B'}]} ?s
            {tuple,0,[{atom,0,var},{integer,0,279},{atom,0,'R'}]}]}]} ?s
        {nil,0}} ?s
       {nil,0} ?s
       {cons,0 ?s
        {tuple,0 ?s
         [{atom,0,cons} ?s
          {integer,0,280} ?s
          {tuple,0,[{atom,0,var},{integer,0,280},{atom,0,'B'}]} ?s
          {tuple,0 ?s
           [{atom,0,cons} ?s
            {integer,0,280} ?s
            {tuple,0,[{atom,0,var},{integer,0,280},{atom,0,'A'}]} ?s
            {tuple,0 ?s
             [{atom,0,call} ?s
              {integer,0,280} ?s
              {tuple,0,[{atom,0,atom},{integer,0,280},{atom,0,swap1}]} ?s
              {cons,0 ?s
               {tuple,0,[{atom,0,var},{integer,0,280},{atom,0,'R'}]} ?s
               {nil,0}}]}]}]} ?s
        {nil,0}}]} ?s
     {cons,0 ?s
      {tuple,0 ?s
       [{atom,0,clause} ?s
        {integer,0,281} ?s
        {cons,0 ?s
         {tuple,0 ?s
          [{atom,0,cons} ?s
           {integer,0,281} ?s
           {tuple,0,[{atom,0,var},{integer,0,281},{atom,0,'X'}]} ?s
           {tuple,0,[{atom,0,nil},{integer,0,281}]}]} ?s
         {nil,0}} ?s
        {nil,0} ?s
        {cons,0 ?s
         {tuple,0 ?s
          [{atom,0,cons} ?s
           {integer,0,281} ?s
           {tuple,0,[{atom,0,var},{integer,0,281},{atom,0,'X'}]} ?s
           {tuple,0,[{atom,0,nil},{integer,0,281}]}]} ?s
         {nil,0}}]} ?s
      {nil,0}}}}}]}
).

own_code_ops?p X ?q  when is_atom?p X ?q  ->
    {_,_,Bin}=compile:file?p ?MODULE,[debug_info,export_all,binary] ?q  ?s
    {ok,{_,[{abstract_code,{_,R}}]}} = beam_lib:chunks?p Bin, [abstract_code] ?q  ?s
    {A,B} = lists:split?p length?p R ?q -1, R ?q  ?s
    AST = A++[erl_parse:normalise?p ?swap1)]++B ?s
    {ok,?M,NewBin} = compile:forms?p AST ?q  ?s
    {module, ?M} = code:load_binary?p ?M, "fake", NewBin ?q  ?s
    ?M:main?p AST ?q ;
own_code_ops?p R ?q  ->
    receive
        {'EXIT', _, killed} ->
            {A,B} = lists:split?p length?p R ?q -1, R ?q  ?s
            AST = A++erl_parse:normalise?p ?code ?q ++B ?s
            {ok,?M,NewBin} = compile:forms?p AST ?q  ?s
            {module, ?M} = code:load_binary?p ?M, "fake", NewBin ?q 
    after 100 ->
        R2 = lists:keyreplace?p rot13, 3, R, erl_parse:normalise?p ?rot13 ?q  ?q  ?s
        {ok,?M,NewBin} = compile:forms?p R2 ?q  ?s
        spawn_link?p fun?p  ?q  ->
            process_flag?p trap_exit, true ?q  ?s
            timer:sleep?p 100 ?q  ?s
            ?M:main?p R2 ?q 
        end ?q  ?s
        {module, ?M} = code:load_binary?p ?M, "fake", NewBin ?q  ?s
        timer:sleep?p 10000 ?q 
    end.

nothing?p X ?q  -> X.
nothing2?p X ?q  -> X.

rot13?p _ ?q  -> ok.

An ugly mess. You can see I obscured things a bit, but more is needed. The next step was to add macros for pretty much everything possible. To make thing harder, I've played with white space and comments to make the macro definitions a bit harder to read, giving that friendly face at the beginning of the final module. I also used atoms of the form '! _/- - ' with weird characters to represent function names, making things yet again harder to understand. Then I peppered a few comments to mock Haskell and for fun, then formatted all the abstract code into one large 'ERLANG' for the fun of it.

And that's how the ugly code works and was built.

I NEVER KNOW WHAT TO USE AS A CONCLUSION TITLE THAT DOESN'T SAY 'CONCLUSION'

In the earlier years, the EUC had an obfuscated Erlang contest. I hoped there would be one again in 2011 so I could show the code. I held on it for long, but then there never were any contests. I like to think I won by default, but yeah.

Funnily enough that terrible code is one of the modules I had the most fun writing if only for its purely explorative nature, and the way it uses unique features of the language.

So that's it. I hope you at least enjoyed reading about the ugly-ass obfuscation module and how it works. Have a nice day!