le32enc
le32enc(p, uuid->time_low);
le32enc(where, addr);
le32enc(where, addr);
le32enc(where, addr);
le32enc(where, addr);
le32enc(where, addr);
le32enc(where, addr);
le32enc(hdr.fei, fei);
le32enc(buf, (uint32_t)val);
le32enc(p + 8, d->dp_start);
le32enc(p + 12, d->dp_size);
le32enc(p, (uint32_t)nextcl);
le32enc(p, (uint32_t)nextcl);
le32enc(va, val);
le32enc(md + 0, ctx->state[0]);
le32enc(md + 4, ctx->state[1]);
le32enc(md + 8, ctx->state[2]);
le32enc(md + 12, ctx->state[3]);
le32enc(hdr->fei, fei);
le32enc(&rfa->link_addr, 0xffffffff);
le32enc(&rfa->rbd_addr, 0xffffffff);
le32enc(&p_rfa->link_addr, rxp->rx_addr);
le32enc(&rfa->link_addr, 0xffffffff);
le32enc(&rfa->rbd_addr, 0xffffffff);
le32enc(buf, (uint32_t)secs);
le32enc(hdr->fei, fei);
#define putulong(p, v) le32enc(p, v)
le32enc(data + 16, md->md_version);
le32enc(data + 36, md->md_bsize);
le32enc(data + 40, md->md_size);
le32enc(data + 16, md->md_version);
le32enc(data + 36, md->md_id);
le32enc(p, md->md_flags); p += sizeof(md->md_flags);
le32enc(p, md->md_sectorsize); p += sizeof(md->md_sectorsize);
le32enc(p, md->md_iterations); p += sizeof(md->md_iterations);
le32enc(p, md->md_flags); p += sizeof(md->md_flags);
le32enc(p, md->md_sectorsize); p += sizeof(md->md_sectorsize);
le32enc(p, md->md_iterations); p += sizeof(md->md_iterations);
le32enc(p, md->md_version);
le32enc(ptr + 0, d->p_size);
le32enc(ptr + 4, d->p_offset);
le32enc(ptr + 8, d->p_fsize);
le32enc(ptr + 0, d->d_magic);
le32enc(ptr + 40, d->d_secsize);
le32enc(ptr + 44, d->d_nsectors);
le32enc(ptr + 48, d->d_ntracks);
le32enc(ptr + 52, d->d_ncylinders);
le32enc(ptr + 56, d->d_secpercyl);
le32enc(ptr + 60, d->d_secperunit);
le32enc(ptr + 68, d->d_acylinders);
le32enc(ptr + 80, d->d_headswitch);
le32enc(ptr + 84, d->d_trkseek);
le32enc(ptr + 88, d->d_flags);
le32enc(ptr + 92, d->d_drivedata[0]);
le32enc(ptr + 96, d->d_drivedata[1]);
le32enc(ptr + 100, d->d_drivedata[2]);
le32enc(ptr + 104, d->d_drivedata[3]);
le32enc(ptr + 108, d->d_drivedata[4]);
le32enc(ptr + 112, d->d_spare[0]);
le32enc(ptr + 116, d->d_spare[1]);
le32enc(ptr + 120, d->d_spare[2]);
le32enc(ptr + 124, d->d_spare[3]);
le32enc(ptr + 128, d->d_spare[4]);
le32enc(ptr + 132, d->d_magic2);
le32enc(ptr + 140, d->d_bbsize);
le32enc(ptr + 144, d->d_sbsize);
le32enc(data, hdr->jh_journal_id);
le32enc(data, hdr->jh_journal_next_id);
le32enc(data, hdr->jrh_journal_id);
le32enc(data + 16, md->md_version);
le32enc(data + 20, md->md_id);
le32enc(data + 49, md->md_jid);
le32enc(data + 16, md->md_version);
le32enc(data + 16, md->md_version);
le32enc(data + 36, md->md_mid);
le32enc(data + 40, md->md_did);
le32enc(data + 45, md->md_genid);
le32enc(data + 49, md->md_syncid);
le32enc(data + 54, md->md_slice);
le32enc(data + 67, md->md_sectorsize);
le32enc(data, md->md_version);
le32enc(data, md->md_sectorsize);
le32enc(ptr + 0, DISKMAGIC); /* d_magic */
le32enc(ptr + 40, pp->sectorsize); /* d_secsize */
le32enc(ptr + 44, basetable->gpt_sectors); /* d_nsectors */
le32enc(ptr + 48, basetable->gpt_heads); /* d_ntracks */
le32enc(ptr + 52, ncyls); /* d_ncylinders */
le32enc(ptr + 56, secpercyl); /* d_secpercyl */
le32enc(ptr + 60, msize); /* d_secperunit */
le32enc(ptr + 132, DISKMAGIC); /* d_magic2 */
le32enc(ptr + 140, BBSIZE); /* d_bbsize */
le32enc(table->bbarea + pp->sectorsize + 60, msize); /* d_secperunit */
le32enc(buf + 60, msize);
le32enc(p + 0, entry->part.p_size);
le32enc(p + 4, entry->part.p_offset);
le32enc(p + 8, entry->part.p_fsize);
le32enc(&dlp->d_magic, DISKMAGIC64);
le32enc(&dlp->d_align, table->d_align);
le32enc(&dlp->d_npartitions, basetable->gpt_entries);
le32enc(&dlp->d_crc, crc32(&dlp->d_magic, v));
le32enc(buf + 8, start);
le32enc(buf + 12, end - start + 1);
le32enc(p + 8, entry->ent.dp_start);
le32enc(p + 12, entry->ent.dp_size);
le32enc(buf + 8, table->hdr->hdr_revision);
le32enc(buf + 12, table->hdr->hdr_size);
le32enc(buf + 80, table->hdr->hdr_entries);
le32enc(buf + 84, table->hdr->hdr_entsz);
le32enc(buf + 88, crc);
le32enc(buf + 16, 0); /* hdr_crc_self. */
le32enc(buf + 16, crc);
le32enc(buf + 16, 0); /* hdr_crc_self. */
le32enc(buf + 16, crc);
le32enc(mbr + 8, (uint32_t)start);
le32enc(mbr + 12, (uint32_t)(end - start + 1));
le32enc(p + 8, entry->ent.dp_start);
le32enc(p + 12, entry->ent.dp_size);
le32enc((f), (v)); \
le32enc(data + 16, md->md_version);
le32enc(data + 36, md->md_id);
le32enc(data + 44, md->md_genid);
le32enc(data + 48, md->md_syncid);
le32enc(data + 60, md->md_sectorsize);
le32enc(data + 16, md->md_version);
le32enc(data + 36, md->md_id);
le32enc(data + 16, md->md_version);
le32enc(data + 36, md->md_id);
le32enc(data + 44, md->md_stripesize);
le32enc(bs->data + bs->pos, data);
le32enc(p, uuid->time_low);
le32enc(frm, v); \
le32enc(mc->mc_seq, ms->ms_seq);
le32enc(rqp->sr_rqsig, rqp->sr_seqno);
le32enc(rqp->sr_rqsig + 4, 0);
le32enc(p, (uint32_t)(u & 0xffffffffU));
le32enc(p + 4, (uint32_t)(u >> 32));
le32enc(dst, src[0]);
le32enc(&dst[4], src[1]);
le32enc(&dst[8], src[2]);
le32enc(&dst[12], src[3]);
le32enc(p, (uint32_t)(u & 0xffffffffU));
le32enc(p + 4, (uint32_t)(u >> 32));
le32enc(p, (uint32_t)(u & 0xffffffffU));
le32enc(p + 4, (uint32_t)(u >> 32));
le32enc(&dp->p_size, imgsz);
le32enc(&dp->p_size, part->size);
le32enc(&dp->p_offset, part->block);
le32enc(&dp->p_fsize, 0);
le32enc(&d->d_magic, BSD_MAGIC);
le32enc(&d->d_secsize, secsz);
le32enc(&d->d_nsectors, nsecs);
le32enc(&d->d_ntracks, nheads);
le32enc(&d->d_ncylinders, ncyls);
le32enc(&d->d_secpercyl, nsecs * nheads);
le32enc(&d->d_secperunit, imgsz);
le32enc(&d->d_magic2, BSD_MAGIC);
le32enc(&d->d_bbsize, BSD_BOOTBLOCK_SIZE);
le32enc(&dp->dp_start, next->block - nsecs);
le32enc(&dp->dp_size, size + nsecs);
le32enc(&dp->dp_start, nsecs);
le32enc(&dp->dp_size, size);
le32enc(p, (uint32_t)(u & 0xffffffffU));
le32enc(p + 4, (uint32_t)(u >> 32));
le32enc(pmbr + DOSPARTOFF + 8, 1);
le32enc(pmbr + DOSPARTOFF + 12, secs);
le32enc(&hdr->hdr_revision, GPT_HDR_REVISION);
le32enc(&hdr->hdr_size, offsetof(struct gpt_hdr, padding));
le32enc(&hdr->hdr_entries, tblsz * secsz / sizeof(struct gpt_ent));
le32enc(&hdr->hdr_entsz, sizeof(struct gpt_ent));
le32enc(&hdr->hdr_crc_table, crc);
le32enc(&dp->dp_start, part->block);
le32enc(&dp->dp_size, size);
le32enc(p, uuid->time_low);
le32enc(&header.signature, VHDX_HEADER_SIGNATURE);
le32enc(&header.sequence_number, 0);
le32enc(&header.log_length, SIZE_1MB);
le32enc(&header.checksum, checksum);
le32enc(&header.sequence_number, 1);
le32enc(&header.checksum, checksum);
le32enc(&header.signature, VHDX_REGION_TABLE_HEADER_SIGNATURE);
le32enc(&header.entry_count, 2);
le32enc(region_table + 4, checksum);
le32enc(&entry.offset, data_ptr);
le32enc(&entry.length, 8);
le32enc(&entry.flags, META_IS_REQUIRED);
le32enc(metadata + data_ptr, PAYLOAD_BLOCK_SIZE);
le32enc(metadata + data_ptr, 0);
le32enc(&entry.offset, data_ptr);
le32enc(&entry.length, 8);
le32enc(&entry.flags, META_IS_REQUIRED | META_IS_VIRTUAL_DISK);
le32enc(&entry.offset, data_ptr);
le32enc(&entry.length, 16);
le32enc(&entry.flags, META_IS_REQUIRED | META_IS_VIRTUAL_DISK);
le32enc(&entry.offset, data_ptr);
le32enc(&entry.length, 4);
le32enc(&entry.flags, META_IS_REQUIRED | META_IS_VIRTUAL_DISK);
le32enc(metadata + data_ptr, secsz);
le32enc(&entry.offset, data_ptr);
le32enc(&entry.length, 4);
le32enc(&entry.flags, META_IS_REQUIRED | META_IS_VIRTUAL_DISK);
le32enc(metadata + data_ptr, blksz);
le32enc(&hdr.magic, VMDK_MAGIC);
le32enc(&hdr.version, VMDK_VERSION);
le32enc(&hdr.flags, VMDK_FLAGS_NL_TEST | VMDK_FLAGS_RGT_USED);
le32enc(&hdr.ngtes, VMDK_NGTES);
le32enc(gd + n, sec);
le32enc(rgd + n, sec);
le32enc(gt + n, cursec);
le32enc(tbuf, (uint32_t)len);
le32enc(tbuf, 0);
le32enc(tbuf, 0xffffffff);
le32enc(cmd.data + 4, boot_param);
le32enc(data, load_attrs);
le32enc(pos, attributes);
le32enc(buf, val);
le32enc(buf, val);