00:21:35 -!- amadaluzia has quit (Quit: Hi, this is Paul Allen. I'm being called away to London for a few days. Meredith, I'll call you when I get back. Hasta la vista, baby.).
01:05:24 -!- Noisytoot has changed nick to \a.
01:31:44 -!- FreeFull has quit (Ping timeout: 260 seconds).
01:33:12 -!- FreeFull has joined.
01:45:33 <esolangs> [[VFUSL]] N https://esolangs.org/w/index.php?oldid=156042 * AlmostGalactic * (+2681) Created page with "= VFUSL = '''VFUSL''' (Very Full Stack Language) is a stack-based esoteric programming language where every operation is added to the stack and executed at runtime. It's designed with a mix of simplicity and flexibility, inspired by Reverse Polish Notation and oth
03:58:55 <esolangs> [[Ifle-complete]] M https://esolangs.org/w/index.php?diff=156043&oldid=154955 * JHSHernandez-ZBH * (-7)
04:45:08 -!- amadaluzia has joined.
05:05:08 -!- amadaluzia has quit (Quit: Hi, this is Paul Allen. I'm being called away to London for a few days. Meredith, I'll call you when I get back. Hasta la vista, baby.).
05:05:32 <esolangs> [[VFUSL]] https://esolangs.org/w/index.php?diff=156044&oldid=156042 * Stkptr * (+457)
05:11:45 <esolangs> [[FooProg]] M https://esolangs.org/w/index.php?diff=156045&oldid=156000 * None1 * (+7)
05:25:26 <esolangs> [[Pseudocode]] https://esolangs.org/w/index.php?diff=156046&oldid=155178 * JHSHernandez-ZBH * (-328) delete
06:32:46 -!- craigo has quit (Quit: Leaving).
06:56:58 -!- tromp has joined.
07:19:02 -!- Sgeo has quit (Read error: Connection reset by peer).
07:19:29 -!- Lord_of_Life_ has joined.
07:20:21 -!- Lord_of_Life has quit (Ping timeout: 248 seconds).
07:20:52 -!- Lord_of_Life_ has changed nick to Lord_of_Life.
07:23:51 <esolangs> [[Unvague]] N https://esolangs.org/w/index.php?oldid=156047 * JHSHernandez-ZBH * (+6363) Created page with "'''Unvague''' is an esolang designed by [[User:JHSHernandez-ZBH]] based on [[Vague]] and is completely compatible with it but with a few special commands. First, a stack is pushed on the stack stack, the input is taken as a binary number, the number seperated
07:24:17 <esolangs> [[Unvague]] https://esolangs.org/w/index.php?diff=156048&oldid=156047 * JHSHernandez-ZBH * (+0)
07:28:07 <esolangs> [[Esolang:Sandbox]] M https://esolangs.org/w/index.php?diff=156049&oldid=155886 * JHSHernandez-ZBH * (+35)
07:30:39 <esolangs> [[Unvague]] M https://esolangs.org/w/index.php?diff=156050&oldid=156048 * JHSHernandez-ZBH * (+26)
07:33:41 <esolangs> [[Unvague]] M https://esolangs.org/w/index.php?diff=156051&oldid=156050 * JHSHernandez-ZBH * (-3)
07:38:51 <esolangs> [[Unvague]] M https://esolangs.org/w/index.php?diff=156052&oldid=156051 * JHSHernandez-ZBH * (+0)
07:40:17 <esolangs> [[Unvague]] M https://esolangs.org/w/index.php?diff=156053&oldid=156052 * JHSHernandez-ZBH * (-17)
07:40:37 <esolangs> [[Unvague]] M https://esolangs.org/w/index.php?diff=156054&oldid=156053 * JHSHernandez-ZBH * (+24)
07:41:06 <esolangs> [[Unvague]] https://esolangs.org/w/index.php?diff=156055&oldid=156054 * JHSHernandez-ZBH * (+0)
07:48:04 <esolangs> [[Transposed]] https://esolangs.org/w/index.php?diff=156056&oldid=86418 * JHSHernandez-ZBH * (-8) /* Basic description of language */
07:48:19 <esolangs> [[Transposed]] https://esolangs.org/w/index.php?diff=156057&oldid=156056 * JHSHernandez-ZBH * (+2) /* Basic description of language */
09:01:15 <esolangs> [[Talk:Vague]] M https://esolangs.org/w/index.php?diff=156058&oldid=137326 * JHSHernandez-ZBH * (+45)
09:01:47 <esolangs> [[Talk:Vague]] M https://esolangs.org/w/index.php?diff=156059&oldid=156058 * JHSHernandez-ZBH * (+0)
09:02:38 <esolangs> [[Talk:Vague]] https://esolangs.org/w/index.php?diff=156060&oldid=156059 * JHSHernandez-ZBH * (-45)
09:03:31 <esolangs> [[Vague]] https://esolangs.org/w/index.php?diff=156061&oldid=151294 * JHSHernandez-ZBH * (+44)
09:05:14 <esolangs> [[Vague]] M https://esolangs.org/w/index.php?diff=156062&oldid=156061 * JHSHernandez-ZBH * (+25) /* Examples */
09:05:35 <esolangs> [[Vague]] https://esolangs.org/w/index.php?diff=156063&oldid=156062 * JHSHernandez-ZBH * (+7) /* Examples */
09:07:18 <esolangs> [[Vague]] M https://esolangs.org/w/index.php?diff=156064&oldid=156063 * JHSHernandez-ZBH * (+33) /* Examples */
09:07:31 <esolangs> [[Vague]] https://esolangs.org/w/index.php?diff=156065&oldid=156064 * JHSHernandez-ZBH * (+1) /* Examples */
09:10:09 <esolangs> [[Vague]] https://esolangs.org/w/index.php?diff=156066&oldid=156065 * JHSHernandez-ZBH * (+0) /* Examples */
09:10:53 <esolangs> [[Vague]] https://esolangs.org/w/index.php?diff=156067&oldid=156066 * JHSHernandez-ZBH * (+0) /* Examples */
09:11:52 <esolangs> [[Vague]] https://esolangs.org/w/index.php?diff=156068&oldid=156067 * JHSHernandez-ZBH * (+0) /* Examples */
09:12:15 <esolangs> [[Vague]] https://esolangs.org/w/index.php?diff=156069&oldid=156068 * JHSHernandez-ZBH * (+7) /* Examples */
09:12:30 <esolangs> [[Vague]] https://esolangs.org/w/index.php?diff=156070&oldid=156069 * JHSHernandez-ZBH * (+2) /* Examples */
09:12:42 <esolangs> [[Vague]] https://esolangs.org/w/index.php?diff=156071&oldid=156070 * JHSHernandez-ZBH * (-6) /* Examples */
09:13:03 <esolangs> [[Vague]] https://esolangs.org/w/index.php?diff=156072&oldid=156071 * JHSHernandez-ZBH * (+5) /* Examples */
09:13:26 <esolangs> [[Vague]] https://esolangs.org/w/index.php?diff=156073&oldid=156072 * JHSHernandez-ZBH * (-7) /* Examples */
09:15:27 <esolangs> [[Vague]] https://esolangs.org/w/index.php?diff=156074&oldid=156073 * JHSHernandez-ZBH * (+21) /* Examples */
09:15:35 <esolangs> [[Vague]] https://esolangs.org/w/index.php?diff=156075&oldid=156074 * JHSHernandez-ZBH * (+1) /* Examples */
09:16:17 <esolangs> [[Vague]] https://esolangs.org/w/index.php?diff=156076&oldid=156075 * JHSHernandez-ZBH * (+10)
09:21:07 <esolangs> [[Befunk]] M https://esolangs.org/w/index.php?diff=156077&oldid=129625 * JHSHernandez-ZBH * (+69) /* Language overview */
09:24:56 -!- wib_jonas has joined.
09:33:05 -!- wib_jonas has quit (Quit: Client closed).
09:40:33 <esolangs> [[Filename "xxx" doesn't seem to be a valid filename. Please check if the filename your trying to execute is written correctly]] https://esolangs.org/w/index.php?diff=156078&oldid=145645 * JHSHernandez-ZBH * (+0)
09:52:50 -!- wib_jonas has joined.
10:03:20 <esolangs> [[Selter]] N https://esolangs.org/w/index.php?oldid=156079 * TheSpiderNinjas * (+2933) Selter Page Creation
10:04:27 <esolangs> [[User:TheSpiderNinjas]] N https://esolangs.org/w/index.php?oldid=156080 * TheSpiderNinjas * (+40) TheSpiderNinjas' Page
10:07:10 <esolangs> [[Language list]] M https://esolangs.org/w/index.php?diff=156081&oldid=156019 * TheSpiderNinjas * (+13) Added Selter to Language List
10:09:30 <esolangs> [[Works in progress]] M https://esolangs.org/w/index.php?diff=156082&oldid=155686 * TheSpiderNinjas * (+63) Added Selter To WIP
10:10:15 <esolangs> [[User:TheSpiderNinjas]] M https://esolangs.org/w/index.php?diff=156083&oldid=156080 * TheSpiderNinjas * (+19) added to my page
10:10:49 <esolangs> [[Selter]] M https://esolangs.org/w/index.php?diff=156084&oldid=156079 * TheSpiderNinjas * (+8) add WIP to page
10:12:14 <wib_jonas> so you know how I want to make a column-sensitive language? the columns that tokens are in are significant in that each column works as a variable name. you put a mark in a column to indicate that you're accessing that variable.
10:12:17 <wib_jonas> in the fictional history, just like Fortran this was invented with the source on fixed-width punch cards, but these days the sources are ordinary unix ascii text files. unix text files complicate the matter because now you can use tab characters.
10:12:21 <wib_jonas> in the wimpmode, a linefeed or carriage return resets the column to 0, a printable character or space advances the column by 1, and a tab jumps the column to the first tab stop that is strictly after the current column.
10:12:30 <wib_jonas> the programmer can define tab stops as a list of column positions and a mark for where the distances start to repeat periodically after the last explicitly marked tab stop column.
10:12:35 <wib_jonas> in normal mode, the columns are notionally determined by reading the file backwards: a linefeed or carriage return resets the column to -1, a printable character or space advances the column by -1,
10:12:39 <wib_jonas> a tab jumps to the column with the first tab stop that is strictly before the current column. the tab stops repeat infinitely with periodical distances to the left instead of to the right.
10:12:42 <wib_jonas> only the columns are determined backwards, finding the tokens and syntax still goes forward as usual, you just assign column numbers to those tokens backwards.
10:12:45 <wib_jonas> while there are editors that handle the variable tab stops for wimpmode, I don't think there's any editor or even viewer that handles the normal mode.
10:12:50 <wib_jonas> I just checked Winword, because it has customizable tab stops. but when I try to put tabs into a right-aligned line, the position of the text becomes weird, I don't understand what the rule is, it's not just aligned to tab stops in any way.
10:12:54 <wib_jonas> this is even better news than I was hoping for: I thought maybe Winword handles normal mode fine, maybe it can align to tab stops but not the correct tab stops (eg. starts from the left instead of from the right).
10:12:57 <wib_jonas> I can write an example program in normal mode, and not only will you not be able to edit it properly, you won't even be able to view it without a specialized program.
10:14:16 <wib_jonas> that said, there might be other software out there that does handle the tab stop rules for normal mode and I'm just not aware of.
10:15:42 <wib_jonas> I have some parts of the language figured out, but not all. I'm especially unsure about the control flow, though I do have an idea.
10:17:09 <wib_jonas> oh, also for mutli-character tokens, the column of the token is the column of its first character in wimpmode but the column of its last character in normal mode so that you can usefully access the columns close to the right edge
10:55:46 -!- tromp has quit (Quit: My iMac has gone to sleep. ZZZzzz…).
11:21:26 -!- tromp has joined.
11:32:25 -!- tromp has quit (Quit: My iMac has gone to sleep. ZZZzzz…).
11:51:34 <strerror> Right aligned, sounds like it could be from a history where the punch cards are invented by arabs
11:52:30 -!- wib_jonas has quit (Ping timeout: 240 seconds).
11:53:20 -!- wib_jonas has joined.
11:54:31 <wib_jonas> strerror: no, if it's just a language that you write from right to left then you'd have the characters in the text file from right to left. that's just a mirroring of left to right text files and doesn't cause any complications. the trick here is that the characters are still listed in the source file left to write, but the columns are numbered
11:54:31 <wib_jonas> from right to left, and the lines can have variable lengths, so you don't know the column numbers until you read a whole line.
11:58:36 <wib_jonas> If you ignore the column dependence and tabs in the middle of a line, I think back aligned lines could actually be useful (in a semi-esoteric way) to write programs this way in a programming language built around that.
11:58:39 <wib_jonas> You'd use a language that is written in kind of reverse polish notation, as in arguments first then function name in a function call, or rvalue first then the lvalue in an assignment. You're typing it from left to right, since this is more natural when you're nesting lots of function calls, such as an APL-like.
11:58:40 <wib_jonas> You write a value, then you transform it with a function. But the code would be displayed on screen right-aligned, so that the top-level function call or the variable that you are assigning to is near the right of the screen, and you can easily scan the code for where a local variable is assigned.
11:59:17 <wib_jonas> You can still have indentation, which means tabs or spaces at the end of lines indicating blocks, shifting the right edge of the lines a bit to the left from the right margin of the paper.
12:00:40 <wib_jonas> But there the right-aligned presentation doesn't change the semantics, you just display the code that way to make it easier for the programmer to understand.
12:01:03 <wib_jonas> Whereas in the column-oriented language the right-aligned actually matters for the semantics.
12:01:52 <wib_jonas> For just right-aligned presentation you could write the code in Wordpad or any other formatted text editor, or run statements interactively in a HTML-based worksheet, you'd just set the textareas and other text right-aligned.
12:02:24 <wib_jonas> And that does still work for column-oriented just as long as you don't use tabs.
12:02:46 <wib_jonas> So for maximal esoteric, I want to use tabs in the source code.
12:03:18 <wib_jonas> Well, not maximal esoteric, there are subjective aesthetic considerations for what kind of esoteric I want.
12:03:44 <wib_jonas> I have some rather specific ideas about the notation, I can tell about them if someone is curious.
12:05:13 <strerror> I was imagining an alternate wimpmode (reverse each line?) which could be handled by an RTL text editor, but perhaps not.
12:06:12 <strerror> Column oriented also makes me think of network sequence diagrams
12:09:18 <wib_jonas> you could kind of write the code in wimpmode in a normal text editor, then try to reverse every line to get normal mode. this doesn't quite work, because you have to reverse again each token, and in some rare cases that could break the program because what should be two separate tokens runs together into one token that you should have separated
12:09:18 <wib_jonas> with a space. in particular, this would happen if you have a minus sign right after a numeric literal, because when you reverse the tokens they'll merge into a numeric literal with negative instead of a subtraction. but if you pay attention to rare cases like that, this can be an easy way to write a normal mode program.
12:10:37 <wib_jonas> (minus isn't actually a subtraction, but it has a normal function and I want to overload it to negative sign when it's before a digit)
12:16:28 <wib_jonas> I'm planning one special syntax that really breaks when you reverse the lines, but you can still write programs reversed if you are deliberately planning the program to only work with lines reversed and not in wimpmode.
12:19:32 <wib_jonas> Namely although almost every other token refers to at most a single column, I'm planning to handle C-like block scoped variables with a brace block that makes every column to the left (right in wimpmode) of the braces local (refer to new local variable names unrelated to those outside the braces; but columns to the right (left in wimpmode) of the
12:19:33 <wib_jonas> braces are not localized, they refer to the same variable names as in the surrounding scope.
12:20:31 <wib_jonas> you have a bigger problem with reversing every line even without the braces
12:20:57 <wib_jonas> I was wrong above, you can't just reverse a wimpmode program to get a normal progra
12:21:40 <wib_jonas> The trick is that function calls and other constructs are executed in the order they appear in the source, so if there are two function calls in the same line they'll run in the opposite order if you reverse the lines
12:22:17 <esolangs> [[BitChanger Busy beaver/Proof]] https://esolangs.org/w/index.php?diff=156085&oldid=155961 * C++DSUCKER * (+0)
12:22:21 <wib_jonas> this isn't a problem if you write every call into a separate line, and though you certainly can do that, it can result in sparser code
12:24:11 <wib_jonas> nor is it a problem if the two calls commute and don't access the same variable. but you will very often want to pass a value from one function to the other in the same line, which breaks, and even without that if both functions have side effects that can be a problem
12:25:32 <wib_jonas> as for the braces, I'll probably have to define them so that you can use either the left-facing or right-facing localization in either wimpmode or normal mode, it's just that localizing variables on the left (right in wimpmode) is more natural style.
12:27:27 <wib_jonas> but the braces really don't work well if you mirror when there's a reference to a variable in the same line as the brace, because a reference in an earlier token (to the left) from the opening brace is never localized, while a reference after it would be localized by right-localization; similarly a reference in the same line as a closing brace but
12:27:27 <wib_jonas> after (to the right) of it is never local, but int he same line before the closing brace would be local for left-localization
12:29:11 <wib_jonas> but still, if you are planning from the start to reverse the program, you could write it reversed in a normal text editor, it just wouldn't work in wimpmode
12:29:30 <wib_jonas> alternately you can write a normal mode program in a right-aligned text editor but without tabs, and then later unexpand the tabs
12:30:36 <esolangs> [[Talk:Onechar]] https://esolangs.org/w/index.php?diff=156086&oldid=155832 * Cycwin * (+170) So my English is really not good....
12:31:50 <wib_jonas> though of course for style you might not want to unexpand *all* spaces to tabs, sometimes you'd use a tab to delimit a range of columns that logically form a group, but in other parts of the program a logical group is too wide so it spans across that tab stop so you'd use spaces within it
12:37:56 <wib_jonas> I'll try to explain some of the syntax. Every token in the source code is either an opcode or an accent. An operation is made from an opcode and zero or more accents attached to it. The opcode is typically the name of a function, but there are other opcodes for eg. defining a function or control flow or the above mentioned braces for localization.
12:38:55 <esolangs> [[Talk:BF busy beaver]] N https://esolangs.org/w/index.php?oldid=156087 * C++DSUCKER * (+189) Created page with "I though the definition of a busy beaver 'takes the most steps' not 'takes the most specific steps? ~~~~"
12:40:01 <wib_jonas> The simplest accents are the backtick and the apostrophe. The backtick ` is attached to the first opcode following it (which may or may not be in the same line), and denotes an input operand for that operation. Imagine it as a little L-shaped pipe that captures the variable from the column above and directs it to the opcode to its right (though it
12:40:02 <wib_jonas> may actually be to its left in a later line, in which case the graphical metaphor breaks). Similarly an apostrophe ' is attached to the last opcode preceding it (which may or may not be in the same line), and denotes an input operand for that operation.
12:40:33 <wib_jonas> A comma is attached to the first opcode after it and denotes an output operand, while a dot is attached to the last opcode before it and denotes an output operand.
12:41:55 <wib_jonas> Now an operation may have one additional input operand besides those that it gets from accents, namely the one in the column of the opcode itself, which is the last (first in wimpmode) column of that opcode token. Similarly it may have one additional output operand besides those it gets from accents, the column of the opcode itself.
12:43:24 <esolangs> [[]] N https://esolangs.org/w/index.php?oldid=156088 * PrySigneToFry * (+2979) Created page with " is a programming language designed by PSTF, inspired from [[SLet (Old 3)|SLet 3]]. ==Data types== In this esolang, there is 5 data types. : Fraction/Float. Size is unlimited. Division by 0 is NaN. : or . Pair: A pair of objects. One former value and one latter valu
12:44:13 <wib_jonas> Whether the extra input operand or output operand is actually present is determined from the number of input operands and output operands that the opcode expects. Opcodes can be overloaded with the same name and multiple different number of operands, but if two opcodes with the same name have input operand counts that differ by at most one and
12:44:13 <wib_jonas> output operand count that differs by at most one that's an error.
12:44:18 <esolangs> [[]] https://esolangs.org/w/index.php?diff=156089&oldid=156088 * PrySigneToFry * (+5)
12:45:00 <wib_jonas> So you can define a function with 1 input and 1 output, another with 3 inputs and 1 output, another with 6 inputs and 1 output, and another with 2 inputs and 3 outputs, all four with the same name.
12:45:05 <esolangs> [[Language list]] https://esolangs.org/w/index.php?diff=156090&oldid=156081 * PrySigneToFry * (+13)
12:46:36 <wib_jonas> For functions, the input operands and output operands just mean the obvious thing, an input operand loads the variable from a column and passes it as argument to the function, while an output operand gets a return value from the function and stores it to the local variable in the column of that operand. For special opcodes that aren't functions,
12:46:36 <wib_jonas> the meanings can be different from this, but the syntax of how the operands are determined is the same.
12:46:49 -!- tromp has joined.
12:48:11 <esolangs> [[BF busy beaver]] https://esolangs.org/w/index.php?diff=156091&oldid=140520 * PrySigneToFry * (+190)
12:49:27 <wib_jonas> In particular, according to the current plans, the opcode foo& starts the definition of a function named foo with an even number of input arguments, and the output operands of that foo& opcode are variables where those arguments will be stored in the function. Similarly foo% starts the definition of a function named foo with an odd number of input
12:49:27 <wib_jonas> arguments. There must be two separate sigils or else it would be ambiguous if the opcode uses its own column as one of the output operands (i.e. a local variable to store one more argument).
12:50:30 <wib_jonas> Now there are more accents than the four I mentioned above. Three will definitely make the cut, I'm still thinking about the rest. The tilde ~ is similar to the backtick in that it is an input operand for the following opcode, and the caret ^ is similar to the apostrophe in that it's an input operand for the preceding opcode.
12:51:58 <wib_jonas> How these differ is that the order of operands matter, and these let you put the operands in different order. In particular, the order of the input operands is: first the carets from last to first, then the backticks from first to last, then optionally the opcode itself, then apostrophes from first to last, then tildes from last to first.
12:52:39 <wib_jonas> If you don't care about how long your code is then backtick and apostrophe are enough: just put each accent in a separate line and then they'll be used as operands in that order. But the caret and tilde lets you write more compact code.
12:54:58 <wib_jonas> The seventh accent is the minus - which is both an output operand for the previous opcode and an input operand for the next opcode. The column of the minus doesn't matter, in that this doesn't refer to a variable, instead if connects an output directly to an input. But the source code order that the minus accent appears before or after other tokens
12:54:59 <wib_jonas> still matters to determine the order of operands to both opcodes.
12:55:10 <esolangs> [[Talk:Loop preventing brainfuck]] https://esolangs.org/w/index.php?diff=156092&oldid=152530 * C++DSUCKER * (+43)
12:55:19 <esolangs> [[Talk:Loop preventing brainfuck]] https://esolangs.org/w/index.php?diff=156093&oldid=156092 * C++DSUCKER * (+90)
12:55:44 <wib_jonas> There may be other accents, like one that's both input or output, or the same variable as input twice, but I don't know yet if I want to have those, probably no.
12:58:07 <wib_jonas> Also the graphics metaphor breaks in that if you have a backtick above a dot with no opcodes between, the dot that normally passes its value down will pass its value up to the top of the backtick, because they're the same variable name and the previous function that outputs on the dot will be executed before the next function that inputs from the
12:58:54 <wib_jonas> The minus is overloaded to make a negative numeric literal, which is unambiguous because a numeric literal doesn't take input operands.
13:02:21 <wib_jonas> Also I'm planning to have a well-defined C ABI. So you can define a function in C, declare it in the column-operated language and call it from there; or define a function in the column-operated language, declare it in C and call it from there. You can just link compilation units from the column-operated language to compilation units from other
13:02:21 <wib_jonas> languages that can handle the C ABI general enough, eg. C, C++, Rust, Zig, Haskell, whatever.
13:03:01 <esolangs> [[]] N https://esolangs.org/w/index.php?oldid=156094 * PrySigneToFry * (+2059) Created page with "{{WIP}} is a semi-serious Esolang designed by [[User:PrySigneToFry]] to against [[WaifuScript]], and also called "ljb u da snra" or "Xiyouchangchu". = Commands = Anything in square brackets is placeholder. so "uwu a" is correct but "uwu [a]" isnt. so the correct label
13:03:56 <wib_jonas> There'll be a mangling scheme that maps the name, number of input operands, and number of output operands into a C identifier. And presumably I'll make a helper where if you declare or define a function in the column-operated language, it can output you some C function signatures that you can put in your C program, with the correct C name and
13:04:02 <esolangs> [[Semi-serious language list]] https://esolangs.org/w/index.php?diff=156095&oldid=155016 * PrySigneToFry * (+19)
13:04:43 <wib_jonas> I'm planning to write all functions of the standard library in portable C, and make the reference compiler compile to portable C. There'll of course be non-function operations that aren't implemented in C but are built into the compiler.
13:08:01 <wib_jonas> Also every data type in the column-operated language corresponds straightforwardly to a type in C. You can easily define a new type using this. For each type, there's a function in the column-operated language that just copies a value of that type from its one input argument to its out output argument. This looks like a normal function in the
13:08:01 <wib_jonas> column-operated language (you could implement a new one with the same behavior), but for simplicity it doesn't correspond to a C function, it's just inlined into the compiled code all the time since it's a simple value copy.
13:09:50 <wib_jonas> I'll have at least a fixed-size integer type and an array type in the standard library, but the core language and compiler barely has to know about these, they'll just be implemented as ordinary user-defined type, with the exception that there'll be some built-in syntax for numeric literals and string literals.
13:27:55 -!- wib_jonas has quit (Quit: Client closed).
13:30:30 -!- ais523 has joined.
13:43:32 <esolangs> [[Loop preventing brainfuck]] https://esolangs.org/w/index.php?diff=156096&oldid=156015 * C++DSUCKER * (+131)
13:45:03 -!- wib_jonas has joined.
13:48:57 <wib_jonas> So here's roughly how the compilation notionally works. For every character in the source code, we determine its column number in the above mentioned way. This needs to know whether the source file is in wimpmode and the infinite descending (ascending in wimpmode) sequence of user-defined tab stop column numbers, and which characters in the input
13:50:56 <wib_jonas> (Non-ascii bytes and certain control characters set the column number to undefined -- these are allowed to appear in comments or string literals so we don't just forbid them, but we don't define how they affect the column number so that a later unicode extension could define the widths. If we later find that we need the column number of a character
13:50:57 <wib_jonas> whose column number is undefined, that's a compile error.)
13:53:31 <wib_jonas> Independently of the columns, we tokenize the source code, determining which non-overlapping infixes are tokens (the rest of characters are mostly whitespace or comments). From just the syntax of the characters in each token we determine what kind of tokens they are (eg. which accent, built-in opcode eg. for control flow, function call opcode,
13:53:31 <wib_jonas> function definition/declaration heading opcode, type declaration opcode, etc).
13:54:15 <wib_jonas> For each token we save its column number too, which is just the column number of its last (first in wimpmode) character.
13:54:57 <wib_jonas> We match accents to opcodes, determining the list of input accents and list of output accents for each opcode.
13:59:41 <esolangs> [[Selter]] M https://esolangs.org/w/index.php?diff=156097&oldid=156084 * TheSpiderNinjas * (+26) added smth i forgor what lol
13:59:41 <wib_jonas> Now here's the tricky multi-pass part. Find every function definition/declaration opening and closing operation, match them. The sigil of the opening opcode tells the parity of the input argument count, and the number of output accents to the opening operation tells the approximate input argument count, from these two you get the exact input
13:59:42 <wib_jonas> argument count. Similarly the sigil of the closing opcode tells the parity of the output argument count, and the number of input arguments in that closing operation tells the approximate output argument count, from these two you get the exact output argument count. also from the opening opcode you get the name of the function.
14:01:37 <wib_jonas> Now find each function call operation. The opcode tells the function name, the input accents give the approximate input argument count, and similarly the output accents give the approximate output argument count. Recall all functions defined with this name, and find the overload that has the matching number of input and output operands.
14:04:14 -!- amadaluzia has joined.
14:06:46 <wib_jonas> Now for each function call operation, since you know the number of input and output accents and the number of input and output arguments needed, so you add the column of the opcode as an extra input argument and/or output operand if that's required to match. Similarly for other built-in opcodes you determine if you need the opcode column as extra
14:06:47 <wib_jonas> operand, only there the arities don't count from declarations/definitions but from built-in language rules.
14:07:12 <wib_jonas> Now the following part is provisional and may change because I'm not sure yet if it works.
14:08:45 <wib_jonas> For every token whose column matters, we determine the corresponding variable name from the column and from scope brace-like operations that make some columns lexically local in a range of the code.
14:14:12 <wib_jonas> For every token where the column matters you also determine if it uses that column as value input and/or value output and/or something else. For these tokens and the braces you also determine the variable names. You also determine all possible control flow based based on functions/conditional/loop/branch operations. Now here comes the hard part.
14:14:12 <wib_jonas> You put together the input/output references and variable names and control flow to determine the data flow, that is, which output operand can send data to which input operand.
14:14:15 -!- amadaluzia has quit (Ping timeout: 276 seconds).
14:15:24 <esolangs> [[NameError without a quine with a quine without a quine]] M https://esolangs.org/w/index.php?diff=156098&oldid=137475 * JHSHernandez-ZBH * (+112)
14:15:42 <wib_jonas> This is hard because each variable name can correspond to different actual variables if the data flow isn't connected. Eg. in a sane language if you have `x=B(); C(x); x=D(); E(x);` then the first two instances of x are a different variable from the last two.
14:19:27 <wib_jonas> You also use the function calls, which at this point are resolved to overloads, to determine which variables can be used as which input argument and/or output argument of which function. From these possible data flows you can do global type inference. This simply groups the variables into equivalence classes that must have the same type. In
14:19:28 <wib_jonas> addition, the copy opcode for any type is known to have that type as both its input and output operand. We also know the argument types of a few other built-in operations eg. numeric literals and string literals.
14:20:31 <wib_jonas> This is all we need to determine the types of every variable.
14:21:51 -!- amadaluzia has joined.
14:25:08 <wib_jonas> Function declarations have a syntax that look basically the same as a function definition with different sigils (and possibly some restrictions), but the body of the definition is used only for typechecking. Usually in the body you just put a copy opcode for every input and output argument to set the type of each argument. This is not strictly
14:25:08 <wib_jonas> necessary, you can have the argument types inferred from elsewhere in the same compilation unit. But if you do that then you may get an ambiguity where a type of an argument of an extern function is unknown, and that's an error because then we don't know the C ABI of calls, unless there are no calls to this function from this compilation unit.
14:27:38 <wib_jonas> You can ask the compiler to do the typechecking and emit column-operated language declarations for each function -- you can use these in a different column-operated compilation unit so you can call the function, or edit them to a definition in a different compilation unit to define the function that is called here.
14:28:06 <esolangs> [[Talk:BF busy beaver]] https://esolangs.org/w/index.php?diff=156099&oldid=156087 * Corbin * (+423)
14:28:49 <wib_jonas> Or you can ask the compiler to do the typechecking and emit C declarations for each function. You can edit this to an include file to call or define the functions from a C compilation units, or use them in more complicated ways for other languages that can handle the C ABI.
14:30:18 <esolangs> [[Nope. with no quine]] https://esolangs.org/w/index.php?diff=156100&oldid=151702 * PrySigneToFry * (+21)
14:30:33 <wib_jonas> This is somewhat similar to statically typed languages like Haskell, except that the language is imperative so we have assignments to variables instead of let/case statements, and also the type system is much simpler than what Haskell has, there are no parametrized types or traits or polymorphism etc.
14:31:48 <wib_jonas> Only I'm not entirely sure that you can add a reasonable set of control flow built-ins and get something expressive enough. It's possible that the type system is too rigid and you need something slightly more complicated to be able to express some real-world programs conveniently.
14:36:30 <wib_jonas> Oh yeah, it's possible that some built-in control flow opcodes takes a number as boolean input operand, if so then they also have a known argument type.
14:37:25 -!- amby has joined.
14:44:07 <esolangs> [[Forte]] M https://esolangs.org/w/index.php?diff=156101&oldid=95424 * JHSHernandez-ZBH * (-28)
14:50:48 -!- Sgeo has joined.
15:05:59 <ais523> hmm, Rust macros-by-example are an esolang I think
15:06:29 <ais523> and also appear to be TC (you can implement StackFlow in them pretty much directly via using a macro that expands into a call to itself with different arguments)
15:08:54 <ais523> they're really unintuitive because you can't expand a macro while a macro is running – all you can do is produce a macro call in the output
15:10:15 <wib_jonas> wait, why StackFlow? how is that easier than a general multi-stack machine with arbitrary finite state control, the control encoded such that every state corresponds to a macro?
15:10:37 <ais523> it probably isn't, I just picked the first language that came to mind as trivially implementable
15:12:15 <wib_jonas> also you might run into the macro expansion recursion limit very quickly. you can change that limit, but I don't know if you can change it to high enough.
15:14:07 <ais523> I don't think this hits a recursion limit at all, it's all tail calls – there might be a separate tail-call limit though
15:14:28 <ais523> I'm not convinced macro recursion even exists in Rust
15:14:41 <ais523> the macro syntax looks like you can call a macro from another macro but you actually can't
15:14:49 <wib_jonas> heck, I think you can even implement a multi-register machine that can cons, empty list, and uncons, with a finite state control. It doesn't have to be just stacks. That can be more practical.
15:14:54 <ais523> what you can do is generate output that contains a macro call, and then that gets hit when re-parsing the output
15:15:11 -!- tromp has quit (Quit: My iMac has gone to sleep. ZZZzzz…).
15:18:20 <wib_jonas> that reminds me, I was thinking recently that if you are writing a C++ compiler and the code can contain arbitrarily complicated C preprocessor constructs then it is very hard to make the error messages comprehensible. the error message may have to refer to locations in the code, but to uniquely identify a location in the preprocessed source code
15:18:20 <wib_jonas> you may have to name a complex path in the macro expansion tree, with locations of macro calls, locations of a parameter in the macro definition, locations in the arguments in the macro call.
15:19:01 <wib_jonas> also locations of include directives, and each include file may be included multiple times.
15:19:29 <wib_jonas> so you may have to give any number of locations in the non-preprocessed source code.
15:19:56 <ais523> Rust macros deal with this via attaching an "original location" to every token and having macros copy it around
15:20:01 <ais523> it's not an ideal system but can be abused in interesting ways
15:20:40 <ais523> especially with procedural macros, which let you copy the location from one token to another
15:21:07 <ais523> the current best way to produce an error in a procedural macro is to copy the location in the source onto a call to the compile_error! macro that you generate in the output
15:21:34 <ais523> so that the compiler thinks that the compile_error! was written literally in the source code at that point, and thus highlights the location in question when producing the error
15:21:51 <ais523> I'm not sure whether or not this was originally an intended way to do things, but it's useful enough that it's likely to stay at this point even if it was originally ab ug
15:23:40 <ais523> or, well, not a bug, more like emergent behaviour
15:26:01 <wib_jonas> also in traditional C++, user-defined types could almost be identified by a path through namespaces and functions and type names, function argument types, and template arguments, where each template argument can itself be a path. this was *almost* enough to uniquely identify a type, without mentioning source locations, which is useful for name
15:26:02 <wib_jonas> mangling. the only exception was anonymous namespaces. but now C++ has polymorphic lambdas, which are unnamed, so an error message may actually have to name a location in the preprocessed source to be completely unambiguous.
15:26:42 <wib_jonas> of course it could just give the index of the preprocessed token within the preprocessed source code, but that's hard for the programmer to interpret.
15:27:00 <ais523> all the Rust macro-writing I've been doing recently has lead me to treasure anonymous things
15:27:17 <ais523> because you can't name things without potential name collisions in the surrounding code, and there isn't any sort of gensym
15:27:38 <ais523> so you want to put code in anonymous things as much as possible, otherwise you have to ask the user for a name and it can look out of place
15:27:53 <ais523> trait implementations are anonymous, those are a good place to put your code
15:29:31 <wib_jonas> I'm actually parsing csv files using anonymous types: my parser library automatically creates a row type for every table. But this is in Python where handling anonymous types is much easier, the types are just first-class values.
15:30:15 <wib_jonas> Well I'm not *parsing* the files using them, I'm parsing the files into them and using the parsed data in the rest of the code using those anonymous types, and the same thing backwards for creating and writing a table to a file.
15:31:54 -!- lynndotpy6 has quit (Quit: bye bye).
15:32:14 <wib_jonas> As for Rust macros and anonymous things, I don't yet understand how names work in rust macros, I may or may not have to depending on what kind of macros I want to write in the future. Mostly I want to avoid macros where reasonable, but there are a few places where they're really useful.
15:33:06 -!- lynndotpy6 has joined.
15:34:26 <korvo> ais523: I don't want to sound like a nefarious mystic, but I'm glad to hear that somebody else is seeing the folly of names.
15:36:20 <wib_jonas> Um, that's for which thing, the rust macros, the C++ error messages with source locations, or for column-oriented programming where each variable name is a column number in a scope in a source file?
15:36:48 <ais523> wib_jonas: what are you referring to with "that" in your previous comment?
15:36:59 <ais523> this conversation is confusing enough as it is :-)
15:37:48 <ais523> I do think your right-justified tabs are an interesting concept, I'm vaguely surprised I haven't seen it before
15:38:23 <ais523> it is simultaneously intuitive and difficult to explain
15:38:25 <wib_jonas> does anyone use Corel WordPerfect these days? I wonder if it supports right-aligned tabs, but I'm not going to buy a license just to find out
15:38:54 <ais523> I have used it in the past, but it was a very long time ago and I doubt any of the computers with legitimate copies are still functioning
15:39:13 <ais523> I vaguely remember that it's popular among lawyers (something about Microsoft Word not counting words correctly, which is very important for lawyers)
15:39:25 <wib_jonas> on the opposite side, can anyone explain to me how the heck Winword positions the text in right-aligned lines in text, even in the simple special case when the paragraph fits in one line and all tab stops are right-aligned?
15:39:34 -!- tromp has joined.
15:39:39 <ais523> when I submitted my PhD, I was asked the word count, and I gave three different word counts depending on how you defined it
15:39:48 <ais523> (the highest included things like words that appeared in diagrams)
15:40:23 <ais523> wib_jonas: I don't have a Word license, but my guess is that it lays out the text left-aligned and then moves it right by the distance between the rightmost end of the text and the right margin
15:41:07 <ais523> hmm, now I'm wondering how browsers handle tabs in right-aligned text
15:41:51 <wib_jonas> I think for my MsC-equivalent thesis this was backwards: the guidelines said that the thesis should be at least this many number of pages in this font size with this line spacing.
15:44:20 <ais523> Chromium appears to use the "layout left-aligned then shift right" algorithm: data:text/html,<html><body><pre style="text-align:right">Hello,&%239;,&%239;world!&%2310;Hello,&%239;,&%239;world!!
15:44:39 <ais523> (it took me an annoyingly long time to work out how to type a tab in a data: URI)
15:47:00 <wib_jonas> yeah, I think you're right. I would never have guessed that as the rule.
15:47:25 <ais523> isn't it fairly natural for a rule that comes up if you aren't thinking about the case at all?
15:47:45 <ais523> FWIW, Firefox does the same thing too
15:48:29 <ais523> in general I am quite upset about typical handling of tabs
15:49:36 <ais523> especially the way people reused the tab character for indentation even though its traditional meaning is too wide – I would be fine with a different character for indentation tab, but a tabulation tab is much too wide to be usable for indentation
15:49:55 <wib_jonas> example image of Winword with tabs: https://i.sstatic.net/XWkhvo4c.png
15:50:28 <ais523> so editors have to choose between interpreting tabs as indentation (common in programming editors nowadays), interpreting tabs as tabulation (which was tradtional), interpreting tabs as elastic tabs (which works really well but nobody implements), and implementing a somewhat awkward tab width of 8 which is too wide for indentation and too narrow for tabulation
15:51:01 <wib_jonas> I think the traditional meaning is that you put user-defined tabs to any column you want by moving these little metal clips on a rail on the expensive typewriter
15:51:20 <ais523> yep, traditionally tabstops were settable
15:52:00 <ais523> although, one of the first systems I learned to program on (and the first where I was aware of what a tab even was) had 14-character tabstops, I don't know whether they were changeable or not but it was 14 by default
15:52:35 <ais523> elastic tabstops make the tabs the minimum width that causes them to line up correctly, so they expand to the data when being used for tabulation
15:53:03 <ais523> (and for indentation any width will do, so you can make them configurable there)
15:53:20 <wib_jonas> ok, admittedly that example image is a little unclear because the first and third column has close to the same length
15:55:29 <wib_jonas> here's a clearer example: https://i.sstatic.net/FyO3Ss3V.png
15:56:02 <ais523> I use TSV sometimes as an equivalent to CSV (it's basically CSV but you replace the commas with tabs, and generally deal only with data for which you don't need a quoting or escape syntax)
15:56:22 <wib_jonas> the csvs that I'm working with are actually tab-separated
15:56:30 <wib_jonas> the c doesn't stand for comma or colon anywhere
15:56:35 <ais523> it is so much better than CSV – if you have wide enough tab stops (or elastic tabs) it lines up neatly in your editor or pager, and it's much simpler to parse due to not needing to escape commas
15:56:53 <ais523> oh, I don't call it CSV unless it uses comma as a column separator and double-quotes strings that contain commas
15:57:26 <ais523> (and then you need a further escape syntax for strings that contain both double quotes and commas – I think doubling the double quote is most sensible, otherwise you need a third escape character and a way to escape that)
15:58:27 <ais523> hmm, how does CSV that quotes text handle numbers that contain commas?
15:58:36 <ais523> are you supposed to just not use it in mainland Europe?
15:59:17 <ais523> …or separate the columns with periods, I guess
15:59:32 <wib_jonas> numbers could be quoted just fine, but I haven't seen actually comma-separated csvs for a while, only tab, semicolon, or colon separated
16:00:06 <ais523> well, if you're quoting even with tab separators, the quoting presumably has a purpose other than escaping commas
16:00:14 <ais523> and I think it might be to distinguish numbers from text
16:00:20 <ais523> otherwise you're just quoting things for no reason
16:00:40 <wib_jonas> including semicolon-separated ones written by a stupid program that doesn't bother to escape newlines in any way so the csv is ambiguous
16:01:11 <ais523> I feel like if your data contains raw newlines inside the fields, CSV is probably an inappropriate format anyway
16:01:36 <wib_jonas> but most of them are just tab separated, values can be surrounded by a double-quote in which case a double-quote is represented by two double-quotes and a tab or newline is literal; if a value isn't surrounded by double quotes then it mustn't contain double quotes or tabs or newlines.
16:02:27 <wib_jonas> also most of them are in utf-16-le, but I have a few utf-8 ones as well
16:02:49 <wib_jonas> yes, I'm using csv for compatibility with multiple other programs, not because I like it as a format
16:02:53 <ais523> does Windows still use UTF-16 by default?
16:03:00 <ais523> or, well, "still" is a bit of a weird term
16:03:38 <ais523> it just provides a bunch of APIs and leaves it up to the developer to navigate them
16:04:06 <ais523> I think, for a long time, the choice was between UTF-16 or a locale-specific 8-bit codepage
16:04:22 <ais523> and more recently UTF-8 was added but I'm not sure how it integrates or even which set of APIs it uses
16:04:32 <ais523> I'm leaning towards thinking that it uses the 8-bit APIs? but I'm not sure
16:04:48 <wib_jonas> Excel can read tab-separated csv in just about any encoding, or it can save as tab-separated csv in either utf-16-le or locale-dependent encoding, but the locale-dependent can't represent every character so that's usually not a good idea. The other program I work with reads and writes only utf-16-le encoded tab-separated csv.
16:05:25 <wib_jonas> yes, exactly, utf-16-le is supported in the most cases, so that's the default in some sense
16:05:57 -!- wib_jonas has quit (Quit: Client closed).
16:06:15 -!- ais523 has quit (Quit: quit).
16:15:32 <esolangs> [[Unvague]] https://esolangs.org/w/index.php?diff=156102&oldid=156055 * Stkptr * (+80) I think I get the joke, but it should still have categories
16:17:44 <esolangs> [[idioma]] N https://esolangs.org/w/index.php?oldid=156103 * Imakesi * (+3013) Created page with "'''idioma''' is a Brainfuck clone in which every command is a different language. The name for it is taken from the 2 most popular languages by population, Mandarin Chinese, and Spanish. is programming, and idioma is language. In idioma, every line is a different comma
16:18:24 <esolangs> [[List of ideas]] https://esolangs.org/w/index.php?diff=156104&oldid=155771 * Imakesi * (-52)
16:19:50 <esolangs> [[Joke language list]] https://esolangs.org/w/index.php?diff=156105&oldid=156026 * Imakesi * (+53) /* Brainfuck derivatives */
16:20:45 <esolangs> [[Translated CreativeASM]] https://esolangs.org/w/index.php?diff=156106&oldid=142062 * MihaiEso * (+2)
16:26:32 <esolangs> [[User:Pro465]] https://esolangs.org/w/index.php?diff=156107&oldid=140447 * Pro465 * (-2)
17:14:12 -!- tromp has quit (Quit: My iMac has gone to sleep. ZZZzzz…).
17:37:10 -!- tromp has joined.
17:46:00 <esolangs> [[User:Aadenboy/brainfuck program naming scheme]] https://esolangs.org/w/index.php?diff=156108&oldid=156013 * Aadenboy * (-248) never mind
18:28:40 -!- tromp has quit (Quit: My iMac has gone to sleep. ZZZzzz…).
19:02:20 <esolangs> [[Befunge]] M https://esolangs.org/w/index.php?diff=156109&oldid=156032 * Buckets * (+6)
19:19:24 <esolangs> [[Formal grammar]] https://esolangs.org/w/index.php?diff=156110&oldid=155825 * Stkptr * (+5098) More info
19:29:36 <esolangs> [[Filename "xxx" doesn't seem to be a valid filename. Please check if the filename your trying to execute is written correctly]] https://esolangs.org/w/index.php?diff=156111&oldid=156078 * Ractangle * (+0) trolololo. nope
19:30:29 <esolangs> [[Vague]] https://esolangs.org/w/index.php?diff=156112&oldid=156076 * Ractangle * (-143) was that really nesesary?
19:32:12 <esolangs> [[Special:Log/newusers]] create * Siim * New user account
19:33:00 <esolangs> [[Befunk]] https://esolangs.org/w/index.php?diff=156113&oldid=156077 * Ractangle * (-69) technicaly thats a program. not a command
19:37:24 <esolangs> [[NQ]] N https://esolangs.org/w/index.php?oldid=156114 * K * (+1005) Created page with "{{WIP}} NQ is a queue-based programming language created by User K. It operates on an infinite 1-trit queue and a single flag trit, which initially holds the value 0. Each trit is a trinary digit that can be in one of three states: 0, 1 or 2. Instructions are executed from left
19:40:03 <esolangs> [[Esolang:Introduce yourself]] https://esolangs.org/w/index.php?diff=156115&oldid=155966 * Siim * (+176) /* Introductions */
19:43:34 <esolangs> [[User:Siim]] N https://esolangs.org/w/index.php?oldid=156116 * Siim * (+67) Created page with "== fredqz == I am from Estonia, I have created AksuPaksu and JUICE"
19:44:26 <esolangs> [[Language list]] M https://esolangs.org/w/index.php?diff=156117&oldid=156090 * Buckets * (+12)
19:44:53 <esolangs> [[User:Buckets]] M https://esolangs.org/w/index.php?diff=156118&oldid=156020 * Buckets * (+11)
19:45:02 <esolangs> [[What?]] N https://esolangs.org/w/index.php?oldid=156119 * Buckets * (+722) Created page with "What? is an Esoteric programming language created by [[User:Buckets]] in 2020. {| class="wikitable" |- ! Commands !! Instructions |} Every 0.000001s/Character, It turns the length of the Program then Put it into Octal and put The corresponding Numbers 0-7 into [[brainfuck
19:47:15 <esolangs> [[Language list]] M https://esolangs.org/w/index.php?diff=156120&oldid=156117 * K * (+9) added nq so cool!
19:49:24 <esolangs> [[NQ]] https://esolangs.org/w/index.php?diff=156121&oldid=156114 * K * (+90) Added Categories
19:57:40 <esolangs> [[Brainfuck]] https://esolangs.org/w/index.php?diff=156122&oldid=154877 * Ractangle * (+270) yay trutvh machine works
21:34:38 -!- tromp has joined.
21:56:45 -!- craigo has joined.
22:41:22 -!- visilii_ has quit (Read error: Connection reset by peer).
22:42:12 -!- visilii has joined.
23:06:07 -!- m15k47on1c has joined.
23:10:20 <esolangs> [[Special:Log/upload]] upload * Aadenboy * uploaded "[[File:MCBDigits0-F.png]]"
23:13:59 <esolangs> [[User:Aadenboy/draft2]] N https://esolangs.org/w/index.php?oldid=156124 * Aadenboy * (+357) draft
23:43:02 <esolangs> [[idioma]] https://esolangs.org/w/index.php?diff=156125&oldid=156103 * I am islptng * (+104)
23:51:48 -!- amby has quit (Quit: so long suckers! i rev up my motorcylce and create a huge cloud of smoke. when the cloud dissipates im lying completely dead on the pavement).
23:52:49 -!- m15k47on1c has quit (Remote host closed the connection).
23:53:26 <esolangs> [[User:Aadenboy/draft2]] https://esolangs.org/w/index.php?diff=156126&oldid=156124 * Aadenboy * (+2245) draft
23:55:00 <esolangs> [[]] https://esolangs.org/w/index.php?diff=156127&oldid=156089 * I am islptng * (+27) for combine match 1 29275 match 2 66 all i do put-char latter i all