00:00:42 <lament> so... no :)
00:01:03 <lament> !m.
00:01:05 <falsebot> m
00:01:10 <lament> !m;.
00:01:10 <falsebot> [[1, 'O', 1, 'O', '>', 2, 'O', 2, 'O', '=', '|'], ['$', '@', '\\', '-', '\\'], '#', '%']
00:04:58 <graue> I wrote up a simple non-Turing-completeness proof for Qdeql: http://esoteric.voxelperfect.net/wiki/Qdeql
00:05:52 <lament> ![16807* 2147483647m;!]r:
00:06:03 <lament> !0r;!.
00:06:04 <falsebot> 0
00:06:07 <lament> !1r;!.
00:06:08 <falsebot> 16807
00:06:15 <lament> !78495867r;!.
00:06:15 <falsebot> 725077411
00:06:44 <Robdgreat> this bot seems to be the greatest thing to ever happen to these guys
00:06:51 <lament> ![263*71+100m;!]r:
00:06:58 <lament> !1r;!.
00:06:59 <falsebot> 34
00:07:00 <GregorR> Robdgreat: Only for a brief day or so, I guarantee you ;)
00:07:03 <lament> !34r;!.
00:07:03 <falsebot> 13
00:07:07 <lament> !13r;!.
00:07:07 <falsebot> 90
00:07:11 <lament> blah blah etc
00:07:11 <Robdgreat> oh ye of little attention span
00:07:17 <Robdgreat> ;
00:07:18 <Robdgreat> ;)
00:07:29 <GregorR> I don't have a short ... *yawn* ... what were we talking about?
00:07:38 <lament> Robdgreat: not bad considering it took me an hour or so to write it
00:08:27 <Robdgreat> yeah
00:08:36 <kipple> how about making the bot send the output in a private message instead of spamming the channel?
00:08:42 <lament> kipple: no way!!!
00:08:56 <lament> everybody MUST know the output :P
00:09:01 <jix> sqrt in axo:
00:09:02 <jix> }:1.91+>[#%
00:09:02 <jix> %+1+]/, ;,<,
00:09:02 <jix> >2/].1-^ \{<
00:09:09 <jix> argh
00:09:13 <lament> what's axo?
00:09:19 <jix> my befunge like lang
00:09:19 <Robdgreat> oxa backwards
00:09:28 <jix> in the first line replace % with %%
00:12:11 <jix> replace the number '91+' with a higher one for better precision (bigger numbers) or with a lower one for less precision
00:14:05 <jix> i think axo is turing complete because it's main data structure is a unlimited double ended queue
00:15:34 <graue> aka, a deque
00:16:10 <jix> right
00:20:04 <jix> axo is pronounced aCHzo where CH is pronounced like the ch in Johann Sebastian Bach
00:34:11 <jix> or use this (http://www.ikp.uni-bonn.de/dt/forsch/phonetik/boss/index.html) to synthesize the word achso
00:48:27 <jix> !1,"ACTION is cool"1,
00:48:28 <falsebot> ACTION is cool
00:49:39 -!- jix has quit ("Bitte waehlen Sie eine Beerdigungnachricht").
00:49:45 -!- jix has joined.
00:50:06 <jix> back
00:56:07 <graue> !126,
00:56:07 <falsebot> ~
00:56:13 <graue> !255,
00:56:13 <falsebot> ÿ
00:56:26 <graue> !256,
00:56:27 <falsebot> Run-time error.
00:56:32 <graue> crud
00:56:44 * graue does not actually know how to program in False!
00:57:18 <jix> !2,"TIME"2,
00:57:19 <falsebot> TIME
00:57:23 <jix> hmm
00:57:49 <graue> jix, it's plainly apparent that it does not output characters 0 through 31
00:58:04 <graue> that means our fun is rather limited in this regard
00:58:28 <graue> !2 124+,
00:58:29 <falsebot> ~
00:58:50 <jix> !100O
00:58:50 <falsebot> Run-time error.
00:59:33 <jix> g'night
00:59:44 -!- jix has quit ("Bitte waehlen Sie eine Beerdigungnachricht").
01:17:36 <graue> draft spec for Sceql: http://www.voxelperfect.net:3875/esolang/sceql.txt
01:18:47 <graue> this is a revised Qdeql, with changes that hopefully make it computationally useful
01:18:53 <graue> comments welcome
02:02:35 <graue> I think this may still be unusable because \ still dequeues its test byte when nonzero
02:02:50 <graue> but now it's possible to abbreviate the code that prints a !
02:03:05 <graue> =_________________________________*
02:03:31 <graue> =_\=/=__________\=-=\/\/___=/*
02:28:06 <kipple> it still looks incredibly hard to use...
02:37:22 <graue> well, duh, but maybe a quine can be written in it now?
02:37:46 <graue> I'm not sure though if it's possible to compensate for the \ instruction's crazy antics enough to store an arbitrary amount of data
02:39:37 <graue> what if the \ command just looks at the next byte on the queue, dequeues it if it's zero, but leaves it there and enqueues two zero bytes otherwise?
02:42:43 <graue> well, I'll work on it tomorrow
02:42:48 -!- graue has quit (Remote closed the connection).
02:59:22 <GregorR> Why don't they cook cows the same way that they cook lobsters?
03:15:19 <cpressey> Run-time error.
03:19:26 <lament> !.
03:19:26 <falsebot> Run-time error.
03:19:45 <calamari> !1 1+
03:20:05 <calamari> !1 1+,
03:20:14 <calamari> !1 64+,
03:20:14 <falsebot> A
03:20:20 <lament> !1 1+.
03:20:20 <falsebot> 2
03:20:27 <calamari> thanks :)
03:20:46 <lament> cpressey: sorry for not making it a befunge bot :P
03:20:51 <calamari> !123 321+.
03:20:51 <falsebot> 444
03:21:00 <calamari> !123456 654321+.
03:21:00 <falsebot> 777777
03:21:05 <calamari> !123456789 987654321+.
03:21:06 <falsebot> 1111111110
03:21:13 <calamari> !123456789012345678 987654321+.
03:21:13 <falsebot> 123456789999999999
03:21:19 <calamari> !123456789012345678111111111111111111111111111111 987654321+.
03:21:19 <falsebot> 123456789012345678111111111111111111112098765432
03:21:22 <calamari> cool
03:21:40 <lament> it just uses python longs
03:21:47 -!- falsebot has quit (Remote closed the connection).
03:21:57 <lament> which is perhaps not such a great idea
03:22:13 <calamari> why not?
03:22:17 -!- falsebot has joined.
03:22:31 <lament> cause logical (bitwise) operations don't work on them properly, i think
03:22:34 <lament> !.
03:22:34 <falsebot> Error: pop from empty list
03:22:46 <calamari> !1&1.
03:22:47 <falsebot> Error: pop from empty list
03:22:52 <calamari> oops
03:22:55 <lament> !11&.
03:22:55 <calamari> !1 1&.
03:22:55 <falsebot> Error: pop from empty list
03:22:55 <falsebot> 1
03:23:06 <lament> calamari: &, |, ~
03:23:09 <lament> are all bitwise
03:23:11 <lament> true is -1
03:23:13 <lament> false is 0
03:23:16 <calamari> !1 1&.
03:23:16 <falsebot> 1
03:23:21 <lament> so bitwise ops also work as logical ops
03:23:28 <calamari> !3 4&.
03:23:28 <falsebot> 0
03:23:33 <lament> !1~.
03:23:33 <falsebot> -2
03:23:34 <calamari> !3 5&.
03:23:35 <falsebot> 1
03:23:36 <lament> !111111~.
03:23:36 <falsebot> -111112
03:23:40 <lament> !11111111111111111111111111~.
03:23:41 <falsebot> -11111111111111111111111112
03:23:44 <lament> heh
03:23:47 <calamari> seems fine
03:23:50 <lament> yeah.
03:24:02 <lament> !0~.
03:24:02 <falsebot> -1
03:24:04 <calamari> !1.2 3.4+.
03:24:04 <falsebot> 136
03:24:22 <calamari> lol, I see how it got that
03:24:56 <calamari> no floats then?
03:24:59 <lament> no
03:25:16 <lament> not at all
03:25:21 <lament> !1 2/.
03:25:21 <falsebot> 0
03:25:48 <lament> oh
03:26:01 <calamari> !2 4^
03:26:12 <calamari> !2 4^.
03:26:13 <falsebot> 4
03:26:18 <calamari> !2 100^.
03:26:18 <falsebot> 100
03:26:29 <calamari> !2 100j.
03:26:30 <falsebot> j
03:26:35 <calamari> !2 100j...
03:26:35 <falsebot> j1002
03:26:51 <calamari> !a b c...
03:26:51 <falsebot> cba
03:26:59 <lament> !abc...
03:26:59 <falsebot> cba
03:27:05 <lament> calamari: just read the manual
03:27:07 <lament> it's short
03:27:30 <lament> http://wouter.fov120.com/false/false.txt
03:27:35 <calamari> lament: I'm just fooling around, it is bothering you? :)
03:27:38 <lament> no
03:27:45 <calamari> cool
03:28:43 <calamari> !1 2/ 3*
03:28:45 <calamari> !1 2/ 3*.
03:28:45 <falsebot> 0
03:28:53 <calamari> !2 2/ 3*.
03:28:54 <falsebot> 3
03:31:56 -!- falsebot has quit (Remote closed the connection).
03:32:28 -!- falsebot has joined.
03:32:40 <lament> ![12$%*1blah].
03:32:41 <falsebot> Error: global name 'source' is not defined
03:32:47 <lament> haha
03:33:26 <calamari> !2a:a.
03:33:26 <falsebot> a
03:33:30 <calamari> !2a:a;.
03:33:30 <falsebot> 2
03:36:41 <calamari> !1a:2b:+.
03:36:41 <falsebot> Error: pop from empty list
03:36:47 <calamari> !1a:2b:ab+.
03:36:47 <falsebot> ba
03:36:51 <calamari> !1a:2b:a;b;+.
03:36:52 <falsebot> 3
03:37:27 <calamari> !1a:2b:a;b;+b;a:b:a;.b;.
03:37:28 <falsebot> 23
03:38:08 <lament> calamari: note that definitions are persistent
03:38:14 <lament> !a;.
03:38:14 <falsebot> 2
03:38:25 <lament> o_O
03:38:51 <calamari> is there a way to clear a var after using it?
03:38:58 <lament> no
03:39:05 <lament> put something else in it
03:39:13 <lament> !0a:
03:39:33 <calamari> !zzz;.
03:39:33 <falsebot> Error: 'z'
03:39:37 <calamari> !z;.
03:39:38 <falsebot> Error: 'z'
03:39:57 <calamari> heh, so a is now different than z
03:40:05 <calamari> !a;.
03:40:05 <falsebot> 0
03:41:23 <lament> calamari: well, referencing unassigned variables is undefined behaviour anyway :)
03:42:50 <calamari> !1 2 4@.
03:42:50 <falsebot> 1
03:42:56 <calamari> !1 2 4@...
03:42:56 <falsebot> 142
03:43:26 -!- falsebot has quit (Remote closed the connection).
03:43:59 -!- falsebot has joined.
03:44:01 <lament> ![1_][]#
03:44:08 <calamari> is it having ping timeout problems?
03:44:18 <lament> no
03:44:23 <lament> i'm improving it :)
03:44:34 <falsebot> Error:
03:45:52 -!- falsebot has quit (Remote closed the connection).
03:45:55 <calamari> !3 2$@+\..
03:46:24 -!- falsebot has joined.
03:46:24 <lament> that should output 3 4, right?
03:46:31 <lament> ![1_][]#
03:46:33 <falsebot> ...Endless loop?
03:46:35 <calamari> I messed up.. I wanted
03:46:40 <calamari> !2 3$@+\..
03:46:40 <falsebot> 35
03:46:45 <calamari> cool
03:46:50 <calamari> !3 2$@+\..
03:46:50 <falsebot> 25
03:46:58 <calamari> !3 5$@+\..
03:46:58 <falsebot> 58
03:47:01 <calamari> !3 5$@+\. .
03:47:01 <falsebot> 58
03:47:07 <lament> heee :)
03:47:11 <calamari> !3 5$@+\." ".
03:47:11 <falsebot> 5 8
03:47:15 <calamari> !5 8$@+\." ".
03:47:16 <falsebot> 8 13
03:47:22 <calamari> !8 13$@+\." ".
03:47:22 <falsebot> 13 21
03:48:04 <calamari> now I need to read about loops :)
03:49:41 <lament> !1 1 10a:[a;0>][$@+\." "." "]#
03:49:41 <falsebot> Error: list index out of range
03:50:12 <calamari> trying to steal my thunder? :)
03:50:17 <lament> yes :P
03:50:22 <lament> !1 1 10a:[a;0>][O1O1$@+\." "." "]#
03:50:22 <falsebot> Error: list index out of range
03:50:50 <calamari> you only want to print the first one, otherwise terms will repeat
03:50:56 <lament> !1 1 10a:[a;0>][$@+\." "]#
03:50:56 <falsebot> Error: list index out of range
03:51:04 <lament> !1 1 10a:[a;0>][O1O1$@+\." "]#
03:51:04 <calamari> let me figure it out :)
03:51:04 <falsebot> Error: list index out of range
03:51:09 <lament> by the way
03:51:25 <lament> the ø instruction
03:51:27 <lament> um
03:51:34 <lament> the circle with line through it
03:51:39 <lament> is just O here
03:51:46 <lament> cause i don't even know how to write that.
03:51:48 <calamari> ahh okay, was wondering that
03:53:08 <lament> i guess i should accept the real one anyway but i don't even know what ascii code it is.
03:53:36 <GregorR> Ø?
03:53:43 <lament> GregorR: yes
03:53:51 <GregorR> What OS are you on?
03:54:01 <lament> os x
03:54:06 <GregorR> Hmm, can't help ya :-P
03:54:07 <calamari> !0 1 10a:[a;0>][$@+\." "a;1-a:]#
03:54:07 <falsebot> Error: list index out of range
03:54:18 <GregorR> If you can set up a compose key, alt-O-/
03:55:06 <calamari> did I do something wrong ?
03:55:36 <lament> i dunno
03:55:43 <lament> probably.
03:55:58 <calamari> !5a:a;.
03:55:58 <falsebot> 5
03:56:03 <calamari> !5a:a;1-.
03:56:03 <falsebot> 4
03:56:08 <calamari> !5a:a;1-.a:
03:56:08 <falsebot> Error: pop from empty list
03:56:13 <calamari> !5a:a;1-a:
03:56:15 <calamari> !5a:a;1-a:.
03:56:15 <falsebot> Error: pop from empty list
03:56:18 <calamari> !5a:a;1-a:a;.
03:56:18 <falsebot> 4
03:56:52 <calamari> !5a:[a;0>][a;1-a:a;.]#
03:56:52 <falsebot> 43210
03:57:10 <calamari> !10a:[a;0>][a;1-a:a;.]#
03:57:10 <falsebot> 9876543210
03:58:13 <calamari> !10a:[a;0>][a;1-a:a;." "]#
03:58:13 <falsebot> 9 8 7 6 5 4 3 2 1 0
03:58:28 <calamari> !0 1 10a:[a;0>][a;1-a:a;." "]#
03:58:28 <falsebot> 9 8 7 6 5 4 3 2 1 0
03:58:34 <calamari> !0 1 10a:[a;0>][$ a;1-a:a;." "]#
03:58:34 <falsebot> 9 8 7 6 5 4 3 2 1 0
03:58:38 <calamari> !0 1 10a:[a;0>][$@ a;1-a:a;." "]#
03:58:38 <falsebot> 9 8 7 6 5 4 3 2 1 0
03:58:42 <calamari> !0 1 10a:[a;0>][$@+ a;1-a:a;." "]#
03:58:42 <falsebot> 9 8 7 6 5 4 3 2 1 0
03:58:47 <calamari> aha
03:59:11 <calamari> printing is killing it .. I need to dup first
04:00:30 <calamari> !0 1 10a:[a;0>][$@+\$." "a;1-a:]#
04:00:30 <falsebot> 1 1 1 1 1 1 1 1 1 1
04:00:40 <calamari> !0 1 10a:[a;0>][$@+\$.@" "a;1-a:]#
04:00:40 <falsebot> Error: list index out of range
04:01:07 <lament> one moment
04:01:08 -!- falsebot has quit (Remote closed the connection).
04:01:40 -!- falsebot has joined.
04:01:42 <calamari> !0 1 10a:[a;0>][$@+\$.\" "a;1-a:]#
04:01:42 <falsebot> 1 1 2 3 5 8 13 21 34 55
04:01:48 <lament> weee
04:01:56 <calamari> :D
04:02:05 <lament> how about this
04:02:47 <lament> ![0 1@a:[a;0>][$@+\$.\" "a;1-a:]#]f:
04:02:55 <lament> !10f;!
04:02:55 <falsebot> 1 1 2 3 5 8 13 21 34 55
04:02:59 <lament> !100f;!
04:03:00 <falsebot> Flood!
04:03:04 <calamari> haha
04:03:05 <lament> !50f;!
04:03:06 <falsebot> Flood!
04:03:09 <lament> aww
04:03:12 <lament> !30f;!
04:03:12 <falsebot> 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765 10946 17711 28657 46368 75025 121393 196418 317811 514229 832040
04:03:24 <calamari> !35f;!
04:03:24 <falsebot> 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765 10946 17711 28657 46368 75025 121393 196418 317811 514229 832040 1346269 2178309 3524578 5702887 9227465
04:03:30 <calamari> !45f;!
04:03:30 <falsebot> 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765 10946 17711 28657 46368 75025 121393 196418 317811 514229 832040 1346269 2178309 3524578 5702887 9227465 14930352 24157817 39088169 63245986 102334155 165580141 267914296 433494437 701408733 1134903170
04:03:37 <calamari> !47f;!
04:03:38 <falsebot> 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765 10946 17711 28657 46368 75025 121393 196418 317811 514229 832040 1346269 2178309 3524578 5702887 9227465 14930352 24157817 39088169 63245986 102334155 165580141 267914296 433494437 701408733 1134903170 1836311903 2971215073
04:03:41 <calamari> !49f;!
04:03:41 <falsebot> Flood!
04:03:43 <calamari> !48f;!
04:03:43 <falsebot> Flood!
04:04:03 <GregorR> Nice
04:04:09 <GregorR> !1f;!
04:04:10 <falsebot> 1
04:04:13 <GregorR> !17f;!
04:04:14 <falsebot> 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597
04:04:17 <lament> ![{prints n fibonacci numbers}0 1@a:[a;0>][$@+\$.\" "a;1-a:]#]f:
04:04:17 <GregorR> Sexy
04:04:23 <lament> !f;.
04:04:23 <falsebot> [{prints n fibonacci numbers}0 1@a:[a;0>][$@+\$.\" "a;1-a:]#]
04:04:28 <calamari> btw, is there a better way to decrement a than a;1-a: ?
04:04:34 <lament> no
04:05:18 <lament> !0f;!
04:05:24 <lament> !1_f;!
04:05:30 <lament> heh
04:06:00 <calamari> !0 1 10a:[a;0>][$@+\$.\" "a;1-a:].#
04:06:01 <falsebot> Error: len() of unsized object
04:06:06 <calamari> !0 1 10a:[a;0>][$@+\$.\" "a;1-a:]#.
04:06:06 <falsebot> 1 1 2 3 5 8 13 21 34 55 89
04:06:36 <calamari> !0 1 0." ".10a:[a;0>][$@+\$.\" "a;1-a:]#.
04:06:37 <falsebot> Error: list index out of range
04:06:43 <calamari> !0 1 0." "10a:[a;0>][$@+\$.\" "a;1-a:]#.
04:06:43 <falsebot> 0 1 1 2 3 5 8 13 21 34 55 89
04:06:54 <lament> i need to work on it giving real error messages
04:08:49 <lament> ![][]+
04:08:58 <lament> ![][]+.
04:08:58 <falsebot> []
04:09:05 <lament> oh god
04:09:09 <lament> that's SOOOO wrong
04:09:16 <lament> hahahahahahaha
04:09:25 <lament> !f;f;+.
04:09:26 <falsebot> [0, 1, '@', 'a', ':', ['a', ';', 0, '>'], ['$', '@', '+', '\\', '$', '.', '\\', '" "', 'a', ';', 1, '-', 'a', ':'], '#', 0, 1, '@', 'a', ':', ['a', ';', 0, '>'], ['$', '@', '+', '\\', '$', '.', '\\', '" "', 'a', ';', 1, '-', 'a', ':'], '#']
04:09:37 <calamari> ![0 1 0." "@a:[a;0>][$@+\$.\" "a;1-a:]#.]f:
04:09:43 <calamari> !10f;
04:09:53 <calamari> !10f;!
04:09:53 <falsebot> 0 1 1 2 3 5 8 13 21 34 55 89
04:10:00 <calamari> !49f;!
04:10:00 <falsebot> Flood!
04:10:02 <calamari> !48f;!
04:10:02 <falsebot> Flood!
04:10:05 <calamari> !47f;!
04:10:05 <falsebot> Flood!
04:10:09 <calamari> !46f;!
04:10:10 <falsebot> 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765 10946 17711 28657 46368 75025 121393 196418 317811 514229 832040 1346269 2178309 3524578 5702887 9227465 14930352 24157817 39088169 63245986 102334155 165580141 267914296 433494437 701408733 1134903170 1836311903 2971215073
04:10:32 <calamari> ![0 1 0." "@a:[a;0>][$@+\$.\" "a;1-a:]#.]fib:
04:10:36 <calamari> !46fib;!
04:10:52 <calamari> var's are only one letter?
04:10:57 <calamari> hehe
04:11:06 <calamari> and functions 
04:11:29 <GregorR> Hmm, I'm thinking up a new OO esolang....
04:12:04 <lament> calamari: yes :(
04:12:09 <lament> can't change that
04:12:17 <lament> without completely breaking compatibility with false
04:14:30 <calamari> !2971215073 100000000 1836311903 * /.
04:14:30 <falsebot> 0
04:14:39 <GregorR> {M[ma"Hello World!"=bO!bo.a^]}
04:15:16 <calamari> !1000000000 1836311903 * 2971215073 /.
04:15:16 <falsebot> 618033988
04:15:22 <calamari> !10000000000 1836311903 * 2971215073 /.
04:15:23 <falsebot> 6180339887
04:15:27 <calamari> !100000000000 1836311903 * 2971215073 /.
04:15:27 <falsebot> 61803398874
04:15:32 <calamari> !1000000000000 1836311903 * 2971215073 /.
04:15:32 <falsebot> 618033988749
04:15:36 <calamari> !100000000000000000000 1836311903 * 2971215073 /.
04:15:36 <falsebot> 61803398874989484815
04:15:59 <calamari> not sure how many deciamls I'm really supposed to have there :)
04:16:22 <calamari> !100000000000000000000 1836311903 * 2971215073 /"1.".
04:16:22 <falsebot> 1.61803398874989484815
04:21:34 -!- falsebot has quit (Remote closed the connection).
04:22:34 -!- falsebot has joined.
04:22:47 <lament> ![][]+
04:22:47 <falsebot> Parsing error.
04:22:59 <lament> crap
04:23:02 <lament> !1 2
04:23:08 <lament> !1 2..
04:23:09 <falsebot> 21
04:23:15 <lament> ![].
04:23:15 <falsebot> []
04:23:20 <lament> ![][]
04:23:27 <lament> !1 2+
04:23:29 <lament> !1 2+.
04:23:29 <falsebot> 3
04:23:37 <lament> ![][]..
04:23:37 <falsebot> [][]
04:23:42 <lament> what the hell
04:25:05 <lament> ![][]+
04:25:05 <falsebot> Parsing error.
04:25:19 <lament> i hate programming.
04:27:00 <Robdgreat> go figure
04:27:16 -!- falsebot has quit (Remote closed the connection).
04:27:39 <lament> it's true.
04:27:49 -!- kipple has quit (Read error: 110 (Connection timed out)).
04:28:05 -!- falsebot has joined.
04:28:26 <lament> ![][]+
04:28:26 -!- falsebot has quit (Remote closed the connection).
04:29:51 -!- falsebot has joined.
04:29:59 <lament> ![][]+
04:29:59 -!- falsebot has quit (Remote closed the connection).
04:34:30 -!- falsebot has joined.
04:34:49 <lament> you always start writing something with best intentions, and the next day it already needs a complete rewrite.
04:34:52 <lament> ![][]+
04:34:52 <falsebot> Error: Argument to + is not a number
04:35:23 <lament> !0 1 0." ".10a:[a;0>][$@+\$.\" "a;1-a:]#.
04:35:23 <falsebot> Error: Not enough stack elements for %
04:35:35 <lament> whoops
04:35:58 -!- falsebot has quit (Remote closed the connection).
04:36:30 -!- falsebot has joined.
04:37:03 <lament> !0 1 0." ".10a:[a;0>][$@+\$.\" "a;1-a:]#.
04:37:03 <falsebot> Error: Not enough stack elements for @
04:37:14 <lament> !1 0/
04:37:14 <falsebot> Error: integer division or modulo by zero
04:37:34 <lament> !.
04:37:35 <falsebot> Error: Pop from empty stack
04:37:50 <lament> !#
04:37:50 <falsebot> Error: Pop from empty stack
04:37:55 <lament> !1 2#
04:37:55 <falsebot> Error: # loop body is not a function
04:39:01 <calamari> !46f;!
04:39:01 <falsebot> Error: 'f'
04:39:10 <calamari> ![0 1 0." "@a:[a;0>][$@+\$.\" "a;1-a:]#.]f:
04:39:13 <calamari> !46f;!
04:39:14 <falsebot> 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765 10946 17711 28657 46368 75025 121393 196418 317811 514229 832040 1346269 2178309 3524578 5702887 9227465 14930352 24157817 39088169 63245986 102334155 165580141 267914296 433494437 701408733 1134903170 1836311903 2971215073
04:43:07 <GregorR> AAHHHHHHHHHHHHHHHHHHHHHHH
04:43:12 * GregorR fails to write a parser for his new esolang.
04:43:25 <lament> do you also hate programming? :)
04:43:47 <GregorR> I love programming.
04:43:58 <GregorR> It just doesn't love me ;)
04:44:04 <lament> awwwww
04:50:22 <Robdgreat> I thought of attempting an esolang in which functions take the form of haiku
04:50:48 <Robdgreat> wouldn't surprise me if it's been attempted
04:59:22 -!- calamari has quit ("Leaving").
05:07:28 <GregorR> http://www.esolangs.org/wiki/Glass
05:28:51 <GregorR> Comments?
05:28:53 <GregorR> Anybody?
05:59:02 <Robdgreat> looking
06:00:12 * Robdgreat head asplode.
06:19:38 -!- calamari has joined.
06:21:34 <GregorR> 'lo
06:24:02 <calamari> hi GregorR 
06:25:04 <GregorR> Check out Gregor's partially developed new esolang: http://www.esolangs.org/wiki/Glass
06:27:29 <calamari> how do you add/subtract, etc? :)
06:27:56 <calamari> or is it all done by string manipulations?
06:28:10 <GregorR> There are builtin classes, as in ORK.
06:28:15 <GregorR> So, to add would be something like this:
06:28:40 <GregorR> {M[m(_m)M!<12><13>(_m)(add).?]}
06:29:05 <GregorR> Except the word "add" would probably be something shorter, like "a"
06:29:26 <calamari> were the () to simplify parsing?
06:29:49 <GregorR> Not exactly, it's because you can do this: aaa, to push a onto the stack thrice.
06:30:00 <GregorR> So, if you want to push aaa onto the stack, you have to use (aaa)
06:30:14 <GregorR> So, variables with >1 character names are mildly less convenient :-P
06:30:26 <calamari> a a a?  then you can use () instead of []? :) (j.k. it's your lang)
06:31:03 <GregorR> Umm ... no ...
06:31:06 <calamari> hehe
06:31:08 <GregorR> [] = function
06:31:22 <GregorR> [(a)...] = declare a function in the current class with the code ... named a
06:31:41 <GregorR> That is, the variable a in the current class will point towards a function with the code ...
06:33:22 <calamari> hehe.. I'm mentally translating that to Java, isn't that sad?
06:33:33 <GregorR> Yes.
06:33:35 <GregorR> Yes it is.
06:34:06 <calamari> I've never implemented an oo lang.. I should sometime
06:35:09 <GregorR> Glass is fun because it has both pointers and objects :P
06:36:00 <GregorR> If you do ab=, a will be set to a pointer to b.  If you do ab*=, a will be set to the value of b.
06:36:43 <calamari> like c++
06:36:48 <calamari> (pointers and objects)
06:36:50 <GregorR> Yeah
06:36:54 * GregorR loves C++
06:36:57 <lament> what does the esolongs wiki logo signify?
06:37:08 <calamari> I don't know C++ except the C compatible subset of it
06:37:10 <GregorR> Esoteric programmers like lemons.
06:37:16 <GregorR> Or whatever they are.
06:37:27 <lament> limes?
06:37:28 <calamari> limes
06:38:50 <calamari> or oranges on the mirror.. except the forground one which looks nasty :)
07:06:40 -!- nooga has joined.
07:08:36 <GregorR> noooooooooooooooooooooooooooga!
07:10:23 <Robdgreat> nooooooooooooooooooooooooooooooooooooooooooga!
07:11:38 <nooga> hi? :>
07:12:02 <GregorR> {M[mHello World!]}
07:13:00 <GregorR> That wasn't proper code btw ;)
07:13:43 <calamari> .oO( Hello World )
07:14:03 <GregorR> {M[m(_o)O!"Hello World!"(_o)o.?]}
07:14:17 <nooga> what's this?
07:14:24 <calamari> Glass
07:14:30 <GregorR> http://www.esolangs.org/wiki/Glass
07:14:31 <nooga> something new?
07:14:35 <GregorR> I'm working on it.
07:14:41 <nooga> looks cool
07:21:41 <nooga> great job :)
07:21:48 <GregorR> I'm trying to write fibonacci :P
07:22:26 <nooga> :>
07:22:52 <nooga> hm
07:24:08 <GregorR> I need a better way to do "return"
07:24:14 <GregorR> {F[f(_m)M!<2>(_m)(le).?a1=/a,<1>\      ......... in progress :P
07:24:58 <nooga> how to use falsebot?
07:25:12 <GregorR> Just put the false code after a !
07:26:45 <nooga> !"hello"
07:26:46 <falsebot> hello
07:27:21 <Robdgreat> !"blah blah"
07:27:22 <falsebot> blah blah
07:27:27 <Robdgreat> !"perl is evil"
07:27:27 <falsebot> perl is evil
07:27:30 <Robdgreat> :D
07:28:50 <nooga> !"a hedgehog" 5 -
07:28:51 <falsebot> Error: Pop from empty stack
07:29:37 <nooga> hm
07:29:43 <nooga> !5 5 +
07:29:57 <nooga> ?:>
07:30:24 <Robdgreat> postfix is weird
07:32:26 <nooga> !55+.
07:32:26 <falsebot> Error: Pop from empty stack
07:32:39 <nooga> erm
07:34:53 <nooga> shouldn't stack have 10 on the top?
07:35:54 <nooga> !5 5+.
07:35:54 <falsebot> 10
07:35:58 <nooga> heh
07:36:03 <nooga> -.-' 
07:37:29 <nooga> !"foo" "bar" +
07:37:29 <falsebot> Error: Pop from empty stack
07:39:20 <GregorR> {F[f(_c)A!<2>(_c)(le).?(_a)1=/(_a),<1>^\(_a)$0<1>(_c)m.?(_a)f.?1<2>(_c)m.?(_a)f.?(_c)a.?(_a)1=,,(_a)*]} {M[m(_n)<50>=(_f)F!(_a)A!(_c)<0>=/(_n)(_c)(_f)f.?(_c)1=,(_n)(_n)*<1>(_a)s.?=\]}
07:39:29 <GregorR> That should be Fibonacci.
07:39:40 <GregorR> Maybe :P
07:40:33 <GregorR> Oh, blerr, wait ...
07:40:59 <Robdgreat> you need help, Gregor
07:41:44 <GregorR> {F[f(_c)A!0<2> (_c)(le).?(_a)1=,/(_a),<1>^\(_a)$0<1>(_c)m.?(_a)f.?1<2>(_c)m.?(_a)f.?(_c)a.?(_a)1=,,(_a)*]} {M[m(_n)<50>=(_f)F!(_a)A!(_c)<0>=/(_n)(_c)(_f)f.?(_c)1=,(_n)(_n)*<1>(_a)s.?=\]}
07:41:47 <GregorR> That's more like it.
07:41:53 <Robdgreat> ok now we need a glassbot
07:41:54 <Robdgreat> :)
07:42:01 <GregorR> That was the plan from the start ;)
07:42:18 <GregorR> It's concise enough that it can be typed in the channel, plus it can store classes, so you could share :)
07:42:59 * Robdgreat head asplode again.
07:43:45 <GregorR> G! {M[m(_o)O!"Join the club, Robdgreat!"(_o)o.?]}
07:45:41 <Robdgreat> that's wild.
07:55:40 <GregorR> Time for sleep.
07:55:43 <GregorR> By all.
07:56:00 <GregorR> I'm so tired I said "by" instead of "bye"
07:56:01 <GregorR> Bye all
07:56:04 <Robdgreat> night Gregor
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
08:36:51 -!- falsebot has quit (Remote closed the connection).
08:37:46 -!- falsebot has joined.
08:37:59 <lament> night
09:23:09 -!- nooga has quit (Read error: 110 (Connection timed out)).
11:10:04 -!- CXII has changed nick to CXI.
11:14:52 -!- calamari has left (?).
11:51:16 -!- jix has joined.
11:53:54 <jix> moin
13:38:56 <jix> stub for axo http://esolangs.org/wiki/Axo
13:43:44 -!- kipple has joined.
13:45:36 <jix> moin kipple 
13:45:39 <jix> kipple: http://esolangs.org/wiki/Axo
13:57:57 <kipple> I don't really understand those modes
14:00:15 <jix> you start string mode with " and end it with " ... in string mode every character that isn't a command in stringmode (has no (s) in the list) gets pushed onto the stack
14:00:28 <jix> same for ' with the difference that there are no commands in ' mode
14:00:49 <jix> "Hello, world!" pushes 'H','e'....
14:03:00 <kipple> ok
14:10:56 <jix> updated interpreter
15:11:46 <GregorR> *yaaaaaaaaaaaaaaaaawn*
15:18:10 <GregorR> It would be awesome if I could wake up and just continue working on Glass, rather than going to my class :P
15:49:43 -!- Aardwolf has joined.
15:57:53 -!- graue has joined.
16:26:07 <jix> there is a bug in axo2i :(
16:26:16 <jix> somewhere in the stack code
16:31:08 <jix> maybe i'm going to rewrite this using c++ and stl
16:37:41 <jix> realloc sucks
16:40:52 <graue> you should write super super clean C code like I do: http://www.esolangs.org/files/prolan-m/impl/prolan-m.c
16:41:36 <jix> i can't write clean c code
16:41:42 <graue> why not?
16:41:51 <jix> without complex and ugly macros i have to type too much
16:42:33 <graue> why don't you use functions for that?
16:42:38 <graue> C compilers know how to inline
16:43:06 <jix> because i don't like plain c ;)
16:54:51 <jix> i'm going to rewrite it in clean c++ code
16:55:23 <jix> making it a good base code for any other fungoid interpreter
16:59:14 <graue> I like plain C
16:59:51 <graue> it's such a formal affair
17:00:03 <graue> you have to dress up in a suit and tie to write plain C code, if you truly mean it
17:12:52 <graue> tentative instruction set for Sceql: http://www.voxelperfect.net:3875/esolang/sceql.txt
17:16:49 <jix> graue: and where is a dequeue instruction?
17:17:49 <graue> jix: nowhere :)))))))))
17:17:52 <graue> that's what makes it evil
17:18:05 <jix> and slow (if the queue grows)
17:18:09 <graue> I assume you mean a dequeue instruction that doesn't also re-enqueue
17:18:16 <jix> right
17:20:00 <graue> I suppose I could add a dequeue operation and make it an error to dequeue the last byte (or a 0 gets enqueued if that happens)
17:20:44 <jix> make a dequeue instruction and make it an error to dequeue a byte ;)
17:25:13 -!- GregorR-L has joined.
17:25:35 <GregorR-L> !"Hi all."
17:25:36 <falsebot> Hi all.
17:27:57 <GregorR-L> I see these smokers outside, and have a strong urge to find myself a firearm and solve the problem, but I have thusfar managed to resist ...
17:29:51 <jix> smokers--
17:29:57 <jix> free(smokers)
17:30:14 <graue> jix: good idea!
17:30:17 <jix> argh they will resist in memory
17:30:33 <jix> bzero(smokers,smokers->size)
17:31:45 <GregorR-L> for (i = 0; i < smokers.count(); i++) delete smokers[i];
17:31:47 <graue> why don't you memset them to 255 and then to 0 several times?
17:32:14 <graue> this should make sure they can't be retrieved from disk if they were stored in an mmap'd file
17:32:22 <GregorR-L> lol
17:32:35 * GregorR-L watches the metaphore stretch beyond its logical limit :P
17:32:44 <graue> by "good idea", I was referring to the dequeue instruction idea, by the way
17:37:05 -!- mtve has quit (Read error: 110 (Connection timed out)).
17:40:41 <GregorR-L> {(StackE)[(c__)n<0>=][sn1=,][gn*]} {(Stack)[(c__)h<0>=][a(_a)A!(_c)h*=(_n)<0>=/(_c)(_c)(_c)g.?=(_n)(_n)*<1>(_a)a.?=\(_n)*]}
17:40:49 <GregorR-L> A stack with a counter 8D
17:40:53 <GregorR-L> (maybe)
17:41:49 * jix is learning c++
17:41:54 <GregorR-L> Hoopla
18:00:39 <GregorR-L> New stack!
18:00:40 <GregorR-L> {(StackE)[(c__)n<0>=][(gn)n*][(sn)n1=,]}{(Stack)[(c__)h<0>=][(cnt)(_a)A!(_cur)h*=(_cnt)<0>=/(_cur)(_cnt)(_cnt)*<1>(_a)a.?=(_cur)(_cur)(gn).?=\(_cnt)*]}
18:00:40 <GregorR-L> It's a bit better
18:01:13 -!- GregorR-L has quit ("bbiab").
18:01:48 -!- mtve has joined.
18:05:57 -!- GregorR-L has joined.
18:12:44 -!- CXI has quit (Connection timed out).
18:16:32 <graue> I've put up an interpreter for Sceql, the revised Qdeql: http://esoteric.voxelperfect.net/files/sceql/impl/sceql.c
18:17:10 -!- CXI has joined.
18:23:05 <GregorR-L> Better fibonacci'r: {F[f(_num)1=,(_a)A!(_t)$(_ile)(_num)*<2>(_a)(le).?=/(_ile)<1>^\(_num)*<1>(_a)m.?(_t)f.?(_num)*<2>(_a)m.?(_t)f.?(_a)a.?]}{M[m(_o)O!(_f)F!(_a)A!(_num)<50>=(_cur)<0>=/(_num)(_cur)(_cur)*(_f)f.?=(_cur)*(_o)(on).?(_num)(_num)*<1>(_a)m.?=\]}
18:23:32 <graue> cool
18:23:37 <graue> do you have an interpreter written for this language yet?
18:25:29 <GregorR-L> I'm working on it.
18:25:29 <GregorR-L> It's tough :P
18:33:16 <lament> !99 9[1-$][\$@$@$@$@\/*=[1-$$[%\1-$@]?0=[\$.' ,\]?]?]#
18:33:36 -!- grim_ has quit ("Lost terminal").
18:34:55 <lament> ooh
18:34:58 -!- falsebot has quit (Remote closed the connection).
18:35:38 -!- falsebot has joined.
18:35:46 <lament> !99 9[1-$][\$@$@$@$@\/*=[1-$$[%\1-$@]?0=[\$.' ,\]?]?]#
18:35:47 <falsebot> 97 89 83 79 73 71 67 61 59 53 47 43 41 37 31 29 23 19 17 13 11 7 5 3 2
18:36:17 <lament> neat.
18:36:18 <GregorR-L> lament: Your first bit of code made grim underscore leave ;)
18:36:23 <lament> !999 9[1-$][\$@$@$@$@\/*=[1-$$[%\1-$@]?0=[\$.' ,\]?]?]#
18:36:35 <falsebot> 997 991 983 977 971 967 953 947 941 937 929 919 911 907 887 883 881 877 863 859 857 853 839 ...Endless loop?
18:36:38 <GregorR-L> Factor?
18:36:51 <GregorR-L> Hmm, not quite factor ...
18:36:57 <GregorR-L> Primes?
18:36:57 <lament> primes
18:37:02 <lament> not my code
18:37:05 <GregorR-L> Ah :)
18:37:11 <GregorR-L> !5 9[1-$][\$@$@$@$@\/*=[1-$$[%\1-$@]?0=[\$.' ,\]?]?]#
18:37:13 <falsebot> 3 2
18:37:36 <lament> funny that they're backwards.
18:37:43 <GregorR-L> Does anybody know of a good pseudocode snippet of primes so maybe I could write a Glass version?
18:39:30 <lament> eratosthenes' sieve...
18:39:59 <GregorR-L> That's a good google que :)
18:42:00 -!- GregorR-L has quit ("/me disappears.").
19:01:14 -!- graue has quit (Remote closed the connection).
19:55:24 -!- GregorR-L has joined.
20:00:56 <GregorR-L> {M[m(_a)A!(_o)O!(_cnt)<99>=/(_cnt)(_cnt)*(_o)(on).?" bottles of beer on the wall!\n"(_o)o.?(_cnt)*(_o)(on).?" bottles of beer!\nTake one down and pass it around,\n"(_o)o.?(_cnt)(_cnt)*<1>(_a)m.?=(_cnt)*(_o)(on).?" bottles of beer on the wall!\n"(_o)o.?\"No more bottles of beer on the wall!"(_o)o.?]}
20:05:26 <Robdgreat> wow
20:08:15 <GregorR-L> The trick is that I write it like this: http://pastebin.ca/26086
20:08:17 <GregorR-L> :P
20:17:53 <Robdgreat> interesante
20:34:00 -!- GregorR-L has set topic: #esoteric, the international hub for esoteric programming language design and deployment - wiki: http://esoteric.voxelperfect.net/wiki/ - logs: http://tunes.org/~nef/logs/esoteric/ or http://meme.b9.com/cdates.html?channel=esoteric - falsebot is a False interpreter, prefix commands with a '!'.
20:43:33 <jix> hmm are there manpages for c++ functions/methods/libs ?
20:44:38 <GregorR-L> No, sadly enough.
20:45:34 <GregorR-L> Or at least, I've never seen them.
20:46:55 <jix> i don't know what the methods do... do they allocate memory.. do i have to delete it...
20:47:09 <GregorR-L> That's what the interweb is for.
20:47:21 <GregorR-L> And in C++, they're functions.
20:47:35 <jix> ok
20:48:17 <jix> but they arn't real functions (like in functional programming)
20:48:45 <GregorR-L> Mmmmmm, so-so.
20:49:04 <GregorR-L> You can do all the funky functional programming stuff, but it gets very very confusing when you do it with functions in classes ;)
20:49:45 <jix> real functions have no side effects
20:50:29 <jix> but using an oo lang for strict functional programming is stupid anyways
20:50:53 <GregorR-L> Well, admittedly if you actually conform to the OO paradigm, you have defeated the possibility of functional programming, for that very reason.
20:50:58 <GregorR-L> Yyyyyyyyup :)
21:16:58 -!- GregorR-L has quit (Read error: 113 (No route to host)).
21:31:03 <GregorR> Ping
21:31:22 <jix> Pong
21:36:25 <GregorR> Time to continue working on Glass 8-D
21:36:30 <GregorR>  / kill myself
21:36:38 <Robdgreat> pick your poison
21:37:03 <GregorR> Glass
21:37:20 <Robdgreat> touche'
21:37:23 * jix wants a glass interpreter / compiler
21:37:29 <GregorR> Oh, I know, dihydrogen monoxide!
21:37:33 <GregorR> jix: I'm working on it XD
21:37:45 <Robdgreat> ok, but you have to inhale it
21:37:59 <jix> GregorR: ah not the EVIL dihydrogen monoxide!
21:38:09 <Robdgreat> it can be lethal.
21:38:23 <GregorR> It's the primary ingredient of acid rain!
21:38:36 <Robdgreat> it kills thousands annually
21:38:56 <GregorR> And yet, they still put it in all beverages!
21:39:10 <Robdgreat> Including Moxie!
21:39:28 <jix> MOnoXIdE !
21:39:43 <Robdgreat> ZOMG!!!111
21:40:23 <Robdgreat> I just now started on a BF interpreter in atari basic
21:40:27 <Robdgreat> but soon lost interest
21:41:00 <jix> i started writing a BF interpreter in ti-92(v200/92+/89) basic and decided that ti-basic sucks
21:41:07 <Robdgreat> yeah
21:41:24 <jix> and lost interest
21:41:27 <Robdgreat> I had an 86 and it was sufficient to keep me entertained in math class, but that was about the extent of its programming capabilities
21:41:58 <jix> my new primary portable esolang development device is going to be a gp2x
21:42:08 <Robdgreat> oh?
21:42:11 <Robdgreat> not familiar with it
21:42:30 <Robdgreat> oh that's nice
21:42:37 <jix> gp2x == device like the nintendo ds or psp but running linux and with open source api (and without 3d acceleration)
21:42:38 <Robdgreat> I need something a little more affordable
21:42:54 <jix> palm?
21:42:55 <Robdgreat> like, something I could pick up for next to nothingon ebay
21:43:16 <Robdgreat> hm think that'd work?
21:43:27 <jix> palm has open source apis
21:43:55 <Robdgreat> could you suggest a model?
21:44:13 <jix> no i don't own a palm.. i just know people that own a palm
21:44:20 <Robdgreat> thought I'd ask :)
21:44:36 <jix> well i have TWO palms ;)
21:44:51 <jix> one in my right hand another one in my left hand
21:44:53 <Robdgreat> I have only two, as well
21:45:07 <jix> but they have no open source api
21:45:26 <Robdgreat> they're useful, all the same
21:45:27 <Robdgreat> they can store info
21:45:41 <jix> they use cryptic proprietary code called DNA
21:45:45 <Robdgreat> using a commonly available stylus
21:46:18 <jix> yeah of course you can add many extensions but you can't modify the core that easy
21:47:11 <GregorR> lol
21:47:30 <jix> is there a function of deque to get the last item?
21:48:37 <GregorR> jix: .back()
21:48:49 <jix> GregorR: thanks
21:49:15 <Robdgreat> any other suggestions for an inexpensive portable esolang development device?
21:49:48 <jix> powerbook ;)
21:49:55 <Robdgreat> inexpensive, eh
21:50:04 <jix> hrhr
21:50:16 <jix> ibook ^^
21:50:20 <Robdgreat> newton
21:50:23 <Robdgreat> haha
21:50:30 <Robdgreat> ok I'm gonna be late for work
21:50:31 <Robdgreat> laters
22:21:02 <GregorR> Gad this is difficult >_<
22:47:29 <GregorR> mainStack[0]->fval->contents->runFunc(mainStack[0]->kival, fvar);
22:56:11 <jix> Glass interpreter?
23:01:00 <GregorR> Yup
23:03:08 <GregorR> YAY, I made tons o' errors!
23:14:45 <GregorR> I'm so close to completing this I can taste it ...
23:20:19 -!- graue has joined.
23:33:32 <jix> stl makes many things easier
23:33:38 <jix> stl and the string class
23:36:58 <jix> GregorR: completed?
23:44:56 -!- graue has quit (Remote closed the connection).
23:50:43 -!- GregorR-L has joined.
23:51:06 <GregorR-L> Not yet.
23:51:13 <GregorR-L> Heh, I use strings, maps, vectors and deques in Glass :P
23:52:13 <jix> i use strings, vectors and deques in axopp
23:52:44 <GregorR-L> Well, I'm away from my code right now, so I'll just write more examples :P
23:52:46 <GregorR-L> Suggestions?
23:54:09 <jix> mandelbrot
23:54:21 <GregorR-L> Eww :P
23:54:30 <jix> it's very easy
23:54:36 <GregorR-L> Pseudocode?
23:54:58 <jix> math code: f(z) = z^2+c
23:55:19 <GregorR-L> That doesn't help a lot ;)
23:57:18 <jix> pseudocode (using floats) r = x;i = y;iter = 20 /*iteration count*/;while(iter-- && r*r+i*i < 4){tmp = r;r=r*r-i*i+x;i=2*tmp*i+y;} plot(x,y,iter)
23:57:30 <jix> a good range for x and y is -2..2
23:58:33 <jix> if you want julia-set instead of mandelbrot-set replace +x and +y with +cr and +ci (where cr and ci are real and imaginary part of the parameter c)
23:59:05 <GregorR-L> Yay! :)
23:59:36 <jix> i'm always able to write a mandelbrot program (without internet!)