NBBY
#define MALLOC_BITS (NBBY * sizeof(u_short))
#define MALLOC_BITS (NBBY * sizeof(u_short))
map[(u_int)((ino) - 1) / NBBY] |= 1 << ((u_int)((ino) - 1) % NBBY)
map[(u_int)((ino) - 1) / NBBY] &= ~(1 << ((u_int)((ino) - 1) % NBBY))
(map[(u_int)((ino) - 1) / NBBY] & (1 << ((u_int)((ino) - 1) % NBBY)))
mapsize = roundup(howmany(maxino, NBBY), TP_BSIZE);
if (((ino - 1) % NBBY) == 0) /* map is offset by 1 */
if (((ino - 1) % NBBY) == 0) /* map is offset by 1 */
if (((ino - 1) % NBBY) == 0) /* map is offset by 1 */
for (i = fs->e2fs.e2fs_ipg / NBBY; i < fs->e2fs_bsize; i++)
bmapsize = roundup(howmany(maxfsblock, NBBY), sizeof(int16_t));
fs->e2fs.e2fs_bpg = fs->e2fs_bsize * NBBY;
mapsize = &ocg->cg_free[howmany(fs->fs_fpg, NBBY)] -
blkmapsize = howmany(fs->fs_fpg, NBBY);
if ((i & (NBBY - 1)) != (NBBY - 1)) {
bmapsize = roundup(howmany(maxfsblock, NBBY), sizeof(int16_t));
allocate += roundup(howmany(maxfsblock, NBBY), sizeof(int16_t));
len = sblock.e2fs.e2fs_bpg / NBBY;
bno = loc * NBBY;
bno = loc * NBBY;
for (i = 0; i < NBBY; i++, bno++) {
blocks_per_cg = sblock.e2fs_bsize * NBBY;
pblock += pbsize[i] * NBBY /* bpg */)
for (i = nblcg; i < roundup(nblcg, NBBY); i++)
memset(&buf[i / NBBY], ~0U, sblock.e2fs.e2fs_bpg - i);
for (i = 0; i < cgoverhead(cylno) / NBBY; i++)
i = i * NBBY;
i = sblock.e2fs.e2fs_ipg / NBBY;
(map[(u_int)((ino) - 1) / NBBY] & (1 << ((u_int)((ino) - 1) % NBBY)))
map[(u_int)((ino) - 1) / NBBY] |= 1 << ((u_int)((ino) - 1) % NBBY)
maxino = (spcl.c_count * TP_BSIZE * NBBY) + 1;
map = calloc(1, howmany(maxino, NBBY));
map = calloc(1, howmany(maxino, NBBY));
bpf = (sc->channels * sc->precision) / NBBY;
bpf = (sc->channels * sc->precision) / NBBY; /* bytes per frame */
hw_blocksize = sc->pdma_count * (sc->precision / NBBY * 2);
bpf = (sc->channels * sc->precision) / NBBY; /* bytes per frame */
hw_blocksize = sc->pdma_count * (sc->precision / NBBY * 2);
bpf = (sc->channels * sc->precision) / NBBY; /* bytes per frame */
bpf = (sc->channels * sc->precision) / NBBY; /* bytes per frame */
glyph <<= (4 - ri->ri_font->stride) * NBBY;
glyph <<= (4 - ri->ri_font->stride) * NBBY;
glyph <<= (4 - ri->ri_font->stride) * NBBY;
glyph <<= (4 - ri->ri_font->stride) * NBBY;
if ((bp->b_bcount / sc->sc_dk.dk_label->d_secsize) >= (1 << NBBY)) {
if ((bp->b_bcount / wd->sc_dk.dk_label->d_secsize) >= (1 << NBBY)) {
l = (sc->sc_curs_size.x * sc->sc_curs_size.y) / NBBY;
imcount = (curs->size.x * curs->size.y) / NBBY;
if ((bp->b_bcount / wd->sc_dk.dk_label->d_secsize) >= (1 << NBBY)) {
for (byte = *data++, bit = NBBY-1; bit >= 0; bit--)
count = (CURSOR_MAX_SIZE / NBBY) * data->cursize.y;
count = (CURSOR_MAX_SIZE / NBBY) * data->cursize.y;
count = (CURSOR_MAX_SIZE / NBBY) * data->cursize.y;
pkt_bitlen = pkt_len * NBBY;
if (pkt_bitlen1 - pkt_bitlen >= NBBY)
((frmlen) * NBBY) + \
#define IEEE80211_CCK_NBITS(frmlen) ((frmlen) * NBBY)
u_int8_t devmap[256 / NBBY];
blksize = (blksize * NBBY) / (param->precision * param->channels) - 1;
blksize = (blksize * NBBY) / (param->precision * param->channels) - 1;
howmany(sizeof(long) * NBBY, RADIX_TREE_MAP_SHIFT)
uint8_t sc_ucode_api[howmany(IWM_NUM_UCODE_TLV_API, NBBY)];
uint8_t sc_enabled_capa[howmany(IWM_NUM_UCODE_TLV_CAPA, NBBY)];
uint8_t sc_ucode_api[howmany(IWX_NUM_UCODE_TLV_API, NBBY)];
uint8_t sc_enabled_capa[howmany(IWX_NUM_UCODE_TLV_CAPA, NBBY)];
CTASSERT(MCX_ISSI < NBBY);
for (i = 0; i < sizeof(map) * NBBY; i++) {
#define THT_REG_RX_MCST_HASH_SIZE (256 / NBBY)
count = (cursorp->size.y * 64 * 2) / NBBY;
count = (cursorp->size.y * 64 * 2) / NBBY;
l = (sc->sc_curs_size.x * sc->sc_curs_size.y) / NBBY;
imcount = (curs->size.x * curs->size.y) / NBBY;
sc->sc_fmtgrp[fmtidx].format->u.uc.bBitsPerPixel / NBBY;
fmtgrp->format->u.uc.bBitsPerPixel / NBBY);
for (i = 1; i < CLONE_MAPSZ * NBBY; i++)
if (i == CLONE_MAPSZ * NBBY)
#define KPRINTF_BUFSIZE (sizeof(quad_t) * NBBY / 3 + 2)
sby = off / NBBY;
sbi = off % NBBY;
eby = (off+len) / NBBY;
ebi = (off+len) % NBBY;
#define QMEM(n) ((((n)-1)/NBBY)+1)
char *p, buf[(sizeof(u_int64_t) * NBBY / 4) + 1];
char *p, buf[(sizeof(long) * NBBY / 3) + 1];
char *p, buf[(sizeof(u_int64_t) * NBBY / 3) + 1];
return (max(howmany(limit, NBBY), sizeof(struct if_idxmap_dtor)));
memcpy(nusedidx, if_idxmap.usedidx, howmany(olimit, NBBY));
unsigned int pf_tcount[CLONE_MAPSZ * NBBY];
int off = offset * NBBY;
#define NBSK (NBBY * sizeof(stoeplitz_key))
uint16_t column[NBBY];
for (b = 0; b < NBBY; ++b)
for (b = 0; b < NBBY; ++b) {
shift = NBBY - b - 1;
length = htole16(len * NBBY);
uint8_t nr_rxmcs[howmany(80,NBBY)];
u_char occupied[howmany(IEEE80211_CHAN_MAX, NBBY)];
uint8_t ni_rxmcs[howmany(80,NBBY)];
uint8_t ni_basic_mcs[howmany(128,NBBY)];
u_char ic_chan_avail[howmany(IEEE80211_CHAN_MAX,NBBY)];
u_char ic_chan_active[howmany(IEEE80211_CHAN_MAX, NBBY)];
u_char ic_chan_scan[howmany(IEEE80211_CHAN_MAX,NBBY)];
u_int8_t ic_sup_mcs[howmany(80, NBBY)];
#define DP_MAPBITS (sizeof(u_int32_t) * NBBY)
#define setbit(a,i) ((a)[(i)>>3] |= 1<<((i)&(NBBY-1)))
#define clrbit(a,i) ((a)[(i)>>3] &= ~(1<<((i)&(NBBY-1))))
#define isset(a,i) ((a)[(i)>>3] & (1<<((i)&(NBBY-1))))
#define isclr(a,i) (((a)[(i)>>3] & (1<<((i)&(NBBY-1)))) == 0)
start = dtogd(fs, bpref) / NBBY;
end = howmany(fs->e2fs.e2fs_fpg, NBBY) - start;
bno = loc * NBBY;
bno = loc * NBBY;
start = ipref / NBBY;
len = howmany(fs->e2fs.e2fs_ipg - ipref, NBBY);
ipref = i * NBBY;
for (i = 1; i < (1 << NBBY); i <<= 1, ipref++) {
start = dtogd(fs, bpref) / NBBY;
len = howmany(fs->e2fs.e2fs_fpg, NBBY) - start;
bno = i * NBBY;
for (i = 1; i < (1 << NBBY); i <<= 1, bno++) {
start = cgp->cg_irotor / NBBY;
len = howmany(fs->fs_ipg - cgp->cg_irotor, NBBY);
ipref = i * NBBY;
for (i = 1; i < (1 << NBBY); i <<= 1, ipref++) {
start = dtogd(fs, bpref) / NBBY;
start = cgp->cg_frotor / NBBY;
len = howmany(fs->fs_fpg, NBBY) - start;
(u_char)(1 << (allocsiz - 1 + (fs->fs_frag % NBBY))));
(u_char)(1 << (allocsiz - 1 + (fs->fs_frag % NBBY))));
bno = (start + len - loc) * NBBY;
for (i = bno + NBBY; bno < i; bno += fs->fs_frag) {
mapp = &freemapp[start / NBBY];
bit = 1 << (start % NBBY);
if ((i & (NBBY - 1)) != (NBBY - 1)) {
mapp = &freemapp[start / NBBY];
bit = 1 << (start % NBBY);
if ((i & (NBBY - 1)) != 0) {
bit = 1 << (NBBY - 1);
if ((inblk & (1 << (siz + (fs->fs_frag % NBBY)))) == 0)
/* inode map */ howmany((fs)->fs_ipg, NBBY) + \
/* block map */ howmany((fs)->fs_fpg, NBBY) + \
/* cluster map */ howmany(fragstoblks(fs, (fs)->fs_fpg), NBBY)))
(((map)[(loc) / NBBY] >> ((loc) % NBBY)) & (0xff >> (NBBY - (fs)->fs_frag)))
u_int8_t mediacap[MMC_FEATURE_MAX / NBBY];
#define cdio_isset(a,i) ((a)[(i)>>3] & (1<<((i)&(NBBY-1))))
#define cdio_setbit(a,i) ((a)[(i)>>3] |= 1<<((i)&(NBBY-1)))
memset(cap, 0, MMC_FEATURE_MAX / NBBY);
nfds = len * NBBY;
apme->a_maxchan = roundup(IEEE80211_CHAN_MAX, NBBY);
for (i = 0; i < NBBY * sizeof(cap.available); i++) {
start = dtogd(fs, bpref) / NBBY;
start = cgp->cg_frotor / NBBY;
len = howmany(fs->fs_fpg, NBBY) - start;
(1 << (allocsiz - 1 + (fs->fs_frag % NBBY))));
(1 << (allocsiz - 1 + (fs->fs_frag % NBBY))));
bno = (start + len - loc) * NBBY;
for (i = bno + NBBY; bno < i; bno += fs->fs_frag) {
mapp = &freemapp[start / NBBY];
bit = 1 << (start % NBBY);
if ((i & (NBBY - 1)) != (NBBY - 1)) {
mapp = &freemapp[start / NBBY];
bit = 1 << (start % NBBY);
if ((i & (NBBY - 1)) != 0) {
bit = 1 << (NBBY - 1);