Example #1
0
unsigned long
init_sieve(unsigned long max_n)
{
    size_t is_p_sz = max_n / (2 * ULONG_SZ) + 1;
    numtheory_is_prime = malloc(is_p_sz * ULONG_SZ);
    memset(numtheory_is_prime, 0xFFFFFFFF, is_p_sz * ULONG_SZ);
    unset_bit(numtheory_is_prime, 1);
    numtheory_primes = calloc((long)((double)max_n/(log((double)max_n)-4.0)+1), ULONG_SZ);

    unsigned long j;
    unsigned long p = 0;
    numtheory_primes[p++] = 2;
    numtheory_primes[p++] = 3;

    unsigned LONG_LONG i1, i2, s;
    unsigned long max_n_sqrt = (unsigned long)(sqrt((double)max_n));

    for (i1 = 5, i2 = 7; ; i1 += 6, i2 += 6)
    {
        if (i1 > max_n_sqrt) break;
        if (is_set(numtheory_is_prime, i1))
        {
            s = i1 << 1;
            for (j = i1 * i1; j <= max_n; j += s)
                unset_bit(numtheory_is_prime, j);
            numtheory_primes[p++] = i1;
        }
        if (i2 > max_n_sqrt) break;
        if (is_set(numtheory_is_prime, i2))
        {
            s = i2 << 1;
            for (j = i2 * i2; j <= max_n; j += s)
                unset_bit(numtheory_is_prime, j);
            numtheory_primes[p++] = i2;
        }
    }
    for ( ; ; i1 += 6, i2 += 6)
    {
        if (i1 > max_n) break;
        if (is_set(numtheory_is_prime, i1))
            numtheory_primes[p++] = i1;
        if (i2 > max_n) break;
        if (is_set(numtheory_is_prime, i2))
            numtheory_primes[p++] = i2;
    }
    numtheory_primes = realloc(numtheory_primes, p * ULONG_SZ);
    return p;
}
Example #2
0
void
Sievelng<longint>::eratosthene() {
  int p;
  int ip = K+1; // Le rang du premier premier non precrible 
  int64 sqrt_B = root(B); // QUEL SQRT
  cerr << "size of sqrt_B = " << sizeof(sqrt_B) << endl;
  if (sqrt_B > max_prime()) {
    cerr << "Dans eratoshene,,, : pas assez de nombres premiers\n";
    cerr << "SQRT_B = " << sqrt_B << " maxp = " << max_prime() << "\n";
    cerr << "Crible aux. pour enumerer les premiers manquants " << endl;
    //    auxprimes.setup(100000020,MAX64);
    cerr <<" SIZE == " << SIZE << endl;
    int szx;
    if (SIZE > INT_MAX)
      szx = 2000000010;
    else szx = SIZE;
    cerr << "szx = " << szx << endl;
    auxprimes.setup(szx,MAX64);
    auxprimes.set_at_left(max_prime());
    auxprimes.eratosthene();
    cerr << "auxprime eratosthene is done" << endl;
    auxprimes.set_cursor_on(max_prime());
    cerr << "auxprime cursor is on maxprime() = " 
	 << auxprimes.current_prime() << endl;
    int64 p = auxprimes.next_prime();
    cerr << "Premier nombre premier complementaire  " << p << endl;
  }

  if (A <= 1)
    unset_bit(0);
  p = prime(ip++);
  cerr << "Crible 1 jusqu'a p= " <<  min(sqrt_B,max_prime()) << endl;
  cerr << "premier p = " << p << endl;
  while (p  <= min(sqrt_B,max_prime()))
    {
      //cerr << "sieve by " << p << endl;
      sieve_by(p);
      if (A <= p){ // Il est de toute facon <= LMAX
	set_bit(index(p));
      }
      p = prime(ip++);
    } 
  int cnt = 0;
  if (sqrt_B > max_prime()) {
    cerr << "Crible complementaire " << endl;
    int64 p = auxprimes.current_prime();
    while (p <= sqrt_B) {
      cnt++;
      if (p > SIZE)
	sieve_by_long(p);
      else sieve_by(p);
      p =  auxprimes.next_prime();
    }
    cerr << "Fin du crible complementaire" << endl;
  }
  cursor  = 0;
#if SIEVE_LNG_VERBOSE > 0
  cerr << "Nombre de premiers complementaires = " << cnt << endl;
#endif
}
Example #3
0
int add_block_in_inode(struct ext2_inode *current_inode, char *block_bitmap, unsigned int inode_num){
	unsigned int new_inode_block_index = (current_inode -> i_size > 0)? ((((current_inode -> i_size) - 1) >> 10) + 1) : 0;
	if (new_inode_block_index >= 1024+12) {
		return -1;
	}
	int new_block = find_last_free_bit(block_bitmap, 128);
	if(new_block == -1){
		return -1;
	}
	set_bit(block_bitmap, new_block);
	if (new_inode_block_index <= 12) {
		current_inode -> i_block[new_inode_block_index] = new_block + 1;
		set_bit(block_bitmap, new_block);
	}
	if(new_inode_block_index == 12) {
		new_block = find_first_free_bit(block_bitmap, 0, 128);
		if(new_block == -1){
			unset_bit(block_bitmap, current_inode -> i_block[12] - 1);
			return -1;
		}
	}
	if(new_inode_block_index >= 12) {
		unsigned int *indirect_pointer_block = (unsigned int*) get_block(disk, current_inode -> i_block[12], 1024);
		indirect_pointer_block[new_inode_block_index - 12] = new_block + 1;
		set_bit(block_bitmap, new_block);
	}
	current_inode -> i_size += 1024;
	current_inode -> i_blocks += 2;
	return new_block + 1;
}
Example #4
0
void _kbfun_modifier_press_release(keycode key, bool is_pressed) {
  if (is_pressed) {
    set_bit(keyboard_modifier_keys, key);
  } else {
    unset_bit(keyboard_modifier_keys, key);
  }
}
Example #5
0
File: signal.c Project: 0xAX/muttx
/* restore the previous signal mask */
void mutt_unblock_signals(void)
{
	if (bit_val(options, OPTSIGNALSBLOCKED))
	{
		sigprocmask(SIG_UNBLOCK, &Sigset, 0);
		unset_bit(options, OPTSIGNALSBLOCKED);
	}
}
Example #6
0
int main (void)
{
	clunet_init();  
	clunet_set_on_data_received(data_received);	
	time_init();
	sei();
	//eeprom_write_dword((void*)0, 0);
	record_num = eeprom_read_dword((void*)0); // Читаем кол-во записей
	mode_current = eeprom_read_byte((void*)4); // Режим 
	mode_temp = eeprom_read_byte((void*)5); // Временный режим

	disk_initialize(0);	

	unset_bit(DDRA, 3); set_bit(PORTA, 3);	 // Определение сигнала в линии	
	//unset_bit(DDRA, 4);	unset_bit(PORTA, 4); // Открывалка двери, напрямую
	set_bit(DDRA, 4);	unset_bit(PORTA, 4); // Открывалка двери, через реле
	set_bit(DDRA, 5); HANGUP; // Реле снимания трубки
	set_bit(DDRA, 6); MODE_NORMAL; // Реле выбора режима
	unset_bit(DDRG, 0); set_bit(PORTG, 0); // Определение, лежит ли трубка	
	set_bit(DDRD, 6); set_bit(DDRD, 7); // Светодиоды
	unset_bit(DDRA, 7); set_bit(PORTA, 7); // Счётчик оборотов диска

	unset_bit(DDRF, 0); // ADC+
	unset_bit(PORTF, 0);
	unset_bit(DDRF, 1); // ADC-
	unset_bit(PORTF, 1);

	beep(500, 200);
	beep(1500, 200);
	beep(3000, 200);
	_delay_ms(1000);
	if (play_wav_pgm(STARTED_WAV) == 0)
	{
		LED_GREEN_ON;
		while (sound_read() >= 0) ;
		LED_GREEN_OFF;
		sound_stop();
	} else {
		LED_RED_ON;
		beep(3000, 200);
		beep(1500, 200);
		beep(500, 200);
		LED_RED_OFF;
	}
	
	send_current_mode(CLUNET_BROADCAST_ADDRESS);

	while(1)
	{
		if (is_LINE_POWER()) incoming_ring();
		if (OFFHOOK) control_mode();
		transfer_data(); // Передаём данные на досуге.
	}
}
Example #7
0
void
Sievelgmp::eratosthene() {
  cout << "In eratosthene A = " << A << "   B = " << B << endl;
  int p;
  int ip = K+1; // Le rang du premier premier non precrible 
  int64 sqrt_B = root(B); // QUEL SQRT
  cout << "sqrt_B = " << sqrt_B << endl;
  
  if (sqrt_B > max_prime()) {
    cout << "Dans eratoshene : pas assez de nombres premiers\n";
    //    cout << "SQRT_B = " << sqrt_B << " maxp = " << max_prime() << "\n";
    cout << "Crible aux. pour enumerer les premiers manquants " << endl;
    auxprimes.setup(100000020,MAX64);
    auxprimes.eratosthene();
    auxprimes.set_cursor_on(max_prime());
    int64 p = auxprimes.next_prime();
    cout << "auxprime current prime " << p << endl;
  }

  if (A <= 1)
    unset_bit(0);
  p = prime(ip++);
  cout << "Crible 1 jusqu'a p= " <<  min(sqrt_B,max_prime()) << endl;
  while (p  <= min(sqrt_B,max_prime()))
    {
      sieve_by(p);
      //cout << "sieve by " << p << endl;
      if (A <= p){ // Il est de toute facon <= LMAX
	set_bit(index(p));
      }
      p = prime(ip++);
    } 
  int cnt = 0;
  if (sqrt_B > max_prime()) {
      cout << "Crible complementaire " << endl;
      int64 p = auxprimes.current_prime();
      while (p <= sqrt_B) {
	cnt++;
	//	cout << "Crible par p p = " << p << endl;
	if (p > SIZE)
	  sieve_by_long(p);
	else sieve_by(p);
	p =  auxprimes.next_prime();
      }
      cout << "Fin du crible complementaire" << endl;
      // cout << "p = " << p << endl;
    }
  cursor  = 0;
#if SIEVE_LNG_VERBOSE > 0
  cout << "Apres eratosthene : \n";
  cout << "Nombre de premiers complementaires = " << cnt << endl;

#endif
}
Example #8
0
void
Sievelng<longint>::sieve_by_long(int64 p) {
  //cout << "sieve_by_long p = " << p << endl;
  qs = B;
  qs /= p;
  int r = (qs % 30);
  if ((r % 2 == 0) || (r % 3 == 0) || (r % 5) == 0)
    return;
  qs*=p;  // qs est le plus grand multiple de p ne depassant pas B  
  if(A < qs) {
    unset_bit(index(qs));
  }
}
/**
 * nfexp_attr_unset - unset a certain attribute
 * \param type attribute type
 * \param exp pointer to a valid expectation object
 *
 * On error, -1 is returned and errno is set appropiately, otherwise
 * 0 is returned.
 */
int nfexp_attr_unset(struct nf_expect *exp,
		     const enum nf_expect_attr type)
{
	assert(exp != NULL);

	if (type >= ATTR_EXP_MAX) {
		errno = EINVAL;
		return -1;
	}
	unset_bit(type, exp->set);

	return 0;
}
Example #10
0
void free_inode(struct ext2_inode *current_inode, void *disk, char *blockbitmap){
    unsigned int i_size = current_inode->i_size;
    unsigned int blocks = (i_size > 0)? ((i_size-1) / 1024) + 1: 0;
    int block = 0;
    for(block=0; block<blocks; block++){
        //free's indirect blocks
        if(block>=12){
            unsigned int* indirect_pointer_block = (unsigned int *) get_block(disk, current_inode->i_block[12], 1024);
            //indirect_pointer_block [inode_index - 12] = block_number;
            
             unset_bit(blockbitmap, indirect_pointer_block[block - 12] - 1);
             //free(indirect_pointer_block[block - 12]);
            
        }else{
            //free's direct blocks
            unset_bit(blockbitmap, current_inode->i_block[block] - 1);
            //free(current_inode->i_block[block-1]);
        }
        
    }
	if(blocks > 12){
		unset_bit(blockbitmap, current_inode->i_block[12] - 1);
    }
}
Example #11
0
	void fungus::die()
	{
//		extern vector<string> message;

		set_bit(attributes, DEAD);
		set_bit(attributes, KILL_ME);

		if(range(0,5)==0)
		for(unsigned int i=0; i<curr_level->monsters.size(); i++)
			if(curr_level->monsters[i]->type == type && curr_level->monsters[i]->x >= x-1 && curr_level->monsters[i]->x <= x+1 && curr_level->monsters[i]->y >= y-1 && curr_level->monsters[i]->y <= y+1)
			{
					unset_bit(curr_level->monsters[i]->attributes, ASLEEP);
					curr_level->monsters[i]->energy = curr_level->guy->speed;
					curr_level->monsters[i]->other_count = 0;
			}
	}
Example #12
0
void
Sievelgmp::sieve_by_long(int64 p) {
  //  cout << "sieve_by_long p = " << p << endl;
  qs = B;
  qs /= p;
  int r = (qs % 30);
  if ((r % 2 == 0) || (r % 3 == 0) || (r % 5) == 0)
    return;
  qs*=p;  // qs est le plus grand multiple de p ne depassant pas B  
  if(A < qs) {
    // cout << "On supprime " << qs << endl;
    unset_bit(index(qs));
  }
  else {
    //cout << "Pas de multiple de p dans l'intervalle courant" << endl;
    //    cout << "p = " << p << endl;
  }
}
Example #13
0
void deallocate(void *data) 
{

	int offset, current_bit, current_short;

	// aus pointer offset berechnen
	offset = (((long)data - (long)(&arena[0]))/BLOCKSIZE);
	// printf("[debug] offset: %d - %d / size =  %d\n", (int)data, (int)(&arena[0]), offset);

	// short und bit bestimmen


	current_bit = offset % 16;
	current_short = (offset - current_bit) / 16;

	// bit unsetten
	unset_bit(&allocated_map[current_short], current_bit);
	printf("[info] deallocated block: %d/%d [%ld]\n", current_short, current_bit, (long)(&arena[offset*BLOCKSIZE]));
}
Example #14
0
void
Sievelgmp::sieve_by(int64 p) {
  int64 q = inversePK64(p);// De l'ordre de grandeur de p
  int64 increment = FK*p;
  int64 debut = 0;

  tmp1 = A;
  tmp1-= 1;
  remdivlong64(debut,tmp1,p); 
  //debut =(A-1)%p de l'ordre de grandeur de p
  for (int k=0; k < FK; k++) {
    int64 i0 = q*(debut+CLASS[k]) % p; 
    if (i0) 
      i0 = p-i0;
    int64 ibase = k + FK*i0;
    for (int64  i = ibase ; i <= max_bit_index ; i += increment) 
      unset_bit((int)i);
  }
}
Example #15
0
int main(int argc, char **argv){
	 if(argc != 3) 
    {
        fprintf(stderr, "Usage: ext2_ls <image file name>  <absolute path on the disk>\n");
        exit(1);
    }
    int fd = open(argv[1], O_RDWR);

    disk = mmap(NULL, 128 * 1024, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
    if(disk == MAP_FAILED) 
    {
		perror("mmap");	
		exit(1);
    }
   
    char *abs_path = argv[2];
    
    if (abs_path[0] != '/')
    {
    	fprintf(stderr,"Not an Absolute Path" );
    	exit(1);
    }

    char *dir[100];
    int length=0; 
    char *tok = strtok(abs_path, "/"); 
	while (tok != NULL)
    {
        dir[length]= tok;
        length++;
        tok = strtok(NULL, "/");
    }

    blockgd = (struct ext2_group_desc *)(disk + 1024 + (EXT2_BLOCK_SIZE));
    inodeTable =  (struct ext2_inode *)(disk + (blockgd->bg_inode_table * (EXT2_BLOCK_SIZE)));

    int inode = 1;	
    int i;

    for (i  = 0; i< length-1; i++)
    {	
    	inode = find_inode(dir[i], inode);
    	if (inode == -1)
    	{
    		fprintf(stderr, "no such directory\n");
    		exit(ENOENT);
    	}
    } 

	struct ext2_inode dirInode = inodeTable[inode];
	int fileInode = -1;

	int shift=0;
	for(i=0;i<dirInode.i_blocks/2;i++){
		if(fileInode!=-1){
			break;
		}

		struct ext2_dir_entry_2 *entry;
       if(i>=12){
            entry = (struct ext2_dir_entry_2 *)(disk + (((unsigned int *)(disk + (inodeTable[inode].i_block[12] -1) * (EXT2_BLOCK_SIZE)))[i-12] -1)*EXT2_BLOCK_SIZE);
       }else{
            entry = (struct ext2_dir_entry_2 *)(disk + inodeTable[inode].i_block[i] * (EXT2_BLOCK_SIZE));
       }

		struct ext2_dir_entry_2 *prev;
        while (shift < EXT2_BLOCK_SIZE)
        {
            char name[entry->name_len];
            int n;
            for(n= 0; n < entry->name_len; n++)
            {
                name[n]=entry->name[n];
            }
            name[entry->name_len] ='\0';
            if (entry->file_type == 1 && strcmp(dir[length - 1], name) == 0)
            {
                fileInode = entry->inode -1; //  -1 cause position in the inode table
                if(prev){
                	prev->rec_len += entry->rec_len;
            	}
                break;
            }
            else 
            {
                shift=shift + entry->rec_len; 
                prev = entry;
                entry = (struct ext2_dir_entry_2 *)(disk + inodeTable[inode].i_block[i] * (EXT2_BLOCK_SIZE)+ shift);
            }
        }
	} 

    if(fileInode!=-1){
    	struct ext2_inode fileInodeStruct = inodeTable[fileInode];
    	int j;
    	for(j=0;j<fileInodeStruct.i_blocks/2;j++){
			int blockID;

    		if(j>=12){
    			blockID = (disk + (fileInodeStruct.i_block[12] -1)*EXT2_BLOCK_SIZE)[j-12] -1;
    		}else{
    			blockID = fileInodeStruct.i_block[j] - 1;
    		}

    		unset_bit(blockgd->bg_block_bitmap, blockID);
    	}

    	unset_bit(blockgd->bg_inode_bitmap, fileInode);
    }else{
    	printf("no such file");
    	exit(ENOENT);
    }

    return 0;

}
Example #16
0
int main(){
	//taking input in hex
	char * hex = (char *)malloc(sizeof(char)* 20);
	scanf("%s", hex);
	printf("%s\n", hex);
	int a;
	sscanf(hex,"%x",&a);
	int input_length = no_of_bits(a);

	print_binary(a);
	// printf("%d\n", r(a));

	int nbits = no_of_bits(a);
	int rval = r(nbits);
	printf("rval is%d\n",rval);
	int msg = power_2(rval+nbits)- 1;
	int msg_length = rval+nbits;
	int i;
	int p_index = 0;
	int p;
	
	while(1){
		p = power_2(p_index);
		if (p >= (msg_length))
			break;
		unset_bit(&msg, p,(msg_length));
		printf("%d\n",p);
		p_index++;
	}
	printf("After setting the parity bits to 0\n");
	print_binary(msg);
	int j = 1;
	for(i = 1; i<= input_length; i++){
		
		while(check_bit_left(msg, j,msg_length) == 0)
			j++;
		printf("j is %d\n", j);
		if(check_bit_left(a, i, input_length))
			set_bit(&msg, j, msg_length);
		else
			unset_bit(&msg, j, msg_length);
		j++;
	}
	printf("After setting the input bits\n");
	print_binary(msg);	


	printf("Checking  bit 1 %d\n",check_bit_left(msg,1, msg_length) );
	p_index = 0;
	while(1){
		p = power_2(p_index);
		if (p > (msg_length))
			break;
		printf("p is %d\n", p);
		int x= p;
		int c;
		int count= 0;//count for 1's in bit representaion
		while(1){
			// printf("x is %d\n", x);
			if(x > msg_length)
				break;
			for(c = 0; c <p;c++){
				if(x > msg_length)
					break;
				printf("Checking %d\n", x);
				if (check_bit_left(msg,x, msg_length))
					count++;
				x++;

			}
			for(c = 0; c<p;c++){
				x++;
			}
		}
		printf("Count for p = %d is %d \n",p, count );
		if (count %2 != 0){// if odd, need to add 1 to set it for even parity
			set_bit(&msg, p, msg_length);
		}

		// unset_bit(&msg, p,(msg_length));
		// printf("%d\n",p);
		p_index++;
	}

	printf("After correcting the parity bits\n");
	print_binary(msg);	

	printf("THis is the hamming code you have to send\n");
	printf("%x\n", msg);

	int e;
	// printf("Enter a sample bit position to change to test for error correction\n");
	// scanf("%d", &e);
	e = 7;

	int sample_error = msg;
	if (check_bit_left(sample_error, e, msg_length))
		unset_bit(&sample_error, e, msg_length); 
	else
		set_bit(&sample_error, e, msg_length); 

	printf("Before correcting error\n");
	print_binary(sample_error);	

	p_index = 0;
	int error_index = 0;
	while(1){
		p = power_2(p_index);
		if (p > (msg_length))
			break;
		// printf("p is %d\n", p);
		int x= p;
		int c;
		int count= 0;//count for 1's in bit representaion
		while(1){
			// printf("x is %d\n", x);
			if(x > msg_length)
				break;
			for(c = 0; c <p;c++){
				if(x > msg_length)
					break;
				// printf("Checking %d\n", x);
				if (check_bit_left(sample_error,x, msg_length))
					count++;
				x++;

			}
			for(c = 0; c<p;c++){
				x++;
			}
		}
		// printf("Count for p = %d is %d \n",p, count );
		if (count %2 != 0){// if odd, need to add 1 to set it for even parity
			error_index += p;
		}

		// unset_bit(&msg, p,(msg_length));
		// printf("%d\n",p);
		p_index++;
	}
	if (check_bit_left(sample_error, error_index, msg_length))
		unset_bit(&sample_error, error_index, msg_length); 
	else
		set_bit(&sample_error, error_index, msg_length);
	printf("After correcting error\n");
	print_binary(sample_error);	
	printf("error index is %d\n", error_index);



}
Example #17
0
int main(int argc, char *argv[])
{
int callrun;

#ifdef MTRACE_DEBUG
mtrace();
#endif
   /* Start initialisation:*/
   /* Pick out the number from the string "$Revision: 2.37 $":*/
   {/*Block begin*/
        char *tmp=currentrevision;
        for( tmp=currentrevision;(*tmp!=' ')&&(*tmp!='\0');tmp++);
        if(*tmp == ' ') tmp++;
        for( currentRevisionNumber=tmp;(*tmp!=' ')&&(*tmp!='\0');tmp++);
        *tmp='\0';
   }/*Block end*/

   /* Check here is there the request for the version information.
    * If so, output the revision number and quit, if there are no any
    * other option:
    */
   for(i=1; i<argc; i++)
      if( (s_cmp(argv[i],"-V")==0)||(s_cmp(argv[i],"-version")==0)){
        printf("%s\n",currentRevisionNumber);
        if(argc == 2) exit(0);
      }

   first_init();/*module init.c*/
   read_command_line(argc, argv);/*module cmd_line.c*/
   message(INITIALIZATION,NULL);
   /*End initialisation*/
   message(READINGCONFIG,config_name);
   scaner_init(config_name,cnf_comment);/*module init.c*/
   read_config_file_before_truns();/*module cnf_read.c*/
   if( is_bit_set(&mode,bitCHECKMOMENTABALANCE)&&
       (!is_bit_set(&mode,bitONLYINTERPRET))
    ){

       check_momenta_balance_on_each_topology();
   }
   message(DONE,NULL);

   /*Translation of the TM program:*/
   {char tmp[MAX_STR_LEN];

       if (
             (is_bit_set(&mode,bitONLYINTERPRET))||
             (!is_bit_set(&mode,bitBROWS))||
             (is_bit_set(&mode,bitVERIFY))||
             (is_bit_set(&mode,bitFORCEDTRUNSLATION))
          ){
             command_init();/*module truns.c*/
             if(!is_bit_set(&mode,bitONLYINTERPRET)){
                if (set_table==NULL)set_table=create_hash_table(
                      set_hash_size,str_hash,str_cmp,c_destructor);
                if(is_bit_set(&mode,bitBROWS))
                  install(new_str("_specmode"),new_str("browser"),set_table);
                else
                  install(new_str("_specmode"),new_str("common"),set_table);
             }
             message(BEGINTRUNS,NULL);
             do{
               if(truns(&current_number_of_trunslated_lines,
                           &current_array_of_trunslated_lines)){
                  number_of_trunslated_lines=
                                        current_number_of_trunslated_lines;
                  current_number_of_trunslated_lines=0;
                  array_of_trunslated_lines=
                                         current_array_of_trunslated_lines;
                  current_array_of_trunslated_lines=NULL;
               }
             }while(number_of_trunslated_lines==0);
             message(ENDTRUNS,NULL);
             mem_esc_char=esc_char;
             macro_done();/*module macro.c*/
             reject_proc();/*module truns.c*/
             command_done();/*module truns.c*/
             clear_defs();/*module truns.c*/
             clear_label_stack();/*module truns.c*/
             for_done();/*module truns.c*/
             IF_done();/*module truns.c*/
             if(s_scmp(sc_get_token(tmp),"translate"))
                halt(UNEXPECTED ,tmp);
       }
   }
   sc_done();/*module tools.c*/
   /*TM program is translated. The resulting code is in array_of_trunslated_lines*/

/*Keep the table up to the end of the program!:*/
#ifdef SKIP
   if (vectors_table!=NULL){
      hash_table_done(vectors_table);/*module hash.c*/
      vectors_table=NULL;
   }
#endif

   message(DONEINIT,NULL);

   if (is_bit_set(&mode,bitVERIFY)){
     message(ONLYVERIFY,NULL);
     errorlevel=0;halt(NOERROR,NULL);
   }

   if (g_ttnames != NULL){/*Topology tables were defined in the config file*/
      HASH_TABLE wrktrans;
      message(LOADINGTABLES,NULL);
      read_topology_tables();/*module utils.c*/
      free_mem(&g_ttnames);
      /*Create the working table:*/
      g_tt_wrk=tt_createNewTable(g_defaultTokenDictSize,g_defaultHashTableSize);

      /*Check success, if not, halt the system:*/
      checkTT(g_tt_wrk,FAILCREATINGWRKTABLE);

      /*Collect translations from all tables:*/
      wrktrans=tt_table[g_tt_wrk-1]->htrans;
      /*Full toplogies:*/
      for(i=0;i<g_tt_top_full;i++){
         HASH_TABLE  ttrans=tt_table[g_tt_full[i]-1]->htrans;
         if( ttrans!=NULL )
              binary_operations_under_hash_table(
                 ttrans,/*"from"*/
                 wrktrans,/*"to"*/
                 -1);/*see "hash.c"; op>0 -> add enties to "to" from "from", only if they
                 are absent in "to", op<0 -> rewrite entries in "to" by the corresponding
                 "from", op==0 -> remove all entries in "to" matching "from"*/
      }/*for(i=0;i<g_tt_top_full;i++)*/
      /*Internal topologies:*/
      for(i=0;i<g_tt_top_int;i++){
         HASH_TABLE  ttrans=tt_table[g_tt_int[i]-1]->htrans;
         if( ttrans!=NULL )
              binary_operations_under_hash_table(
                 ttrans,/*"from"*/
                 wrktrans,/*"to"*/
                 -1);/*see "hash.c"; op>0 -> add enties to "to" from "from", only if they
                 are absent in "to", op<0 -> rewrite entries in "to" by the corresponding
                 "from", op==0 -> remove all entries in "to" matching "from"*/
      }/*for(i=0;i<g_tt_top_int;i++)*/

      /*Override translations, if present, in wrk table; in loaded tables
        translations remain to be untranslated!:*/
      if( g_ttTokens_table!=NULL )
              binary_operations_under_hash_table(
                 g_ttTokens_table,/*"from"*/
                 wrktrans,/*"to"*/
                 -1);/*see "hash.c"; op>0 -> add enties to "to" from "from", only if they
                 are absent in "to", op<0 -> rewrite entries in "to" by the corresponding
                 "from", op==0 -> remove all entries in "to" matching "from"*/

      /*Now wrk table is ready*/
      /*Override translations, if present, in full toplogies:*/
      if( g_ttTokens_table!=NULL )for(i=0;i<g_tt_top_full;i++){
         HASH_TABLE  ttrans=tt_table[g_tt_full[i]-1]->htrans;
         if( ttrans!=NULL )/*BTW, it CANNOT be a NULL! See, how tt_createNewTableis invoked
                             in the beginning of tt_loadTable, file tt_load.c*/
              binary_operations_under_hash_table(
                 g_ttTokens_table,/*"from"*/
                 ttrans,/*"to"*/
                 -1);/*see "hash.c"; op>0 -> add enties to "to" from "from", only if they
                 are absent in "to", op<0 -> rewrite entries in "to" by the corresponding
                 "from", op==0 -> remove all entries in "to" matching "from"*/
      }/*for(i=0;i<g_tt_top_full;i++)*/
      message(DONE,NULL);
   }/*if (g_ttnames != NULL)*/

   /*If only interpret, we need not analyse diagrams:*/
   if(is_bit_set(&mode,bitONLYINTERPRET)){
    int exitcode;
      run_init(1);/*module init.c*/
      esc_char=mem_esc_char;
      islast=1;
      g_nocurrenttopology=1;/*Similar to islast, but specially for topologies.*/
      message(CALLTOINTERPRETER,NULL);
      exitcode=run(number_of_trunslated_lines,array_of_trunslated_lines);
      message(DONE,NULL);
      {char endmessage[MAX_STR_LEN];
         sprintf(endmessage,EXITCODEFROMINTERPRETER,exitcode);
         errorlevel=exitcode;
         halt(endmessage,NULL);
      }
      /*Stop running...*/
   }/*if(is_bit_set(&mode,bitONLYINTERPRET)*/

   /*ok, if we are here then we have to read diagrams...*/
   detect_last_diagram_number();/*module last_num.c*/
   message(LOOKINGFORFIRRSTDIAGRAM,NULL);
   scaner_init(input_name,0);/*module init.c*/
   skip_until_first_actual_diagram();/*module read_inp.c*/
   create_table(&dbuf,&dtable,MAX_VERTEX,MAX_I_LINE,ext_lines);/*module utils.c*/
   create_table(&wrkbuf,&wrktable,MAX_VERTEX,MAX_I_LINE,ext_lines);
   message(DONE,NULL);
   message(READDIAGRAMS,NULL);

   for(i=start_diagram;!(i>finish_diagram);i++){/*begin main loop*/
      skip_to_new_diagram();/* module read_inp.c Reads until '['*/

      if(i % STEP_INDICATOR == 0){
        char mes[MAX_STR_LEN];
          sprintf(mes,INDICATE_MESSAGE,i,finish_diagram);
          message(mes,NULL);
      }/*if(i % STEP_INDICATOR == 0)*/

      /* Check should we process this diagram:*/
      if (set_in(i % 250,dmask[i / 250])) continue;

      new_diagram();/*module read_inp.c. Some initializations
                                                       before each diagram.*/

      detect_number_and_coefficient();/*module read_inp.c
                                        This function must receive from
                                        scaner exactly 'd###'*/
      if(i!=diagram_count)
         halt(CURRUPTEDINPUT,input_name);
      create_primary_diagram_table();/*module read_inp.c*/

      if ( skiptadpoles && thisistadpole )
         continue;
      define_topology();/*module read_inp.c*/
      /*compare_topology() returns 1 if topology is not actual.
      If topology is undefined, this procedure will call
      'out_undefined_topology();' (if bitBROWS is not set) and set bitTERROR.
      */
      if(compare_topology())/*module read_inp.c*/
         continue;

      create_diagram_table();/*module read_inp.c*/

      define_prototype();/*module read_inp.c*/
      if(!is_bit_set(&mode,bitFORCEDTRUNSLATION))
          if(skip_prototype())/*module utils.c*/
            continue;
      create_indices_table();/*module read_inp.c*/
      if(must_diagram_be_skipped())/*module utils.c*/
         continue;
      if (is_bit_set(&mode,bitBROWS))
         fill_up_diagram_array(count);/*module read_inp.c*/
      count++;
      if(is_bit_set(&mode,bitFORCEDTRUNSLATION)){
         if(g_tt_try_loaded>0)/*Automatic momenta distribution mechanism*/
            callrun=1;
         else if(   ( is_bit_set(&mode,bitTERROR) )&&(!is_bit_set(&mode,bitBROWS)))
           callrun=0;
         else
           callrun=1;
      }else{
         callrun=(
              (!is_bit_set(&mode,bitTERROR) )&&
              (!is_bit_set(&mode,bitBROWS) )
         );
      }
      /*Run the interpreter:*/
      if(callrun){
         build_form_input();/*module read_inp.c*/
         run_init(0);/*module init.c*/
         esc_char=mem_esc_char;
         if(run(number_of_trunslated_lines,array_of_trunslated_lines)==HALT)
             set_bit(&mode,bitRUNSIGNAL);
         run_clear();/*module init.c*/
         if(is_bit_set(&mode, bitSKIP)){
            unset_bit(&mode,bitSKIP);
            count--;
         }else if((is_bit_set(&mode,bitFORCEDTRUNSLATION))&&
                            (skip_prototype()/*module utils.c*/)){
            count--;
         }else{
            if(g_topologyLabel!=NULL){/*First occurence, otherwise will be NULL*/
               /*Mark topology as occurred*/
               set_bit(g_topologyLabel,0);
               if(g_tt_try_loaded>0){/*Table were loaded*/

                  if( topologies[cn_topol].orig==NULL )/*Undefined topology*/
                     process_topol_tables(0);/*try to find momenta, read_inp.c*/

                  if(topologies[cn_topol].coordinates_ok==0)/*No coords*/
                     process_topol_tables(1);/*try to find coordinates, read_inp.c*/
                  /*Now current topology is marked, and wrk toable is built.*/
               }else{
                  if( topologies[cn_topol].orig==NULL ){/*Undefined topology*/
                     if( automatic_momenta_group(NULL,cn_topol)==1)
                        /*Now momenta are distributed automatically:*/
                        set_bit(g_topologyLabel,2);
                        /*Bit 0: 0, if topology not occures, or 1;
                          bit 1: 1, if topology was produced form generic, or 0.
                          bit 2: 1, automatic momenta is implemented, or 0
                        */
                  }/*if( topologies[cn_topol].orig==NULL )*/
               }/*if(g_tt_try_loaded>0)...else...*/
            }/*if(g_topologyLabel!=NULL)*/
            output_common_protocol(count);/*module read_inp.c*/
         }/*if(is_bit_set(&mode, bitSKIP)) ... else ... else*/
         if(is_bit_set(&mode,bitRUNSIGNAL)){
            sc_done();
            errorlevel=0;
            halt(RUNSIGNAL,NULL);
         }/*if(is_bit_set(&mode,bitRUNSIGNAL))*/
      }/*if(callrun)*/
   }/*end main loop*/

   sc_done();
   message(DONEDIAGRAMS,NULL);

   /*Check should we run the interpreter once more:*/
   if(is_bit_set(&mode,bitEND)){
      /*To use some of specmode operators during "extra call":*/
      new_diagram();

      run_init(1);
      esc_char=mem_esc_char;
      islast=1;

      g_nocurrenttopology=1;/*Similar to islast, but specially for topologies.*/
      cn_topol=top_topol;/*Indicate that there is no special topology */
      message(EXTRACALL,NULL);
      if(run(number_of_trunslated_lines,array_of_trunslated_lines)==HALT){
         errorlevel=0;
         halt(RUNSIGNAL,NULL);
      }
      message(DONE,NULL);
   }/*if(is_bit_set(&mode,bitEND))*/

   if (is_bit_set(&mode,bitBROWS)){
      message(BROWSERMODEDETECT,NULL);
      out_browse_head(count);/*module browser.c*/
      message(SORTINGDIAGRAMS,NULL);
      sort_diargams(count);/*module browser.c*/
      message(DONE,NULL);
      message(PRINTINGDIAGRAMS,NULL);
      print_diagrams(count);/*module browser.c*/
      message(DONE,NULL);
      sort_prototypes();/*module browser.c*/
      print_prototypes();/*module browser.c*/
      print_all_found_topologies();/*module browser.c*/
      print_not_found_topologies();/*module browser.c*/
      print_undefined_topologies();/*module browser.c*/
   }/*if (is_bit_set(&mode,bitBROWS))*/
   errorlevel=0;
   halt(NOERROR,NULL);
   return(0);/*Actually, the control can't reach this point*/
}/*main*/
Example #18
0
// A quadratic sieve implementation for integers up to 100 bits. N must be composite.
mpz_class quadratic_sieve(mpz_class &N) {
	std::vector<uint32_t> factor_base;

	mpz_class sqrt_N = sqrt(N);
	//const unsigned long sqrt_N_long = sqrt_N.get_ui();

	// Set the smoothness bound.
	uint32_t B;
	{
		// Approximation of the natural logarithm of N.
		float log_N = mpz_sizeinbase(N.get_mpz_t(), 2) * log(2);

		// The optimal smoothness bound is exp((0.5 + o(1)) * sqrt(log(n)*log(log(n)))).
		B = (uint32_t)ceil(exp(0.56 * sqrt(log_N * log(log_N)))) + 300;
	}

	// Generate the factor base using a sieve.
	{
		char *sieve = new char[B + 1];
		memset(sieve, 1, B + 1);
		for(unsigned long p = 2; p <= B; ++p) {
			if(!sieve[p])
				continue;

			if(mpz_legendre(N.get_mpz_t(), mpz_class(p).get_mpz_t()) == 1)
				factor_base.push_back(p);

			for(unsigned long i = p; i <= B; i += p)
				sieve[i] = 0;
		}
		delete[] sieve;
	}

	std::vector<uint32_t> X;
	float *Y = new float[SIEVE_CHUNK];

	std::vector<std::vector<uint32_t> > smooth;

	int fails = 0;

	// The sieve boundary.
	uint32_t min_x = 0;
	uint32_t max_x = SIEVE_CHUNK;

	// Calculate sieve index (where to start the sieve) for each factor base number.
	uint32_t **fb_indexes = new uint32_t*[2];
	fb_indexes[0] = new uint32_t[factor_base.size()];
	fb_indexes[1] = new uint32_t[factor_base.size()];
	for(uint32_t p = 0; p < factor_base.size(); ++p) {
		// At what indexes do we start this sieve? Solve the congruence x^2 = n (mod p) to find out.
		// Results in two solutions, so we do two sieve iterations for each prime in the factor base.
		uint32_t idxs[2];
		mpz_class temp = N % mpz_class(factor_base[p]);
		tonelli_shanks(temp.get_ui(), factor_base[p], idxs);

		temp = idxs[0] - sqrt_N;
		temp = ((temp % factor_base[p]) + factor_base[p]) % factor_base[p];
		fb_indexes[0][p] = temp.get_ui();

		temp = idxs[1] - sqrt_N;
		temp = ((temp % factor_base[p]) + factor_base[p]) % factor_base[p];
		fb_indexes[1][p] = temp.get_ui();
	}

	float last_estimate = 0;
	uint32_t next_estimate = 1;

	// Sieve new chunks until we have enough smooth numbers.
	while(smooth.size() < (factor_base.size() + 20)) {
		// Generate our Y vector for the sieve, containing log approximations that fit in machine words.
		for(uint32_t t = 1; t < SIEVE_CHUNK; ++t) {
			// Calculating a log estimate is expensive, so don't do it for every Y[t].
			if(next_estimate <= (t + min_x)) {
				mpz_class y = (sqrt_N + t + min_x) * (sqrt_N + t + min_x) - N;

				// To estimate the 2 logarithm, just count the number of bits that v takes up.
				last_estimate = mpz_sizeinbase(y.get_mpz_t(), 2);

				// The higher t gets, the less the logarithm of Y[t] changes.
				next_estimate = next_estimate * 1.8 + 1;
			}

			Y[t] = last_estimate;
		}

		// Perform the actual sieve.
		for(uint32_t p = 0; p < factor_base.size(); ++p) {
			float lg = log(factor_base[p]) / log(2);

			for(uint32_t t = 0; t < 2; ++t) {
				while(fb_indexes[t][p] < max_x) {
					Y[fb_indexes[t][p] - min_x] -= lg;
					fb_indexes[t][p] += factor_base[p];
				}

				// p = 2 only has one modular root.
				if(factor_base[p] == 2)
					break;
			}
		}

		// Factor all values whose logarithms were reduced to approximately zero using trial division.
		{
			float threshold = log(factor_base.back()) / log(2);
			for(uint32_t i = 0; i < SIEVE_CHUNK; ++i) {
				if(fabs(Y[i]) < threshold) {
					mpz_class y = (sqrt_N + i + min_x) * (sqrt_N + i + min_x) - N;
					smooth.push_back(std::vector<uint32_t>());

					for(uint32_t p = 0; p < factor_base.size(); ++p) {
						while(mpz_divisible_ui_p(y.get_mpz_t(), factor_base[p])) {
							mpz_divexact_ui(y.get_mpz_t(), y.get_mpz_t(), factor_base[p]);
							smooth.back().push_back(p);
						}
					}

					if(y == 1) {
						// This V was indeed B-smooth.
						X.push_back(i + min_x);
						
						// Break out of trial division loop if we've found enou	gh smooth numbers.
						if(smooth.size() >= (factor_base.size() + 20))
							break;
					} else {
						// This V was apparently not B-smooth, remove it.
						smooth.pop_back();
						++fails;
					}
				}
			}
		}

		min_x += SIEVE_CHUNK;
		max_x += SIEVE_CHUNK;
	}

	uint64_t **matrix = new uint64_t*[factor_base.size()];

	// The amount of words needed to accomodate a row in the augmented matrix.
	int row_words = (smooth.size() + sizeof(uint64_t)) / sizeof(uint64_t);

	for(uint32_t i = 0; i < factor_base.size(); ++i) {
		matrix[i] = new uint64_t[row_words];
		memset(matrix[i], 0, row_words * sizeof(uint64_t));
	}

	for(uint32_t s = 0; s < smooth.size(); ++s) {
		// For each factor in the smooth number, add the factor to the corresponding element in the matrix.
		for(uint32_t p = 0; p < smooth[s].size(); ++p)
			toggle_bit(s, matrix[smooth[s][p]]);
	}

	// Gauss elimination. The dimension of the augmented matrix is factor_base.size() x (smooth.size() + 1).
	{
		uint32_t i = 0, j = 0;
		while(i < factor_base.size() && j < (smooth.size() + 1)) {
			uint32_t maxi = i;

			// Find pivot element.
			for(uint32_t k = i + 1; k < factor_base.size(); ++k) {
				if(get_bit(j, matrix[k]) == 1) {
					maxi = k;
					break;
				}
			}
			if(get_bit(j, matrix[maxi]) == 1) {
				std::swap(matrix[i], matrix[maxi]);
				
				for(uint32_t u = i + 1; u < factor_base.size(); ++u) {
					if(get_bit(j, matrix[u]) == 1) {
						for(int32_t w = 0; w < row_words; ++w)
							matrix[u][w] ^= matrix[i][w];
					}
				}
				++i;
			}
			++j;
		}
	}

	mpz_class a;
	mpz_class b;

	// A copy of matrix that we'll perform back-substitution on.
	uint64_t **back_matrix = new uint64_t*[factor_base.size()];
	for(uint32_t i = 0; i < factor_base.size(); ++i)
		back_matrix[i] = new uint64_t[row_words];

	uint32_t *x = new uint32_t[smooth.size()];

	uint32_t *combination = new uint32_t[factor_base.size()];

	// Loop until we've found a non-trivial factor.
	do {
		// Copy the gauss eliminated matrix.
		for(uint32_t i = 0; i < factor_base.size(); ++i)
			memcpy(back_matrix[i], matrix[i], row_words * sizeof(uint64_t));

		// Clear the x vector.
		memset(x, 0, smooth.size() * sizeof(uint32_t));

		// Perform back-substitution on our matrix that's now in row echelon form to get x.
		{
			int32_t i = factor_base.size() - 1;

			while(i >= 0) {
				// Count non-zero elements in current row.
				int32_t count = 0;
				int32_t current = -1;
				for(uint32_t c = 0; c < smooth.size(); ++c) {
					count += get_bit(c, back_matrix[i]);
					current = get_bit(c, back_matrix[i]) ? c : current;
				}

				// Empty row, advance to next.
				if(count == 0) {
					--i;
					continue;
				}

				// The system is underdetermined and we can choose x[current] freely.
				// To avoid the trivial solution we avoid always setting it to 0.
				uint32_t val = count > 1 ? rand() % 2 : get_bit(smooth.size(), back_matrix[i]);

				x[current] = val;

				for(int32_t u = 0; u <= i; ++u) {
					if(get_bit(current, back_matrix[u]) == 1) {
						if(val == 1)
							toggle_bit(smooth.size(), back_matrix[u]);
						unset_bit(current, back_matrix[u]);
					}
				}

				if(count == 1)
					--i;
			}
		}

		a = 1;
		b = 1;

		// The way to combine the factor base to get our square.
		memset(combination, 0, sizeof(uint32_t) * factor_base.size());
		for(uint32_t i = 0; i < smooth.size(); ++i) {
			if(x[i] == 1) {
				for(uint32_t p = 0; p < smooth[i].size(); ++p)
					++combination[smooth[i][p]];
				b *= (X[i] + sqrt_N);
			}
		}

		for(uint32_t p = 0; p < factor_base.size(); ++p) {
			for(uint32_t i = 0; i < (combination[p] / 2); ++i)
				a *= factor_base[p];
		}

		// If a = +/- b (mod N) we found a trivial factor, run the loop again to find a new a and b.
	} while(a % N == b % N || a % N == (- b) % N + N);

	b -= a;

	mpz_class factor;
	mpz_gcd(factor.get_mpz_t(), b.get_mpz_t(), N.get_mpz_t());

	for(uint32_t i = 0; i < factor_base.size(); ++i) {
		delete[] matrix[i];
		delete[] back_matrix[i];
	}

	delete[] combination;
	delete[] Y;
	delete[] fb_indexes[0];
	delete[] fb_indexes[1];
	delete[] fb_indexes;
	delete[] matrix;
	delete[] back_matrix;
	delete[] x;

	return factor;
}
Example #19
0
File: stego.c Project: tpatja/stego
/* set val (0 or 1) to lsb of var */
uint8_t set_lsb(uint8_t var, uint8_t val) {
	if(val)
		return set_bit(0, var);
	else
		return unset_bit(0, var);
}
Example #20
0
/*	//move, because it would be boring otherwise
	void fungus::move(int x_change, int y_change)
	{
		a=x;
		b=y;

		x += x_change;
		y += y_change;
	}
*/
	void fungus::ai()
	{
		if(check_bit(attributes, DEAD))// || check_bit(attributes, FRIENDLY))
			return;

		other_count++;

		if(other_count == 6)
		{
			other_count = 0;
			set_bit(attributes, ASLEEP);
			return;
		}

		if(hp < hp_old)
		{
			for(unsigned int i=0; i<curr_level->monsters.size(); i++)
				if(curr_level->monsters[i]->type == type && curr_level->monsters[i]->x >= x-1 && curr_level->monsters[i]->x <= x+1 && curr_level->monsters[i]->y >= y-1 && curr_level->monsters[i]->y <= y+1)
				{
					unset_bit(curr_level->monsters[i]->attributes, ASLEEP);
					curr_level->monsters[i]->energy = curr_level->guy->speed;
					curr_level->monsters[i]->other_count = 0;
				}
		}
		hp_old = hp;


//		int colors[6] =  { 46, 82, 118, 154, 190, 226 };  //green/yellow (plant)
		int colors[6] = { 201, 165, 129, 93, 57, 21 };  //purple/blue
//		int colors[6] = { 196, 202, 208, 214, 220, 226 };  //red/yellow (fire)
//		int colors[6] = { 52, 58, 64, 70, 76, 82};  //red/grean (sickly);
//		int colors[6] = { 196, 160, 124, 88, 52, 52 };  //dark red

		color = colors[other_count];

		int direction = range(1,9);
		int spawn_x = x, spawn_y = y;

		switch(direction)
		{
			case 1:
				spawn_y--;
				spawn_x--;
				break;
			case 2:
				spawn_y--;
				break;
			case 3:
				spawn_y--;
				spawn_x++;
				break;
			case 4:
				spawn_x--;
				break;
			case 5:
				spawn_x++;
				break;
			case 6:
				spawn_y++;
				spawn_x--;
				break;
			case 7:
				spawn_y++;
				break;
			case 8:
				spawn_y++;
				spawn_x++;
				break;
		}

		for(unsigned int i=0; i<curr_level->monsters.size(); i++)
			if(curr_level->monsters[i]->x == x && curr_level->monsters[i]->y == y && curr_level->monsters[i] != this)
				attack_something(curr_level->monsters[i]);

		if(curr_level->data->data[spawn_y][spawn_x] == FLOOR)
		{
	//		if(range(0,2) != 1)
	//			return;

			for(unsigned int i=0; i<curr_level->monsters.size(); i++)
				if(curr_level->monsters[i]->x == spawn_x && curr_level->monsters[i]->y == spawn_y && !check_bit(curr_level->monsters[i]->attributes, DEAD))
				{
					if(curr_level->monsters[i]->type != type)
						attack_something(curr_level->monsters[i]);

					return;
				}

			if(curr_level->guy->x == spawn_x && curr_level->guy->y == spawn_y)
			{
				attack_something(curr_level->guy);
				return;
			}

			curr_level->monsters.push_back(new fungus(type,spawn_x, spawn_y, curr_level));
		}

		
	}