()

int n = 1;     //  n
int x = n + 1; // OK:   ::n

int z = y - 1; // :   
int y = 2;     //  y

int n = 1; // 
namespace N
{
  int m = 2;
  namespace Y
  {
    int x = n; // OK,   ::n
    int y = m; // OK,   ::N::m
    int z = k; // :   
  }
  int k = 3;
}

namespace X
{
    extern int x; // ,  
    int n = 1; //  
};
int n = 2; //  .
int X::x = n; //  X::n,  X::x  1

namespace A
{
   namespace N
   {
       void f();
       int i=3; //   (  )
   }
   int i=4; //   (  )
}

int i=5; //   (  )

void A::N::f()
{
    int i = 2; //   (  )
    while(true)
    {
       int i = 1; //  :  
       std::cout << i;
    }
}

// int i; //  

namespace A
{
  namespace N
  {
    // int i; //  
  }
}

namespace M
{
    // const int i = 1; //   
    class B
    {
        // static const int i = 3; //   (   
                                   // )
    };
}
// const int i = 5; //  
namespace N
{
    // const int i = 4; //  
    class Y : public M::B
    {
        // static const int i = 2; //  
        class X
        {
            // static const int i = 1; //  
            int a[i]; //  i
            // static const int i = 1; //   
        };
        // static const int i = 2; //   
    };
    // const int i = 4; //   
}
// const int i = 5; //   

class B
{
    // int i; //  
};
namespace M
{
    // int i; //  
    namespace N
    {
        // int i; //  
        class X : public B
        {
            // int i; //  
            void f();
            // int i; //   
        };
        // int i; //  
    }
}
// int i; //  
void M::N::X::f()
{
    // int i; //  
    i = 16;
    // int i; //   
}
namespace M
{
  namespace N
  {
    // int i; //   
  }
}

struct X { void f(); };
struct B1: virtual X { void f(); };
struct B2: virtual X {};
struct D : B1, B2
{
    void foo()
    {
        X::f(); // OK,  X::f ( )
        f(); // OK,  B1::f ( )
//  C++98: B1::f  X::f,    X::f     D
//  B2,          D.
//  C++11:    f  D   ,    
//     f  B1,  B1::f,  
//    ,     f  C  B1::f  B1
//     f  B2   ,      
//      f  X  X::f
//     ,     f  B2  X::f  X
//   C ,    (X)     B2 
//      (B1),  ,   B2
// 
// C    B1::f,   B1
// (    D : B2, B1,    * *  C,
//    X::f  X,    ,    C
// (  X),            (B1),
//     :    C   B1::f,
//   B1)
    }
};

struct V { int v; };
struct A
{
        int a;
        static int s;
        enum { e };
};
struct B : A, virtual V { };
struct C : A, virtual V { };
struct D : B, C { };

void f(D& pd)
{
        ++pd.v; // OK:   v,       
        ++pd.s; // OK:    A::s,      B  C
        int i = pd.e; // OK:    A::e,    
                      //  B  C
        ++pd.a; // , : A::a  B  A::a  C 
}

int i = 3; //    f1,    f2
struct X
{
    static const int i = 2; //    f1,     f2
    friend void f1(int x)
    {
        // int i; //  
        i = x; //    X::i
    }
    friend int f2();
    // static const int i = 2; //    f1    
};
void f2(int x)
{
    // int i; //  
    i = x; //    ::i
}

// , -  
struct A
{ 
    typedef int AT;
    void f1(AT);
    void f2(float);
    template <class T> void f3();
};

// ,  
struct B
{
    typedef char AT;
    typedef float BT;
    friend void A::f1(AT); //   AT  A::AT
    friend void A::f2(BT); //   BT  B::BT 
    friend void A::f3<AT>(); //   AT  B::AT 
};

class X
{
    int a, b, i, j;
public:
    const int& r;
    X(int i): r(a), //  X::r   X::a
              b(i), //  X::b   i
              i(i), //  X::i   i
              j(this->i) //  X::j  X::i
    { }
};

int a;
int f(int a, int b = a); // :   a   a,  ::a,
                         //         

struct X
{
    static int x;
    static const int n = 1; //  
};
int n = 2; //  .
int X::x = n; //  X::n,  X::x  1,   2

const int RED = 7;
enum class color
{
    RED,
    GREEN = RED+2, // RED  color::RED,  ::RED,  GREEN = 2
    BLUE = ::RED+4 //    ::RED, BLUE = 11
};

int n = 3; //  
int f(int n = 2) //  
try
{
   int n = -1;  //   
} catch(...)
{
   // int n = 1; //  
   assert(n == 2); //   n    f
   throw;
}

struct A {};
void operator+(A, A); //   operator+,   

struct B
{
    void operator+(B); //   operator+,  
    void f ();
};

A a;

void B::f() //  - B
{
    operator+(a,a); // :     -
                    //   operator+    B
                    //   ,    
                    //  
    a + a; // OK:    B::operator+,   
           //  ::operator+(A,A),    ::operator+(A,A)
}

void f(char); //   f

template<class T> 
void g(T t)
{
    f(1);    //  :   ::f(char)    
    f(T(1)); //  :  
    f(t);    //  :  
//  dd++;    //  :    
}

enum E { e };
void f(E);   //   f
void f(int); //   f
double dd;

void h()
{
    g(e);  //   g<E>,    
           //      'f'
           //    ::f(char) ( )  ::f(E)
           // ( ADL),     ::f(E).
           //   f(char),  f(E) 
    g(32); //   g<int>,    
           //      'f'
           //   ::f(char),  
           //    ::f(char)
           //   f(char)  
}

typedef double A;
template<class T> class B
{
   typedef int A;
};
template<class T> struct X : B<T>
{
   A a; //   A  ::A (double),  B<T>::A
};