(len-- == 0 ||
                      (begin[3] == '\0' &&
                       memcmp(begin, begin + 4, len) == 0))))))));
}
//---------------------------------------------------------
/*
 * One 4-byte pointer per block and then the actual blocked
 * output. The first block does not need an offset pointer,
 * as it will start immediately after the pointer block;
 * so the i'th pointer points to the end of the i'th block
 * (i.e. the start of the (i+1)'th block or past EOF).
 *
 * Note that size > 0, as a zero-sized file wouldn't ever
 * have gotten here in the first place.
 */
static unsigned int do_compress(char *base, unsigned int offset,
        char const *name, char *uncompressed, unsigned int size)
{
        unsigned long original_size = size;
        unsigned long original_offset = offset;
        unsigned long new_size;
        unsigned long blocks = (size - 1) / blksize + 1;
        unsigned long curr = offset + 4 * blocks;
        int change;

        total_blocks += blocks;

        do {
                unsigned long len = 2 * blksize;
                unsigned int input = size;
                int err;

                if (input > blksize)
                        input = blksize;
                size -= input;
                if (!(opt_holes && is_zero (uncompressed, input))) {
                        err = compress2(base + curr, &len, uncompressed, input, Z_BEST_COMPRESSION);
                        if (err != Z_OK) {
                                die(MKFS_ERROR, 0, "compression error: %s", zError(err));
                        }
                        curr += len;
                }
                uncompressed += input;

                if (len > blksize*2) {
                        /* (I don't think this can happen with zlib.) */
                        die(MKFS_ERROR, 0, "AIEEE: block \"compressed\" to > 2*blocklength (%ld)", len);
                }

                *(u32 *) (base + offset) = curr;
                offset += 4;
        } while (size);

        curr = (curr + 3) & ~3;
        new_size = curr - original_offset;
        /* TODO: Arguably, original_size in these 2 lines should be
           st_blocks * 512.  But if you say that then perhaps
           administrative data should also be included in both. */
           
        change = new_size - original_size;
        if (opt_verbose > 1) {
                printf("%6.2f%% (%+d bytes)\t%s\n",
                       (change * 100) / (double) original_size, change, name);
        }

        return curr;
}
//---------------------------------------------------------
/*
 * Traverse the entry tree, writing data for every item that has
 * non-null entry->path (i.e. every non-empty regfile) and non-null
 * entry->uncompressed (i.e. every symlink).
 */
static unsigned int write_data(struct entry *entry, char *base, unsigned int offset)
{
        do {
                if (entry->path || entry->uncompressed) {
                        if (entry->same) {
                                set_data_offset(entry, base, entry->same->offset);
                                entry->offset = entry->same->offset;
                        }
                        else {
                                set_data_offset(entry, base, offset);
                                entry->offset = offset;
                                map_entry(entry);
                                offset = do_compress(base, offset, entry->name,
                                        (char *)entry->uncompressed, entry->size);
                                unmap_entry(entry);
                        }
                }
                else if (entry->child)
                        offset = write_data(entry->child, base, offset);
                entry=entry->next;
        } while (entry);
        return offset;
}
//---------------------------------------------------------
static unsigned int write_file(char *file, char *base, unsigned int offset)
{
        /*
        int fd;
        char *buf;

        fd = open(file, O_RDONLY);
        if (fd < 0) {
                die(MKFS_ERROR, 1, "open failed: %s", file);
        }
        buf = mmap(NULL, image_length, PROT_READ, MAP_PRIVATE, fd, 0);
        if (buf == MAP_FAILED) {
                die(MKFS_ERROR, 1, "mmap failed");
        }
        memcpy(base + offset, buf, image_length);
        munmap(buf, image_length);
        close (fd);
        */

        HANDLE fh;
        HANDLE fm;
        char *buf;

        DWORD Access = GENERIC_READ;
        DWORD AShare = FILE_SHARE_READ;
        DWORD Create = OPEN_EXISTING;
        DWORD Attrib = FILE_FLAG_SEQUENTIAL_SCAN;

        fh = CreateFile(file, Access, AShare, 0, Create, Attrib, 0);

        if(fh == INVALID_HANDLE_VALUE)
        {
                die(MKFS_ERROR, 1, "open failed: %s", file);
        }

        fm = CreateFileMapping(fh, NULL, PAGE_READONLY, 0, image_length, NULL);

        if(fm == INVALID_HANDLE_VALUE)
        {
                die(MKFS_ERROR, 1, "fmap failed: %s", file);
        }

        buf = (char *)MapViewOfFile(fm, FILE_MAP_READ, 0, 0, image_length);

        if(buf == NULL)
        {
                die(MKFS_ERROR, 1, "mapv failed: %s", file);
        }

        memcpy(base + offset, buf, image_length);

        UnmapViewOfFile(buf);

        CloseHandle(fm);
        CloseHandle(fh);

        /* Pad up the image_length to a 4-byte boundary */
        while (image_length & 3) {
                *(base + offset + image_length) = '\0';
                image_length++;
        }
        return (offset + image_length);
}
//---------------------------------------------------------
void _main(const char *dirname, const char *outfile)
{
        struct stat st;         /* used twice... */
        struct entry *root_entry;
        char *rom_image;
        DWORD offset, written;
        int fd;
        /* initial guess (upper-bound) of required filesystem size */
        DWORD fslen_ub = sizeof(struct cramfs_super);
        //char const *dirname, *outfile;
        u32 crc;
        int c;                  /* for getopt */
        char *ep;               /* for strtoul */

        total_blocks = 0;

        progname = "make_cramfs";//argv[0];

        if (lstat(dirname, &st) < 0) {
                die(MKFS_USAGE, 1, "stat failed: %s", dirname);
        }

        //fd = open(outfile, O_WRONLY | O_CREAT | O_TRUNC, 0666);
        fd = FileCreate(outfile);
        if (fd < 0) {
                die(MKFS_USAGE, 1, "open failed: %s", outfile);
        }

        root_entry = (struct entry *)calloc(1, sizeof(struct entry));
        if (!root_entry) {
                die(MKFS_ERROR, 1, "calloc failed");
        }
        root_entry->mode = st.st_mode;
        root_entry->uid = st.st_uid;
        root_entry->gid = st.st_gid;

        root_entry->size = parse_directory(root_entry,
            dirname, &root_entry->child, (unsigned int *)&fslen_ub);

        /* always allocate a multiple of blksize bytes because that's
           what we're going to write later on */
        fslen_ub = ((fslen_ub - 1) | (blksize - 1)) + 1;

        if (fslen_ub > MAXFSLEN) {
                fprintf(stderr,
                        "warning: estimate of required size (upper bound) is %LdMB, but maximum image size is %uMB, we might die prematurely\n",
                        fslen_ub >> 20,
                        MAXFSLEN >> 20);
                fslen_ub = MAXFSLEN;
        }

        /* find duplicate files. TODO: uses the most inefficient algorithm
           possible. */
        eliminate_doubles(root_entry, root_entry);

        /* TODO: Why do we use a private/anonymous mapping here
           followed by a write below, instead of just a shared mapping
           and a couple of ftruncate calls?  Is it just to save us
           having to deal with removing the file afterwards?  If we
           really need this huge anonymous mapping, we ought to mmap
           in smaller chunks, so that the user doesn't need nn MB of
           RAM free.  If the reason is to be able to write to
           un-mmappable block devices, then we could try shared mmap
           and revert to anonymous mmap if the shared mmap fails. */
        //rom_image = mmap(NULL, fslen_ub?fslen_ub:1, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);

        //if (rom_image == MAP_FAILED) {
        //      die(MKFS_ERROR, 1, "mmap failed");
        //}
        HANDLE fm;

        fm = CreateFileMapping(INVALID_HANDLE_VALUE, NULL,
                PAGE_READWRITE, 0, fslen_ub ? fslen_ub : 1, NULL);

        if(fm == INVALID_HANDLE_VALUE)
        {
                die(MKFS_ERROR, 1, "mmap failed");
        }

        rom_image = (char *)MapViewOfFile(fm,
                FILE_MAP_ALL_ACCESS, 0, 0, fslen_ub ? fslen_ub  : 1);

        if(rom_image == NULL)
        {
                die(MKFS_ERROR, 1, "mapv failed");
        }

        /* Skip the first opt_pad bytes for boot loader code */
        offset = opt_pad;
        memset(rom_image, 0x00, opt_pad);

        /* Skip the superblock and come back to write it later. */
        offset += sizeof(struct cramfs_super);

        /* Insert a file image. */
        if (opt_image) {
                printf("Including: %s\n", opt_image);
                offset = write_file(opt_image, rom_image, offset);
        }

        offset = write_directory_structure(root_entry->child, rom_image, offset);
        printf("Directory data: %d bytes\n", offset);

        offset = write_data(root_entry, rom_image, offset);

        /* We always write a multiple of blksize bytes, so that
           losetup works. */
        offset = ((offset - 1) | (blksize - 1)) + 1;
        printf("Everything: %d kilobytes\n", offset >> 10);

        /* Write the superblock now that we can fill in all of the fields. */
        write_superblock(root_entry, rom_image+opt_pad, offset);
        printf("Super block: %d bytes\n", sizeof(struct cramfs_super));

        /* Put the checksum in. */
        crc = crc32(0L, Z_NULL, 0);
        crc = crc32(crc, (rom_image+opt_pad), (offset-opt_pad));
        ((struct cramfs_super *) (rom_image+opt_pad))->fsid.crc = crc;
        printf("CRC: %x\n", crc);

        /* Check to make sure we allocated enough space. */
        if (fslen_ub < offset) {
                die(MKFS_ERROR, 0, "not enough space allocated for ROM image (%Ld allocated, %d used)", fslen_ub, offset);
        }

        //written = write(fd, rom_image, offset);
        written = FileWrite(fd, rom_image, offset);
        if (written < 0) {
                die(MKFS_ERROR, 1, "write failed");
        }
        if (offset != written) {
                die(MKFS_ERROR, 0, "ROM image write failed (wrote %d of %d bytes)", written, offset);
        }

        UnmapViewOfFile(rom_image);
        CloseHandle(fm);

        FileClose(fd);

//      /* (These warnings used to come at the start, but they scroll off the
//         screen too quickly.) */
//      if (warn_namelen)
//              fprintf(stderr, /* bytes, not chars: think UTF-8. */
//                      "warning: filenames truncated to %d bytes (possibly less if multi-byte UTF-8)\n",
//                      CRAMFS_MAXPATHLEN);
//      if (warn_skip)
//              fprintf(stderr, "warning: files were skipped due to errors\n");
//      if (warn_size)
//              fprintf(stderr,
//                      "warning: file sizes truncated to %luMB (minus 1 byte)\n",
//                      1L << (CRAMFS_SIZE_WIDTH - 20));
//      if (warn_uid) /* (not possible with current Linux versions) */
//              fprintf(stderr,
//                      "warning: uids truncated to %u bits (this may be a security concern)\n",
//                      CRAMFS_UID_WIDTH);
//      if (warn_gid)
//              fprintf(stderr,
//                      "warning: gids truncated to %u bits (this may be a security concern)\n",
//                      CRAMFS_GID_WIDTH);
//      if (warn_dev)
//              fprintf(stderr,
//                      "WARNING: device numbers truncated to %u bits (this almost certainly means\n"
//                      "that some device files will be wrong)\n",
//                      CRAMFS_OFFSET_WIDTH);
//      if (opt_errors &&
//          (warn_namelen||warn_skip||warn_size||warn_uid||warn_gid||warn_dev))
//              exit(MKFS_ERROR);
//
//      exit(MKFS_OK);
}
//---------------------------------------------------------
#endif//CRAMFS_CB_C