#include <vector>

typedef unsigned char BYTE;

class image
{
    class rgb
    {
    public:
        BYTE r,g,b; /* 0..255 */
        rgb(BYTE rr, BYTE gg, BYTE bb) : r(rr),g(gg),b(bb) { }
        rgb() { }
    };
    
    void rgbscale(rgb &dest, const rgb &L, const rgb &R, double pos) const
    {
        dest.r = BYTE(L.r * (1-pos) + R.r * pos);
        dest.g = BYTE(L.g * (1-pos) + R.g * pos);
        dest.b = BYTE(L.b * (1-pos) + R.b * pos);
    }
    rgb rgbscale(const rgb &L, const rgb &R, double pos) const
    {
    	return rgb(L.r * (1-pos) + R.r * pos,
    	           L.g * (1-pos) + R.g * pos,
    	           L.b * (1-pos) + R.b * pos);
    }
    inline double frac(double x) const
    {
    	return x-(int)x;
    }    

public:
    unsigned Xsize, Ysize;
    vector<rgb> pix;
    
    image(unsigned x, unsigned y) : Xsize(x), Ysize(y), pix(x*y)
    {
    }
    
    void Scaleto(unsigned newX, unsigned newY)
    {
        image tmp(newX, newY);
        
        double Ystep = (double)newY / Ysize;
        double Xstep = (double)newX / Xsize;
        
        double Ys = 0;
        for(unsigned y=0; y<newY; ++y)
        {
            double Xs = 0;
            
            unsigned diu = Ysize*(unsigned)Ys;
            for(unsigned x=0; x<newX; ++x)
            {
            	unsigned Xd = (unsigned)Xs;
                rgb p1 = pix[diu+Xd],       p2 = pix[diu+Xd+1];
                rgb p3 = pix[diu+Xd+Xsize], p4 = pix[diu+Xd+1+Xsize];
                
                double fpart = frac(Ys);
                
                rgbscale(pix[y*newX+x],
                  rgbscale(p1,p3, fpart),
                  rgbscale(p2,p4, fpart),
                  frac(Xs));
                
                Xs += Xstep;
            }
            
            Ys += Ystep;
        }
        
        *this = tmp;
    }
    void operator= (const image &n)
    {
        pix = n.pix;
        Xsize = n.Xsize;
        Ysize = n.Ysize;
    }
};