SRL Archive - General

The object of this competition is to produce the scariest/most artistic code. This does not mean you may simply one line a script/program and apply to be graded on it (or if using a compiled language convert the whole thing to bytecode/machine language), as this has no talent. Some things you can do, however, are:

• Turn the script/program into ASCII art,
• Do something atrocious with it,
• Something else.
• ????
• PROFIT!

You may use anything you want for this, meaning you do not need to write another script. Try not to have 3000+ line scripts (although the obfuscation will shorten them a good amount), as it would be untolerable.

I'd like the deadline to be around 12:00 am, October 32nd. You may send it to me any time before that, also.

EDIT: The prize is a spoon.

I entered.

I NEED THEM SP00NS!

program IAm1337;
begin
  repeat
    writeln('Ha1 w0r1d!');
  until false;
end.

So is halloween today or tomorrow. I know some peeps who are trick'n'treating today! (30/10 here)

Oh, hmm. I meant by Friday, I'll go change the date.

1) Think of a three+ digit # (not all zeroes)
2) Rearrange the digits of that number to make a new number
3) Using these two numbers, subtract the smaller from the larger.
4) Select and remove one nonzero digit from that number.
5) ???
6) Profit!

OMG liek it readz ur mind kthx
http://stephenphp.freehostia.com/num.php
($_POST['nums'] is the input number.)
[PHP]
if(isset($_POST['nums']))
{
$nums = $_POST['nums'];
settype($nums, "int");
$arr = preg_split("//", $nums);
$sum = 0;
foreach($arr as $value)
{
$sum = $sum + $value;
}
for($i=1; $i <= 9; $i++)
{
if(is_int(($sum + $i)/ 9) )
{
die("the number you selected was $i");
}
}
}
[/PHP]

This is C++ btw. It might look a bit better in a notepad. (not much really)

#include <iostream>
#include <iomanip>
using namespace std;

class bx { public: bx* hxax() const { return ax; } bx* hxjx()     const { return jx; }        int hxcx() const { return cx; } void ixcx
(int incx); void ixjx(bx* injx); bx(int incx, bx* inax, bx*              injx);               private:                           bx* ax;
bx* jx;                                                                 int cx;               }; class                           dx { public:
dx(int                                                                   cx=0);               dx(const                           dx& inkx);
~dx();                                                                 int hxex()             const                              { return ex;
} bx*                                                                    hxgx()               const                              { return gxbx;
} dx&                                                                 operator +=            (const                              dx& inrx);
dx& operator = (const dx& inrx); private: bx*                            qxbx;                bx* gxbx; int ex; }; bx::bx(int incx, bx* inax,
bx* injx) { ax = inax; jx = injx; cx = incx; }                           void                 bx::ixjx(bx* injx) { jx = injx; } void bx::ixcx
(int incx)                                                              { cx                  = incx;                          } dx::dx(int
cx) {                                                                   ex =                  1; qxbx                           = new bx
(cx,                                                                     NULL                 , NULL);                           gxbx = qxbx;
}dx::dx                                                                (const                 dx& inkx)                          { ex = inkx.ex;
bx*                                                                     inmx                  = inkx.qxbx;                       qxbx = new bx(
inmx                                                                  ->hxcx()                ,NULL                              , NULL);
bx*                                                                     fxbx                  = qxbx;                           for (int i = 1;
i <                                                                    ex; ++i)               { inmx                            = inmx->hxjx();
fxbx                                                                   ->ixjx                 (new                             bx(inmx->hxcx(),
fxbx,                                                               NULL)); fxbx              = fxbx->hxjx(); } gxbx = fxbx; } dx::~dx() { bx*
mx = qxbx;                                                 for (int i = 0; i < ex; ++i)       { bx* fx = mx; mx = mx->hxjx(); delete fx; } }

dx& dx::operator = (const dx& inrx) { bx* mx = qxbx; for (int i = 0; i < ex; ++i) { bx* fx = mx; mx = mx->hxjx(); delete fx; } ex = inrx.ex;
 bx* inmx = inrx.qxbx; qxbx = new bx(inmx->hxcx(), NULL, NULL); bx* fxbx = qxbx; for (int i = 1; i < ex; ++i) { inmx = inmx->hxjx(); fxbx
  ->ixjx(new bx(inmx->hxcx(), fxbx, NULL)); fxbx = fxbx->hxjx(); } gxbx = fxbx; } dx& dx::operator += (const dx& inrx) { const int px_ex
   = 1000000000; bx* fxbx = qxbx; bx* infxbx = inrx.qxbx; int ox = 0; int i = 0; while (i < inrx.ex && i < ex) { int lx[] = {fxbx->hxcx
    (), infxbx->hxcx()}; fxbx->ixcx((lx[0] + lx[1] + ox) % px_ex); ox = (lx[0] + lx[1]) / px_ex; if (fxbx->hxjx() != NULL) { fxbx=fxbx
     ->hxjx(); infxbx = infxbx->hxjx(); } ++i; } while (i < ex && ox > 0) { int lx = fxbx->hxcx(); fxbx->ixcx((lx + ox) % px_ex); ox
      = (lx + ox) / px_ex; if (fxbx->hxjx() != NULL) { fxbx = fxbx->hxjx(); } ++i; } while (i < inrx.ex) { int lx = infxbx->hxcx();
       fxbx->ixjx(new bx((lx + ox) % px_ex, fxbx, NULL)); ox = (lx + ox) / px_ex; fxbx = fxbx->hxjx(); ++ex; ++i; } if (ox > 0) {
          fxbx->ixjx(new bx(ox, fxbx, NULL)); fxbx = fxbx->hxjx(); ++ex; } gxbx = fxbx; return *this; } ostream& operator << (
            ostream& out, const dx& kx) { int ex = kx.hxex(); bx* fx = kx.hxgx(); for (int i = 0; i < ex; ++i) { int cx = fx
             ->hxcx(); if (fx->hxjx() != NULL) { out << setfill('0') << setw(9) << cx; } else { out << cx; } fx = fx->hxax
               (); } return out; } dx nx(int n) { dx gx(1); dx lx(0); for (int i = 0; i < n; ++i) { dx mx(lx); lx += gx;
                 gx = mx; } return lx; } int main() { for (int i = 0; i < 350; ++i) { cout << nx(i) << endl; } return
                                                                 0; }

Goo- Bad, Bad. Don't keep doing this… :p

EDIT: New contestants…

Requirements: x>=0; 0<=m<=127; 0<=n<=128

#define likelyhasbetween(x,m,n) \
((((x)-~0UL/255*(n))&~(x)&((x)&~0UL/255*127)+~0UL/255*(127-(m)))&~0UL/255*128)

#define hasbetween(x,m,n) \
((~0UL/255*(127+(n))-((x)&~0UL/255*127)&~(x)&((x)&~0UL/255*127)+~0UL/255*(127-m))&~0UL/255*128)

#define countless(x,n) \
(((~0UL/255*(127+(n))-((x)&~0UL/255*127))&~(x)&~0UL/255*128)/128%255)

http://graphics.stanford.edu/~seander/bithacks.html

iv got some lisp ones

(lambda (*<8-]= *<8-[= ) (or *<8-]= *<8-[= ))

(defun :-] (<) (= < 2))

(defun !(!)(if(and(funcall(lambda(!)(if(and '(< 0)(< ! 2))1 nil))(1+ !))
(not(null '(lambda(!)(if(< 1 !)t nil)))))1(* !(!(1- !)))))

I got a SCAR one

Program New;
{.include srl/srl.scar
Var x,y : Integer;

Begin  MoveMouse(x,y); Wait(800); ClickMouse(x, y, True);
  x := 0; writeln('MoVEd The MOuSE'); eXIT; BREAK;
  y := 0;
  Inc(x); Inc(y); Inc(x); Inc(y);
end.

Sorry I went SCAR Happy, Oh I inclueded srl for no reason oh and I have a comment error :p

Naum, you missed a loop, and the Inc doesn't do anything as far as I can tell :P.

Inc, increases 'x' by one :p

From: R0b0t1


I'd like the deadline to be around 12:00 am, October 32nd. You may send it to me any time before that, also.

EDIT: The prize is a spoon.

32nd? lol wut

Anyway OnTopic, how will we know who won?

I tried it with the Inc, but it doesn't change anything :P.

OK, well, I'll give it another day. I'm working on a essay.

Uses python. Prints a acii skull!

last = {}
old = {23:1,21:2,20:3,15:4,17:5,16:6,19:7,12:8,18:9,13:10,14:11,22:12}
t = True;f = False;oop = '   ';z = ' '
def y(): return 
def x(): return '                    |   |        }:{        |    | '
last[9]="                       | |`IIII_I_I_I_IIII'| |  "
def w():return u(18,' ')+rs(' ,~^~~~-,  ~  |')+'|'+rs('| ~  ,-~~~^~, ')
last[12]='                            \.    ^    ./   '
def v():return u(18,' ')+"|  `/~-     ~- . -~    -~%s'  |"%bks()
last[4]="                     \__.       \/^\/       .__/  "
def bks():return "\ ".replace(' ','')
last[1]='                              ^~~~^~~~^ '
def mrr(st,m):return st+m+rs(st).replace('/','\ '.replace(' ',''))
last[10]='                    .~  (__,.--" .^. "--.,__)  ~. '
def rs(s):return s[::-1]
last[3]="                        \   `~~~~~~~~~~'    /"
def s():return u(18,' ')+'| ;'+oop+d(5,'_')+'        '+d(5,'_')+oop+'; |'
def u(it,cha):return o(it,cha)
def n():return d(19,' ')+o(1,';')+d(1,'      ')+rt('.')+d(2,'     ')+'  '+'.'+q()
last[11]="                    |     ---;' / | \ `;---     | "
def o(i,char):return char+p(i)+char
last[2]='                          \   .       .   / '
def p(z):
    y = ''
    for a in range(0,z):y+=' '
    return y
last[5]="                       | |T~\___!___!___/~T| | "
def q():return rt(d(3,'  '))+o(1,';')
last[6]='                      V| \                 / |V  '
def l():
    oo = '                    '
    return oo+',;'+d(13,'  ')+';,'
def k():return '                     '+rt(",'")+d(24,' ')+"',"
def a():
    b = ''
    return d(28,z)+c(t)+d(8,'-')+c(f)
def c(option):
    if option:return '_,.'
    else:return '.,_'
def d(o,ch):
    b = ''
    for a in range(0,o):b+=ch
    return b
def e():return d(24,z)+f2(t)+d(14,z)+f2(f)
last[7]='                       |  \,III I I I III,/  |  '
def f2(t):
    if t:return ',;~"'
    else: return '"~;,'
def g():return d(23,z)+',;'+'                    '+rt(';,')
def rt(z):return z 
def h():return mp(i,22)+rt(';')+d(24,' ')+rt(';')
def mp(func,i):
    z = ''
    for a in range(0,i):
        z+=func()
    return z
def i():return ' '
last[8]="                    |   l       / | \       !   |"
def j(i,c):
    b = []
    for a in range(0,i):b.append(c)
    return b
image = {}
func = {1:a,2:e,3:g,4:h,5:k,6:l,7:n,8:s,9:v,10:w,11:x}
for inta in range(1,12):image[inta]=func[inta]()
for into in range(12,24):image[into]=last[old[into]]
def b(a):print image[a]
for a in range(1,24):b(a)
print ''
print 'Happy halloween!'
raw_input()

I'd say of bobng, boberman, yakman, and Wizzup, its a close tie with Yakman's LISP and Wizzup's… Stuff…

I'd give you both a spoon, but there is no spoon.

Honorable mentions go to bobng, and then boberman.

    SetLength(Result[Length(tTPA)], Length(Result[Length(tTPA)]) + 1);
    Result[Length(tTPA)][High(result[Length(tTPA)])].TPA := tTPA;
    SetLength(Result[Length(tTPA)][High(result[Length(tTPA)])].BA, w);
    for j := 0 to w - 1 do
      SetLength(Result[Length(tTPA)][High(result[Length(tTPA)])].BA[j], h);
    for j := 0 to high(Result[Length(tTPA)][High(result[Length(tTPA)])].TPA) do
        Result[Length(tTPA)][High(result[Length(tTPA)])].BA[Result[Length(tTPA)][High(result[Length(tTPA)])].TPA[j].x][Result[Length(tTPA)][High(result[Length(tTPA)])].TPA[j].y] := true;
    Result[Length(tTPA)][High(result[Length(tTPA)])].c := cc;

I want another entry. :p

begin
      writeln(              ' '+chr(122 xor 90)+' '+chr(22 xor 54)+chr(29 xor 61)+chr(5+27)+chr(6+26)+' '+
                    ' '+chr(32)+#32+' '+chr(280-248)+chr(173-141)+chr(198 xor 230)+#32+#32+chr(69 xor 101)+#32+
                 chr(-15+47)+' '+chr(251-219)+chr(32)+chr(32)+' '+#32+chr(32)+chr(156 xor 188)+chr(113 xor 81)+chr(101
              -69)+chr(188 xor 156)+' '+' '+chr(-179+211)+chr(-63+95)+chr(144 xor 176)+chr(-82+114)+' '+chr(-108+140)+chr(-214
          +246)+#32+' '+chr(140 xor 172)+chr(49 xor 31)+'"'+chr(196 xor 230)+#45+chr(201 xor 228)+chr(51-5)+chr(4+42)+chr(138-43)+
       chr(180-148)+' '+#32+chr(156-124)+chr(46-14)+chr(184 xor 152)+chr(-162+194)+' '+chr(-21+53)+chr(-123+155)+chr(32)+#32+#32+' '+
      #32+chr(42 xor 10)+chr(32)+' '+chr(-16+48)+chr(150-118)+#32+' '+chr(26 xor 58)+chr(153 xor 185)+chr(128-96)+chr(208 xor 240)+chr(28
     xor 60)+#32);writeln(chr(-176+208)+chr(136 xor 168)+chr(91-59)+chr(-85+117)+#32+chr(109-77)+chr(-91+123)+#32+chr(112 xor 80)+chr(246
    xor 214)+chr(218-186)+chr(32)+chr(32)+chr(   -79+111)+chr(32)+chr(29 xor 61)+chr(   236 xor 204)+chr(-120+152)+chr(-75+107)+chr( -100 +
  132)+chr(32)+chr(-110+142)+chr(83-51)+chr(-     161+193)+chr(161 xor 129)+chr(32)+     #32+#32+' '+' '+' '+#32+chr(100-68)+chr(129-97)+' '
+chr(148 xor 180)+chr(116 xor 84)+chr(107            -75)+chr(-150+182)+#32+' '+            chr(224 xor 192)+chr(111-79)+'['+chr(13+80)+chr(
32)+chr(257-225)+chr(100-68)+chr(220 xor              252)+chr(102 xor 70)+' '+              chr(143 xor 239)+chr(3 xor 36)+#45+#45+chr(231
xor 201)+chr(30+16)+chr(241 xor 174));                 writeln(chr(152-120)                    +chr(32)+chr(32)+chr(25 xor 57)+chr(32)+chr(32)
+chr(150 xor 182)+chr(-54+86)+chr(-92+124)+' '+' '+' '+chr(235 xor 203)+chr(246 xor 214)+chr(-32+64)+chr(32)+chr(32)+chr(230 xor 198)+chr(-35+
67)+chr(144 xor 176)+chr(28 xor 60)+chr(-204+236)+' '+chr(18+14)+   chr(-190+222)+chr(228-196)+chr(30 xor 62)+chr(32)+chr(172-140)+chr(160-128)+chr
(95 xor 127)+chr(167 xor 135)+#32+chr(32)+' '+chr(32)+' '+chr(         32)+chr(-19+51)+chr(32)+#32+#32+chr(72 xor 104)+'|'+chr(122 xor 6)+#95+'_'+chr(
32)+chr(-88+120)+' '+chr(68 xor 100)+chr(232 xor 200)+#32+               chr(181-149)+chr(32)+chr(32)+' '+chr(185 xor 153)+chr(55+41)+chr(-34+73)+chr(
45)+chr(227 xor 207));writeln(chr(32)+chr(32)+chr(32)+                     chr(211-179)+chr(-194+226)+chr(236-204)+chr(224-192)+chr(204 xor 236)+' '+chr(
226 xor 194)+#32+chr(244 xor 212)+chr(109 xor 77)+chr(-173+205)+chr(-52+84)+chr(-213+245)+chr(91-59)+' '+chr(-4+36)+chr(-54+86)+chr(278-246)+chr(1 xor 33)+
#32+chr(124 xor 92)+chr(0 xor 32)+chr(152-120)+' '+chr(164 xor 132)+' '+chr(57 xor 25)+chr(32)+chr(-37+69)+chr(8+24)+chr(32)+chr(55-23)+chr(32)+#32+chr(22
xor 54)+chr(7+25)+chr(186 xor 154)+chr(216 xor 248)+#96+chr(47 xor 6)+chr(243 xor 143)+chr(123 xor 7)+'_'+chr(32)+chr(96)+chr(96)+chr(211-115)+chr(246 xor
209)+#45+#45+chr(218 xor 244)+#46+chr(250-218)+chr(-75+107)+#32+' '+' '+chr(32)+chr(211 xor 243)+#92);writeln(chr(32)+chr(-51+83)+chr(28 xor 60)+chr(32)+' '+
chr(259-227)+#32+chr(76 xor    108)+chr(32)+chr   (263-231)+chr(85 xor 117)+   ' '+chr(32)+chr(32)+   chr(80 xor 112)+   chr(179-147)+chr(186-154)+chr(182-150)
+chr(-213+245)+chr(32)+' '      +'_'+#32+' '+       chr(-154+186)+chr(32)+       #32+#32+chr(-179      +211)+chr(87          xor 119)+chr(32)+#32+chr(46-14)+#32
+chr(-80+112)+chr(-141             +173)+              chr(15 xor 47)+             ' '+chr(192           xor 224)              +chr(57 xor 25)+chr(32)+chr(104 xor
72)+#47+chr(-16+140)+               chr                  (48-1)+chr                  (149 xor              186)+                 chr(125)+chr(-155+187)+chr(32 xor
0)+chr(270-238)+chr                                        (-64+96                       )+                 chr                   (127-95)+#32+chr(32)+#32+#96+'`'+
'-'+chr(196 xor                                              233)                                                                  +chr(58 xor 20)+#95+chr(131-99)+
' '+chr(156                                                                                                                          xor 224));writeln(chr(209 xor
241)+chr(12                                                                                                                           xor 44)+chr(32)+chr(-87+119)+
chr(113 xor 81)+chr(172 xor 140)+chr(-52+84)+#32+chr(57-25)+#32+chr(194 xor 226)+chr(32)+chr(23 xor 55)+chr(117-85)+chr(161 xor 129)+#32+#32+chr(32)+chr(201-155)+''''
+#96+#32+chr(96)+chr(39)+chr(52 xor 26)+chr(32)+' '+chr(32)+chr(86-54)+chr(192-160)+chr(-42+74)+chr(84 xor 116)+#32+chr(32)+#32+chr(227-195)+chr(216-184)+chr(-157+189)
+' '+chr(32)+' '+chr(275-228)+chr(45 xor 2)+chr(31+16)+'/'+chr(152 xor 183)+chr(270-145)+chr(233-201)+chr(122-90)+chr(178 xor 146)+chr(223-191)+#32+' '+chr(-142+174)+
chr(190 xor 158)+chr(70 xor 102)+#32+chr(-152+184)+' '+#32+chr(61-29)+chr(107 xor 11)+chr(79 xor 19)+chr(208 xor 255));writeln(chr(98-66)+' '+chr(32)+chr(-197+229)+
 chr(279-247)+chr(119 xor 87)+chr(140 xor 172)+chr(-102+134)+#32+chr(82-50)+chr(-52+84)+chr(133 xor 165)+#32+chr(121 xor 89)+chr(78-46)+chr(69-37)+chr(72 xor 104)+
  chr(-120+167)+#32+chr(66 xor 98)+chr(136-90)+chr(159-125)+chr(-181+215)+'"'+'.'+chr(225-133)+chr(131-99)+' '+chr(32)+chr(83-51)+#32+chr(226-194)+chr(-143+175)+
  ' '+chr(-193+225)+chr(193 xor 225)+' '+chr(-112+144)+chr(-1+33)+chr(-14+46)+chr(116 xor 91)+chr(-43+90)+chr(-24+147)+chr(93 xor 114)+chr(199-152)+#47);writeln(
    chr(104 xor 72)+chr(69 xor 101)+chr(204 xor 236)+chr(32)+chr(141-109)+chr(221 xor 253)+chr(145 xor 177)+chr(128 xor 160)+chr(170 xor 138)+#32+chr(117 xor 85
     )+chr(-175+207)+chr(-127+159)+chr(227-195)+chr(-25+57)+chr(32)+#47+chr(32)+chr(32)+'/'+'_'+#32+chr(32)+chr(229-134)+chr(133 xor 229)+chr(-52+144)+chr(-149
       +241)+chr(-158+190)+chr(104 xor 72)+chr(51 xor 19)+chr(-17+49)+chr(12 xor 44)+chr(105 xor 73)+chr(-172+204)+chr(201-169)+chr(82 xor 114)+chr(-190+222)
        +chr(-207+239)+chr(249-217)+chr(131-84)+chr(3+44)+#32+chr(93 xor 61)+#124+chr(-22+146));writeln(chr(-177+209)+chr(229 xor 197)+chr(32)+chr(265-233)
            +chr(-209+241)+chr(-18+50)+chr(160 xor 128)+chr(32)+chr(32)+chr(155-123)+chr(32)+chr(58 xor 26)+chr(138-106)+chr(75 xor 107)+chr(-93+125)+chr
               (223 xor 255)+'|'+' '+chr(45 xor 81)+chr(40)+chr(95)+chr(236 xor 197)+chr(40)+chr(315-220)+chr(161-120)+chr(124)+#124+#32+chr(32)+' '+
                   chr(155 xor 187)+#32+#32+#32+' '+chr(257-225)+chr(182-150)+chr(337-242)+#47+chr(108 xor 67)+' '+chr(5+27)+chr(243-211)+'|'+chr(
                     172-48)+chr(17 xor 49)+chr(269-237));writeln(chr(-79+111)+chr(-125+157)+#32+chr(20 xor 52)+chr(16 xor 48)+' '+#32+chr(32)+
                         chr(129 xor 161)+chr(230 xor 198)+chr(149-117)+' '+chr(32)+' '+chr(53-21)+chr(213 xor 245)+chr(124)+chr(-120+152)+
                           chr(59+65)+chr(125 xor 93)+#32+chr(47)+'\'+chr(-51+83)+chr(32)+chr(137-96)+chr(124)+chr(-103+135)+chr(32)+

chr(122-90)+chr(194 xor 226)+chr(111 xor 79)+chr(156 xor 188)+chr(-25+57)+chr(32)+'_'+chr(47)+chr(47)+chr(47)+#92+chr(14 xor 46)+#32+chr(31+1)+chr(315-191)+chr(196 xor 184));
writeln(' '+chr(264-232)+#32+' '+#32+chr(-161+193)+' '+chr(4 xor 36)+chr(32)+#32+chr(99-67)+chr(-124+156)+chr(159 xor 191)+#32+#32+' '+chr(156 xor 224)+chr(149 xor 181)+'|'+
chr(76)+chr(31 xor 34)+chr(-25+86)+chr(-172+233)+chr(193-132)+chr(125 xor 55)+#32+'|'+chr(-59+91)+chr(109 xor 77)+chr(218 xor 250)+#32+chr(74-42)+chr(32)+chr(235 xor 203)+#47+
chr(32)+chr(202 xor 182)+chr(292-245)+#32+chr(124)+chr(-152+184)+chr(140-108)+' '+#124+#124);writeln(chr(32)+chr(173-141)+chr(-194+226)+#32+chr(-120+152)+chr(188 xor 156)+chr(
73-41)+                                                                                                                                                          chr(75 xor 107)
+chr(260    -228)+         chr   (32)   +chr      (32)      +chr(32)+       chr     (42   xor      10)        +chr(-178                                          +210)+chr(32)+'/'
         +         #32     +chr  (177    xor    145)+chr    (       -       123    +170   )+chr(201-162)+#45+chr(214 xor 248)+#46+chr(145 xor 188)+chr(150-111)+chr(25 xor 57)+chr
        (47)  +     chr    (53 xor 21)+' '+#32+    chr   (-103+135)      +chr(34 xor    12)+chr(156-117)+chr(312-216)+chr(39-7)+chr(-217+249)+chr(14 xor 82)+chr(-167+199)+chr(
        38- 6)  +    chr   (24 xor 100)+chr(44 xor 12)+chr(32)+#32+chr(351-227)+chr(104+20));
end.

Oh hell. Markus has nothing useful to do.

Ok, Markus wins :p

i <3's markus :). scary code inside scary code!

haha, I think markus wins, that is pretty cool!

Bestow upon him the spoon!

Here we go Markus!

lol the way he's placed the text in the shape of a pumpkin :p that's awesome

Yes, Yes, Markus wins. That made me snort my milk IRL. Although Wizzup's… Stuff… Is pretty… Impressive…

Actually it isn't finished yet :p Beneath the pumpkin I wanted it to show © Markus, but that turned out to be hard :(

                                          .""--.._                            
                                           []      `'--.._
                                           ||__           `'-,
                                         `)||_ ```'--..       \
                     _                    /|//}        ``--._  |
                  .'` `'.                /////}              `\/
                 /  .""".\              //{///
                /  /_  _`\\            // `||
                | |(_)(_)||          _//   ||  
                | |  /\  )|        _///\   ||
                | |L====J |       / |/ |   ||
               /  /'-..-' /    .'`  \  |   ||

lol if u run it looks like this
it is scary AHHHHH