remainder
double remainder(double, double);
#define remainder(x, y) __tg_simple2(x, y, remainder)
nanosleep(const struct timespec *timeout, struct timespec *remainder)
ret = HIDDEN(nanosleep)(timeout, remainder);
BN_div_internal(BIGNUM *quotient, BIGNUM *remainder, const BIGNUM *numerator,
if (remainder != NULL) {
if (!bn_copy(remainder, numerator))
if (remainder != NULL) {
BN_rshift(remainder, snum, norm_shift);
BN_set_negative(remainder, neg);
BN_div(BIGNUM *quotient, BIGNUM *remainder, const BIGNUM *numerator,
return BN_div_internal(quotient, remainder, numerator, divisor, ctx, ct);
BN_div_nonct(BIGNUM *quotient, BIGNUM *remainder, const BIGNUM *numerator,
return BN_div_internal(quotient, remainder, numerator, divisor, ctx, 0);
BN_div_ct(BIGNUM *quotient, BIGNUM *remainder, const BIGNUM *numerator,
return BN_div_internal(quotient, remainder, numerator, divisor, ctx, 1);
uint32_t remainder = x - quotient * kPrime;
return reduce_once(remainder);
uint32_t remainder = shifted - quotient * kPrime;
assert(remainder < 2u * kPrime);
quotient += 1 & constant_time_lt(kHalfPrime, remainder);
quotient += 1 & constant_time_lt(kPrime + kHalfPrime, remainder);
uint32_t remainder = product & (power - 1);
return lower + (remainder >> (bits - 1));
DEF_STD(remainder);
LDBL_UNUSED_CLONE(remainder);
PROTO_NORMAL(remainder);
DEF_STD(remainder);
LDBL_MAYBE_UNUSED_CLONE(remainder);
return remainder(x, y);
int remainder = 0;
BF_cfb64_encrypt(bt->in, out, bt->in_len * 8, &key, iv, &remainder, 1);
remainder = 0;
BF_cfb64_encrypt(bt->out, out, bt->out_len, &key, iv, &remainder, 0);
int remainder = 0;
BF_ofb64_encrypt(bt->in, out, bt->in_len, &key, iv, &remainder);
remainder = 0;
BF_ofb64_encrypt(bt->out, out, bt->out_len, &key, iv, &remainder);
int remainder = 0;
RC2_cfb64_encrypt(rt->in, out, rt->in_len * 8, &key, iv, &remainder, 1);
RC2_cfb64_encrypt(rt->out, out, rt->out_len, &key, iv, &remainder, 0);
int remainder = 0;
RC2_ofb64_encrypt(rt->in, out, rt->in_len, &key, iv, &remainder);
RC2_ofb64_encrypt(rt->out, out, rt->out_len, &key, iv, &remainder);
ATF_CHECK(isnan(remainder(x, y)));
rem = remainder(x, y);
remainder.tv_sec = 0;
remainder.tv_nsec = 0;
if (nanosleep(&timeout, &remainder) == 0) {
if (remainder.tv_sec == 0 && remainder.tv_nsec == 0) {
struct timespec timeout, remainder;
remainder.tv_sec = 0;
remainder.tv_nsec = 0;
if (nanosleep(&timeout, &remainder) == 0) {
timespecadd(&duration, &remainder, &timeout);
remainder.tv_sec = 0;
remainder.tv_nsec = 10000000;
timespecadd(&timeout, &remainder, &timeout);
struct timespec timeout, remainder;
remainder.tv_sec = 4711; /* Just add to the confusion */
remainder.tv_nsec = 4711;
if (nanosleep(&timeout, &remainder) < 0) {
if (remainder.tv_sec != 0 || remainder.tv_nsec != 0) {
(long long)remainder.tv_sec, remainder.tv_nsec);
struct timespec timeout, remainder;
int ack, bitlen, data_dur, remainder;
remainder = (bitlen * 2) % rate;
if (remainder != 0) {
d->d_residue = (rate - remainder) / 16;
int remainder;
remainder = (16 * len) % 22;
if (remainder != 0 && remainder < 7)
int i, remainder;
remainder = (16 * len) % 22;
if (remainder != 0 && remainder < 7)
int ack, bitlen, data_dur, remainder;
remainder = (bitlen * 2) % rate;
if (remainder != 0) {
d->d_residue = (rate - remainder) / 16;
static inline uint16_t div16_u16_rem(uint16_t dividend, uint16_t divisor, uint16_t *remainder)
*remainder = dividend % divisor;
uint16_t *remainder)
return div16_u16_rem(dividend, divisor, (uint16_t *)remainder);
uint16_t remainder;
arg1_value, arg2_value, &remainder);
remainder <<= 1;
if (remainder >= arg2_value) {
remainder -= arg2_value;
uint16_t summand = (remainder << 1) >= arg2_value;
uint64_t remainder;
res_value = div64_u64_rem(arg1_value, arg2_value, &remainder);
remainder <<= 1;
if (remainder >= arg2_value) {
remainder -= arg2_value;
uint64_t summand = (remainder << 1) >= arg2_value;
uint32_t remainder;
remainder = a % b;
b = remainder;
unsigned long long summand = (remainder << 1) >= arg2_value;
unsigned long long *remainder)
result = div64_u64_rem(dividend, divisor, remainder);
unsigned long long remainder;
arg1_value, arg2_value, &remainder);
remainder <<= 1;
if (remainder >= arg2_value) {
remainder -= arg2_value;
struct fixed31_32 remainder;
remainder = dc_fixpt_sub_int(layouts_per_line,
remainder = dc_fixpt_mul_int(remainder, layout_config->symbols_per_layout);
remainder = dc_fixpt_add_int(remainder, audio_sdp_overhead);
remainder = dc_fixpt_mul(remainder, audio_sdp_margin);
required_symbols_per_hblank += ((dc_fixpt_ceil(remainder) + av_stream_map_lane_count) /
unsigned int remainder;
remainder = num % multiple;
if (remainder == 0)
return (num + multiple - remainder);
return (num - remainder);
dml_uint_t remainder;
remainder = num % multiple;
if (remainder == 0)
return (num + multiple - remainder);
return (num - remainder);
unsigned int remainder;
remainder = num % multiple;
if (remainder == 0)
return (num + multiple - remainder);
return (num - remainder);
static double dml2_core_div_rem(double dividend, unsigned int divisor, unsigned int *remainder)
*remainder = ((dividend / divisor) - (int)(dividend / divisor) > 0);
unsigned int remainder;
remainder = num % multiple;
if (remainder == 0)
return (num + multiple - remainder);
return (num - remainder);
double dml2_core_utils_div_rem(double dividend, unsigned int divisor, unsigned int *remainder)
*remainder = ((dividend / divisor) - (int)(dividend / divisor) > 0);
double dml2_core_utils_div_rem(double dividend, unsigned int divisor, unsigned int *remainder);
struct fixed31_32 remainder;
remainder = dc_fixpt_sub_int(layouts_per_line,
remainder = dc_fixpt_mul_int(remainder, layout_config.symbols_per_layout);
remainder = dc_fixpt_add_int(remainder, audio_sdp_overhead);
remainder = dc_fixpt_mul(remainder, audio_sdp_margin);
required_symbols_per_hblank += ((dc_fixpt_ceil(remainder) + av_stream_map_lane_count) /
unsigned long long *remainder)
result = spl_div64_u64_rem(dividend, divisor, remainder);
unsigned long long remainder;
arg1_value, arg2_value, &remainder);
remainder <<= 1;
if (remainder >= arg2_value) {
remainder -= arg2_value;
unsigned long long summand = (remainder << 1) >= arg2_value;
static inline uint64_t spl_div_u64_rem(uint64_t dividend, uint32_t divisor, uint32_t *remainder)
return div_u64_rem(dividend, divisor, remainder);
static inline uint64_t spl_div64_u64_rem(uint64_t dividend, uint64_t divisor, uint64_t *remainder)
return div64_u64_rem(dividend, divisor, remainder);
u8 remainder = 0;
remainder <<= 1;
remainder |= (data[array_index] & bitmask) >> bitshift;
if ((remainder & 0x10) == 0x10)
remainder ^= 0x13;
remainder <<= 1;
if ((remainder & 0x10) != 0)
remainder ^= 0x13;
return remainder;
u16 remainder = 0;
remainder <<= 1;
remainder |= (data[array_index] & bitmask) >> bitshift;
if ((remainder & 0x100) == 0x100)
remainder ^= 0xd5;
remainder <<= 1;
if ((remainder & 0x100) != 0)
remainder ^= 0xd5;
return remainder & 0xff;
int remainder;
remainder = (16 * len) % 22;
if (remainder != 0 && remainder < 7)
remainder = (16 * len) % 22;
if (remainder != 0 && remainder < 7)
int remainder;
umb_align(size_t bufsz, int offs, int alignment, int remainder)
align = (((size_t)offs + m) & ~m) - alignment + remainder;
umb_padding(void *buf, size_t bufsz, int offs, int alignment, int remainder)
nb = umb_align(bufsz, offs, alignment, remainder);
const int remainder = (16 * totlen) % 22;
if (remainder != 0 && remainder < 7)
struct timespec elapsed, remainder, request, start, stop;
memset(&remainder, 0, sizeof(remainder));
remainder = request;
copyout_error = copyout(&remainder, rmtp, sizeof(remainder));
ktrreltimespec(p, &remainder);
size_t remainder = input_to_consume % (size_t)136U;
return remainder;
size_t remainder = input_to_consume % (size_t)168U;
return remainder;
u_int number, each, size, this, remainder;
remainder = size - (number * (each + 1)) + 1;
if (remainder > 0) {
remainder--;
if (remainder > 0) {
remainder--;
off_t from_off, to_off, remainder;
remainder = from_len;
length = MINIMUM(remainder, 8 * 1048576);
remainder -= length;
} while (!dfound && remainder > 0);