////////////////////////////////////////////////////////////////////////////////
using IntPtr_NumType         =System.Int64;
using IntPtr_UnsignedNumType =System.UInt64;
////////////////////////////////////////////////////////////////////////////////
//class intptr_utils

public static class intptr_utils
{
 private const ste_err_src_id c_src_id=ste_err_src_id.intptr_utils;

 //-----------------------------------------------------------------------
 public static readonly IntPtr_NumType Zero
  =0;

 public static readonly IntPtr_NumType MaxValue
  =t_intptr_utils__data.GetProvider().MaxValue;

 public static readonly IntPtr_NumType MinValue
  =t_intptr_utils__data.GetProvider().MinValue;

 //-----------------------------------------------------------------------
 public static IntPtr_NumType ToNumeric(IntPtr x)
 {
  return x.ToInt64();
 }//ToNumeric

 //-----------------------------------------------------------------------
 public static IntPtr ToIntPtr(IntPtr_NumType x)
 {
  if(!(MinValue<=x && x<=MaxValue))
   throw_sys_error.arithmetic_overflow(c_src_id,"ToIntPtr__NumType",x);

  return (IntPtr)x;
 }//ToIntPtr

 //IntPtr+UInt32 ---------------------------------------------------------
 public static IntPtr Add(IntPtr a,UInt32 b)
 {
  Debug.Assert(MinValue<0);
  Debug.Assert(MaxValue>0);

  var a1=ToNumeric(a);
  var b1=b;

  while(b1>MaxValue)
  {
   if(a1>0)
    throw_sys_error.arithmetic_overflow(c_src_id,"Add__IntPtr_UInt32",a,b);

   a1+=MaxValue;
   b1-=(UInt32)MaxValue;
  }//while b1>MaxValue

  Debug.Assert(b1>=0);
  Debug.Assert(b1<=MaxValue);

  Debug.Assert(a1>=MinValue);
  Debug.Assert(a1<=MaxValue);

  if(a1>=0)
  {
   if((MaxValue-a1)<b1)
    throw_sys_error.arithmetic_overflow(c_src_id,"Add__IntPtr_UInt32",a,b);
  }//a1>=0

  return (IntPtr)(a1+((IntPtr_NumType)b1));
 }//Add - IntPtr+UInt32

 //-----------------------------------------------------------------------
 public static IntPtr Add(UInt32 a,IntPtr b)
 {
  return Add(b,a);
 }//Add - UInt32+IntPtr

 //IntPtr+UInt64 ---------------------------------------------------------
 public static IntPtr Add(IntPtr a,UInt64 b)
 {
  Debug.Assert(MinValue<0);
  Debug.Assert(MaxValue>0);

  var a1=ToNumeric(a);
  var b1=b;

  while(b1>((IntPtr_UnsignedNumType)MaxValue))
  {
   if(a1>0)
    throw_sys_error.arithmetic_overflow(c_src_id,"Add__IntPtr_UInt64",a,b);

   a1+=MaxValue;
   b1-=(IntPtr_UnsignedNumType)MaxValue;
  }//while b1>MaxValue

  Debug.Assert(b1>=0);
  Debug.Assert(b1<=((IntPtr_UnsignedNumType)MaxValue));

  Debug.Assert(a1>=MinValue);
  Debug.Assert(a1<=MaxValue);

  if(a1>=0)
  {
   if(((IntPtr_UnsignedNumType)(MaxValue-a1))<b1)
    throw_sys_error.arithmetic_overflow(c_src_id,"Add__IntPtr_UInt64",a,b);
  }//a1>=0

  return (IntPtr)(a1+((IntPtr_NumType)b1));
 }//Add - IntPtr+UInt64

 //-----------------------------------------------------------------------
 public static IntPtr Add(UInt64 a,IntPtr b)
 {
  return Add(b,a);
 }//Add - UInt64+IntPtr
 
 //IntPtr+Int32 ----------------------------------------------------------
 public static IntPtr Add(IntPtr a,Int32 b)
 {
  Debug.Assert(MinValue<0);
  Debug.Assert(MaxValue>0);

  if(b>=0)
   return Add(a,(UInt32)b);

  return Sub(a,remove_numeric_sign.exec(b));
 }//Add - IntPtr+Int32

 //-----------------------------------------------------------------------
 public static IntPtr Add(Int32 a,IntPtr b)
 {
  return Add(b,a);
 }//Add - Int32+IntPtr

 //IntPtr+UIntPtr --------------------------------------------------------
 public static IntPtr Add(IntPtr a,UIntPtr b)
 {
  Debug.Assert(MinValue<0);
  Debug.Assert(MaxValue>0);

  var a1=ToNumeric(a);
  var b1=uintptr_utils.ToNumeric(b);

  while(b1>((IntPtr_UnsignedNumType)MaxValue))
  {
   if(a1>0)
    throw_sys_error.arithmetic_overflow(c_src_id,"Add__IntPtr_UIntPtr",a,b);

   a1+=MaxValue;
   b1-=(IntPtr_UnsignedNumType)MaxValue;
  }//while b1>MaxValue

  Debug.Assert(b1>=0);
  Debug.Assert(b1<=((IntPtr_UnsignedNumType)MaxValue));

  Debug.Assert(a1>=MinValue);
  Debug.Assert(a1<=MaxValue);

  if(a1>=0)
  {
   if(((IntPtr_UnsignedNumType)(MaxValue-a1))<b1)
    throw_sys_error.arithmetic_overflow(c_src_id,"Add__IntPtr_UIntPtr",a,b);
  }//a1>=0

  return (IntPtr)(a1+((IntPtr_NumType)b1));
 }//Add - IntPtr+UIntPtr

 //-----------------------------------------------------------------------
 public static IntPtr Add(UIntPtr a,IntPtr b)
 {
  return Add(b,a);
 }//Add - UIntPtr, IntPtr

 //-----------------------------------------------------------------------
 public static IntPtr Sub(IntPtr a,UInt32 b)
 {
  Debug.Assert(MinValue<0);
  Debug.Assert(MaxValue>0);
  Debug.Assert(MaxValue==-(MinValue+1));

  var a1=ToNumeric(a);
  var b1=b;

  if(a1>=0)
  {
   if(a1>=b1)
    return (IntPtr)(a1-((IntPtr_NumType)b1));

   b1-=(UInt32)a1;
   a1=0;
  }//if a1>0

  Debug.Assert(a1<=0);

  while(b1>MaxValue)
  {
   Debug.Assert(a1>=MinValue);
   Debug.Assert(a1<=MaxValue);

   if(a1<0)
    throw_sys_error.arithmetic_overflow(c_src_id,"Sub__IntPtr_UInt32",a,b);

   a1-=MaxValue;
   b1-=(UInt32)MaxValue;
  }//while b>MaxValue

  Debug.Assert(a1<=0);
  Debug.Assert(a1>=MinValue);
  Debug.Assert(b1<=MaxValue);

  if(a1<0)
  {
   if((a1-MinValue)<b1)
    throw_sys_error.arithmetic_overflow(c_src_id,"Sub__IntPtr_UInt32",a,b);
  }//if a1<0

  return (IntPtr)(a1-((IntPtr_NumType)b1));
 }//Sub - IntPtr, UInt32

 //private data ----------------------------------------------------------
 private static readonly t_intptr_utils__provider
  sm_Impl=t_intptr_utils__data.GetProvider();
}//class intptr_utils

public static class serialization_utils
{
 public static void read_value<T>(SerializationInfo si,string name,out T value)
 {
  Debug.Assert(si!=null);
  Debug.Assert(name!=null);
  Debug.Assert(name!="");

  value=(T)si.GetValue(name,typeof(T));
 }//read_value

 //-----------------------------------------------------------------------
 public static void write_value<T>(SerializationInfo si,string name,T value)
 {
  Debug.Assert(si!=null);
  Debug.Assert(name!=null);
  Debug.Assert(name!="");

  si.AddValue(name,value,typeof(T));
 }//write_value
}//class serialization_utils

////////////////////////////////////////////////////////////////////////////////
//interface IComparer2_Base

public interface IComparer2_Base<T1,T2,tagID>
{
 int Compare(T1 a,T2 b);
};//interface IComparer2_Base

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

public class tagComparer2_Base_ID1<T1,T2>{};                                    
public class tagComparer2_Base_ID2<T1,T2>{};                                    
public class tagComparer2_Base_ID3<T1,T2>{};                                    
public class tagComparer2_Base_ID4<T1,T2>{};

////////////////////////////////////////////////////////////////////////////////
//interface IComparer2

public interface IComparer2<T1,T2>:IComparer2_Base<T1,T2,tagComparer2_Base_ID1<T1,T2>>,
                                   IComparer2_Base<T2,T1,tagComparer2_Base_ID2<T1,T2>>,
                                   IComparer2_Base<T1,T1,tagComparer2_Base_ID3<T1,T2>>,
                                   IComparer2_Base<T2,T2,tagComparer2_Base_ID4<T1,T2>>
{
};//interface IComparer2

////////////////////////////////////////////////////////////////////////////////
//class lower_bound

public static class lower_bound
{
 static public int exec<TItem,TKey>(IList<TItem>           container,
                                    TKey                   key,
                                    IComparer2<TItem,TKey> comparer)
 {
  Debug.Assert(container!=null);
  Debug.Assert(comparer!=null);

  int left=0;
  int right=container.Count;

  while(right>left)
  {
   int middle=left+(right-left)/2;

   Debug.Assert(right>middle);
   Debug.Assert(comparer.Compare(container[left],container[middle])<=0);

   if(comparer.Compare(container[middle],key)<0)
   {
    left=middle+1;
    continue;
   }

   right=middle;
  }//for[ever]

  return left;
 }//exec

 //-----------------------------------------------------------------------
 static public int exec<TKey>(IList<TKey>     container,
                              TKey            key,
                              IComparer<TKey> comparer)
 {
  Debug.Assert(container!=null);
  Debug.Assert(comparer!=null);

  int left=0;
  int right=container.Count;

  while(right>left)
  {
   int middle=left+(right-left)/2;

   Debug.Assert(right>middle);
   Debug.Assert(comparer.Compare(container[left],container[middle])<=0);

   if(comparer.Compare(container[middle],key)<0)
   {
    left=middle+1;
    continue;
   }

   right=middle;
  }//for[ever]

  return left;
 }//exec
}//class lower_bound

public struct t_search_result<TPosition>
{
 public TPosition position;
 public bool      result;

 public t_search_result(TPosition pos,bool res)
 {
  this.position=pos;
  this.result  =res;
 }//t_search_result
};//struct t_search_result

public static class lower_search
{
 public static t_search_result<int>
  exec<TItem,TKey>(IList<TItem>           container,
                   TKey                   key,
                   IComparer2<TItem,TKey> comparer)
 {
  Debug.Assert(container!=null);
  Debug.Assert(comparer!=null);

  int x=lower_bound.exec(container,key,comparer);

  Debug.Assert(x>=0);
  Debug.Assert(x<=container.Count);

  if(x<container.Count)
  {
   int c=comparer.Compare(key,container[x]);

   if(c==0)
    return new t_search_result<int>(x,true);

   Debug.Assert(c<0);
  }//if

  return new t_search_result<int>(x,false);
 }//exec

 //-----------------------------------------------------------------------
 public static t_search_result<int>
  exec<TKey>(IList<TKey>            container,
             TKey                   key,
             IComparer<TKey>        comparer)
 {
  Debug.Assert(container!=null);
  Debug.Assert(comparer!=null);

  int x=lower_bound.exec(container,key,comparer);

  Debug.Assert(x>=0);
  Debug.Assert(x<=container.Count);

  if(x<container.Count)
  {
   int c=comparer.Compare(key,container[x]);

   if(c==0)
    return new t_search_result<int>(x,true);

   Debug.Assert(c<0);
  }//if

  return new t_search_result<int>(x,false);
 }//exec
};//class lower_search

using System;
using System.Collections.Generic;

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

interface IProcessor2<T1,T2>
{
};

////////////////////////////////////////////////////////////////////////////////
//class utils

class utils
{
 public static void exec<T1,T2>(IList<T1> list,T2 key,IProcessor2<T1,T2> proc)
 {
 }
}//utils

////////////////////////////////////////////////////////////////////////////////
//processors

class TProcessor:IProcessor2<string,int>,IProcessor2<Guid,int>
{
};//class TProcessor

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

class Program
{
 static int Main()
 {
  var list_str=new List<string>();
  var list_guid=new List<Guid>();

  var proc=new TProcessor();

  int n=0;
  
  //VS2010 - ok.
  
  //VS2008 - fail
  //Ошибка    1    Аргументы-типы для метода
  //"utils.exec<T1,T2>(System.Collections.Generic.IList<T1>, T2, IProcessor2<T1,T2>)"
  //не должны определяться по использованию. Попытайтесь явно определить аргументы-типы.
  
  utils.exec/*<string,int>*/(list_str,n,proc);
  utils.exec/*<Guid,int>*/(list_guid,n,proc);
  
  return 0;
 }//Main
}//class Program