int main()
{
int i,k;
char s[20];
n=1;
while(1)
{
scanf("%s",s);
if(s[0]=='#') break;
else
{
scanf("%d%d",&a[n][0],&a[n][1]);
a[n][2]=a[n][1];
n++;
}
}
scanf("%d",&k);
for(i=n/2;i>0;i--)
{
shiftdown(i);
}
for(;k;k--)
{
printf("%d\n",a[1][0]);
a[1][2]+=a[1][1];
shiftdown(1);
}
return 0;
}
void proc_ctrl() {
#ifdef FOR_PSP
static int counter = 0;
if(++counter % 4 == 0) {
sceCtrlReadBufferPositive(&pad, 1);
if(pad.Buttons & PSP_CTRL_CROSS) {
shiftdown();
}
if(pad.Buttons & PSP_CTRL_SQUARE)
shiftup();
if(pad.Buttons & PSP_CTRL_LEFT)
moveleft();
if(pad.Buttons & PSP_CTRL_RIGHT)
moveright();
if(pad.Buttons & PSP_CTRL_DOWN)
movedown();
if(pad.Buttons & PSP_CTRL_LTRIGGER)
rquad -= 0.5f;
if(pad.Buttons & PSP_CTRL_RTRIGGER)
rquad += 0.5f;
if(pad.Buttons & PSP_CTRL_CIRCLE)
r_quad += 0.5f;
if(pad.Buttons & PSP_CTRL_TRIANGLE)
r_quad -= 0.5f;
}
#endif
}
heapNode removeMin(heapNode* heap, int size) {
heapNode rv = heap[1];
//printf("%d:%d:%d\n", size, heap[1].value, heap[size].value);
heap[1] = heap[size];
--size;
shiftdown(heap, size, 1);
return rv;
}
static MCGeneric deleteRoot(MCHeap* heap)
{
MCGeneric root = heap->values[1];
heap->values[1] = heap->values[heap->count];
heap->count--;
shiftdown(heap, 1);
return root;
}
void heapify(int a[], int count)
{
int i;
for (i = parentnode(count - 1); i > -1; --i)
{
shiftdown(a, i, count);
}
}
void heapsort(int a[], int count)
{
int end = count - 1;
while (end > 0)
{
swap(&a[0], &a[end]);
shiftdown(a, 0, end);
--end;
}
}
HEAP GetHeapTop()
{
HEAP ret = heap[1];
heap[1] = heap[hSize];
heap[hSize].groups = INF;
heap[hSize].st = heap[hSize].et = INF;
--hSize;
shiftdown( 1, hSize );
return ret;
}/* PopHeadTop */
int main(int argc, char const *argv[])
{
int i, j, temp;
f = (int *) malloc((n0 - k) * sizeof(int));
result = (int *) malloc(k * sizeof(int));
if (f == NULL)
{
return -1;
}
for (i = 0; i < n0 - k; ++i)
{
f[i] = rand();
}
// Build the heap of (n0 - k) numbers. Cost: O(n0 - k)
heapify(f, n0 - k);
/**
* For each of the rest k number. If its value is greater than max heap, it will be
* added to the result array (because it's greater than n0 - k other number).
* Otherwise, it would replace the max heap value. The heap will be heapify
* again and the max value will be pushed to the result array.
*
* The complexity is log(n0 - 1) + log(n0 - 2) + ... + log(n0 - k)
* */
for (i = 0; i < k; ++i)
{
temp = rand();
if (temp <= f[0])
{
add(f[0]);
f[0] = temp;
shiftdown(f, 0, n0 - k);
}
else
{
add(temp);
}
}
// The result will contains max values
free(f);
free(result);
return 0;
}
void gpuarray_elemwise_collapse(unsigned int n, unsigned int *_nd,
size_t *dims, ssize_t **strs) {
unsigned int i;
unsigned int k;
unsigned int nd = *_nd;
/* Remove dimensions of size 1 */
for (i = nd; i > 0; i--) {
if (nd > 1 && dims[i-1] == 1) {
shiftdown((ssize_t *)dims, i-1, nd);
for (k = 0; k < n; k++)
shiftdown(strs[k], i-1, nd);
nd--;
}
}
for (i = nd - 1; i > 0; i--) {
int collapse = 1;
for (k = 0; k < n; k++) {
collapse &= (strs[k] == NULL ||
strs[k][i - 1] == dims[i] * strs[k][i]);
}
if (collapse) {
dims[i-1] *= dims[i];
shiftdown((ssize_t *)dims, i, nd);
for (k = 0; k < n; k++) {
if (strs[k] != NULL) {
strs[k][i-1] = strs[k][i];
shiftdown(strs[k], i, nd);
}
}
nd--;
}
}
*_nd = nd;
}
int
minheap_push(minheap_t *heap, const void *val) {
void *item;
if (heap->len == array_len(heap->array)) {
if ((item=array_push(heap->array)) == NULL) {
return -1;
}
} else {
item = array_at(heap->array, heap->len);
}
heap->cpy(item, val);
heap->len++;
shiftdown(heap, 0, heap->len - 1);
return 0;
}
void keydown(unsigned char key, int x, int y)
{
#ifndef FOR_PSP
switch(key)
{
case 27:
{
// glutDestroyWindow(wnd);
exit(0);
}
break;
case 'x':
case 'A':
shiftup();
break;
case 'S':
case 'd':
shiftdown();
break;
case 'l':
{
rquad += 0.5;
}
break;
case 'r':
{
rquad -= 0.5;
}
break;
case 'o':
{
r_quad -= 0.5f;
}
break;
case 's':
{
r_quad += 0.5f;
}
break;
}
#endif
}
static void
shiftup(minheap_t *heap, long start) {
long iend, istart, ichild, iright;
iend = (long) heap->len;
istart = start;
ichild = 2 * istart + 1;
while (ichild < iend) {
iright = ichild + 1;
if (iright < iend && heap->comp(array_at(heap->array, ichild),
array_at(heap->array, iright)) > 0) {
ichild = iright;
}
heap->swp(array_at(heap->array, istart), array_at(heap->array, ichild));
istart = ichild;
ichild = 2 * istart + 1;
}
shiftdown(heap, start, istart);
}
void TileMap::shift(int dx, int dy)
{
while (dx < 0)
{
shiftleft();
dx++;
}
while (dx > 0)
{
shiftright();
dx--;
}
while (dy < 0)
{
shiftup();
dy++;
}
while (dy > 0)
{
shiftdown();
dy--;
}
}
void show(void)
{
register byte *pos;
static byte y;
static byte i;
pos=filebuf+screen_offset;
for(y=i=0;i<num_lines;i++,y+=line_height)
{
if(!ateof && pos>=filebuf+FILEBUF_LEN-MAX_CLINE)
{
shiftdown();
pos-=FILEBUF_LEN/2;
/* putformatted(0,0,"| |",pos-filebuf,FILEBUF_LEN-MAX_CLINE);
ozgetch(); */
}
if(pos>=filebuf+in_buf) break;
pos=dcompline(pos);
/* ozputs(0,y,line_buf); */
if(!showbot || i==num_lines-1)
puttextline(y);
}
if(y<80) _ozfilledbox(0,y,239,80-y,0);
showbot=0;
}
int imail(struct zint_symbol *symbol, unsigned char source[], int length)
{
char data_pattern[200];
int error_number;
int i, j, read;
char zip[35], tracker[35], zip_adder[11], temp[2];
short int accum[112], x_reg[112], y_reg[112];
unsigned char byte_array[13];
unsigned short usps_crc;
int codeword[10];
unsigned short characters[10];
short int bit_pattern[13], bar_map[130];
error_number = 0;
if(length > 32) {
strcpy(symbol->errtxt, "Input too long");
return ERROR_TOO_LONG;
}
error_number = is_sane(SODIUM, source, length);
if(error_number == ERROR_INVALID_DATA) {
strcpy(symbol->errtxt, "Invalid characters in data");
return error_number;
}
strcpy(zip, "");
strcpy(tracker, "");
/* separate the tracking code from the routing code */
read = 0;
j = 0;
for(i = 0; i < length; i++) {
if(source[i] == '-') {
tracker[read] = '\0';
j = 1;
read = 0;
} else {
if(j == 0) {
/* reading tracker */
tracker[read] = source[i];
read++;
} else {
/* reading zip code */
zip[read] = source[i];
read++;
}
}
}
if(j == 0) {
tracker[read] = '\0';
} else {
zip[read] = '\0';
}
if(strlen(tracker) != 20) {
strcpy(symbol->errtxt, "Invalid length tracking code");
return ERROR_INVALID_DATA;
}
if(strlen(zip) > 11) {
strcpy(symbol->errtxt, "Invalid ZIP code");
return ERROR_INVALID_DATA;
}
/* *** Step 1 - Conversion of Data Fields into Binary Data *** */
/* Routing code first */
for(i = 0; i < 112; i++) {
accum[i] = 0;
}
for(read = 0; read < strlen(zip); read++) {
for(i = 0; i < 112; i++) {
x_reg[i] = accum[i];
}
for(i = 0; i < 9; i++) {
binary_add(accum, x_reg);
}
x_reg[0] = BCD[ctoi(zip[read]) * 4];
x_reg[1] = BCD[(ctoi(zip[read]) * 4) + 1];
x_reg[2] = BCD[(ctoi(zip[read]) * 4) + 2];
x_reg[3] = BCD[(ctoi(zip[read]) * 4) + 3];
for(i = 4; i < 112; i++) {
x_reg[i] = 0;
}
binary_add(accum, x_reg);
}
/* add weight to routing code */
for(i = 0; i < 112; i++) {
x_reg[i] = accum[i];
}
if(strlen(zip) > 9) {
strcpy(zip_adder, "1000100001");
} else {
if(strlen(zip) > 5) {
strcpy(zip_adder, "100001");
} else {
if(strlen(zip) > 0) {
strcpy(zip_adder, "1");
} else {
strcpy(zip_adder, "0");
}
}
}
for(i = 0; i < 112; i++) {
accum[i] = 0;
}
for(read = 0; read < strlen(zip_adder); read++) {
for(i = 0; i < 112; i++) {
y_reg[i] = accum[i];
}
for(i = 0; i < 9; i++) {
binary_add(accum, y_reg);
}
y_reg[0] = BCD[ctoi(zip_adder[read]) * 4];
y_reg[1] = BCD[(ctoi(zip_adder[read]) * 4) + 1];
y_reg[2] = BCD[(ctoi(zip_adder[read]) * 4) + 2];
y_reg[3] = BCD[(ctoi(zip_adder[read]) * 4) + 3];
for(i = 4; i < 112; i++) {
y_reg[i] = 0;
}
binary_add(accum, y_reg);
}
binary_add(accum, x_reg);
/* tracking code */
/* multiply by 10 */
for(i = 0; i < 112; i++) {
y_reg[i] = accum[i];
}
for(i = 0; i < 9; i++) {
binary_add(accum, y_reg);
}
/* add first digit of tracker */
y_reg[0] = BCD[ctoi(tracker[0]) * 4];
y_reg[1] = BCD[(ctoi(tracker[0]) * 4) + 1];
y_reg[2] = BCD[(ctoi(tracker[0]) * 4) + 2];
y_reg[3] = BCD[(ctoi(tracker[0]) * 4) + 3];
for(i = 4; i < 112; i++) {
y_reg[i] = 0;
}
binary_add(accum, y_reg);
/* multiply by 5 */
for(i = 0; i < 112; i++) {
y_reg[i] = accum[i];
}
for(i = 0; i < 4; i++) {
binary_add(accum, y_reg);
}
/* add second digit */
y_reg[0] = BCD[ctoi(tracker[1]) * 4];
y_reg[1] = BCD[(ctoi(tracker[1]) * 4) + 1];
y_reg[2] = BCD[(ctoi(tracker[1]) * 4) + 2];
y_reg[3] = BCD[(ctoi(tracker[1]) * 4) + 3];
for(i = 4; i < 112; i++) {
y_reg[i] = 0;
}
binary_add(accum, y_reg);
/* and then the rest */
for(read = 2; read < strlen(tracker); read++) {
for(i = 0; i < 112; i++) {
y_reg[i] = accum[i];
}
for(i = 0; i < 9; i++) {
binary_add(accum, y_reg);
}
y_reg[0] = BCD[ctoi(tracker[read]) * 4];
y_reg[1] = BCD[(ctoi(tracker[read]) * 4) + 1];
y_reg[2] = BCD[(ctoi(tracker[read]) * 4) + 2];
y_reg[3] = BCD[(ctoi(tracker[read]) * 4) + 3];
for(i = 4; i < 112; i++) {
y_reg[i] = 0;
}
binary_add(accum, y_reg);
}
/* printf("Binary data 1: ");
hex_dump(accum); */
/* *** Step 2 - Generation of 11-bit CRC on Binary Data *** */
accum[103] = 0;
accum[102] = 0;
memset(byte_array, 0, 13);
for(j = 0; j < 13; j++) {
i = 96 - (8 * j);
byte_array[j] = 0;
byte_array[j] += accum[i];
byte_array[j] += 2 * accum[i + 1];
byte_array[j] += 4 * accum[i + 2];
byte_array[j] += 8 * accum[i + 3];
byte_array[j] += 16 * accum[i + 4];
byte_array[j] += 32 * accum[i + 5];
byte_array[j] += 64 * accum[i + 6];
byte_array[j] += 128 * accum[i + 7];
}
usps_crc = USPS_MSB_Math_CRC11GenerateFrameCheckSequence(byte_array);
/* printf("FCS 2: %4.4X\n", usps_crc); */
/* *** Step 3 - Conversion from Binary Data to Codewords *** */
/* start with codeword J which is base 636 */
for(i = 0; i < 112; i++) {
x_reg[i] = 0;
y_reg[i] = 0;
}
x_reg[101] = 1;
x_reg[98] = 1;
x_reg[97] = 1;
x_reg[96] = 1;
x_reg[95] = 1;
x_reg[94] = 1;
for(i = 92; i >= 0; i--) {
y_reg[i] = islarger(accum, x_reg);
if(y_reg[i] == 1) {
binary_subtract(accum, x_reg);
}
shiftdown(x_reg);
}
codeword[9] = (accum[9] * 512) + (accum[8] * 256) + (accum[7] * 128) + (accum[6] * 64) +
(accum[5] * 32) + (accum[4] * 16) + (accum[3] * 8) + (accum[2] * 4) +
(accum[1] * 2) + accum[0];
/* then codewords I to B with base 1365 */
for(j = 8; j > 0; j--) {
for(i = 0; i < 112; i++) {
accum[i] = y_reg[i];
y_reg[i] = 0;
x_reg[i] = 0;
}
x_reg[101] = 1;
x_reg[99] = 1;
x_reg[97] = 1;
x_reg[95] = 1;
x_reg[93] = 1;
x_reg[91] = 1;
for(i = 91; i >= 0; i--) {
y_reg[i] = islarger(accum, x_reg);
if(y_reg[i] == 1) {
binary_subtract(accum, x_reg);
}
shiftdown(x_reg);
}
codeword[j] = (accum[10] * 1024) + (accum[9] * 512) + (accum[8] * 256) +
(accum[7] * 128) + (accum[6] * 64) + (accum[5] * 32) +
(accum[4] * 16) + (accum[3] * 8) + (accum[2] * 4) +
(accum[1] * 2) + accum[0];
}
codeword[0] = (y_reg[10] * 1024) + (y_reg[9] * 512) + (y_reg[8] * 256) +
(y_reg[7] * 128) + (y_reg[6] * 64) + (y_reg[5] * 32) +
(y_reg[4] * 16) + (y_reg[3] * 8) + (y_reg[2] * 4) +
(y_reg[1] * 2) + y_reg[0];
for(i = 0; i < 8; i++) {
if(codeword[i] == 1365) {
codeword[i] = 0;
codeword[i + 1]++;
}
}
/* printf("Codewords 3: ");
for(i = 0; i < 10; i++) {
printf("%d ", codeword[i]);
}
printf("\n"); */
/* *** Step 4 - Inserting Additional Information into Codewords *** */
codeword[9] = codeword[9] * 2;
if(usps_crc >= 1024) {
codeword[0] += 659;
}
/* printf("Codewords 4b: ");
for(i = 0; i < 10; i++) {
printf("%d ", codeword[i]);
}
printf("\n"); */
/* *** Step 5 - Conversion from Codewords to Characters *** */
for(i = 0; i < 10; i++) {
if(codeword[i] < 1287) {
characters[i] = AppxD_I[codeword[i]];
} else {
characters[i] = AppxD_II[codeword[i] - 1287];
}
}
/* printf("Characters 5a: ");
for(i = 0; i < 10; i++) {
printf("%4.4X ", characters[i]);
}
printf("\n"); */
breakup(bit_pattern, usps_crc);
for(i = 0; i < 10; i++) {
if(bit_pattern[i] == 1) {
characters[i] = 0x1FFF - characters[i];
}
}
/* printf("Characters 5b: ");
for(i = 0; i < 10; i++) {
printf("%4.4X ", characters[i]);
}
printf("\n"); */
/* *** Step 6 - Conversion from Characters to the Intelligent Mail Barcode *** */
for(i = 0; i < 10; i++) {
breakup(bit_pattern, characters[i]);
for(j = 0; j < 13; j++) {
bar_map[AppxD_IV[(13 * i) + j] - 1] = bit_pattern[j];
}
}
strcpy(data_pattern, "");
temp[1] = '\0';
for(i = 0; i < 65; i++) {
j = 0;
if(bar_map[i] == 0)
j += 1;
if(bar_map[i + 65] == 0)
j += 2;
temp[0] = itoc(j);
concat(data_pattern, temp);
}
/* Translate 4-state data pattern to symbol */
read = 0;
for(i = 0; i < strlen(data_pattern); i++)
{
if((data_pattern[i] == '1') || (data_pattern[i] == '0'))
{
set_module(symbol, 0, read);
}
set_module(symbol, 1, read);
if((data_pattern[i] == '2') || (data_pattern[i] == '0'))
{
set_module(symbol, 2, read);
}
read += 2;
}
symbol->row_height[0] = 3;
symbol->row_height[1] = 2;
symbol->row_height[2] = 3;
symbol->rows = 3;
symbol->width = read - 1;
return error_number;
}
void checkshiftdown(void)
{
if(screen_offset>=in_buf-MAX_CLINE && !ateof)
shiftdown();
}
