Ошибка в программе `write' undeclared (first use this function)

#include <cstdlib>
#include <iostream>
 
using namespace std;
 
int main(int argc, char *argv[])
{
    system("PAUSE");
    return EXIT_SUCCESS;
}
 
    #define u unsigned
    struct BitMapFileHeader {
    unsigned __int16 Typf;      // тип файла
    unsigned __int32 Size;      // размер файла 
    unsigned __int16 Res1;      // зарезервировано
    unsigned __int16 Res2;      // зарезервировано
    unsigned __int32 OfBm;      // смещение изображения в байтах (1078)
    };
    
    struct bmInfoHeader {       // информационный заголовок
    unsigned __int32 Size;      // длина заголовка в байтах (40)
    unsigned __int32 Widt;      // ширина изображения (в точках)
    unsigned __int32 Heig;      // высота изображения (в точках)
    unsigned __int16 Plan;      // число плоскостей (1)
    unsigned __int16 BitC;      // глубина цвета (бит на точку) (8)
    unsigned __int32 Comp;      // тип компрессии (0 - нет)
    unsigned __int32 SizI;      // размер изображения в байтах
    unsigned __int32 XppM;      // горизонтальное разрешение точек на метр - обычно 0
    unsigned __int32 YppM;      // вертикальное разрешение точек на метр - обычно 0                
    unsigned __int32 NCoL;      // число цветов, если максимально допустимое - 0                  
    unsigned __int32 NCoI;      // число основных цветов
    };
 
    struct bmHeader {           // полный заголовок файла
    BitMapFileHeader f;         // заголовок файла
    bmInfoHeader i;             // информационный заголовок
    u char p[256*4];            // таблица палитры
    //int p[256];
    };
 
    int CreateBMP_Header (bmHeader &head, int x, int y);
    int WriteBMP_header (FILE *out, bmHeader &head);
 
    int CreateBMP_Header (bmHeader &head, int x, int y){
    
    //BitMapFileHeader
    head.f.Typf = (u __int16)(((__int8)'B')|((__int8)'M')<<8);
    head.f.Size = (u __int32)(x*y+1078);
    head.f.Res1 = 0;
    head.f.Res2 = 0;
    head.f.OfBm = 1078;
 
    //bmInfoHeader      
    head.i.Size = 40;
    head.i.Widt = x;
    head.i.Heig = y;
    head.i.Plan = 1;
    head.i.BitC = 8;
    head.i.Comp = 0;
    head.i.SizI = x*y;
    head.i.XppM = 11808;
    head.i.YppM = 11808;
    head.i.NCoL = 0;          
    head.i.NCoI = 0;
    //формирование таблицы цветов
    int j = 0;
    for (int i= 0; i<1024; j++){
        head.p[i++] = j;
        head.p[i++] = j;
        head.p[i++] = j;
        head.p[i++] = 0;
    }
 
 
    return 0;
};
 
int WriteBMP_header (int out, bmHeader &head){
    //BitMapFileHeader
    //write(out, &head, sizeof(head));
    
    write(out, &head.f.Typf, sizeof(head.f.Typf)); 
    write(out, &head.f.Size, sizeof(head.f.Size));
    write(out, &head.f.Res1, sizeof(head.f.Res1));
    write(out, &head.f.Res2, sizeof(head.f.Res2));
    write(out, &head.f.OfBm, sizeof(head.f.OfBm));
 
    //bmInfoHeader  
    write(out, &head.i.Size, sizeof(head.i.Size));
    write(out, &head.i.Widt, sizeof(head.i.Widt));
    write(out, &head.i.Heig, sizeof(head.i.Heig));
    write(out, &head.i.Plan, sizeof(head.i.Plan));
    write(out, &head.i.BitC, sizeof(head.i.BitC));
    write(out, &head.i.Comp, sizeof(head.i.Comp));
    write(out, &head.i.SizI, sizeof(head.i.SizI));
    write(out, &head.i.XppM, sizeof(head.i.XppM));
    write(out, &head.i.YppM, sizeof(head.i.YppM));
    write(out, &head.i.NCoL, sizeof(head.i.NCoL));
    write(out, &head.i.NCoI, sizeof(head.i.NCoI));
    
    
    write(out, &head.p, 1024);
    
 
    return 0;
};

int main(int argc, char *argv[])

system("PAUSE");

char *argv[];
int argc;
write(out, &head.p, 1024);

#include <windows.h>
#include <tchar.h>
#define  DIB_RGB(r, g, b) \
((DWORD)((r & 0xFF) << 16) | ((g & 0xFF) << 8) | (b & 0xFF)) 
 
void fill_rect(__int32*, int, int, int, int, int, DWORD);
 
 
 
 
 
// 24/32 бит
BOOL  SaveArrFile(const TCHAR* filename, const __int32* arr, 
                         int width, int height, int bpp = 24){
 
    if((bpp < 24) || (bpp > 32)) // только 24/32 бит
         return FALSE;
 
    DWORD p_row = (DWORD)((width * bpp + 31) & ~31) / 8uL;
    DWORD size  = (DWORD)(height * p_row);
 
    // формируем файловый заголовок
    BITMAPFILEHEADER  hdr;
    ZeroMemory(&hdr, sizeof(BITMAPFILEHEADER));
    hdr.bfType    = 0x4D42;
    hdr.bfOffBits = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER);
    hdr.bfSize    = hdr.bfOffBits + size;
 
    // заголовок описателя растра
    BITMAPINFO dib;
    ZeroMemory(&dib, sizeof(BITMAPINFO));
    dib.bmiHeader.biSize        = sizeof(BITMAPINFOHEADER);
    dib.bmiHeader.biBitCount  = bpp;
    dib.bmiHeader.biCompression  = BI_RGB;
    dib.bmiHeader.biPlanes  = 1u;
    dib.bmiHeader.biWidth   = (long)width;
    dib.bmiHeader.biHeight  = (long)-height;
    dib.bmiHeader.biSizeImage   = size;
    dib.bmiHeader.biXPelsPerMeter = 11811L;
    dib.bmiHeader.biYPelsPerMeter = 11811L;
    dib.bmiHeader.biClrImportant  = 0uL;
    dib.bmiHeader.biClrUsed  = 0uL;
 
    // далее запись в файл
    HANDLE fp = CreateFile(filename, GENERIC_WRITE, FILE_SHARE_WRITE, NULL, 
                                   CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
    if(fp == INVALID_HANDLE_VALUE)
           return FALSE;
 
    // записываем заголовки...
    DWORD  dwr = 0uL;
    WriteFile(fp, (LPCVOID)&hdr, sizeof(BITMAPFILEHEADER), &dwr, NULL);
    WriteFile(fp, (LPCVOID)&dib.bmiHeader, sizeof(BITMAPINFOHEADER), &dwr, NULL);
 
    // запись массива пикселей
    if(bpp == 32) // 32-бит
           WriteFile(fp, (LPCVOID)arr, size, &dwr, NULL);
    else if(bpp == 24) { // 24-бит с дополнением до 32-разрядной границы
 
          BYTE   nil = 0u;
          int   cb  = sizeof(RGBQUAD);
          int  align = ((cb - ((width*bpp + 7) / 8) % cb) % cb);
        
          for(int y = 0; y < height; y++) {
               for(int x = 0; x < width; x++) 
                    WriteFile(fp, (LPCVOID)&arr[y*width+x], sizeof(RGBTRIPLE), &dwr, NULL);
            
                    for(int i = 0; i < align; i++) // до границы DWORD
                          WriteFile(fp, (LPCVOID)&nil, sizeof(BYTE), &dwr, NULL);
               }
   }
 
   FlushFileBuffers(fp);
   CloseHandle(fp);
   return TRUE;
}
 
 
 
 
 
int  main(void) {
    //массив пикселей
    __int32 arr[111*222] = {0};
    int cw = 222; 
    int ch = 111;
 
    // нарисуем что-нибудь
    DWORD rgb;
    int   sx  = ch / 5;
    int   sy  = cw / 10;
    for(int y = 0; y < 5; y++) {
         for(int x = 0; x < 10; x++) {
              rgb = DIB_RGB(rand()%2*0xFF, rand()%2*0xFF, rand()%2*0xFF);
              fill_rect(arr, cw, x*sx, y*sy, sx, sy, rgb);
        }
    }
 
 
    // сохраняем в файл
    if(SaveArrFile(_T("grid.bmp"), arr, cw, ch, 24))
           _putts(_T("Good save file."));
    else
           _putts(_T("Error save file !"));
 
    _gettchar();
    return 0;
}
 
 
 
// вывод прямоугольника
void fill_rect(__int32* arr, int width, int x, int y, int cx, int cy, DWORD color){
     for(int r = y; r <= (y + cy); r++) {
          for(int c = x; c <= (x + cx); c++)
               arr[r*width + c] = color;
     }
}