#include <list>
#include <map>
#include <vector>

#define MACRO(T)    f<T>()

class MyClass
{
 public:
   std::map<int, bool>             someData;
   std::map<int, std::list<bool> > otherData;
};

void foo()
{
   List<byte> bob = new List<byte>();
}

A<B>     foo;
A<B, C>  bar;
A<B *>   baz;
A<B<C> > bay;

void asd(void)
{
   A<B>     foo;
   A<B, C>  bar;
   A<B *>   baz;
   A<B<C> > bay;

   if (a < b && b > c)
   {
      a = b < c > 0;
   }
   if (a<bar()> c)
   {
   }
   a < up_lim() ? do_hi() : do_low;
   a[a<b> c] = d;
}

template<typename T> class MyClass
{
}

template<typename T>
class MyClass
{
}

template<typename A, typename B, typename C> class MyClass : myvar(0),
   myvar2(0)
{
}

template<typename A, typename B, typename C> class MyClass
   : myvar(0),
   myvar2(0)
{
}


static int max_value()
{
   return((std::numeric_limits<int>::max)());
}

template<class Config_>
priority_queue<Config_>::~priority_queue ()
{
}

template<class T>
T test(T a)
{
   return(a);
}

int main()
{
   int k;
   int j;
   h   g<int>;

   k = test<int>          (j);
   return(0);
}

template<typename T, template<typename, unsigned int, unsigned int> class ConcreteStorageClass>
class RotationMatrix
   : public StaticBaseMatrix<T, 3, 3, ConcreteStorageClass>
{
 public:
   RotationMatrix()
      : StaticBaseMatrix<T, 3, 3, ConcreteStorageClass>()
   {
      // do some initialization
   }

   void assign(const OtherClass<T, 3, 3>& other)
   {
      // do something
   }
};

int main()
{
   MyClass<double, 3, 3, MyStorage> foo;
}

template<typename CharT, int N, typename Traits>
inline std::basic_ostream<CharT, Traits>& FWStreamOut(std::basic_ostream<CharT, Traits>&os,
                                                      const W::S<CharT, N, Traits>&s)
{
   return(operator<<<CharT, N, Traits, char, std::char_traits<char> >                (os, s));
}

struct foo
{
   type1<int&> bar;
};
struct foo
{
   type1<int const> bar;
};


template<int i> void f();
template<int i> void g()
{
   f<i - 1>();
   f<i>();
   f<i + 1>();
   f<bar()>();
}
void h()
{
   g<42>();
}

#include <vector>
std::vector<int> A(2);
std::vector<int> B;
std::vector<int> C(2);
std::vector<int> D;

template<class T> struct X
{
   template<class U> void operator()(U);
};

template<class T> class Y {
   template<class V> void f(V);
};

void                        (*foobar)(void) = NULL;
std::vector<void (*)(void)> functions;

#define MACRO(a)    a
template<typename = int> class X;
MACRO(void f(X<>& x));
void g(X<>& x);

#include <vector>
typedef std::vector<std::vector<int> >    Table; // OK
typedef std::vector<std::vector<bool> >   Flags; // Error

void func(List<B>        =default_val1);
void func(List<List<B> > =default_val2);

BLAH<(3.14 >= 42)> blah;
bool               X = j<3> > 1;

void foo()
{
   A<(X > Y)> a;

   a = static_cast<List<B> >(ld);
}

template<int i> class X {   /* ... */
};
X < 1 > 2 > x1;             // Syntax error.
X<(1 > 2)> x2;              // Okay.

template<class T> class Y { /* ... */
};
Y<X<1> >        x3;         // Okay, same as "Y<X<1> > x3;".
Y<X<(6 >> 1)> > x4;


template<typename T>
int
myFunc1(typename T::Subtype val);

int
myFunc2(T::Subtype val);
