#include <stdio.h>

int main()
{
  *(int*)0;

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

using System;
using System.Runtime.InteropServices;
using System.Drawing;

namespace ConsoleApplication1

#include <stdio.h>

int main()
{
    int* p = malloc(sizeof(int));

#include <stdio.h>

int main()
{
    int* p = malloc(sizeof(int));

# simplified monadic packrat (almost CFG) parser
#  derived from parse6.py, added (lazy) backtracking   
#
#  parser :: str -> [ (value, str) ]
class lcons (object):

# simplified monadic (PEG) parser. no memoization, some backtracking.
#  parser :: str -> maybe (value, str)
def ret (value): 
    return lambda s: (value, s)

def main():
  print "now, take it for a spin"
  print "", to_seq([1,2,3]).to_list()
    

from parse import *
from test1 import timeit

def group(p):
  return p % (lambda v: ('group', v))

# first, some boilerplate
class Seq:
  def __init__(self, defer):
    self._defer = defer
  def force(self):

# first, some boilerplate
class Seq:
  def __init__(self, defer):
    self._defer = defer
  def force(self):

#include <iostream>

template <typename T> struct Base {
   void f(int) {
       std::cout << "Base<T>::f\n";

#include <iostream>

template <typename T> struct Base {
   void f(int) {
       std::cout << "Base<T>::f\n";

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

namespace n1 {

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

import operator 
print len(reduce(operator.add, (((),),((),))))

import random
import time


def analyzeCoin(coin, numSamples=1000):

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

    template <class T>

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

struct S{

typedef int HRESULT ;
bool SUCCEEDED(HRESULT x){return(x)>=0;}
HRESULT f(){return 0;}
#define g f
#define h f

def e(x):
  return e(x-1) if x else 0
def e(x, e=e):
  return e(x-1) if x else 1

fact = lambda x: 1 if x<1 else x*fact(x-1)
print fact(20)

// in reference to http://hbfs.wordpress.com/2011/08/09/programming-challenge-luminance/
#include <iostream>
#include <iomanip>

using namespace std;

#! python

# digraph.txt used: http://jnicholl.org/Cryptanalysis/Data/DigramFrequencies.php
import math

;; QR card for scheme
;; (c) 2011 Aaron Lahman

;; r5rs load module
(load {filename-string})

;QR card for scheme

;r5rs load module
(load {filename-string})

;;
;; hello world plt-scheme servlet
;;

; mb.ss
;
; mandelbrot set

(define (1+ r)

    #include <iostream>
    using namespace std;

    void f() {
        throw 1;

def adds_dynamic_z_decorator(f):
  def replacement(*arg,**karg):
    # create a new 'z' binding in globals, saving previous
    if 'z' in globals():
      oldZ = (globals()['z'],)

/// answer to question on blog post
/// http://eli.thegreenplace.net/2008/12/22/an-rc-circuit-puzzle/
///
/// From the exercise, Eli said "But the current through the capacitor 
/// and resistor is the same current".  I'm not sure where you get this 

#include <type_traits>

using std::tr1::is_base_of;

// --- policy metaprogramming ---

function memoize(f)
  store = {}
  function anon(x)
    if store[x] then
      return store[x]

function memoize(f)
  store = {}
  function anon(x)
    if store[x] then
      return store[x]

function memoize(f)
  store = {}
  function anon(x)
    if store[x] then
      return store[x]

struct to_listoftuples
{
    template <class OuterContainerType>
    static PyObject* convert(OuterContainerType const& a)

#include <iostream>
#include <vector>
#include <iterator>
using namespace std;
template <class It>

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

#include <iostream>
#include <iomanip>
#include <set>
#include <algorithm>
#include <iterator>

#include <iostream>
#include <iomanip>
#include <vector>
#include <algorithm>
#include <iterator>

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

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

#include <iostream>
#include <iomanip>
#include <map>

// memoizer.  

#include <iostream>
using namespace std;
template <int I, bool Fizz = !(I % 3), bool Buzz = !(I % 5)> struct number {};
template <int I> void fizzbuzz(number<I, false, false>){ cout << I << "\n"; }
template <int I> void fizzbuzz(number<I, true, false>){ cout << "Fizz\n"; }