00:00:21 <GregorR> oerjan: http://www.reprap.org
00:01:32 <zuff> INFINITE PRINTER-PRINTERS
00:01:34 <zuff> FUCKING AWESOME
00:01:42 <zuff> RepRap achieved self-replication at 14:00 hours UTC on 29 May 2008 at Bath University in the UK. The machine that did it - RepRap Version 1.0 "Darwin" - can be built now - see the Make your own RepRap link there or on the left, and for ways to get the bits and pieces you need, see the Obtaining Parts link.
00:01:47 <zuff> it sounds like it took a whil
00:02:08 <GregorR> It took them many years to achieve self-replication.
00:02:10 <zuff> To increase that 60%, the next version of RepRap will be able to make its own electric circuitry - a technology we have already proved experimentally - though not its electronic chips. After that we'll look to doing transistors with it, and so on...
00:02:12 <zuff> HAHAHAHHAHAHAH YES
00:02:30 <lament> you realize what this eventually leads to.
00:02:31 <GregorR> I was watching the RepRap project until ... oh, about a month before it became successful X_X
00:03:27 <zuff> while (1) { replicate() }
00:03:52 <zuff> that reprap printer takes a "few minutes" to print itself
00:03:53 <zuff> just speed that up a lot
00:03:55 <zuff> and make it smaller
00:04:01 <zuff> LIGHT_GRAY GOOOOOOO
00:04:43 <lament> yeah, you kinda need nanotech for grey goo
00:04:57 <zuff> lament: thus why I said light gray goo
00:06:27 <zuff> I wonder how fast gray goo would be.
00:06:31 <zuff> Seconds? Minutes? Hours? Years?
00:06:32 <oerjan> +ul (:^::^:^^)()~((())~:a~*):a~*~^!(~((!())(!:^(:)*)(!!:^(^)*))a~*^!!^):^aS
00:06:41 <Warrigal> Gray goo would be a lot like bacteria.
00:06:42 <zuff> oerjan: wuzzat
00:07:05 <zuff> Warrigal: I prefer thinking of something that takes a few minutes to cross the whole earth.
00:07:12 <lament> zuff: that's too fast.
00:07:31 <zuff> lament: Millenia?
00:07:38 <lament> they can't move fast by themselves
00:07:48 <zuff> why would they move
00:07:55 <zuff> if they want to go in some direction, just replicate that way
00:07:56 <oerjan> +ul (:^::^:^^)()~((())~:a~*):a~*~^!(~((!())(!:^(:):S*)(!!:^(^):S*))a~*^!!^):^
00:08:10 <lament> zuff: you need resources to replicate
00:08:15 <lament> you need to get resources somewhere first
00:08:22 <zuff> lament: stuff around you :P
00:09:39 <oerjan> air in itself is probably not very energetic, although you can burn things in it
00:10:16 * Warrigal finds out how much is produced in the United States in one day
00:10:39 -!- psygnisfive has joined.
00:11:20 <oerjan> +ul (:^::^:^^)()~((())~:a~*):a~*~^!(~((!())(!:^(:)*)(!!:^(^)*))a~*^(~aS:^):^):^
00:11:21 <thutubot> ()((!())(!:^(:)*)(!!:^(^)*))(~((!())(!:^(:)*)(!!:^(^)*))a~*^(~aS:^):^)(())(((())~:a~*)(())~:a~*)(())(((())~:a~*)(())~:a~*)(((())~:a~*)(())~:a~*) ...too much output!
00:11:58 <zuff> oerjan: is this look and say?
00:12:09 <oerjan> no, it's what i was doing initially
00:13:25 <oklopol> hmm. trying to open {:^}^n?
00:13:59 <oerjan> hm i could do that, but this is more ambitious
00:14:29 <oerjan> i realized : and ^ should be easier than : and a which i had thought of before but which was too complicated
00:14:31 <oklopol> zuff: that's pretty standard notation
00:14:43 <zuff> oerjan: what does your program do
00:15:02 <oklopol> {:^}^n, n-tuples from {":", "^"}
00:15:09 <oerjan> +ul (:^::^:^^)()~((())~:a~*):a~*~^!(~((!())(!:^(:)*)(!!:^(^)*))~*^!!^):^aS
00:15:31 <zuff> +ul (::**) (:)~*(*)* S
00:15:37 <oerjan> you realized what it did?
00:15:46 <zuff> +ul (::**)(:)~*(*)*S
00:15:51 <oklopol> oerjan: your mother realized what that did.
00:16:27 <oklopol> oerjan: so, err, yes, yes i did
00:16:30 <oerjan> it's a compact bit representation, using : and ^ for bits. this program just computes NOT
00:16:57 <oklopol> yeah maybe that could be the standard way to do bitstrings in underload :)
00:17:16 <oklopol> oerjan: now step me through it
00:17:27 -!- psygnisf_ has joined.
00:17:35 <oerjan> and as you pointed out it can also analyze standard numbers
00:17:46 <zuff> it occurs to me that a far easier number representation is:
00:18:03 <oerjan> zuff: this is for compactness, not ease
00:18:15 <zuff> +ul (^^^)(^)*S
00:18:21 <zuff> I dunno how to subtract :D
00:18:43 <zuff> +ul (^^^)((^)*)S
00:18:50 <zuff> +ul (^^^)((^)*)~^S
00:19:01 <zuff> +ul (^^^)(!)((^)*)~^S
00:19:05 <oklopol> oerjan: are you preparing the step-through ;)
00:19:06 <oerjan> +ul (:^::^:^^)()~((())~:a~*):a~*~^!(~((!())(!:^(:)*)(!!:^(^)*))~*^!!^):^aS
00:19:15 <zuff> +ul (^^^)(aaaa)((^)*)~^S
00:19:23 <zuff> +ul (^^^)(!)((^)*)~^S
00:19:31 <oerjan> oklopol: in this damn noise?
00:19:49 <zuff> +ul ()((^)*)(^^^)^S
00:20:09 -!- jayCampbell has left (?).
00:20:09 <zuff> the representation
00:20:24 <zuff> dup dip call dup dip call dup dip call
00:20:29 <zuff> uhh you know what i mean
00:20:47 <oerjan> oklopol: first, we arrange to get () ((())~:a~*) (:^::^:^^) on the stack
00:21:30 <oerjan> not ((())~:a~*) but the result of ((())~:a~*):a~*
00:22:04 <oerjan> that program is essential for the building up. if it is run, it leaves (()) plus itself on the stack
00:22:42 <oerjan> the first () is for marking the bottom of stack
00:23:26 <oerjan> now when we run (:^::^:^^) with ((())~:a~*):a~* = (((())~:a~*)(())~:a~*) below
00:23:43 <oerjan> each : will just copy it
00:24:12 <oerjan> while each ^ will run it, leaving a (()) below a copy of it
00:24:48 -!- psygnisfive has quit (Remote closed the connection).
00:25:16 <oerjan> after running (:^::^:^^) we have turned each : -> (((())~:a~*)(())~:a~*) and each ^ -> (()) .
00:25:40 <oerjan> +ul (:^::^:^^)()~((())~:a~*):a~*~^!(~((!())(!:^(:)*)(!!:^(^)*))~*^!!^):^aS
00:26:26 <oklopol> tbh i kinda dropped off the wagon at some point, i'd probably have to run that on paper to really get it.
00:26:32 <oklopol> (or look at it before 2 am)
00:26:34 <oerjan> then we do a ! to get rid of the top copy of (((())~:a~*)(())~:a~*). now we just have () at the bottom, (()) for each ^ and (((())~:a~*)(())~:a~*) for each :
00:27:22 <oerjan> this is the state after (:^::^:^^)()~((())~:a~*):a~*~^!
00:27:43 <oerjan> let me do a run to show the stack
00:27:58 <oerjan> +ul (:^::^:^^)()~((())~:a~*):a~*~^!(~aS:^):^
00:27:59 <thutubot> (())(())(((())~:a~*)(())~:a~*)(())(((())~:a~*)(())~:a~*)(((())~:a~*)(())~:a~*)(())(((())~:a~*)(())~:a~*)() ...a out of stack!
00:28:06 <oklopol> i'm not sure you have to, i got it on the second read.
00:28:20 <oerjan> (recall this is printed top down)
00:28:30 <oerjan> well someone else might want to follow too
00:28:45 <oklopol> : copies the droppifier, ^ makes it drop
00:29:06 <oklopol> so naturally after the run the droppifiers and droppeds represent the string.
00:29:09 <oerjan> not quite drop, buts (()) under it
00:29:30 <oklopol> just happened to use a stack term with the complete opposite meaning :P
00:30:14 <oerjan> and now the different marks are conveniently differentiated by how much they leave on the stack when run: () drops itself, (()) leaves just 1, and (((())~:a~*)(())~:a~*) leaves two elements when run
00:30:41 <oklopol> yeah, the rest is just technical mongering.
00:30:47 <oklopol> which by the way i'm pretty surprised fit that little space
00:31:06 <oklopol> even though hmm yeah that's a simple way to distinguish
00:31:24 <oklopol> anyway, like i've said before, you're a god
00:33:28 <oklopol> +ul (^)(~:*~:)(~:*~:)(^^^)^S
00:34:04 <oklopol> +ul (^)(~:*~:)(~:*~:)(^^^)!!^S
00:34:08 <oklopol> +ul (^)(~:*~:)(~:*~:)(^^^)!^S
00:34:22 <oklopol> +ul (^)(~:*~:)(~:*~:)(^^^)^!S
00:34:26 <oklopol> +ul (^)(~:*~:)(~:*~:)(^^^)^!!S
00:34:52 <oklopol> +ul (^)(~(^)**~:)(~(^)**~:)(^^^)^!!S
00:35:13 <oklopol> +ul (^)(~(^)*~:)(~(^)*~:)(^^^)^!!S
00:35:30 <oklopol> +ul ()(~(^)*~:)(~(^)*~:)()(^^^)^!!S
00:36:00 <oklopol> +ul (^^^)()~(~(^)*~:)~(~(^)*~:)~^!!S
00:36:13 <oklopol> +ul (^^^)()~(~(^)*~:)~(~(^)*~:)~()~^!!S
00:37:43 <oklopol> anyway i'm off to sleep, i'm very tired am i.
01:14:50 -!- psygnisf_ has quit (Remote closed the connection).
01:16:37 -!- adu has joined.
01:18:33 -!- puzzlet_ has quit (Read error: 104 (Connection reset by peer)).
01:19:37 -!- puzzlet has joined.
01:28:59 -!- Sgeo has joined.
01:29:01 <MizardX> +ul (^^^^)()~(~(^)*~:)~(~(^)*~:)~()~()~^!!S
01:29:07 <MizardX> +ul (^^^^)()~(~(^)*~:)~(~(^)*~:)~()~()~()~^!!S
01:32:54 <MizardX> +ul ()()~(~(^)*~:)~(~(^)*~:)~()~^!!S
01:33:06 <MizardX> +ul (^)()~(~(^)*~:)~(~(^)*~:)~()~^!!S
01:33:23 <MizardX> +ul (^^)()~(~(^)*~:)~(~(^)*~:)~()~^!!S
01:34:03 <MizardX> +ul (^)()~(~(^)*~:)~(~(^)*~:)~()~^!!(")SS(")S
01:35:32 <MizardX> +ul (!)()~(~(^)*~:)~(~(^)*~:)~()~^!!(")SS(")S
01:36:37 <MizardX> +ul ((x)S^^)()~(~(^)*~:)~(~(^)*~:)~()~^!!(")SS(")S
01:37:03 <MizardX> +ul ((x)S^(x)S^(x)S)()~(~(^)*~:)~(~(^)*~:)~()~^!!(")SS(")S
01:38:40 -!- GreaseMonkey has joined.
01:42:55 <MizardX> +ul (^^^^)(^^)~(~(^)*~:)~(~(^)*~:)~^!!S
01:45:22 <MizardX> +ul (^^^^)(^^)(~(^)*~:)~(~(^)*~:)~^!!S
01:47:23 <oerjan> +ul (:^::^:^^)()~((())~:a~*):a~*~^!(~((!()((*)~:a~*a*^):a~*)(!:^(:)~^)(!!:^(^)~^))~*^!!^):^aS
01:47:59 <oerjan> +ul (:^::^:^^)()~((())~:a~*):a~*~^!(~((!()((*)~:a~*a*^):a~*)(!:^(:)~^)(!!:^(^)~^))~*^!!^):^!aS
01:51:08 <oerjan> +ul (:^::^:^^)()~((())~:a~*):a~*~^!(~((!())(!:^(^)*)(!!:^(~^)*))~*^!!^):^aS
01:51:27 <MizardX> +ul (^^^^^)(^^^)~(~()~(~(^)*~:)~(~(^)*~:)~()~^~:)~(~()~(~(^)*~:)~(~(^)*~:)~()~^~:)~^!!S
01:51:39 <oerjan> +ul (:^::^:^^)()~((())~:a~*):a~*~^!(~((!())(!:^(~^)*)(!!:^(^)*))~*^!!^):^aS
02:06:50 <adu> how are you
02:07:35 <adu> + ul (:::::)
02:07:42 <oerjan> no printing statement in there
02:08:03 <adu> oerjan: i don't know thu
02:08:37 <adu> I know forth
02:08:37 <oerjan> functional stack language
02:09:18 <oerjan> ^ runs the command at top of stack
02:09:27 <oerjan> : duplicates the top of stack
02:09:45 <oerjan> ~ switches top two stack elements
02:10:05 <oerjan> a adds parentheses around top of stack
02:10:17 <adu> +ul (:::):^S
02:10:40 <adu> +ul (:::)^S
02:10:49 <oerjan> ! drops the top of stack
02:11:06 <oerjan> the : had nothing duplicate there
02:11:44 <oerjan> (...) puts ... as an element on top of the stack
02:11:44 <adu> +ul (hello world)S
02:11:56 <adu> +ul helloworldS
02:12:13 <oerjan> that's illegal because h is not a command.
02:12:29 <adu> so I guess parentheses don't work like I thought
02:12:39 <oerjan> nope, they are like quoting
02:12:59 <oerjan> * concatenates the two top stack elements
02:13:02 <adu> +ul (hi)(lo)~S
02:13:14 <adu> +ul (hi)(lo)~SS
02:13:19 <adu> +ul (hi)(lo)SS
02:15:01 <Sgeo> What language is this?
02:16:31 <Sgeo> So much for []<> being reserved?
02:16:37 -!- oerjan has set topic: Logs: http://tunes.org/~nef/logs/esoteric | Wiki: http://esolangs.org.
02:17:04 <oerjan> Sgeo: no known interpreter implements that, it says as much
02:17:39 <oerjan> although " quoting could be useful. especially if it ignored that they cannot be used with ordinary parentheses.
02:18:31 <oerjan> nope, and the spec also says you cannot
02:21:53 <oerjan> +ul ((*)(*))(~:^~S( )S~a^*a*~:^):^
02:22:49 <oerjan> +ul ((*)(*))(~:^~S( )Sa~^*a*~:^):^
02:22:50 <thutubot> * * ** *** ***** ******** ************* ********************* ********************************** ******************************************************* ...too much output!
02:34:04 <MizardX> +ul (:^::^:^^)()~((())~:a~*):a~*~^!(~((!())(!:^(:^)*)(!!:^(^)*))~*^!!^):^aS
02:34:24 <MizardX> +ul (:^::^:^^)()~((())~:a~*):a~*~^!(~((!())(!:^(~^)*)(!!:^(^)*))~*^!!^):^aS
02:34:50 <MizardX> +ul (:^::^:^^)()~((())~:a~*):a~*~^!(~((!())(!:^(^)*)(!!:^(:)*))~*^!!^):^aS
02:37:02 <oerjan> +ul (::^:^^)()~((())~:a~*):a~*~^!(~((!())(!:^:*)(!!:^:*(*)*))~*^!!^):^aS
02:37:02 <thutubot> (****************************************************)
02:37:43 <oerjan> +ul (^::^:)()~((())~:a~*):a~*~^!(~((!())(!:^:*)(!!:^:*(*)*))~*^!!^):^aS
02:41:23 <oerjan> adu: i found out how to unpack lists of ^ and : as binary strings. it's not trivial because underload has no basic way of taking apart the inside of parentheses.
02:42:41 <oerjan> you have to trick the ^ and : commands into doing the work for you
02:43:13 <adu> oerjan: then make it do it
02:43:49 <MizardX> +ul (:^::^:^^)()~((())~:a~*):a~*~^!(~((!())(!:^((caret))*)(!!:^((colon))*))~*^!!^):^aS
02:43:49 <thutubot> ((colon)(caret)(colon)(colon)(caret)(colon)(caret)(caret))
02:45:29 -!- adu has quit.
02:45:31 <oerjan> essentially you can turn each of : and ^ into any sequence of commands you choose, by putting it where it says ((caret))* and ((colon))*
02:48:59 <Warrigal> +ul (^^^)()~((())~:a~*):a~*~^!(~((!())(!:^((caret))*)(!!:^((colon))*))~*^!!^):^aS
02:49:13 <oerjan> you can also select the recursion base case inside the (!())
02:49:26 -!- Corun has quit ("Leaving").
02:59:41 <MizardX> +ul (:^::^:^^)()~((())~:a~*):a~*~^!(~((!(<))(!:^(0)*)(!!:^(1)*))~*^!!^):^(>)*S
02:59:43 <Warrigal> Hmm. I wonder if one row of the Sierpinski gasket is the Cantor set, scaled linearly.
03:00:12 <oerjan> topologically it must be
03:01:03 <oerjan> (the cantor set is the unique zero-dimensional compact metric space without isolated points, if i'm not forgetting something)
03:02:19 <oerjan> hm except some rows of the sierpinsky gasket have whole lines, at least in part
03:02:36 <oerjan> such as the outer edges
03:03:16 <oerjan> but if you pick a coordinate which doesn't have a finite binary representation, you should avoid those
03:04:25 <Warrigal> But I said scaled linearly. That's a bit stronger than a homeomorphism.
03:05:57 <oerjan> it would not be the same proportions at every scale, i don't think
03:06:35 <oerjan> unless you hit some spot which solves an equation to make it exact, possibly
03:07:01 <Warrigal> I think I'll stare at it until I know the answer.
03:07:56 <oerjan> note that the obvious spots where you would expect an exact trisection are where you have whole lines
03:10:22 <oerjan> however, it may be of a generalized form, where you have a sequence of numbers to determine how much to remove at each step
03:11:13 <oerjan> but all blocks get the same amount removed in a given step
03:11:27 <Warrigal> Remove the middle half instead of the middle third.
03:11:32 <Warrigal> That's in the Sierpinski gasket.
03:12:01 <oerjan> for _some_ rows. it varies.
03:12:56 <Warrigal> There's a piecewise recursive formula for this, no doubt.
03:13:38 <oerjan> i think possibly the proportions taken away at one step is a function of the previous step
03:14:09 <oerjan> so you really need only one number
03:15:38 <oerjan> note there are some symmetries there. the top triangle is a rescaling of the whole, preserving all the removed proportions
03:16:06 <oerjan> (for a horizontal row)
03:16:23 <oerjan> hm vertical ones are different
03:16:47 <oerjan> they will not be that simple
03:17:39 <oerjan> they will not have whole line segments, but may have isolated points instead
03:18:01 <Warrigal> Straight down the middle, you get countably infinitely many points.
03:18:18 <Warrigal> Homeomorphic to {0, 1/2, 2/3, 3/4, . . ., 1}.
03:18:55 <Warrigal> Anywhere else, it's probably still a piecewise recursive matter.
03:19:09 <Warrigal> Now, ponder lines of slope 1/phi. :-P
03:19:18 <oerjan> i think x with finite binary expansion also gives countable set
03:20:26 <oerjan> otherwise, it should be at least a topological cantor set i think
03:23:02 <oerjan> i assume with any non-trivial angle, you can never get line segments, and only get isolated points if you hit the corner of a subtriangle.
03:24:40 <oerjan> which means for each angle there are only a countable number of lines that don't give a topological cantor set
03:27:14 <MizardX> Cantor set contains all trinary numbers that can be written without any 1's. 0.202002020220202002202020022 in base-3.
03:27:16 <oerjan> also i think there are only a countable number of angles for which you can intersect more than one isolated point
03:27:53 <MizardX> possibly ending with a single 1
03:28:06 -!- Corun has joined.
03:28:18 <oerjan> because if you intersect two, you intersect two triangle corners, and are down to some rational numbers as coordinates
03:28:50 <oerjan> MizardX: a single 1 = 0222222222222... anyway
03:29:15 <MizardX> but that would be infinite
03:30:02 <oerjan> but you avoid special cases that way, so may be worth it
03:38:46 <Warrigal> The Cantor set contains infinite decimals anyway.
04:34:55 <MizardX> The rational fractions with infinite trinary expansion would have to be of the form '0.xxxx(yyyy)', where 'yyyy' is repeating. If 'x' is 'n' trits long, and 'y' is 'm' trits long, then those numbers could be written as 'x / 3^n + y / (3^m+1) / 3^n'.
04:40:06 <MizardX> oh, and neither xxxx nor yyyy can contain any '1'.
04:46:09 <MizardX> err... that would be (3^m - 1)
04:46:33 <MizardX> 1/4 = 0.020202... = 0.(02) = 0/3^0 + 2/(3^2 - 1) = 2/8 = 1/4
05:10:20 -!- oerjan has quit ("Good night").
05:47:21 -!- revcompgeek has joined.
05:52:16 -!- revcompgeek has quit ("http://www.mibbit.com ajax IRC Client").
06:20:20 -!- Sgeo has quit (Read error: 110 (Connection timed out)).
06:32:44 -!- revcompgeek has joined.
06:38:21 -!- revcompgeek has quit ("http://www.mibbit.com ajax IRC Client").
07:57:47 -!- Corun has quit ("Leaving").
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
09:06:30 -!- GreaseMonkey has quit ("You only need one wheel. Bikers are just greedy.").
09:13:56 -!- jix has joined.
09:22:30 -!- puzzlet_ has joined.
09:23:24 -!- puzzlet has quit (Read error: 60 (Operation timed out)).
10:29:28 -!- jix has quit ("Computer has gone to sleep").
11:02:09 -!- puzzlet_ has quit (Read error: 104 (Connection reset by peer)).
11:03:15 -!- puzzlet has joined.
11:52:06 -!- fungot has quit (Remote closed the connection).
12:42:36 -!- oklokok has joined.
12:46:09 -!- ineiros_ has changed nick to ineiros.
12:47:15 -!- oklopol has quit (Read error: 60 (Operation timed out)).
13:13:07 -!- jix has joined.
13:16:01 -!- zuff has changed nick to ehird.
13:28:24 -!- jix has quit ("Computer has gone to sleep").
13:29:43 -!- jix has joined.
13:33:09 -!- ehird has changed nick to zuff.
13:39:23 <zuff> +ul (a)(:a~*)^
13:39:26 <zuff> +ul (a)(:a~*)^S
13:39:34 <zuff> +ul (a)(:a~*)^(:a~*)^S
14:10:21 -!- jix has quit ("...").
14:16:23 -!- clsmith has joined.
14:22:19 -!- jix has joined.
14:30:54 <zuff> http://www.blackbirdhome.com/ what
14:32:14 <clsmith> African Americans need a different browser to caucasians, see. It's a fact of life. Different, uh, internet habits?
14:34:20 <clsmith> Oh wow, it even has black search and black bookmarks. Which are different from normal search and bookmarks, because of their... colour.
14:34:32 <zuff> Proposal: Black browsers can only access black sites
14:34:41 <zuff> Same for every other trait
14:34:48 <clsmith> That way we can divide everyone again. :D
14:35:02 <zuff> also, you need a Black License to download any Black Browsers
14:35:11 <zuff> to be sure you're not some random whitey poking around in the black 'net
14:38:12 <zuff> clsmith: you new here? :)
14:38:55 <zuff> clsmith: have you gone through the initiation procedure yet?
14:39:22 <clsmith> zuff: Would it be tactical for me to say yes?
14:39:48 <zuff> clsmith: Okay, it's very simple, just sacrifice a few goats.
14:39:51 <zuff> 20 should be enough.
14:40:02 <zuff> Also, you have to drink about three cups of children's blood.
14:40:06 <zuff> 'sall there is to it.
14:40:26 <clsmith> Psh. Some initiation; I do that every week or so.
14:41:13 <zuff> clsmith: I should avoid mentioning the massive orgy/lobotomy hybrid, then.
14:41:23 <zuff> Umm. Forget I said that.
14:44:20 <clsmith> Has anyone ever written a Tar program in Befunge? 'Cause I was thinking of doing one.
14:45:02 <zuff> Nope. That'd be neat.
14:45:26 <zuff> +ul (:(^)~a*^)(:(^)~a*^)*
14:45:29 <zuff> +ul (:(^)~a*^)(:(^)~a*^)*S
14:45:36 <zuff> welp, addition is pretty trivial.
14:45:43 <zuff> now to do the * prog
14:45:51 <zuff> +ul (*S)(:(^)~a*^)^
14:45:55 <zuff> +ul ((*)S)(:(^)~a*^)^
14:46:00 <zuff> +ul ((*)S)(:(^)~a*^:(^)~a*^)^
14:48:14 <zuff> +ul (:(^)~a*^:(^)~a*^)((:(^)~a*^))~:(^!())~a*^!(*)~^S
14:48:23 <zuff> +ul (:(^)~a*^)((:(^)~a*^))~:(^!())~a*^!(*)~^S
14:58:19 -!- jix has quit ("...").
15:50:26 -!- KingOfKarlsruhe has joined.
16:15:39 -!- oerjan has joined.
16:22:41 -!- Slereah_ has joined.
16:23:31 <Slereah_> How much time would you estimate a txt file with roughly 6 million chars would take to open?
16:23:41 <zuff> read, long time.
16:24:09 <Slereah_> It's been a while and still no dice.
16:24:43 <Slereah_> It does seem like it, doesn't it.
16:24:52 <Slereah_> I guess I'll go back with a hundred thousand numbers.
16:25:21 <oerjan> well you see notepad's opening time is really an ackermann function of the input length. it's just that the constant overhead is really low so you don't notice until you get up to some size.
16:26:46 <Slereah_> Well, I'm back at ~600,000 chars, which I know it can open in reasonable time.
16:26:57 <Slereah_> (I'm testing a random number generator))
16:29:51 <Slereah_> Although it's still pretty Ackermanny
16:30:15 <fizzie> Please make a plot of notepad's file-opening time as a function of the file length.
16:30:40 <Slereah_> I'm a lousy programmer, as you know
16:31:08 <fizzie> Yes, a stopwatch. Take at least a dozen measurements for each data point to get more reliable values, also.
16:31:20 <Azstal> SendMessageTimeout might work.
16:31:35 -!- Azstal has changed nick to Asztal.
16:33:44 <Slereah_> The program takes like a microsecond to run
16:33:53 <Slereah_> And the resulting file ten minutes to open
16:34:40 <Asztal> I think notepad actually gives up and refuses to open files above a certain size.
16:34:49 <oerjan> have you checked that the file size is what you think?
16:35:21 <oerjan> try wordpad, i vaguely recall that is better
16:35:21 <Asztal> it's worse if you have word wrap on
16:37:20 <Asztal> I just opened a 2MB file in 7 seconds. I think it also helps if it doesn't think your file isn't full of CJK characters...
16:38:19 <Asztal> it uses a heuristic to distinguish UTF-16 files from ascii files
16:38:20 <oerjan> only if because of the double negation, you see
16:39:21 <oerjan> NEVER AVOID ESCHEWING DOUBLE NEGATION
16:39:21 <Asztal> it's slightly ironic that my constant revision and re-organizing of my sentences results in poorer grammar than it started with :(
16:41:37 <Asztal> I was going to ask if double negation cancels out in Finnish (because it doesn't cancel out in Hungarian), but then realised you're not Finnish :)
16:43:01 <oerjan> it doesn't cancel out in norwegian either, for what it's worth
16:44:01 -!- Slereah_ has quit (Read error: 60 (Operation timed out)).
16:44:08 <oerjan> zuff: you should do something about those exposed entrails
16:48:40 <zuff> Rather esoteric C question... how fast would calling mmap with O_CREAT be?
16:48:50 <zuff> I mean, does it create immediately or lazily?
16:48:57 <zuff> And how quick is that?
16:49:05 <oerjan> O_CREAT sounds strangely religious
16:50:49 <fizzie> I also don't think it's a mmap flag at all. I don't see how it could create a file anyway since it only takes a file descriptor.
16:51:07 <zuff> Well, forget the mmap part.
16:51:11 <zuff> How long does creating a file take? :P
16:55:04 <fizzie> I think you need to do something rather explicit to cause it to actually preallocate the disk space and fill it with zeroes; I think even ftruncate() won't yet do it.
16:55:43 <fizzie> posix_fallocate() will, since that's what it's for.
16:55:46 <zuff> For added WTF, this is, by the way, to replace malloc with open/mmap.
17:10:30 -!- Slereah_ has joined.
17:10:51 <Slereah_> Also here it is : http://membres.lycos.fr/bewulf/Divers7/GR.jpg
17:11:10 <Slereah_> It's supposed to be a uniform distribution between 0 and 1.
17:11:47 <zuff> who wants to partake in a random number challenge.
17:12:21 <zuff> it inspired me
17:12:41 <Slereah_> Also it's like the building block of my program, but I'm still fucking far from being done
17:13:23 <Slereah_> I use it to generate another random number, this time on a Boltzmann distribution
17:14:03 <zuff> Basically, the idea is that we keep making RNG functions to get the even-distribution line as straight as possible.
17:14:09 <zuff> The straightest one wins. (No gays allowed.)
17:15:12 <Slereah_> It's not supposed to be straight.
17:15:17 <Slereah_> Unless you use infinity numbers.
17:15:19 <zuff> I'm talking about the distribution.
17:15:36 <Slereah_> You don't generate a distribution
17:15:54 <zuff> Slereah_: no shit?
17:15:59 <zuff> I mean the distribution of the rng function.
17:16:08 <Slereah_> The graph isn't even the numbers, it's the normalized classes.
17:16:17 <zuff> I don't care about your graph...
17:16:24 <zuff> I'm not talking about it.
17:16:39 <Slereah_> I would have done moar stuff, but it gets laggy after 100,000
17:17:27 <Slereah_> Well, time to test the Boltzmann distribution now.
17:24:04 <Slereah_> That program doesn't work now :(
17:30:17 <Slereah_> I have to redo the classes thingamagig
17:48:35 <Slereah_> How can I impose conditions on constants in Mathematica?
17:48:48 <Slereah_> Like say it's real and positive
17:56:05 <fizzie> I think you can use Assumptions[] for that.
17:56:27 <fizzie> Quite many commands also accept an Assumptions->{} parameter.
17:57:04 <fizzie> Apparently it's either the Assumpitions option or the Assuming[] command.
17:58:07 <fizzie> Assuming[x >= 0, Integrate[...]] might do something sensible. Although maybe it's not the sort of "constraint" you want.
17:59:04 <Slereah_> 1/Sqrt[2 \[Pi]]\[ExponentialE]^-(n v^2)/(2 l U) Sqrt[n/(
17:59:15 <Slereah_> Why is v still there after integration?
18:04:01 -!- oerjan has quit ("leaving").
18:15:56 <Warrigal> This is my RNG function: (phi*seed) modulo 1
18:16:09 <Warrigal> seed should be values in [1..100000].
18:21:50 -!- Slereah- has joined.
18:21:50 -!- Slereah_ has quit (Read error: 104 (Connection reset by peer)).
18:22:51 -!- Sgeo has joined.
18:22:51 -!- Slereah- has quit (Read error: 104 (Connection reset by peer)).
19:28:22 -!- kar8nga has joined.
19:53:33 -!- Slereah_ has joined.
19:59:27 -!- jix has joined.
20:18:03 -!- Slereah_ has quit (Read error: 113 (No route to host)).
20:56:38 -!- clsmith has left (?).
21:16:59 -!- Corun has joined.
21:47:58 <SimonRC> "Windows got an essential update and decided to reboot your computer without your express permission."
21:48:10 <Warrigal> That's why I have Windows ask for permission first.
21:49:27 <Warrigal> The registry somewhere, I think.
21:49:31 <zuff> Whee, I use twitter now.
21:49:34 <zuff> http://twitter.com/zuffix.
21:49:37 <zuff> Add me so I feel worthwhile.
21:59:22 -!- cherez has joined.
22:03:10 -!- jix has quit ("...").
22:14:17 <SimonRC> well now I know what is worse than trying to stay connected to a machine with a dodgy connection
22:14:48 <SimonRC> trying to stay connected to a machine with a dodgy connection from a machine with an independantly dodgy connection
22:24:19 -!- kar8nga has left (?).
22:29:26 -!- oerjan has joined.
22:31:10 -!- KingOfKarlsruhe has quit (Remote closed the connection).
22:38:46 <AnMaster> I just ran into a crazy person today, a php coder who likes xhtml but can't stand xml. Does anyone else see the contradiction? (btw: is "does" or "do" the right word there?)
22:39:11 <zuff> and they're a php coder. ignore them.
22:39:19 <zuff> but they probably mean <enterpriseXMLDataFormat/>
22:39:50 <AnMaster> zuff, hm that could explain it I guess
22:40:14 <AnMaster> and yes a php coder I know. I was just amazed at the contradiction in what he said, in the way he said it.
22:41:21 <zuff> thanks for the report. :p
22:42:42 -!- cherez has left (?).
22:43:07 <oerjan> +ul (^^^!^!^!^^!^^)(()()(!)()(!)(:a~*:(!^(!^((!^)*)(!(^)*))(!^((^)*)(!(^)*)))~*~(!^(!^((!^)*)(!(^)*))(!^((^)*)(!(!^)*)))~*):^)~*^aS
22:43:07 <thutubot> (!^(!^((!^)*)(!(^)*))(!^((^)*)(!(!^)*))(:a~*:(!^(!^((!^)*)(!(^)*))(!^((^)*)(!(^)*)))~*~(!^(!^((!^)*)(!(^)*))(!^((^)*)(!(!^)*)))~*):a~*:(!^(!^((!^)*)(!(^)*))(!^((^)*)(!(^)*)))~*~(!^(!^((!^)*)(!(^)*))(!^((^)*)(!(!^)*)))~*) ...too much output!
22:43:21 <oklokok> oerjan: am i to understand you failed?
22:43:50 * oklokok has idea for cool language, need to spec tomorrowww
22:43:52 <oerjan> at making the program work on first test run
22:44:14 <oklokok> yes of course, but i'm actually more interested in what it was supposed to do.
22:46:00 <oklokok> btw how do you write these, do you use another representation and compile manually, or just write it in one piece? i'm assuming you don't use another interp for cheating your way into works-on-first-attempt, for obvious reasons
22:46:02 <oerjan> ok time for some unit testing
22:46:11 <oerjan> write it in one piece yeah
22:46:35 <oerjan> otherwise, how would you make it brief enough for irc
22:46:54 <oklokok> well you can optimize after compilation
22:47:52 <oerjan> +ul (()()(!)()(!)(:a~*:(!^(!^((!^)*)(!(^)*))(!^((^)*)(!(^)*)))~*~(!^(!^((!^)*)(!(^)*))(!^((^)*)(!(!^)*)))~*):^)^(~aS:^):^
22:47:53 <thutubot> (!^(!^((!^)*)(!(^)*))(!^((^)*)(!(!^)*))(:a~*:(!^(!^((!^)*)(!(^)*))(!^((^)*)(!(^)*)))~*~(!^(!^((!^)*)(!(^)*))(!^((^)*)(!(!^)*)))~*):a~*:(!^(!^((!^)*)(!(^)*))(!^((^)*)(!(^)*)))~*~(!^(!^((!^)*)(!(^)*))(!^((^)*)(!(!^)*)))~*) ...too much output!
22:49:56 <oklokok> is ^^^!^!^!^^!^^... your input format?
22:50:28 <oklokok> ! is zero, because zeroes are inactive
22:50:41 <oerjan> !^ is 0, ^ is 1. makes case selection easy.
22:51:18 -!- poiuy_qwert has quit.
22:52:11 <oklokok> ! would make no sense ofc, or you'd have to have an infinite amount of () on the stack when running the first one
22:52:12 <oerjan> +ul (:a~*:(!^(!^((!^)*)(!(^)*))(!^((^)*)(!(^)*)))~*~(!^(!^((!^)*)(!(^)*))(!^((^)*)(!(!^)*)))~*):^(~aS:^):^
22:52:13 <thutubot> (!^(!^((!^)*)(!(^)*))(!^((^)*)(!(!^)*))(:a~*:(!^(!^((!^)*)(!(^)*))(!^((^)*)(!(^)*)))~*~(!^(!^((!^)*)(!(^)*))(!^((^)*)(!(!^)*)))~*):a~*:(!^(!^((!^)*)(!(^)*))(!^((^)*)(!(^)*)))~*~(!^(!^((!^)*)(!(^)*))(!^((^)*)(!(!^)*)))~*) ...too much output!
22:52:40 <oklokok> but with !^, you can keep state on tos, in some form
22:56:13 <oerjan> +ul (()()(!)()(!)(:a~*:(!^(!^((!^)*)(!(^)*))(!^((^)*)(!(^)*)))~*~(!^(!^((!^)*)(!(^)*))(!^((^)*)(!(!^)*)))~*):^)^^!!(~aS:^):^
22:56:13 <thutubot> (!^((^)*)(!(!^)*))(!^((!^)*)(!(^)*))(!)()() ...a out of stack!
22:57:17 <oerjan> on my first test, i forgot all of the post-cleanup before printing
22:58:24 <oerjan> +ul (^^^!^!^!^^!^^)(()()(!)()(!)(:a~*:(!^(!^((!^)*)(!(^)*))(!^((^)*)(!(^)*)))~*~(!^(!^((!^)*)(!(^)*))(!^((^)*)(!(!^)*)))~*):^)~*^!!!!!!aS
22:59:02 <oerjan> (111000101) -> (0100111)
22:59:29 -!- SimonRC has quit ("Reconnecting").
22:59:32 -!- SimonRC has joined.
23:00:21 <oklokok> make it show iterations of (^)
23:02:44 <oerjan> what do you mean (^) ?
23:03:12 <oerjan> also, you will notice that so far it cuts off the edges
23:03:50 <oerjan> +ul (^^^!^!^!^^!^^)(~:aS(()()(!)()(!)(:a~*:(!^(!^((!^)*)(!(^)*))(!^((^)*)(!(^)*)))~*~(!^(!^((!^)*)(!(^)*))(!^((^)*)(!(!^)*)))~*):^)~*^!!!!!!:aS~:^):^
23:03:51 <thutubot> (^^^!^!^!^^!^^)(!^^!^!^^^^)(!^^!^!^^^^)(^!^^^!^)(^!^^^!^)(^^^)(^^^)(!^)(!^)()()()()()()()()()()()()()()()()()()()()()()()()()()() ...too much output!
23:04:18 <oerjan> +ul (^^^!^!^!^^!^^)(~:aS(()()(!)()(!)(:a~*:(!^(!^((!^)*)(!(^)*))(!^((^)*)(!(^)*)))~*~(!^(!^((!^)*)(!(^)*))(!^((^)*)(!(!^)*)))~*):^)~*^!!!!!!~:^):^
23:04:19 <thutubot> (^^^!^!^!^^!^^)(!^^!^!^^^^)(^!^^^!^)(^^^)(!^)()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()() ...too much output!
23:05:09 <oerjan> +ul (^)(~:aS(()()(!)()(!)(:a~*:(!^(!^((!^)*)(!(^)*))(!^((^)*)(!(^)*)))~*~(!^(!^((!^)*)(!(^)*))(!^((^)*)(!(!^)*)))~*):^)~*^!!!!!!~:^):^
23:05:10 <thutubot> (^)()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()() ...too much output!
23:05:32 <oerjan> i told you it cuts off the edges
23:06:01 <oklokok> you can't run that in any way? hmm...
23:06:10 <oklokok> +ul (^!!!!!!!!!!!!!!^!!!!!!!!!!!!!!1^)(~:aS(()()(!)()(!)(:a~*:(!^(!^((!^)*)(!(^)*))(!^((^)*)(!(^)*)))~*~(!^(!^((!^)*)(!(^)*))(!^((^)*)(!(!^)*)))~*):^)~*^!!!!!!~:^):^
23:06:10 <thutubot> (^!!!!!!!!!!!!!!^!!!!!!!!!!!!!!1^) ...! out of stack!
23:06:18 <oklokok> +ul (^!!!!!!!!!!!!!!^!!!!!!!!!!!!!!^)(~:aS(()()(!)()(!)(:a~*:(!^(!^((!^)*)(!(^)*))(!^((^)*)(!(^)*)))~*~(!^(!^((!^)*)(!(^)*))(!^((^)*)(!(!^)*)))~*):^)~*^!!!!!!~:^):^
23:06:19 <thutubot> (^!!!!!!!!!!!!!!^!!!!!!!!!!!!!!^) ...! out of stack!
23:06:50 <oklokok> +ul (^!^!^!^!^^!^!^!^!^^)(~:aS(()()(!)()(!)(:a~*:(!^(!^((!^)*)(!(^)*))(!^((^)*)(!(^)*)))~*~(!^(!^((!^)*)(!(^)*))(!^((^)*)(!(!^)*)))~*):^)~*^!!!!!!~:^):^
23:06:52 <thutubot> (^!^!^!^!^^!^!^!^!^^)(!^!^!^^^!^!^!^^)(!^^^^!^!^^)(^!^^!^^)(^^^)(!^)()()()()()()()()()()()()()()()()()()()()()()()()()()()()()() ...too much output!
23:07:16 <oklokok> died just before the first interesting step
23:07:23 <oklokok> +ul (^!^!^!^!^!^^!^!^!^!^!^^)(~:aS(()()(!)()(!)(:a~*:(!^(!^((!^)*)(!(^)*))(!^((^)*)(!(^)*)))~*~(!^(!^((!^)*)(!(^)*))(!^((^)*)(!(!^)*)))~*):^)~*^!!!!!!~:^):^
23:07:24 <thutubot> (^!^!^!^!^!^^!^!^!^!^!^^)(!^!^!^!^^^!^!^!^!^^)(!^!^^^^!^!^!^^)(^^!^^!^!^^)(^^^!^^)(!^^^)(^)()()()()()()()()()()()()()()()()()()() ...too much output!
23:09:04 <oklokok> hmmhmm. 1000001000001 -> 00001100001 -> 001110001 -> 1101001 <<< here 1101 is what became out of the 111, right?
23:11:39 <oerjan> +ul (^!^!^!^!^!^^!^!^!^!^!^^)(~:(:a~*:((0)S)~*~((1)S)~*):^~^( )S!!(()()(!)()(!)(:a~*:(!^(!^((!^)*)(!(^)*))(!^((^)*)(!(^)*)))~*~(!^(!^((!^)*)(!(^)*))(!^((^)*)(!(!^)*)))~*):^)~*^!!!!!!~:^):^
23:12:03 <oklokok> making it output in binary?
23:12:20 * SimonRC gives up for this evening.
23:12:22 -!- Corun has quit ("This computer has gone to sleep").
23:12:32 <oerjan> +ul (^!^!^!^!^!^^!^!^!^!^!^^)(~:(:a~*:((0)S)~*~(!(1)S)~*):^~^( )S!!(()()(!)()(!)(:a~*:(!^(!^((!^)*)(!(^)*))(!^((^)*)(!(^)*)))~*~(!^(!^((!^)*)(!(^)*))(!^((^)*)(!(!^)*)))~*):^)~*^!!!!!!~:^):^
23:12:42 <oklokok> btw. if it's not too much trouble, i suggest making it not cur things, i mean (^) is the only thing i've seen 110 run on, that's what i wanna see.
23:13:02 <zuff> who wants to figure out the most elegant way to do this ul arith system:
23:13:04 <oklokok> you can make it *cure things though
23:13:15 <oerjan> the alternative is growing it
23:13:57 <oklokok> although you can prolly just grow in one direction, because, well, 110.
23:13:58 <oerjan> (also, wrapping, when i get around to it)
23:19:22 <oerjan> +ul (^!^!^!^!^!^^!^!^!^!^!^^)(~:(:a~*:((0)S)~*~(!(1)S)~*):a~*~*^( )S!!(()()(!)()(!)(:a~*:(!^(!^((!^)*)(!(^)*))(!^((^)*)(!(^)*)))~*~(!^(!^((!^)*)(!(^)*))(!^((^)*)(!(!^)*)))~*):^)~*^!!!!!!~:^):^
23:19:26 <thutubot> 1000001000001 00001100001 001110001 1101001 11101 011 1 ...too much output!
23:20:20 <oklokok> yeah okay looks like it works, somewhat.
23:20:33 <oerjan> +ul (^)(~:(:a~*:((0)S)~*~(!(1)S)~*):a~*~*^( )S!!(!^!^)~*(!^)*(()()(!)()(!)(:a~*:(!^(!^((!^)*)(!(^)*))(!^((^)*)(!(^)*)))~*~(!^(!^((!^)*)(!(^)*))(!^((^)*)(!(!^)*)))~*):^)~*^!!!!!!~:^):^
23:20:37 <thutubot> 1 11 111 1101 11111 110001 1110011 11010111 111111101 1100000111 11100001101 110100011111 1111100110001 11000101110011 111001111010111 1101011001111101 11111111011000111 110000001111001101 1110000011001011111 11010000111011110001 111110001101110010011 1100 ...too much output!
23:26:48 <oerjan> (^^^^^!^!^!^^^!^^^^!^!^^!^!^^^)(~:(:a~*:((0)S)~*~(!(1)S)~*):a~*~*^( )S!!(!^!^)~*(!^)*(()()(!)()(!)(:a~*:(!^(!^((!^)*)(!(^)*))(!^((^)*)(!(^)*)))~*~(!^(!^((!^)*)(!(^)*))(!^((^)*)(!(!^)*)))~*):^)~*^!!!!!!~:^):^
23:26:52 <oerjan> +ul (^^^^^!^!^!^^^!^^^^!^!^^!^!^^^)(~:(:a~*:((0)S)~*~(!(1)S)~*):a~*~*^( )S!!(!^!^)~*(!^)*(()()(!)()(!)(:a~*:(!^(!^((!^)*)(!(^)*))(!^((^)*)(!(^)*)))~*~(!^(!^((!^)*)(!(^)*))(!^((^)*)(!(!^)*)))~*):^)~*^!!!!!!~:^):^
23:26:56 <thutubot> 111110001101110010011 1100010011111010110111 11100110110001111111101 110101111110011000000111 1111111000010111000001101 11000001000111101000011111 111000011001100111000110001 1101000111011101101001110011 11111001101110111111011010111 1100010111110111000011 ...too much output!
23:27:38 <oerjan> +ul (^^^^^!^!^^^!^^^^!^^^^^^^!^^^!^^!^^^^)(~:(:a~*:((0)S)~*~(!(1)S)~*):a~*~*^( )S!!(!^!^)~*(!^)*(()()(!)()(!)(:a~*:(!^(!^((!^)*)(!(^)*))(!^((^)*)(!(^)*)))~*~(!^(!^((!^)*)(!(^)*))(!^((^)*)(!(!^)*)))~*):^)~*^!!!!!!~:^):^
23:27:41 <thutubot> 11111001101110111111011010111 110001011111011100001111111101 1110011110001110100011000000111 11010110010011011100111000001101 111111110110111110101101000011111 1100000011111100011111111000110001 11100000110000100110000001001110011 1101000011100011011100000 ...too much output!
23:28:20 <oerjan> when that long, irssi now wraps them under each other
23:28:52 <oerjan> hm although the growing to the left makes it shift
23:29:53 <oklokok> i'm sure that's trivial ;)
23:30:18 <oerjan> might be simpler to reverse printing, actually
23:32:59 <oerjan> +ul (^^^^^!^!^^^!^^^^!^^^^^^^!^^^!^^!^^^^)(~:(())(:a~*:((0)~*)~*~(!(1)~*)~*):a~**~*^( )*S!!(!^!^)~*(!^)*(()()(!)()(!)(:a~*:(!^(!^((!^)*)(!(^)*))(!^((^)*)(!(^)*)))~*~(!^(!^((!^)*)(!(^)*))(!^((^)*)(!(!^)*)))~*):^)~*^!!!!!!~:^):^
23:33:00 <thutubot> !(1)~*(:a~*:((0)~*)~*~(!(1)~*)~*):a~*:((0)~*)~*~(!(1)~*)~* !(1)~*(:a~*:((0)~*)~*~(!(1)~*)~*):a~*:((0)~*)~*~(!(1)~*)~* !(1)~*(:a~*:((0)~*)~*~(!(1)~*)~*):a~*:((0)~*)~*~(!(1)~*)~* ...too much output!
23:33:39 <oerjan> +ul (^^^^^!^!^^^!^^^^!^^^^^^^!^^^!^^!^^^^)(~:(())(:a~*:((0)~*)~*~(!(1)~*)~*):a~**~*^!!( )*S(!^!^)~*(!^)*(()()(!)()(!)(:a~*:(!^(!^((!^)*)(!(^)*))(!^((^)*)(!(^)*)))~*~(!^(!^((!^)*)(!(^)*))(!^((^)*)(!(!^)*)))~*):^)~*^!!!!!!~:^):^
23:33:42 <thutubot> 11101011011111101110110011111 101111111100001110111110100011 1110000001100010111000111100111 10110000011100111011001001101011 111110000101101011111011011111111 1000110001111111100011111100000011 11001110010000001100100001100000111 111010110110000011101100011100001011 ...too much output!
23:37:15 <oerjan> of course changing the rules is also trivial, since about one line is a rule table
23:59:23 -!- olsner_ has quit ("Leaving").