int uncalledFunction()
{
}

template <typename T>
int uncalledTemplateFunction()
{
}

class NonVirtualClass
{
 public:

  NonVirtualClass()
  {
  }

  ~NonVirtualClass()
  {
  }

  void inClassFunction()
  {
  }

  void outOfClassFunction();

  template <typename T2>
  void templateFunction()
  {
  }

  template <typename T2>
  void templateOutOfClassFunction();
};

void NonVirtualClass::outOfClassFunction()
{
}

template <typename T2>
void NonVirtualClass::templateOutOfClassFunction()
{
}

class NonVirtualClass2
{
 public:
   NonVirtualClass2();
   ~NonVirtualClass2();
};

NonVirtualClass2::NonVirtualClass2()
{
}

NonVirtualClass2::~NonVirtualClass2()
{
}

class VirtualClass
{
 public:

  VirtualClass()
  {
  }

  virtual ~VirtualClass()
  {
  }

  virtual void inClassFunction()
  {
  }

  virtual void outOfClassFunction();

  template <typename T2>
  void templateFunction()
  {
  }

  template <typename T2>
  void templateOutOfClassFunction();
};

void VirtualClass::outOfClassFunction()
{
}

template <typename T2>
void VirtualClass::templateOutOfClassFunction()
{
}

template <typename T1>
class TemplateClass
{
public:
  TemplateClass()
  {
  }

  ~TemplateClass()
  {
  }

  void inClassFunction()
  {
  }

  void outOfClassFunction();

  template <typename T2>
  void templateFunction()
  {
  }
  
  template <typename T2>
  void templateOutOfClassFunction();
};

template <typename T1>
void TemplateClass<T1>::outOfClassFunction()
{
}

template <typename T1>
template <typename T2>
void TemplateClass<T1>::templateOutOfClassFunction()
{
}

template <typename T1>
class VirtualTemplateClass
{
public:
  VirtualTemplateClass()
  {
  }

  virtual ~VirtualTemplateClass()
  {
  }

  virtual void inClassFunction()
  {
  }

  virtual void outOfClassFunction();

  template <typename T2>
  void templateFunction()
  {
  }
  
  template <typename T2>
  void templateOutOfClassFunction();
};

template <typename T1>
void VirtualTemplateClass<T1>::outOfClassFunction()
{
}

template <typename T1>
template <typename T2>
void VirtualTemplateClass<T1>::templateOutOfClassFunction()
{
}

int main()
{
    /*
  uncalledFunction();

  uncalledTemplateFunction<int>();

  NonVirtualClass nvo;
  nvo.inClassFunction();
  nvo.outOfClassFunction();
  nvo.templateFunction<int>();
  nvo.templateOutOfClassFunction<int>();

  NonVirtualClass2 nvo2;

  VirtualClass vo;
  vo.inClassFunction();
  vo.outOfClassFunction();
  vo.templateFunction<int>();
  vo.templateOutOfClassFunction<int>();

  TemplateClass<int> to;
  to.inClassFunction();
  to.outOfClassFunction();
  to.templateFunction<int>();
  to.templateOutOfClassFunction<int>();

  VirtualTemplateClass<int> vto;
  vto.inClassFunction();
  vto.outOfClassFunction();
  vto.templateFunction<int>();
  vto.templateOutOfClassFunction<int>();
  */

  return 0;
}