class TAngle{
private:
      scalar FValue;   
protected:
      inline scalar GetRadians(){return Value*M_2xPI;};
      inline scalar GetDegrees(){return Value*360.;};
      inline scalar GetGrads(){return Value*400.;};
      inline scalar GetScale(TAngleScale n){return Value*AngleScales[n];};
      inline scalar GetCustomScale(scalar aScale){return Value*aScale;};
      inline void SetRadians(scalar New){Value=New/M_2xPI;};
      inline void SetDegrees(scalar New){Value=New/360.;};
      inline void SetGrads(scalar New){Value=New/400.;};
      inline void SetScale(TAngleScale n,scalar New){Value=New/AngleScales[n];};
      inline void SetCustomScale(scalar aScale,scalar New){Value=New/aScale;};
      inline void SetValue(scalar New){FValue=New-(int)New;if (FValue<0) FValue=1+FValue;else if (FValue==1)FValue=0;};
      inline TVector __fastcall GetVector(){scalar c,s; SinCos(Radians,&s,&c); return TVector(c,s,0);};
      inline void  SetVector(TVector New){Radians=ArcTan2(New.y,New.x);};
public:
      __property scalar Scale[TAngleScale ScaleId]={read=GetScale,write=SetScale};
      __property scalar CustomScale[scalar aScale]={read=GetCustomScale,write=SetCustomScale};
      __property scalar Radians={read=GetRadians,write=SetRadians};
      __property scalar Degrees={read=GetDegrees,write=SetDegrees};
      __property scalar Grads={read=GetGrads,write=SetGrads};
      __property TVector Vector={read=GetVector,write=SetVector};
      __property scalar Value={read=FValue,write=SetValue};
      __fastcall TAngle(){FValue=0;};
      __fastcall TAngle(scalar V){Value=V;};
      TAngle __fastcall operator -(){TAngle A; A.Value=-Value;return A;};
      inline TAngle& operator -=(const TAngle &Angle){Value-=Angle.Value;return *this;};
      inline TAngle& operator +=(const TAngle &Angle){Value+=Angle.Value;;return *this;};
      inline TAngle& operator *=(const scalar& V){Value*=V;return *this;};
      inline TAngle& __fastcall operator /=(const scalar& V){Value/=V;return *this;};
 
      inline TAngle operator *(const scalar& V){TAngle A; A.Value=Value*V;return A;};
      inline TAngle operator /(const scalar& V){TAngle A; A.Value=Value/V;return A;};
      inline TAngle operator +(const TAngle& A){TAngle R; R.Value=Value+A.Value;return R;};
      inline TAngle operator -(const TAngle& A){TAngle R; R.Value=Value-A.Value;return R;};
      inline scalar operator /(const TAngle& A){return Value/A.Value;};
 
      inline bool operator ==(const TAngle &Angle){return Value==Angle.Value;};
      inline bool operator !=(const TAngle &Angle){return Value!=Angle.Value;};
      inline bool operator <=(const TAngle &Angle){return Value>=Angle.Value;};
      inline bool operator >=(const TAngle &Angle){return Value<=Angle.Value;};
      inline bool operator >(const TAngle &Angle){return Value>Angle.Value;};
      inline bool operator <(const TAngle &Angle){return Value<Angle.Value;};
};

void main(void){
      TMax<unsigned> max,max2;
      for (int i=0;i<100;i++) max<<rand();
      for (int i=0;i<300;i++) max2<<rand();
      max<<max2;
      cout<<"Max:"<<(int)max<<endl<<"MaxId:"<<MaxId;
}

template <class Type>
class TFind{
private:
      Type FNeedle;   
protected:    
    unsigned __int32 FCount=0;    
    unsigned __int32 FFound=0;    
    int FFirstId=-1;      
    int FLastId=-1;      
    bool FLatest=false;
public:
    inline TFind(const Type& aNeedle ):FNeedle(Needle){};   
        inline void Reset(){
           FLatest=FFound=FCount=0;
           FFirsId=FLastId=-1;
    };
    inline TFind& operator << (const Type& Right){
        if (FLatestPassed=Compare(NeedleRight)){        
            FLastId=FCount;
            if (!Found) FFirstId=FCount;
            FFound++;
        } 
        FCount++;
        return &this;
    };
    inline TFind& operator <<(const TFind& Right){          
          if (Right.Count){
               FFirstId=Found?FirstId:Right.Found?Right.FirstId+Count:-1;
               FLastId=Right.LastId+Count;
               FFound+=Right.Found;
               FCount+=Right.Count;
               FLatestPassed=Right.LatestPassed;
          }
          return &this;
    }
     operator bool(){return FLatestPassed;};
         operator int(){return FLastId;};   
    __property unsigned Count={read=FCount};
    __property Type Needle={read=FNeedle};
    __property unsigned Found={read=FFound};
        __property int FirstId={read=FFirstId};
    __property int LastId={read=FLastId};
    __property LatestPassed={read=FLatestPassed}; 
};
 
template <class Type> class TFindEqual:public TFind<Type>{
public:
    TFindEqual(const Type& aNeedle):TFind(aNeedle){};
    inline bool Compare(const Type& L,const Type& R) {return L==R;};
};

struct TVersion {
    int Digits[2];
 
    TVersion() : Major(1), Minor(0) {
    };
 
    TVersion(unsigned aMajor, unsigned aMinor) : Major(aMajor), Minor(aMinor) {
    }
 
    TVersion(const char* VersionStr) {
        int n = 0;
        Digits[0] = 0;
        bool Digit = *VersionStr >= '0' && *VersionStr <= '9';
        while (*VersionStr) {
            if (*VersionStr >= '0' && *VersionStr <= '9') {
                Digit = true;
                Digits[n] *= 10;
                Digits[n] += *VersionStr - '0';
            }
            else {
                if (Digit) {
                    n++;
                    if (n > 1)
                        break;
                    Digits[n] = 0;
                }
                Digit = false;
            }
            VersionStr++;
        };
 
    }
    inline TVersion& operator = (const TVersion & R) {
        Major = R.Major;
        Minor = R.Minor;
        return *this;
    }
 
    inline bool operator != (const TVersion& R) const {
        return (Major == R.Major && Minor == R.Minor);
    }
 
    inline bool operator == (const TVersion& R) const {
        return (Major == R.Major && Minor == R.Minor);
    }
 
    inline bool operator >= (const TVersion& R) const {
        if (Major >= R.Major)
            return true;
        if (Minor >= R.Minor)
            return true;
        return false;
    }
 
    inline bool operator > (const TVersion& R) const {
        if (Major > R.Major)
            return true;
        if (Minor > R.Minor)
            return true;
        return false;
    }
 
    inline bool operator < (const TVersion& R) const {
        if (Major < R.Major)
            return true;
        if (Minor < R.Minor)
            return true;
        return false;
    }
 
    inline bool operator <= (const TVersion& R) const {
        if (Major <= R.Major)
            return true;
        if (Minor <= R.Minor)
            return true;
        return false;
    }
    inline int GetVer(int Id) const {return Digits[Id];}
    inline void SetVer(int Id, int Value){Digits[Id]=Value;}
    __property int Major = {index=0, read = GetVer,write=SetVer};
    __property int Minor = {index=1, read = GetVer,write=SetVer};
};