Return Styles: Pseud0ch, Terminal, Valhalla, NES, Geocities, Blue Moon. Entire thread

Lisp, the sacred language of the now and forever

Name: Anonymous 2015-02-18 8:24

La lingua sacra ed eterna

I can feel the godforce emanating from it.

You will soon have your God and you will construct it with your own hands.

Name: Anonymous 2015-02-20 19:41

>>37
Scheme is just a poorer and less portable version of Common Lisp.

Name: Anonymous 2015-02-20 19:42

>>38
Your sentence is as valid as "C is just a poorer and less portable version of C++"

Name: Anonymous 2015-02-20 19:43

>>39
Nope, C is actually more portable than C++. Though it is poorer, of course.

Name: Anonymous 2015-02-20 19:44

>>40
My point still stands. Think about what you think you know before posting it.

Name: Anonymous 2015-02-20 19:45

Stop arguing for the sake of arguing, fagshits.

Name: Anonymous 2015-02-20 19:52

>>42
Piss off!

Name: Anonymous 2015-02-20 19:57

>>41
My point still stands: Scheme is only a poorer and less portable version of Common Lisp. Certainly its metaprogramming support is not any better. In fact, it's even worse because of only one namespace, because of forced hygiene etc. Thus, writing a correct codewalker in Scheme is no easier than in CL (which is very hard).

There was a similar sentiment expressed in Let Over Lambda, too. You see, even experienced Lispers admit the weaknesses of Lisp metaprogramming, and only you - an obvious newbie to Lisp - are trying to deny it. To no avail except amusing me, of course.

Name: Anonymous 2015-02-20 19:59

>>39
C was created before Sepples, you ignoramus. Scheme on the other hand was created later than CL.

Name: Anonymous 2015-02-20 20:09

>>44
because of only one namespace, because of forced hygiene
To think, features that restrict the semantics of a language make it more difficult to understand programmatically! Oh the irony!
an obvious newbie to Lisp
I wrote an ANSI Lisp compiler in Scheme when I was 12, thanks.
To no avail except amusing me
Actually I'm amusing myself more.

>>45
Yes, that's the entire fucking point of what I was saying, shitfarts.

Name: Anonymous 2015-02-20 20:10

Scheme is such unadulterated shit:

http://stackoverflow.com/questions/25824466/how-do-i-write-anaphoric-macros-in-portable-scheme

How do I write anaphoric macros in portable scheme?
Yes, you can write it in a portable way assuming that R6RS is portable enough for you. (The same cannot be said on R7RS

While a Common Lisper just writes macros and uses them for pleasure, the Scheme faggots spend their time blabbering about some "R6RS", "SRFI" and eventually admit that their shitty language is non-portable and doesn't work.

Name: Anonymous 2015-02-20 20:13

>>46
I still don't see your point. >>38-kun said that Scheme is just a poorer and less portable version of Common Lisp. You've admitted that Scheme was created later than Common Lisp (and thus had all the chances to be a poorer and less portable version of it). You've also admitted that C was created before C++ and thus couldn't possibly be a poorer version of it. So what is your point in >>39? It is a contradiction in itself.

Name: Anonymous 2015-02-20 20:19

>>47
SRFI means Scheme Request for Implementation. A Scheme program written in RnRS Scheme using some SRFIs is portable between Schemes supporting RnRS which implement those SRFIs. This is common knowledge to anyone who has touched the language, and the implementations are numerous.

Common Lisp, however, has about four 30-year-old implementations, each of which contains a buggy, ad-hoc reimplementation of half of Common Lisp.

Name: Anonymous 2015-02-20 20:23

>>49
So they aimed to make a minimalistic, standardized language, but created a trash-heap of loads of different versions with loads of non-portable implementations none of which suppor those standards.

Name: Anonymous 2015-02-20 20:24

>>48
Are you autistic?
>>39:
[>>38] is as valid as [invalid statement]
Get it now? At no point did I mention the fucking time of implementation of anything. For some reason you decided that was a cornerstone of the argument and spent all your time spacking out on it.

Name: Anonymous 2015-02-20 20:28

>>50
So they aimed to make a minimalistic, standardized language
Correct
but created a trash-heap of loads of different versions
They've created 7 revisions of a language specification. That's it.
loads of non-portable implementations
Scheme is portable. Whatever implementations of Scheme you are talking about may not be portable (for your definition of portable -- what is that, by the way?)
none of which suppor those standards.
Each SRFI document has an implementation listed at the end.

Name: Anonymous 2015-02-21 3:42

>>36
I've been reading On Lisp recently
good for you.

Though the abbreviation can’t be passed to apply or funcall.
What? What's the code?
* (defun a (&rest vars) (apply #'+ vars))
A
* (a 1 2 3)
6
* (funcall #'a 1 2 3)
6

whereas if we had tried to define an abbreviationfor quote using a normal macro,
(defmacro q (obj)
‘(quote ,obj))

it would work in isolation,
(eq ’a (q a))
T
but not when nested.

Actually it does work when nested as far as eval in concerned.
* (defmacro q (f) `(quote ,f))
Q
* (q 2)
2
* (q (q 2))
(Q 2)
* (eval (q (q 2)))
2

The book saying it doesn't work because (q (q 2)) evaluates to (q 2) rather than (quote 2). These expression will both evaluate to 2, but as they are, equal thinks they are different. If that's actually a problem, you could try to write q so that it inspects the form inside and replaces all nested q's with quote's, but it would be difficult since not every q in the car position will neccessarily be a call to q. Not every sexp will be evaluated, or evaluated in vanilla lisp. Replacing every q inside in the car position with quote might not always be what you want.

So you can bullshit all you want, but that doesn't change the fact that Lisp is a very bad metaprogramming language and very hard to use correctly. There are all sorts of corner cases that the shitty unannotated text s-exps cannot handle.
I didn't get the first problem. The second example I found silly. The quotes do get weird, though. They get really weird when you nest quasiquotes. But still, I'd rather have the quotes than not have them.

>>44
Thus, writing a correct codewalker in Scheme is no easier than in CL (which is very hard).
Nope, it's easier in scheme than lisp. It's harder in lisp because of all the macros in the standard library. You need to be able to walk them all and they all introduce their own context to the walk.

There was a similar sentiment expressed in Let Over Lambda, too. You see, even experienced Lispers admit the weaknesses of Lisp metaprogramming, and only you - an obvious newbie to Lisp - are trying to deny it.
I believe lisp could do what it does better, but I have yet to find another language that can do what lisp does as well. But you don't need a language to do what lisp does. You can write code that writes code for you. It's just time consuming to design a language and compile it to another. And once it's created, adjusting that language takes effort. In lisp, it's easier.

Name: Anonymous 2015-02-21 3:56

>>47
But that's a terrible thing to do in any LISP. I don't consider it good form.

Name: Alexander Dubček 2015-02-21 4:35

Dubs, the sacred language of the now and forever.

Name: Anonymous 2015-02-21 4:49

>>55
It's been a while since I've checked anything this holy.

Name: Anonymous 2015-02-21 4:54

>>23
How could anybody read this and not hate Lisp?

Name: Anonymous 2015-02-21 8:40

>>52
7 revisions
That's it.

Hahahaha. Scheme is shit. Common Lisp has only two revisions, plus the second one is already fully supported by at least 4 major implementations.

Scheme is portable

Read up on any popular implementation of Scheme, and you'll see that it doesn't implement something from DA STANDARD, whether it be continuations or macros or something else.

>>46
I wrote CLISP back in 1987 when I was ten. So trust me, boy, when I tell you: you're a newbie to Lisp.

Name: Anonymous 2015-02-21 8:46

http://wiki.call-cc.org/man/4/Deviations%20from%20the%20standard

It doesn't even implement R5RS fully, and they're already working on R7RS? Ahahahahaha tell me Scheme is portable.

Name: Anonymous 2015-02-21 8:50

>>57
But I don't read religious literature, therefore I have not read that post. Thus my hate for LITHP is based on different foundations.

Name: Anonymous 2015-02-21 8:55

>>59

s7 Scheme is the BEST LISP

Use it with confidence, mein freunds.

Name: Anonymous 2015-02-21 9:12

>>61
A compiler made by an air travel company? Negro, please.

http://www.trip.ru/cheap-flights/with/s7/s7-tickets?gclid=CIacsofm8sMCFcQCcwod13QAnQ

I believe it is compatible with r5rs and r7rs
I believe
I don't read religious literature, thank you.

Name: Anonymous 2015-02-21 9:37

>>54
That's because you're a pathetic, limited person. Anaphoric macros are one of the most basic displays of Lisp's power, the kind of power which is absent from boring "safe" languages (and from the minds of their adepts).

Common Lisp can teach people to do with their computers things they didn't believe possible. And Scheme? It's just a watered-down strict Haskell. Forced hygine and purity everywhere pleases only low-intelligence law-abiding average Joe types.

Name: Anonymous 2015-02-21 10:18

I don't read religious literature

That's because you're a pathetic, limited person.

Name: Anonymous 2015-02-21 11:13

What the fuck are anaphoric macros used for? Don't say C is crippled because it doesn't have these, write a reduced case for C where its beneficial to have an anaphoric macro then i'll listen.

Name: Anonymous 2015-02-21 11:36

ｄ ｕ ｂ ｓ

Name: Anonymous 2015-02-21 14:46

>>65
behold the power of anaphoric macros
#include "void.h" //gist.github.com/FrozenVoid/87e6ad6212ac9ce496e0#file-void-h"
STDSTART
/* advanced anaphoric macro stolen from LISP wizards

(defmacro aif (test-form then-form &optional else-form)
`(let ((it ,test-form))
(if it ,then-form ,else-form)))

(aif (+ 2 7)
(format nil "~A does not equal NIL." it)
(format nil "~A does equal NIL." it))
;; ? "9 does not equal NIL."
*/
#define aif(expr,action1,action2) ({auto master_programmer_secret_storage_device=expr;/*very advanced and known only to LISP wizards*/;\
if(0!=master_programmer_secret_storage_device/*powerful lambda-calculus mathemathics, you won't understand*/){action1(master_programmer_secret_storage_device,"does not equal NULL.");}else{/*extremely esoteric and arcane secondary path*/action2(master_programmer_secret_storage_device,"does equal NULL.");};/*we don't return nothing, because the secret of master_programmer_secret_storage_device must be kept */;})
aif(2+7,p,p);//p prints arguments to stdout or FILE* see textio.h https://gist.github.com/FrozenVoid/87e6ad6212ac9ce496e0

STDEND

Name: Anonymous 2015-02-21 14:58

>>67
Arguments of aif must not be inside aif : action1(a , b) is hardcoded here

Name: Anonymous 2015-02-21 15:04

minor fix >>68
#include "void.h" //gist.github.com/FrozenVoid/87e6ad6212ac9ce496e0#file-void-h"
STDSTART
/* advanced anaphoric macro stolen from LISP wizards

(defmacro aif (test-form then-form &optional else-form)
`(let ((it ,test-form))
(if it ,then-form ,else-form)))

(aif (+ 2 7)
(format nil "~A does not equal NIL." it)
(format nil "~A does equal NIL." it))
;; ? "9 does not equal NIL."
*/
#define aif(expr,action1,action2) ({auto master_programmer_secret_storage_device=expr;/*very advanced and known only to LISP wizards*/;\
if(0!=master_programmer_secret_storage_device/*powerful lambda-calculus mathemathics, you won't understand*/){action1;}else{/*extremely esoteric and arcane secondary path*/action2;};/*we don't return nothing, because the secret of master_programmer_secret_storage_device must be kept */;})
aif(2+7,p(master_programmer_secret_storage_device,"does not equal NULL."),p(master_programmer_secret_storage_device,"does equal NULL."));//p prints arguments to stdout or FILE* see textio.h https://gist.github.com/FrozenVoid/87e6ad6212ac9ce496e0
aif(0+0+1-2+1,p(master_programmer_secret_storage_device,"does not equal NULL."),p(master_programmer_secret_storage_device,"does equal NULL."));

STDEND

Name: Anonymous 2015-02-21 16:08

>>69
Fix your formatting, bitch.

Name: Anonymous 2015-02-21 16:23

>>70
Perhaps you might be interested in http://astyle.sourceforge.net/ ?

Artistic Style is a source code indenter, formatter, and beautifier for the C, C++, C++/CLI, Objective‑C, C# and Java programming languages.

When indenting source code, we as programmers have a tendency to use both spaces and tab characters to create the wanted indentation. Moreover, some editors by default insert spaces instead of tabs when pressing the tab key, and other editors (Emacs for example) have the ability to "pretty up" lines by automatically setting up the white space before the code on the line, possibly inserting spaces in a code that up to now used only tabs for indentation.

Since the NUMBER of space characters showed on screen for each tab character in the source code changes between editors (unless the user sets up the number to his liking...), one of the standard problems programmers are facing when moving from one editor to another is that code containing both spaces and tabs that was up to now perfectly indented, suddenly becomes a mess to look at when changing to another editor. Even if you as a programmer take care to ONLY use spaces or tabs, looking at other people's source code can still be problematic.

Name: Anonymous 2015-02-21 16:43

>>71
Code should be XML, not text.

Name: Anonymous 2015-02-21 17:05

Frozen in the void*!!

Name: Anonymous 2015-02-21 20:04

>>73
const void*

Name: Anonymous 2015-02-21 21:18

Frozenvoid has returned! /prog/ is complete once again!

Name: Anonymous 2015-02-21 21:44

>>77
checked

Name: Anonymous 2015-02-21 22:09

I claim these dubs for the People's Republic of Checkem.

Name: Anonymous 2015-02-21 23:59

>>72
I fear people might take this seriously.

Name: Anonymous 2015-02-22 1:02

I fear the next incoming dubs.

Name: Anonymous 2015-02-22 1:14

Why don't we just rename this board /dubs/?

Name: Anonymous 2015-02-22 2:13

>>79
Why don't you check my perfect square in the meantime?

Name: Anonymous 2015-02-22 2:19

Why don't we just rename tis board Error: Your IP address is blacklisted?

Name: Anonymous 2015-02-22 2:34

>>82
Why would we?

Name: Anonymous 2015-02-22 3:01

>>82
Never happened to me before.
Been spamming have you?

Name: Anonymous 2015-02-22 3:22

>>82
You could stop posting through Tor.

>>84
It's because he's posting through Tor.

Name: Anonymous 2015-02-22 3:28

I post through a dual-layer VPN purchased with bitcoin.

Name: Anonymous 2015-02-22 3:58

>>75
Actually i've been posting the whole week. I just wanted to show this "Advanced LISP wizardry"(which Paul Graham is fond of) is equivalent to "primitive, text juggling" C preprocessor macro.
The "killer feature" is passing code to the macro to expand somewhere and integrate into the macro. e.g. textreplace(parametername, chunkofcode) you can pass entire programs as ({macroblocks}) in C and even chain them in like 10 levels of macroexpansion. Nobody even thinks these are killer features, they are basic abstractions.
Example:
#define macropgrogram3(arg1,...) ({;arg1+1;})

#define macro3(macroprogram1,macroprogram2,macroprogram3,...) macroprogram1(macroprogram2(macroprogram3(__VA_ARGS__)))
Advanced LISP wizards would claim this macro chain is "function combinator" "lambda calculus" or some kind of academic bullshit which is only available in their LISP/Haskell/academic language.
Also, i see like 90% of TOR exit nodes blocked and this makes it harder to post.

Name: Anonymous 2015-02-22 4:22

>>85
It's more convenient for me to just wait until it switches to a node that isn't banned. Looking for a proxy to chain in front of tor is a huge pain in the ass to do regularly.

>>87
You can do a lot with cpp but it's still easier and more sane to write advanced macros with an actual programming language.

Name: Anonymous 2015-02-22 5:58

>>88
Would you like to demonstrate how elegant LISP is by rewriting this simple program as lisp macros?
#include "void.h" //gist.github.com/FrozenVoid/87e6ad6212ac9ce496e0#file-void-h"

#define add5(x) x+5
#define fv5(...) apply(add5,__VA_ARGS__)
#define add4(x) x+4
#define fv4(...) apply(add4,__VA_ARGS__)
#define add3(x) x+3
#define fv3(...) apply(add3,__VA_ARGS__)
#define add2(x) x+2
#define fv2(...) apply(add2,__VA_ARGS__)
#define add1(x) x+1
#define fv1(...) apply(add1,revargs(__VA_ARGS__))
#define fv0(dist1,len2,...) "fv1 result:", __VA_ARGS__,"\n ",len2 ,"numbers in reverse order starting from ",dist1,"th to last from fv1 were:\n",sliceargs(dist1,len2,revargs(__VA_ARGS__))," and their product minus their sum:",opapply(-,original,opapply( * ,original,sliceargs(dist1,len2,revargs(__VA_ARGS__))),opapply( + ,original,sliceargs(dist1,len2,revargs(__VA_ARGS__))))

STDSTART
p(fv0(2,3,capply(5,fv1,fv2,fv3,fv4,fv5,1,2,3,4,5,6,7))) /* expected:
fv1 result: 22 21 20 19 18 17 16
3 numbers in reverse order starting from 2 th to last from fv1 were:
18 19 20 and their product minus their sum: 6783
*/

STDEND

Name: Anonymous 2015-02-22 6:09

>>87
still using TOR
The NSA owns over half of the exit nodes now you moron, it's completely compromised.

I'd advise moving to a dual-layer VPN, yes it costs money, but ask yourself how much your freedom and privacy is worth?

Name: Anonymous 2015-02-22 6:27

>>90
I'm a poorfag and paying to shitpost through VPN doesn't seem like a great idea anyway. TOR works, is fast and i set it to use obfs3 bridges for added privacy.
i2p is much slower and doesn't have much gateways to the web.

Name: Anonymous 2015-02-22 7:15

>>89
seems too convoluted.

Name: Anonymous 2015-02-22 7:24

>>92
#include "void.h" //gist.github.com/FrozenVoid/87e6ad6212ac9ce496e0#file-void-h"

#define add5(x) x+5
#define fv5(...) apply(add5,__VA_ARGS__)
#define add4(x) x+4
#define fv4(...) apply(add4,__VA_ARGS__)
#define add3(x) x+3
#define fv3(...) apply(add3,__VA_ARGS__)
#define add2(x) x+2
#define fv2(...) apply(add2,__VA_ARGS__)
#define add1(x) x+1
#define fv1(...) apply(add1,revargs(__VA_ARGS__))

#define product(...) opapply(*,original,__VA_ARGS__)
#define sum(...) opapply(+,original,__VA_ARGS__)
#define substracted(...) opapply(-,original,__VA_ARGS__)
#define revsliceargs(slicestart,slicedist,...) sliceargs(slicestart,slicedist,revargs(__VA_ARGS__))

#define fv0(dist1,len2,...) "fv1 result:", __VA_ARGS__,"\n ",len2 ,"numbers in reverse order starting from ",dist1,"th to last from fv1 were:\n",sliceargs(dist1,len2,revargs(__VA_ARGS__))," and their product minus their sum:",substracted(product(revsliceargs(dist1,len2,__VA_ARGS__)), sum(revsliceargs(dist1,len2,revargs(__VA_ARGS__))))

#define numbers genargs(7)
#define genfunc(x) merge(fv,x)
#define functions apply(genfunc,genargs(5))

STDSTART
p(fv0(2,3,fapply(functions,numbers))) /* expected:
fv1 result: 22 21 20 19 18 17 16
3 numbers in reverse order starting from 2 th to last from fv1 were:
18 19 20 and their product minus their sum: 6783
*/

STDEND

Name: Anonymous 2015-02-22 9:18

The truth lisp weenies don't want you to know:

http://conal.net/blog/posts/the-c-language-is-purely-functional

Name: Anonymous 2015-02-22 9:21

Anal Elliott

Name: Anonymous 2015-02-22 9:37

>>94
a cpp expression yields a (pure) value of type C, which is an ADT (abstract data type) that represents imperative programs.
Lame.

Name: Anonymous 2015-02-22 9:40

>>96
Do you call any true statement "lame" or just the true statements that offend you?

Name: Anonymous 2015-02-22 9:43

>>97
I wrote that before reading the comments in which it becomes apparent the author doesn't intend for the article to be taken seriously. You clearly took it seriously, and for that you have my condolences.

Name: Anonymous 2015-02-22 9:45

cpp, the sacred language of the now and forever

Name: Anonymous 2015-02-22 9:49

>>98
I didn't take it serious, but that doesn't change the fact that the C pre-processor really does produce a pure monoidal value that represents an imperative program.

Name: Anonymous 2015-02-22 9:50

>>99
cpp < Dlang variadic templates/template mixins

Name: Anonymous 2015-02-22 9:50

>>101
Still primitive text manipulation => shit. Even worse than Lisp, lisp at least has parentheses.

Name: Anonymous 2015-02-22 9:53

>>100
The words "pure" and C preprocessor shouldn't occur in same sentence. C macros are ugly, unsafe and impossible to debug.

Name: Anonymous 2015-02-22 9:53

>>100
The words "pure" and C preprocessor shouldn't occur in same sentence. C macros are ugly, unsafe and impossible to debug.

Name: Anonymous 2015-02-22 9:58

>>100
I use an ASM preprocessor commonly installed on many systems as /usr/bin/cat. It produces a pure monoidal value that represents an imperative program.

Name: Anonymous 2015-02-22 10:08

>>104
I think you're taking the word "pure" too seriously. My condolences. What it really means is that for same inputs the value will be the same at any moment in time. Since the output of the C preprocessor does not change in time, it is indeed a pure function (with the single caveat that Anal Elliott spoke about).

Now, of course all this is just an amusing fact to poke fun at Haskellists. But it is fact nonetheless. C is a purely functional language no less than Haskell.

Name: Anonymous 2015-02-22 11:57

cpp is the primitive caveman, LISP is the civilized professor.
sometimes the caveman wins in racing competitions, but the professor has a car so he doesn't care how fast cavemen are.

Name: Anonymous 2015-02-22 12:00

>>107
LITHP
civilized

Needs a real type system first.

Name: Anonymous 2015-02-22 12:28

>>106
But it is fact nonetheless. C is a purely functional language
Come on, we've just spent the past few posts establishing that cpp is the pure language and C is not.

Name: Anonymous 2015-02-22 13:39

I don't want to read walls of unformatted macros.
Did he wrote some sort of miniLISP in >>93 ?

Name: Anonymous 2015-02-22 14:13

These trips are for our beloved President Robert Mugabe.

Happy birthday Mr. President!!! May Zimbabwe be blessed by 90 more years of your rule!

Name: Anonymous 2015-02-22 14:27

>>110
Greenspun's tenth rule:Any sufficiently complicated C or Fortran program contains an ad hoc, informally-specified, bug-ridden, slow implementation of half of Common Lisp.

Name: Anonymous 2015-02-22 14:54

Is there a way in Common Lisp to get the names of all the bound macros currently in scope?

I want to define my custom defmacro and extend it to all macros, even imported from other packages. I.e. to get names of all macros in scope and have a macro redefine all of them.

Name: Anonymous 2015-02-22 17:31

>>113
Please? Lisp wizards?

Name: Anonymous 2015-02-22 17:51

>>114
Calm down, it's been less than three hours.

Name: Anonymous 2015-02-22 21:25

>>113
Maybe the implementation will expose it for you. If not, define an alternative to defmacro and macrolet that registers the macro in a global list you can access.

Name: Anonymous 2015-02-22 23:13

Type systems are not truly good things or else they'd be more popular with people who know what they are doing. There isn't really any actual industrial or scientific evidence of their value. If anything, they get just get in the way and make things worse. It doesn't help with the fact that some of the main peddlers of type systems have been shown to be frauds and scam artists in their personal lives.

Name: Anonymous 2015-02-23 7:25

>>116
So there isn't a list of all bindings in DA STANDARD? I know there are symbol-value and symbol-function, why aren't there get-all-symbol-values etc?

define an alternative to defmacro and macrolet that registers the macro in a global list you can access
You mean use macrolet to register every macro that I use?

Name: Anonymous 2015-02-23 23:43

>>118
[code]do-all-symbols[code]

Name: Anonymous 2015-02-25 4:18

>>118
See >>119.

You mean use macrolet to register every macro that I use?
I was thinking of something more like:

(defmacro cl-extensions:macrolet (macro-name args and stuff)
(register-a-macro-in-a-global-table macro-name other stuff)
`(macro-let macro-name args and stuff))

And then adjusting the packages of the code you want to affect to use your macro let so then macro lets will add the macro name to a table in addition to behaving like they normally do.

But you don't need to do any of that since >>119 is part of da standard.

Name: Anonymous 2015-02-25 19:01

>>119-120

Wow, thank you Lisp Wizards. I didn't think Lisp can do even that.

Name: Anonymous 2015-02-25 22:09

dubz chekem

Name: BreadCream 2015-02-25 22:21

>>122
I must say, these are splendid dubs indeed.

Name: Anonymous 2015-02-25 22:36

Legit

Name: Anonymous 2015-02-26 6:48

>>121
((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((You're welcome))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
Newer Posts
Don't change these.
Name: Email:
Entire Thread Thread List
All trademarks and copyrights on this site are owned by their respective parties. All comments and posts are the responsibility of their own posters.
- Tinychan + 2ch Mode + RSS -