interface I1<T> {}
interface I2<T> {}
class C1<U> {
   public void Fct1(U u){}   // This method can't ...
   public void Fct1(int i){} // ... be called if 'U' is 'int'.

   public void Fct2(U u1, U u2){}       // Not ambiguous.
   public void Fct2(int i, string s){}  

   public void Fct3(I1<U> a){}          // Not ambiguous.
   public void Fct3(I2<U> a){}

   public void Fct4(U a){}              // Not ambiguous.
   public void Fct4(U[] a){}
}
class C2<U,V> {
   public void Fct5(U u, V v){}     // Might be ambiguous if 'U'='V'.
   public void Fct5(V v, U u){}     

   public void Fct6(U u, V v){}     // Might be ambiguous if ...
   public void Fct6(V v, U u){}     // ... 'U'='V' and 'V'!='int'.
   public void Fct6(int u, V v){}

   public void Fct7(int u, V v){}   // Might be ambiguous if ...
   public void Fct7(U u, int v){}   // ... 'U'='V'='int'.

   public void Fct8(U u, I1<V> v){} // Might be ambiguous ...
   public void Fct8(I1<V> v, U u){} // ... for example c2<I1<int>,int>.

   public void Fct9(U u1, I1<V> v2){} // Not ambiguous.
   public void Fct9(V v1, U u2){}

   public void Fct10(ref U u){}       // Not ambiguous.
   public void Fct10(out V v){ v = default(V); }
}
class Program { 
   static void Main(){
      C1<int> a = new C1<int>();
      a.Fct1(34); // Call 'Fct1(int i)'.
      C2<int, int> b = new C2<int, int>();
      b.Fct5(13, 14);  //  Compilation Error: This call is ambiguous.
      b.Fct6(13, 14);  //  Call 'Fct6(int u, V v)'.
      b.Fct7(13, 14);  //  Compilation Error: This call is ambiguous.
      C2<I1<int>,int> c = new C2<I1<int>,int>();
      c.Fct8(null,null);// Compilation Error: This call is ambiguous.
   }
}