// C++ code from Johannes Schaub (litb)    
// C++0x: Is this "this-parameter" forwarder for function<void(???)> correct?
// http://groups.google.com/group/comp.lang.c++/msg/9a6c60fdb70d638c
// Tested by doing g++ -std=c++0x on GCC 4.5.1 20100924 (Red Hat 4.6.1-4)
//

// NullClass from Scott Meyers, Effective C++ CD, Item 25.
class NullClass {
public:
  template<class T>
    operator T*() const { return 0; } 

template <unsigned N>
unsigned GetNumberOfChars(const char(&)[N])
{
  return N;
}

  struct foo { int first; int second; };

  int main() {
    int foo::*ptr_to_member = 0;

// Based upon an example by Scott Bilas:
// http://stackoverflow.com/questions/547290/is-the-empty-base-optimization-in-gcc-configurable
#include <iostream>

struct Base {};

struct E {
  E(){}
  E(const E&) {
    throw 42;
  }

namespace boost {
  template<class T> class initialized
  {
    T m_data;
  public:

#include <algorithm>

int main() {
  unsigned long big = 76543210UL;
  unsigned short small = 12345;

struct foo {
  explicit foo(int) {}
};

int main() {

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

// noncopyable is copied (!) from boost/noncopyable.hpp, by David Abrahams.

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

struct A {

template<class T> class value_initialized
{
public:
  value_initialized();

#include <iostream>
class Parent;
class Child
{
public:

#include <cstdlib>
#include <new>
#include <stdexcept>
#include <string>

#include <exception>
#include <new>
class MyException: public std::exception
{
public:

#include <fstream>

int main() {
  std::ifstream inputFileStream( L"UnicodeFileName.dcm" );
  return 0;

  int main()
  {
  	unsigned foo = 0;
  	return foo;
  }

#include <iostream>
#include <string>

std::string min_by_value(std::string value)
{

void f1(const int(&)[]);

int main() {}

// Tests the postcondition proposed by LWG 471, with respect to homogeneous copying.
// http://open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#471
// Tests all 15 C++03 exception classes.
//
// Tested implementations (so far):

#include <vector>
#include <string>

class Foo: public std::vector<std::string>
{

#include <iostream>

class exception
{
  const char * m_what;

#include <exception>
#include <stdexcept>
#include <string>
#include <cassert>

#include <exception>
#include <cassert>
#include <cstring>

class user_exception: public std::exception

#include <exception>
#include <cassert>
#include <cstring>
  
int main() {

#include <exception>
#include <iostream>

int main() {
  const std::exception& rhs = std::bad_exception(); 

  #include <exception>
  #include <stdexcept>
  #include <cassert>
  #include <cstring>
  

 ////////////////////////////////////////

 namespace foo // "boost"
 {
  template<class T1, class T2>

#include <string>
#include <algorithm>

namespace foo
{