>     internal struct Matrix
>     {}
> 
>     internal struct Vector
>     {
>         private float x;
>         private float y;
>         private float z;
> 
>         public Vector(float x, float y, float z)
>         {
>             this.x = x;
>             this.y = y;
>             this.z = z;
>         }
> 
>         public static Vector operator +(Vector l, Vector r)
>         {
>             return new Vector(l.x + r.x, l.y + r.y, l.z + r.z);
>         }
> 
>         public static Vector operator *(Vector l, float f)
>         {
>             return new Vector(l.x * f, l.y * f, l.z * f);
>         }
> 
>         public static Vector operator *(Vector l, Matrix m)
>         {
>             return new Vector(l.x, l.y, l.z);
>         }
>     }
> 
> 
>                 Vector v1 = new Vector(1, 2, 3);
>                 Vector v2 = new Vector(3, 2, 1);
>                 v1 = (v1 + v2) * 3;
>                 Matrix m = new Matrix();
>                 v1 = v1 * m;
>

WH>Линух 4ever!!! Мелкософт на свалку!!

WH>        delegate T Operator<T>(T l, T r);
WH>        interface IMathOperators<T>
WH>        {
WH>            Operator<T> Add { get; }
WH>            Operator<T> Sub { get; }
WH>            Operator<T> Mul { get; }
WH>            Operator<T> Div { get; }
WH>        }
WH>        class MathOperatorsInt : IMathOperators<int>
WH>        {
WH>            public Operator<int> Add { get { return delegate(int l, int r) { return l + r; }; } }
WH>            public Operator<int> Sub { get { return delegate(int l, int r) { return l - r; }; } }
WH>            public Operator<int> Mul { get { return delegate(int l, int r) { return l * r; }; } }
WH>            public Operator<int> Div { get { return delegate(int l, int r) { return l / r; }; } }
WH>        }
WH>        static Dictionary<Type, object> MathOperatorsMap = new Dictionary<Type, object>();
WH>        static IMathOperators<T> MathOperators<T>()
WH>        {
WH>            return (IMathOperators<T>)MathOperatorsMap[typeof(T)];
WH>        }
WH>        static Program()
WH>        {
WH>            MathOperatorsMap.Add(typeof(int), new MathOperatorsInt());
WH>        }
WH>

WH>        delegate T Parse<T>(string s);
WH>        static IEnumerable<T> Map<T>(Stream stream)
WH>        {
WH>            Parse<T> parse = (Parse<T>)Delegate.CreateDelegate(typeof(Parse<T>),
WH>                typeof(T), "Parse");
WH>            foreach (string line in Lines(stream))
WH>                yield return parse(line);
WH>        }
WH>        static T Sum<T>(IEnumerable<T> numbers)
WH>        {
WH>            Operator<T> add = MathOperators<T>().Add;
WH>            T val = default(T);
WH>            foreach (T number in numbers)
WH>                val = add(val, number);
WH>            return val;
WH>        }
WH>

FR>>import sys, itertools
FR>>print sum(itertools.imap(int, open("in.txt")))
FR>>

WH>    using (Stream file = File.OpenRead("text.txt"))
WH>        Console.WriteLine(Sum(Map<int>(file)));
WH>