MIN
len = MIN(total, MCONSOLE_MAX_DATA - 1);
#ifndef MIN
len = MIN(sizeof(req->request.data) - 1,
#define STORE_FUNCTION(__FUNC, __PTR, MIN, MAX, __CONV) \
unsigned long __data, __min = (MIN), __max = (MAX); \
#define USEC_STORE_FUNCTION(__FUNC, __PTR, MIN, MAX) \
unsigned long __data, __min = (MIN), __max = (MAX); \
#define STORE_FUNCTION(__FUNC, __PTR, MIN, MAX, __CONV) \
if (__data < (MIN)) \
__data = (MIN); \
#define STORE_INT(__FUNC, __PTR, MIN, MAX) \
STORE_FUNCTION(__FUNC, __PTR, MIN, MAX, )
#define STORE_JIFFIES(__FUNC, __PTR, MIN, MAX) \
STORE_FUNCTION(__FUNC, __PTR, MIN, MAX, msecs_to_jiffies)
#define CLK_RANGE(MIN, MAX) {.min = MIN, .max = MAX,}
int patched_disp_clk = MIN(max_disp_clk, context->bw_ctx.bw.dce.dispclk_khz);
int patched_disp_clk = MIN(max_disp_clk, context->bw_ctx.bw.dce.dispclk_khz);
min = MIN(lower_refresh_brightness, higher_refresh_brightness);
min = MIN(min, stream->lumin_data.luminance_millinits[nearest_smallest_index + 1]);
#ifndef MIN
link_settings->lane_count = MIN(LANE_COUNT_TWO, link_settings->lane_count);
#ifndef MIN
#ifndef MIN
link_settings->lane_count = MIN(LANE_COUNT_TWO, link_settings->lane_count);
link_settings->lane_count = MIN(LANE_COUNT_TWO, link_settings->lane_count);
MIN(LANE_COUNT_TWO, link_settings->lane_count);
#ifndef MIN
#ifndef MIN
#ifndef MIN
#ifndef MIN
vlevel = MIN(MAX(vlevel_req, 3), vlevel_max);
vlevel = MIN(MAX(vlevel_req, 2), vlevel_max);
vlevel = MIN(vlevel_req, vlevel_max);
#ifndef MIN
#ifndef MIN
range->max_target_bpp_x16 = MIN(dsc_caps->edp_sink_max_bits_per_pixel,
out.bits.UHBR10_20_CAPABILITY = MIN(a->bits.UHBR10_20_CAPABILITY,
out.bits.UHBR13_5_CAPABILITY = MIN(a->bits.UHBR13_5_CAPABILITY,
#ifndef MIN
cur_size = MIN(buf_len, HDCP_MAX_AUX_TRANSACTION_SIZE);
cur_size = MIN(buf_len, read_size);
cur_size = MIN(buf_len, HDCP_MAX_AUX_TRANSACTION_SIZE);
#ifndef MIN
rx_id_list_size = MIN((21 + 5 * device_count),
vm->log_shift = MIN(vm_log_shift, 8);
NVVAL(NVC37E, SET_KEY_ALPHA, MIN, 0x0000) |
NVVAL(NVC37E, SET_KEY_RED_CR, MIN, 0x0000) |
NVVAL(NVC37E, SET_KEY_GREEN_Y, MIN, 0x0000) |
NVVAL(NVC37E, SET_KEY_BLUE_CB, MIN, 0x0000) |
#ifndef MIN
static SENSOR_DEVICE_ATTR_2_RW(in0_min, voltage, MIN, 0);
static SENSOR_DEVICE_ATTR_2_RW(in1_min, voltage, MIN, 1);
static SENSOR_DEVICE_ATTR_2_RW(in2_min, voltage, MIN, 2);
static SENSOR_DEVICE_ATTR_2_RW(in3_min, voltage, MIN, 3);
static SENSOR_DEVICE_ATTR_2_RW(in4_min, voltage, MIN, 4);
static SENSOR_DEVICE_ATTR_2_RW(in5_min, voltage, MIN, 5);
static SENSOR_DEVICE_ATTR_2_RW(in6_min, voltage, MIN, 6);
static SENSOR_DEVICE_ATTR_2_RW(temp1_min, temp, MIN, 0);
static SENSOR_DEVICE_ATTR_2_RW(temp2_min, temp, MIN, 1);
static SENSOR_DEVICE_ATTR_2_RW(temp3_min, temp, MIN, 2);
static SENSOR_DEVICE_ATTR_2_RW(fan1_min, tach, MIN, 0);
static SENSOR_DEVICE_ATTR_2_RW(fan2_min, tach, MIN, 1);
static SENSOR_DEVICE_ATTR_2_RW(fan3_min, tach, MIN, 2);
static SENSOR_DEVICE_ATTR_2_RW(fan4_min, tach, MIN, 3);
static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point1_pwm, pwm, MIN, 0);
static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point1_pwm, pwm, MIN, 1);
static SENSOR_DEVICE_ATTR_2_RW(pwm3_auto_point1_pwm, pwm, MIN, 2);
data->voltage[MIN][i] = ret << 2;
data->voltage[MIN][5] = ret << 2;
data->voltage[MIN][6] = ret << 2;
data->temp[MIN][i] = ret << 2;
data->tach[MIN][i] = ret;
data->pwm[MIN][i] = ret;
if (sattr->nr == MIN)
if (sattr->nr == MIN)
if (sattr->nr == MIN)
case MIN:
data->tach[MIN][sattr->index] = rpm2tach(val);
data->tach[MIN][sattr->index]);
case MIN:
set_in_reg(MIN, min)
store_in_reg(MIN, min)
store_in_reg(MIN, min);
store_in_reg(MIN, min);
store_in_reg(MIN, min);
store_in_reg(MIN, min)
#ifndef MIN
MIN(sizeof(*regs), sizeof(u32) * rkvdec->variant->num_regs));
MIN(sizeof(*regs), sizeof(u32) * rkvdec->variant->num_regs));
MIN(sizeof(*regs), sizeof(u32) * rkvdec->variant->num_regs));
#define IONIC_PAGE_SIZE MIN(PAGE_SIZE, IONIC_MAX_BUF_LEN)
#define GET_PRI_TO_USE(MIN, MAX, RUNTIME) \
(MIN + PRI_TOLERANCE == MAX - PRI_TOLERANCE ? \
MIN + PRI_TOLERANCE : RUNTIME)
#define PN544_FW_I2C_WRITE_DATA_MAX_LEN MIN((PN544_FW_I2C_MAX_PAYLOAD -\
window_size = MIN(pci->region_limit + 1, res_size);
atu.size = MIN(pci->region_limit + 1, res_size);
len = MIN(buflen, object->buffer.length);
len = MIN(buflen, sizeof(object->integer.value));
return MAX(MIN(isp_strength, 0), -isp_scale);
#define UNICODE_AGE(MAJ,MIN,REV) \
((unsigned int)(MIN) << UNICODE_MIN_SHIFT) | \
#define VMBUS_MAKE_VERSION(MAJ, MIN) ((((u32)MAJ) << 16) | (MIN))
#define PP_DMA_INDEX_BITS MIN(32, __ffs(POISON_POINTER_DELTA) - PP_DMA_INDEX_SHIFT)
MIN(32, __ffs(PAGE_OFFSET) - PP_DMA_INDEX_SHIFT) : 0)
#define UNICODE_AGE(MAJ, MIN, REV) \
((unsigned int)(MIN) << UNICODE_MIN_SHIFT) | \
int s = MIN(burst_size, NR_TEST_FUNCS);
#ifndef MIN
wr.bufsize = MIN(header.dst_size, header.dict_size);
MIN((1LL << DEPOT_POOL_INDEX_BITS) - 1, 8192);
size_t const length = MIN(dstCapacity, srcSize);
#define BOUNDED(min,val,max) (MAX(min,MIN(val,max)))
U32 const hashLog3 = (forCCtx && cParams->minMatch==3) ? MIN(ZSTD_HASHLOG3_MAX, cParams->windowLog) : 0;
size_t const blockSize = MIN(ZSTD_resolveMaxBlockSize(maxBlockSize), windowSize);
for (level=MIN(compressionLevel, 1); level<=compressionLevel; level++) {
size_t const blockSize = MIN(ZSTD_resolveMaxBlockSize(params->maxBlockSize), (size_t)1 << cParams.windowLog);
for (level=MIN(compressionLevel, 1); level<=compressionLevel; level++) {
U32 const hashLog3 = ((forWho == ZSTD_resetTarget_CCtx) && cParams->minMatch==3) ? MIN(ZSTD_HASHLOG3_MAX, cParams->windowLog) : 0;
{ size_t const windowSize = MAX(1, (size_t)MIN(((U64)1 << params->cParams.windowLog), pledgedSrcSize));
size_t const blockSize = MIN(params->maxBlockSize, windowSize);
ms->nextToUpdate = curr - MIN(192, (U32)(curr - ms->nextToUpdate - 384));
return MIN(srcSize, blockSizeMax);
return MIN(cctx->appliedParams.maxBlockSize, (size_t)1 << cParams.windowLog);
maxDictSize = MIN(maxDictSize, shortCacheMaxDictSize);
{ U32 maxDictSize = 1U << MIN(MAX(params->cParams.hashLog + 3, params->cParams.chainLog + 1), 31);
bs->entropy.fse.offcode_repeatMode = ZSTD_dictNCountRepeat(offcodeNCount, offcodeMaxValue, MIN(offcodeMax, MaxOff));
U32 const limitedSrcSize = (U32)MIN(pledgedSrcSize, 1U << 19);
: MIN((size_t)(iend - ip), zcs->blockSizeMax);
return MIN(remaining, blockSize);
const BYTE* const vEnd = MIN( ip + (mEnd - match), iEnd);
{ int const shift = MIN(9-(int)strategy, 3);
unsigned const extraBits = ofBits - MIN(ofBits, STREAM_ACCUMULATOR_MIN-1);
unsigned const extraBits = ofBits - MIN(ofBits, STREAM_ACCUMULATOR_MIN-1);
ZSTD_memset(ptr, 0, MIN((size_t)((U8*)ws->initOnceStart - (U8*)ptr), alignedBytes));
size_t matchLength = MIN(commonLengthSmaller, commonLengthLarger); /* guaranteed minimum nb of common bytes */
const U32 cappedSearchLog = MIN(cParams->searchLog, rowLog); /* nb of searches is capped at nb entries per row */
assert(MAX(4, MIN(6, ms->cParams.minMatch)) == mls); \
assert(MAX(4, MIN(6, ms->cParams.minMatch)) == mls); \
assert(MAX(4, MIN(6, ms->cParams.minMatch)) == mls); \
assert(MAX(4, MIN(6, ms->cParams.searchLog)) == rowLog); \
size_t matchLength = MIN(commonLengthSmaller, commonLengthLarger); /* guaranteed minimum nb of common bytes */
size_t matchLength = MIN(commonLengthSmaller, commonLengthLarger); /* guaranteed minimum nb of common bytes */
U32 const lim = idx + MIN(ZSTD_ROW_HASH_CACHE_SIZE, maxElemsToPrefetch);
const U32 mls = MIN(ms->cParams.minMatch, 6 /* mls caps out at 6 */);
params->bucketSizeLog = MIN(params->bucketSizeLog, params->hashLog);
size_t const ldmBucketSizeLog = MIN(params.bucketSizeLog, params.hashLog);
curr - MIN(512, curr - ms->nextToUpdate - 1024);
unsigned maxBitsInMask = MIN(params->minMatchLength, 64);
U32 const sufficient_len = MIN(cParams->targetLength, ZSTD_OPT_NUM -1);
size_t matchLength = MIN(commonLengthSmaller, commonLengthLarger); /* guaranteed minimum nb of common bytes */
if (bestLength > 384) positions = MIN(192, (U32)(bestLength - 384)); /* speed optimization */
U32 const sufficient_len = MIN(cParams->targetLength, ZSTD_OPT_NUM -1);
size_t matchLength = MIN(commonLengthSmaller, commonLengthLarger); /* guaranteed minimum nb of common bytes */
size_t matchLength = MIN(commonLengthSmaller, commonLengthLarger); /* guaranteed minimum nb of common bytes */
iters = MIN(iters, oiters);
U32 const targetTableLog = MIN(maxTableLog, HUF_DECODER_FAST_TABLELOG);
size_t const iters = MIN(oiters, iiters);
size_t const blockSize = MIN((size_t)MIN(windowSize, ZSTD_BLOCKSIZE_MAX), blockSizeMax);
unsigned long long const neededSize = MIN(frameContentSize, neededRBSize);
size_t const blockSize = MIN(windowSize, ZSTD_BLOCKSIZE_MAX);
zds->fParams.blockSizeMax = MIN(zds->fParams.blockSizeMax, (unsigned)zds->maxBlockSizeParam);
loadedSize = MIN(toLoad, (size_t)(iend-ip));
size_t const toCopy = MIN(4, srcSize);
zfhPtr->blockSizeMax = (unsigned) MIN(windowSize, ZSTD_BLOCKSIZE_MAX);
dctx->fParams.blockSizeMax = MIN(dctx->fParams.blockSizeMax, (unsigned)dctx->maxBlockSizeParam);
size_t expectedWriteSize = MIN(blockSizeMax, dstCapacity);
int const seqAdvance = MIN(nbSeq, ADVANCED_SEQS);
size_t const blockSizeMax = MIN(dstCapacity, ZSTD_blockSizeMax(dctx));
size_t expectedWriteSize = MIN(blockSizeMax, dstCapacity);
size_t expectedWriteSize = MIN(blockSizeMax, dstCapacity);
const unsigned long curr_end = MIN(vma->vm_end, end);
_(MIN),
max_choice = MIN(list_height, item_count());
check_x = MIN(check_x, list_width);
max_choice = MIN(menu_height, item_count());
choice = MIN(choice + 1, max_choice - 1);
line += MIN(strlen(line), hscroll); /* Scroll horizontally */
waddnstr(win, line, MIN(strlen(line), width - 2));
int tlen = MIN(width - 2, strlen(title));
width = MIN(width, SYMBOL_WIDTH);
written_bytes = MIN(read_bytes, *len - off);
size_t t = MIN(MAX(biased, t_min), t_max);
| MIN '(' expr ',' expr ')'
%token ID NUMBER MIN MAX IF ELSE LITERAL D_RATIO SOURCE_COUNT HAS_EVENT STRCMP_CPUID_STR EXPR_ERROR
%left MIN MAX IF
MIN(a->bytes - bytes, sizeof(batch)), 0);
MIN(total_bytes - bytes, sizeof(batch)), 0);
nthreads = MIN(get_nprocs(), ARRAY_SIZE(thread_id));
MIN(read_size, CMP_BUFFER_SIZE - len));
memcpy(skel->rodata->fmt, fmt, MIN(strlen(fmt) + 1, 10));
result = run_test(size, MIN(size, 8), wr, wp);
= n_periods * quota_usec + MIN(remainder_usec, quota_usec);
= n_periods * quota_usec + MIN(remainder_usec, quota_usec);
threshold = MIN(threshold_mb * _1MB, c.region_size);
rand_size = MAX(MIN(threshold_mb * _1MB,
#ifndef MIN
cpus_online = MIN(MAX_CPUS, sysconf(_SC_NPROCESSORS_ONLN));
#ifndef MIN
MIN(ti.d.size_kernel, sizeof(struct tcp_info)));
MIN(addrs.d.size_kernel, sizeof(struct mptcp_subflow_addrs)));
MIN(mfi.size_tcpinfo_kernel, sizeof(struct tcp_info)));
MIN(mfi.size_sfinfo_kernel, sizeof(struct mptcp_subflow_info)));
#ifndef MIN
if (!strncmp("running", line, MIN(7, nread)))
#ifndef MIN
size_t i, this_size = MIN(size, sizeof(filebuf));
size_t this_size = MIN(size, sizeof(filebuf));