void solve_problem()
{
int v[MAX_ELEMS];
int n, m;
int winner;
int msb, nsb, tmp;
int i, j;
scanf("%d", &n);
for (i = 0; i < n; i++)
scanf("%d", &v[i]);
m = 1 << n;
for (i = 0; i < m; i++)
nodes[i] = -1;
for (i = 0; i < n; i++)
nodes[1 << i] = 1;
for (i = 1; i < m; i++)
if (nodes[i] < 0) {
msb = get_msb(i);
j = i & ~(1 << msb);
if (nodes[j] == 1) {
nsb = get_msb(j);
if (v[msb] > v[nsb])
nodes[i] = 1;
}
}
for (i = 0; i < m; i++)
if (nodes[i] < 0) {
msb = 0;
winner = 0;
for (tmp = i; tmp > 0; tmp >>= 1) {
if (tmp & 1) {
j = i & ~(1 << msb);
if (nodes[j] == 1) {
winner = 1;
break;
}
}
msb++;
}
nodes[i] = winner ^ 1;
}
void BigInteger::print(int n, char* output) const {
// one more for sign and one more for null
int i = get_msb();
if (n < i + 2)
throw "output array is too small";
if (sign)
output[0] = '+';
else
output[0] = '-';
int j = 1;
while (i > 0)
output[j++] = data[--i];
output[j] = '\0';
}
int saturating_add(int x, int y){
int sum = x + y;
// grab the most significant bit for each of our variables
int xmsb = get_msb(x);
int ymsb = get_msb(y);
int summsb = get_msb(sum);
//logic to find out what type of overflow do we have if we have overflow
int positiveflow = ~xmsb & ~ymsb & summsb;
int negativeflow = xmsb & ymsb & ~summsb;
//variable needed for our return statement
int overflow = positiveflow | negativeflow;
//the variable we will be returning.
int newsum = (positiveflow & INT_MAX) | (negativeflow & INT_MIN | sum & ~overflow);
printf("%d\n",newsum );
return newsum;
}
void write_mbc2(const uint16_t address, const uint8_t value, Cart* const cart)
{
if (address > 0x3FFF)
return;
const auto addr_bit = test_bit(0, get_msb(address));
if (address >= 0x2000 && addr_bit) {
const uint8_t new_val = value & 0x0F;
if (cart->mbc2.rom_bank_num != new_val) {
cart->mbc2.rom_bank_num = new_val;
const auto mask = g_cart_info.rom_banks() - 1;
const auto bank_num = cart->mbc2.rom_bank_num & mask;
cart->rom_bank_offset = bank_num < 0x02 ? 0x00 : (0x4000 * (bank_num - 1));
}
} else if (address <= 0x1FFF && !addr_bit) {
const auto new_val = value&0x0F;
if (new_val == 0x0A && !cart->ram_enabled)
enable_ram(cart);
else if (new_val != 0x0A && cart->ram_enabled)
disable_ram(cart);
}
}
R_API bool r_id_storage_set(RIDStorage* storage, void* data, ut32 id) {
ut32 n;
if (!storage || !storage->pool || (id >= storage->pool->next_id)) {
return false;
}
n = get_msb (id + 1);
if (n > ((storage->size / 2) + (storage->size / 4))) {
if ((n * 2) < storage->pool->last_id) {
if (!id_storage_reallocate (storage, n * 2)) {
return false;
}
} else if (n != (storage->pool->last_id)) {
if (!id_storage_reallocate (storage, storage->pool->last_id)) {
return false;
}
}
}
storage->data[id] = data;
if (id > storage->top_id) {
storage->top_id = id;
}
return true;
}
// Calculate the square error of all filter settings. Result:
// res[0][0] : unfiltered
// res[0][1-3] : strength=1,2,4, no signals
// (Only for luma:)
// res[1][0] : (bit count, fb size = 128)
// res[1][1-3] : strength=1,2,4, fb size = 128
// res[1][4] : unfiltered, including skip
// res[1][5-7] : strength=1,2,4, including skip, fb_size = 128
// res[2][0] : (bit count, fb size = 64)
// res[2][1-3] : strength=1,2,4, fb size = 64
// res[3][0] : (bit count, fb size = 32)
// res[3][1-3] : strength=1,2,4, fb size = 32
static int clpf_rdo(int y, int x, const YV12_BUFFER_CONFIG *rec,
const YV12_BUFFER_CONFIG *org, const AV1_COMMON *cm,
unsigned int block_size, unsigned int fb_size_log2, int w,
int h, int64_t res[4][8], int plane) {
int c, m, n, filtered = 0;
int sum[8];
const int subx = plane != AOM_PLANE_Y && rec->subsampling_x;
const int suby = plane != AOM_PLANE_Y && rec->subsampling_y;
int bslog = get_msb(block_size);
uint8_t *rec_buffer =
plane != AOM_PLANE_Y
? (plane == AOM_PLANE_U ? rec->u_buffer : rec->v_buffer)
: rec->y_buffer;
uint8_t *org_buffer =
plane != AOM_PLANE_Y
? (plane == AOM_PLANE_U ? org->u_buffer : org->v_buffer)
: org->y_buffer;
int rec_width = plane != AOM_PLANE_Y ? rec->uv_crop_width : rec->y_crop_width;
int rec_height =
plane != AOM_PLANE_Y ? rec->uv_crop_height : rec->y_crop_height;
int rec_stride = plane != AOM_PLANE_Y ? rec->uv_stride : rec->y_stride;
int org_stride = plane != AOM_PLANE_Y ? org->uv_stride : org->y_stride;
sum[0] = sum[1] = sum[2] = sum[3] = sum[4] = sum[5] = sum[6] = sum[7] = 0;
if (plane == AOM_PLANE_Y &&
fb_size_log2 > (unsigned int)get_msb(MAX_FB_SIZE) - 3) {
int w1, h1, w2, h2, i, sum1, sum2, sum3, oldfiltered;
filtered = fb_size_log2-- == MAX_FB_SIZE_LOG2;
w1 = AOMMIN(1 << (fb_size_log2 - bslog), w);
h1 = AOMMIN(1 << (fb_size_log2 - bslog), h);
w2 = AOMMIN(w - (1 << (fb_size_log2 - bslog)), w >> 1);
h2 = AOMMIN(h - (1 << (fb_size_log2 - bslog)), h >> 1);
i = get_msb(MAX_FB_SIZE) - fb_size_log2;
sum1 = (int)res[i][1];
sum2 = (int)res[i][2];
sum3 = (int)res[i][3];
oldfiltered = (int)res[i][0];
res[i][0] = 0;
filtered |= clpf_rdo(y, x, rec, org, cm, block_size, fb_size_log2, w1, h1,
res, plane);
if (1 << (fb_size_log2 - bslog) < w)
filtered |= clpf_rdo(y, x + (1 << fb_size_log2), rec, org, cm, block_size,
fb_size_log2, w2, h1, res, plane);
if (1 << (fb_size_log2 - bslog) < h) {
filtered |= clpf_rdo(y + (1 << fb_size_log2), x, rec, org, cm, block_size,
fb_size_log2, w1, h2, res, plane);
filtered |=
clpf_rdo(y + (1 << fb_size_log2), x + (1 << fb_size_log2), rec, org,
cm, block_size, fb_size_log2, w2, h2, res, plane);
}
// Correct sums for unfiltered blocks
res[i][1] = AOMMIN(sum1 + res[i][0], res[i][1]);
res[i][2] = AOMMIN(sum2 + res[i][0], res[i][2]);
res[i][3] = AOMMIN(sum3 + res[i][0], res[i][3]);
if (i == 1) {
res[i][5] = AOMMIN(sum1 + res[i][4], res[i][5]);
res[i][6] = AOMMIN(sum2 + res[i][4], res[i][6]);
res[i][7] = AOMMIN(sum3 + res[i][4], res[i][7]);
}
res[i][0] = oldfiltered + filtered; // Number of signal bits
return filtered;
}
