import List(genericReplicate)
fibs=1:1:zipWith(+)fibs(tail fibs)
ggg=map(`genericReplicate`'g')fibs
main=mapM_ putStrLn ggg

class Spam
  def self.[] x
    puts "Spam.[] #{x}"
  end
end

def method_missing *args
  puts args.join ' '
  yield if block_given?
  args
end

(define-syntax ▲
  (syntax-rules ()
    ((▲ a b) (λ a b))))
(print ((
                                       ▲

import List
r=genericReplicate
main=mapM print$do a<-[1..];b<-[1..a];[r a 'f'++r b 'u']

u = ''.join(map(unichr, [1505, 1500, 1511, 1493, 1501]))
s = u.encode('utf-8')
print s.decode('cp1255', 'replace').encode('utf-8')

qux=map('q':)ux
u:ux=iterate('u':)"x"
vars="foo":"bar":"baz":qux
p(v:ars)=putStrLn v>>p ars
main=p vars

#include <cstdio>

void foo(unsigned short x)
{
 puts("x is a unsigned short");

import pickle

__name__ = 't'

class Spam(object):

require 'digest/sha1'
sha1 = ['e69de29bb2d1d6434b8b29ae775ad8c2e48c5391'].pack 'H*'
contents = "100644 a.txt\0#{sha1}100644 b.txt\0#{sha1}"
data = "tree #{contents.length}\0#{contents}"
p Digest::SHA1.hexdigest(data)

[:zero?, :one?, :two?, :three?, :four?, :five?].each_with_index do |x,i|
  Integer.send(:define_method, x) { self == i }
end

p 0.zero?

from collections import defaultdict


def T():
    return defaultdict(lambda:T())

# You can use the yield statement to create a generator...

def iter_function():
    yield 'hello'
    yield 'world'

def f():
    print "lol"
    yield "nope"

f()

def binomial(n):
    result = 1
    yield result
    for i in xrange(1,n+1):
        result *= (n-i+1)

p = method   :p
p             p
3.times      &p
0.upto 2,    &p
(0..2).each  &p

import Char (intToDigit)
import Numeric (showIntAtBase)
import Data.Word

cletus :: Word8 -> Word8

import List
import Control.Monad
import Control.Arrow
collatz 1 = Nothing
collatz n = Just . join (,) $ if even n

class Spam(object):
    def __call__(self): pass
s = Spam()

print callable(s)

data N = Z | S N deriving (Ord,Eq,Show)
instance Num N where
        x + Z = x
        x + (S y) = S (x + y)
        fromInteger 0 = Z

puts VERSION

class Spam
end

puts VERSION

class QuitRequested < Exception
end

#include <stdlib.h>
#include <assert.h>

class Image {
	const int width, height;

&v      <
 >:1-:1`|
   >   *v
   |`0:\<
   $

-- I <3 Cale
import Ratio (numerator,denominator)
import List (sort)
posRationals = 1 : (posRationals >>= \x -> [1+x, 1/(1+x)]) :: [Rational]
pyth r = (x,y,z) where m = numerator r; n = denominator r; [x,y,z] = sort [2*m*n, m^2 - n^2, m^2 + n^2]

try
	tell application "Finder" to set pwd to quoted form of POSIX path of (target of front Finder window as alias)
	tell application "System Events" to set terminalOn to (exists process "Terminal")
	tell application "Terminal"
		if terminalOn then

from BeautifulSoup import BeautifulSoup
from urllib import urlopen
import sys,re

url = 'http://support.dell.com/support/topics/global.aspx/support/my_systems_info/details?servicetag=%s'

import qualified Data.Map as M
import IO
import List
import Random

#!/usr/bin/python

import random
import re
import shutil

#!/usr/bin/env ruby

Dir["*.jpg"].each do |file|
  mm,dd,yy,h,m = [0,3,6,9,11].map { |start| file[start,2] }
  stamp = "20%s-%s-%s %s:%s" % [yy,mm,dd,h,m]

#include <iostream>
#include <csignal>
#include <cstdlib>
#include <unistd.h>
#include <exception>

module Enumerable
  def mymap &b
    results = []
    each {|x| results << b[x] }
    results

import Control.Monad
main = mapM_ print fibs where fibs = 0 : 1 : zipWith (+) fibs (tail fibs)

{-# LANGUAGE EmptyDataDecls #-}

data Z
data S a

#include <stdio.h>

const unsigned seed = 0x0C;
const unsigned mask = 0x11; 
const unsigned bits = 5;

class Monoid m where
    mzero :: m
    madd :: m -> m -> m

reduce :: (Monoid m) => [m] -> m

$sqrt5 = Math.sqrt(5)
$phi = (1+$sqrt5)/2
def fib n
  (($phi**n - (1-$phi)**n) / $sqrt5).to_i
end

require 'socket'

sock = TCPSocket::new("localhost", 9000)
loop do
  select([sock,STDIN],nil,nil)[0].each do |x|

puts (" "..":").to_a.join + (":".."~").to_a.join
puts ("A".."M").to_a.join + ("M".."Z").to_a.join
puts ("9"..";").to_a.join

import java.awt.*;
import java.awt.geom.*;

public class ZoomRect {
	/** The size of the physical drawing area.

module Enumerable
  def product
    catch :zero do
      self.inject 1 do |n,i|
        throw :zero,0 if i==0

import Control.Monad
main = (mapM_ putStrLn . replicateM 4) "01"

def take(n, it):
	r = iter(it)
	for i in xrange(n):
		yield r.next()

import Ratio

order = 13

newtype F = F Integer deriving (Eq)

graycode 1 = [[0],[1]]
graycode (n+1) = map (0:) gn ++ map (1:) (reverse gn) where gn = graycode n

main = mapM_ print (graycode 4)

import sys

def thue(n):
	t = 0
	while n:

import sys

def thue(n):
	t = 0
	while n:

#include <algorithm>
#include <cctype>
#include <iostream>
#include <string>
#include <utility>

import Control.Parallel

-- http://sequence.complete.org/hwn/20080709
forkbomb :: Integer -> ()
forkbomb n = forkbomb (2*n) `par` forkbomb (2*n+1)

#include <iostream>
#include <sstream>
#include <boost/static_assert.hpp>

#define ASSERT BOOST_STATIC_ASSERT

mandel()
Prgm
Local x,y,z,c,m
For y,0,76
 For x,0,168