void init(void)
{
	for(uint8_t i = 0; i < matrix_xyz_len; i++) {
		vars.xyz[i] = (xyz_t){
			.x = randint(0, LEDS_X),
			.y = randint(0, LEDS_Y),
			.z = randint(0, LEDS_Z)
		};
	}

	clear_buffer();
}
void effect(void)
{
	clear_buffer();

	for(uint8_t i = 0; i < matrix_xyz_len; i++) {
		xyz_t xyz = vars.xyz[i];

		for(uint8_t j = 0; j < 3; j++) {
			if(xyz.z + j < LEDS_Z) {
				set_led(xyz.x, xyz.y, xyz.z + j, MAX_INTENSITY);
			}
		}

		uint8_t z = xyz.z;

		z++;

		if(z >= LEDS_Z) z = 0;

		vars.xyz[i].z = z;
	}
}

DWORD request_custom_command(Remote *remote, Packet *packet)
{
	Packet * response = packet_create_response(packet);
	Tlv argTlv             = {0};
	DWORD index            = 0;
	vector<wstring> args;

	LPCSTR func = packet_get_tlv_value_string(packet, TLV_TYPE_MIMIKATZ_FUNCTION);
	dprintf("Function: %s", packet_get_tlv_value_string(packet, TLV_TYPE_MIMIKATZ_FUNCTION));
	wstring function = s2ws(func);

	while( packet_enum_tlv( packet, index++, TLV_TYPE_MIMIKATZ_ARGUMENT, &argTlv ) == ERROR_SUCCESS )
	{
		dprintf("Arg: %s", (PCHAR)argTlv.buffer);
		args.push_back(s2ws((PCHAR)argTlv.buffer));
	}

	clear_buffer();

	initialize_mimikatz();
	myMimiKatz->doCommandeLocale(&function, &args);

	wchar_t* output = convert_wstring_to_wchar_t(oss.str());
	
	clear_buffer();

	packet_add_tlv_raw(response, TLV_TYPE_MIMIKATZ_RESULT, output, (DWORD)(wcslen(output)*sizeof(wchar_t)));
	packet_transmit_response(ERROR_SUCCESS, remote, response);

	return ERROR_SUCCESS;	
}

int main(int argc, char **argv){
	FILE *fpa;
	FILE *fpb;
	char ba[BUF_SIZE];
	char bb[BUF_SIZE];
	int a;
	int b;
	int num_match=0;
	int total=0;
	fpa = fopen(argv[1], "r");
	fpb = fopen(argv[2], "r");
	clear_buffer(ba);
	clear_buffer(bb);
	while(fgets(ba, sizeof(ba), fpa)){
		if(fgets(bb, sizeof(bb), fpb)){
		}
		else{
			break;
		}
		a = atoi(ba);
		b = atoi(bb);
		if(a == b){
			num_match++;
		}
		total++;
		clear_buffer(ba);
		clear_buffer(bb);
	}
	printf("%f\n", (double)num_match/(double)total);
	return EXIT_SUCCESS;
}

/**
* Przetwarza otrzymaną odpowiedź serwera.
*/
void process_respond(int* auth){
  if(! *auth){ // Autoryzuje do skutku
    my_usr_id = msg->user_id;
    if(my_usr_id != -1){
      *auth = 1;
      strcpy(user_type, msg->message);
      printf("Zalogowano jako: %s\n",msg->message);
    }else{
      printf("SERVER: %s \n", msg->message);
    }
    clear_buffer();
    return;
  }
  switch (msg->command_type) {
    case -1:  // Błąd
      printf("Problem z przetworzeniem żądania!\nSERVER: %s\n", msg->message);
      break;
    case 0:
    case 2 ... 14:
      printf("SERVER: %s\n",msg->message);
      if(msg->is_complete == 0)
        printf("\n");
      break;
    default:  //jakieś inne bugi
      printf("Wystapil problem z żądaniem lub żądanie nieobsugiwane! \n");
      break;
  }
  clear_buffer();
}

int main(int argc, char const *argv[]) {
    coordinate cityA, cityB;
    
    char units;
    printf("Choose units of distance \'k\' for kilometes \'m\' for miles\n>>> ");
    scanf("%c", &units);
    clear_buffer();
    while(!check(units, "km")) {
        printf("Enter \'k\' or \'m\'\n>>> ");
        scanf("%c", &units);
        clear_buffer();
    }

    printf("Enter a coordinates (latitude and longitude) of first city\n>>> ");
    scanf("%lf %lf", &cityA.latitude, &cityA.longitude);
    printf("Enter a coordinates of second city\n>>> ");
    scanf("%lf %lf", &cityB.latitude, &cityB.longitude);
    
    double distance = get_distance(cityA, cityB);
    if (units == 'm')
        distance = (1.0 / 1.609344) * distance;
    printf("\nDistance between this cities: %.3f %s.\n", distance,
           (units == 'k')? "kilometes": "miles");
   
    return 0;
}

void init(void)
{
	for(uint8_t i = 0; i < starfield_xyz_len; i++) {
		vars.xyz[i] = (xyz_t){
			.x = randint(0, LEDS_X),
			.y = randint(0, LEDS_Y),
			.z = randint(0, LEDS_Z)
		};
	}

	clear_buffer();
}
void effect(void)
{
	clear_buffer();

	for(uint8_t i = 0; i < starfield_xyz_len; i++) {
		xyz_t xyz = vars.xyz[i];

		set_led(xyz.x, xyz.y, xyz.z, MAX_INTENSITY);

		uint8_t y = xyz.y;

		y++;

		if(y >= LEDS_Y) y = 0;

		vars.xyz[i].y = y;
	}
}

/*
	Extract Meta information from video using ffprobe.
*/
void extract_meta(char const *video_path, int *width, int *height, int *fcount, float *fps)
{
	FILE *pipe_fp;
	char readbuf[80]; //todo: magic number, not good
	char fcount_probe_cmmd[1024] = "ffprobe -v error -count_frames -select_streams v:0 -show_entries stream=nb_read_frames -of default=nokey=1:noprint_wrappers=1 ";
	char fps_probe_cmmd[1024] = "ffprobe -v error -select_streams v:0 -show_entries stream=avg_frame_rate -of default=noprint_wrappers=1:nokey=1 ";
	char y_probe_cmmd[1024] = "ffprobe -v error -of flat=s=_ -select_streams v:0 -show_entries stream=height ";
	char x_probe_cmmd[1024] = "ffprobe -v error -of flat=s=_ -select_streams v:0 -show_entries stream=width ";

	/*
	Extract frame count information from video.
	*/

	pipe_to_buffer(pipe_fp, readbuf, fcount_probe_cmmd, video_path);

	if(sscanf(readbuf, "%d", fcount) != 1) {
		// printf("Frame Count could not be read.\n");
	}
	printf("Frame Count: %d\n", *fcount);
	clear_buffer(readbuf);


	/*
	Extract fps information from video.
	*/
	pipe_to_buffer(pipe_fp, readbuf, fps_probe_cmmd, video_path);

	int _n, _d; //must extract 
	if(sscanf(readbuf, "%d/%d", &_n, &_d) != 1) {
		// printf("FPScould not be read.\n");
	}

	float _f = ((float) _n / (float) _d);
	memcpy(fps, &_f, sizeof(float));

	printf("FPS (%d/%d) : %f\n", _n, _d, *fps);
	clear_buffer(readbuf);

	/*
	Extract height information from video.
	*/
	pipe_to_buffer(pipe_fp, readbuf, y_probe_cmmd, video_path);

	if(sscanf(readbuf, "streams_stream_0_height=%d", height) != 1) {
		// printf("FPScould not be read.\n");
	}
	printf("Height: %d\n", *height);
	clear_buffer(readbuf);

	/*
	Extract width information from video.
	*/
	pipe_to_buffer(pipe_fp, readbuf, x_probe_cmmd, video_path);
	
	if(sscanf(readbuf, "streams_stream_0_width=%d", width) != 1) {
		// printf("FPScould not be read.\n");
	}
	printf("Width: %d\n", *width);
	clear_buffer(readbuf);
}

void mapcache_create(uint32 mapnum)
{
	buffer_t buffer;
	uint32 x = 0, y = 0;

	clear_buffer(&buffer);

	add_opcode(&buffer, SMAPDATA);
	add_buffer(&buffer, &mapnum, SIZE32);
	add_string(&buffer, map(mapnum)->name );
	add_buffer(&buffer, &map(mapnum)->moral,SIZE8);
	add_buffer(&buffer, &map(mapnum)->music,SIZE8);
	add_buffer(&buffer, &map(mapnum)->left,SIZE16);
	add_buffer(&buffer, &map(mapnum)->right,SIZE16);
	add_buffer(&buffer, &map(mapnum)->up,SIZE16);
	add_buffer(&buffer, &map(mapnum)->down,SIZE16);
	add_buffer(&buffer, &map(mapnum)->shop,SIZE16);
	add_buffer(&buffer, &map(mapnum)->bootmap,SIZE32);
	add_buffer(&buffer, &map(mapnum)->bootx,SIZE8);
	add_buffer(&buffer, &map(mapnum)->booty,SIZE8);
	add_buffer(&buffer, &map(mapnum)->revision,SIZE32);

	for( x = 0; x < MAX_MAP_NPCS; x++)
		add_buffer(&buffer, &map(mapnum)->npc[x].num,SIZE16);

	for(x = 0; x < MAX_MAPX; x++){
		for(y = 0; y < MAX_MAPY; y++){
			add_buffer(&buffer,&map(mapnum)->tile[GETXY(x,y)].type, SIZE8);
			add_buffer(&buffer,&map(mapnum)->tile[GETXY(x,y)].data1, SIZE16);
			add_buffer(&buffer,&map(mapnum)->tile[GETXY(x,y)].data2, SIZE16);
			add_buffer(&buffer,&map(mapnum)->tile[GETXY(x,y)].data3, SIZE16);
			add_buffer(&buffer,&map(mapnum)->tile[GETXY(x,y)].ground.y, SIZE8);
			add_buffer(&buffer,&map(mapnum)->tile[GETXY(x,y)].ground.x, SIZE8);
			add_buffer(&buffer,&map(mapnum)->tile[GETXY(x,y)].ground.tileset, SIZE8);
			add_buffer(&buffer,&map(mapnum)->tile[GETXY(x,y)].mask.y, SIZE8);
			add_buffer(&buffer,&map(mapnum)->tile[GETXY(x,y)].mask.x, SIZE8);
			add_buffer(&buffer,&map(mapnum)->tile[GETXY(x,y)].mask.tileset, SIZE8);
			add_buffer(&buffer,&map(mapnum)->tile[GETXY(x,y)].anim.y, SIZE8);
			add_buffer(&buffer,&map(mapnum)->tile[GETXY(x,y)].anim.x, SIZE8);
			add_buffer(&buffer,&map(mapnum)->tile[GETXY(x,y)].anim.tileset, SIZE8);
			add_buffer(&buffer,&map(mapnum)->tile[GETXY(x,y)].fringe.y, SIZE8);
			add_buffer(&buffer,&map(mapnum)->tile[GETXY(x,y)].fringe.x, SIZE8);
			add_buffer(&buffer,&map(mapnum)->tile[GETXY(x,y)].fringe.tileset, SIZE8);
		}
	}

	clear_buffer(&map_array_cache[mapnum]);
	map_array_cache[mapnum] = buffer;
}

token scanner_get_str_bracket()
{
    WCHAR in_char, c;

    clear_buffer();
    if (m_file_in_ptr == 0) return TOKEN_EOF;
    if (src_eof()) return TOKEN_EOF;

    while (((in_char=src_getc())!=0)) {
        if (isspace(in_char))
            continue;
        else if (in_char == 0x0d)
            continue;            
        else if (in_char == 0x0a)
            continue;            
        else if (in_char != ']') {
            buffer_char(in_char);
            for (c=src_getc(); 
                c!=',' && c!='\t' && c!='\n' && c != ']'; 
                c=src_getc()) {
                if (c==0) break;
                buffer_char(c);
            }
            src_ungetc(c);
            return TOKEN_STRING;
        }    
    }
    
    return TOKEN_EOF;
}

int show_vocab(vocab_t *listavocab, int cat, bool imprime) {

int resultados = 0;
	
	
print_buffer_new_line();
if (listavocab) {
	
	listavocab = go_to_cat(listavocab,cat);
	listavocab = listavocab->psiguiente;

	resultados = 0;
	if (listavocab) {
		clear_buffer();
		while (listavocab && !listavocab->pcat) {
			resultados++;
			if (imprime) {
				show_vocab_item(listavocab,resultados);
			}

			listavocab = listavocab->psiguiente;					
  	}    	
	}

}

upgrade_buffer(false);

return resultados;
}

void send_map(void)
{
	buffer_t buffer;
	uint32 x = 0;

	clear_buffer(&buffer);

	add_opcode(&buffer, CMAPDATA);
	add_string(&buffer, map()->name );
	add_buffer(&buffer, &map()->moral,SIZE8);
	add_buffer(&buffer, &map()->music,SIZE8);
	add_buffer(&buffer, &map()->left,SIZE16);
	add_buffer(&buffer, &map()->right,SIZE16);
	add_buffer(&buffer, &map()->up,SIZE16);
	add_buffer(&buffer, &map()->down,SIZE16);
	add_buffer(&buffer, &map()->shop,SIZE16);
	add_buffer(&buffer, &map()->bootmap,SIZE32);
	add_buffer(&buffer, &map()->bootx,SIZE8);
	add_buffer(&buffer, &map()->booty,SIZE8);

	for( x = 0; x < MAX_MAP_NPCS; x++){
		add_buffer(&buffer, &map()->npc[x].num,SIZE16);
	}

	add_buffer(&buffer, map()->tile,(MAX_MAPX * MAX_MAPY) * sizeof(tile_t));

	send_data(&buffer);
}

/**
* cast_spell(void)
*
* @brief
* @param void
* @return void
*/
void cast_spell(void)
{
	buffer_t buffer;

	//Check for subscript out of range
	if(!tempdata()->spell_selected || tempdata()->spell_selected >= MAX_PLAYER_SPELLS)
		return;

	//Check if player has enough MP
	if(player(myindex())->spells[tempdata()->spell_selected]){
		if(player(myindex())->vitals[VITAL_MP] < spell(player(myindex())->spells[tempdata()->spell_selected])->mpreq){
			//	Call AddText("Not enough MP to cast " & Trim$(Spell(SpellSelected).Name) & ".", 12)
			return;
		}
		if(gettickcount() > player(myindex())->attacktimer + 1){
			if(player(myindex())->moving == 0){
				clear_buffer(&buffer);
				add_opcode(&buffer,CCAST);
				add_buffer(&buffer,&tempdata()->spell_selected, SIZE16);
				socketsend(&buffer);
				player(myindex())->attacking = TRUE;
				player(myindex())->attacktimer = gettickcount();
				tempdata()->castedspell = TRUE;
			}
			else{
				//Call AddText("Cannot cast while walking!", 12)
			}
		}
	}
	else{
		//Call AddText("No spell here.", 12)
	}
}

void Renderer::fillBuffers()
{
	cellGcmSetSurface(&deferredLight[0]);
	cellGcmSetDitherEnable(CELL_GCM_FALSE);
	clear_buffer();
	this->SetCurrentShader(*sceneVert, *sceneFrag);
	cellGcmSetDepthTestEnable(CELL_GCM_TRUE);
	cellGcmSetCullFaceEnable(CELL_GCM_TRUE);
	cellGcmSetBlendEnable(CELL_GCM_TRUE);
	cellGcmSetDepthFunc(CELL_GCM_LESS);

	cellGcmSetColorMaskMrt(CELL_GCM_COLOR_MASK_MRT1_A |
						   CELL_GCM_COLOR_MASK_MRT1_R |
						   CELL_GCM_COLOR_MASK_MRT1_G |
						   CELL_GCM_COLOR_MASK_MRT1_B);



	projMatrix = Matrix4::perspective(0.7853982, screen_ratio, 1.0f, 10000.0f);	//CHANGED TO THIS!!
	//projMatrix = Matrix4::orthographic(-0.5,0.5,-0.5,0.5,-1,1);
	viewMatrix = camera->BuildViewMatrix();
	modelMatrix = Matrix4::identity();
	currentVert->UpdateShaderMatrices(modelMatrix, viewMatrix, projMatrix);

	DrawNode(root);
	cellGcmSetDitherEnable(CELL_GCM_TRUE);

	cellGcmSetColorMaskMrt(0);
	//SetTextureSampler(currentFrag->GetParameter("texture"), height->GetMesh()->GetDefaultTexture());
	//height->GetMesh()->Draw(*sceneVert, *sceneFrag);
}

int main() {
    vga_fd = open("/dev/vga", O_RDONLY);
    ioctl(vga_fd, SETVGAMODE, (void*)vga_mode_320x200x256); 

    int fd = open("/dev/mouse", O_RDONLY);
    mousestate_t data;

    int ballX = WIDTH/2 - BALL_SIZE / 2;
    int ballY = HEIGHT/2 - BALL_SIZE /2;
    int velX = 10;
    int velY = 10;

    char color = 1;

    while (1) {
	clear_buffer(buffer);

	// read mouse position
	read(fd, &data, sizeof(data));
	data.y = 199 - data.y;
	data.x = data.x * WIDTH / 320;
	data.y = data.y * HEIGHT / 200;

	// draw ball and racket
	moveBall(&ballX,&ballY,&velX,&velY,data.y);
	drawBall(ballX,ballY,color);
	drawRacket(data.y,color);
	ioctl(vga_fd, FLUSHVGA, buffer);
	
	usleep(10000);
    }
    return 0;
}

// Pop up the Idle screen
void idle_screen(void)
{
	clear_buffer();
	LCD_Display_Text(121,(prog_uchar*)Verdana14,40,12); // "Press"
	LCD_Display_Text(122,(prog_uchar*)Verdana14,24,32); // "for status"
	write_buffer();
};

	/*************************************************************
	 * make_lookup_keyword:
	 *************************************************************/
struct cmd_struct  *make_lookup_keyword( /* Return: addr of cmd_struct	*/
    struct cduKeyword  keywordList[]	/* <r> keyword list		*/
   )
   {
    int   i;
    int   icnt;
    struct cmd_struct  *cmd;
    struct cduKeyword  *key;

		/*=====================================================
		 * Check size of keywordList[] ...
		 *====================================================*/
    for (icnt=0,key=keywordList ; key->keyA_name ; icnt++,key++)
        ;

    cmd = malloc((icnt+1)*sizeof(struct cmd_struct));
    if (!cmd)
       {
        fprintf(stderr,"*EXIT* Out of space!\n");
        exit(0);
       }
    clear_buffer(cmd,(icnt+1)*sizeof(struct cmd_struct));
    cmd[0].cmdA_string = (void *)(icnt+1);

		/*======================================================
		 * Initialize cmd[] table ...
		 *=====================================================*/
    for (i=1,key=keywordList ; i<=icnt ; i++,key++)
       {
        cmd[i].cmdL_id = i;
        cmd[i].cmdA_string = key->keyA_name;
       }
    return(cmd);
   }

/**
 * Ask for 20 numbers in a loop. When 20 valid numbers are entered, calculate
 * the average and report out the largest, smallest and average numbers.
 *
 * Control the loop by controlling the counter alone, letting the loop worry
 * about itself.
 */
int main()
{
  int i = 1, quantity = 20;
  double number = 0, running_sum = 0, largest_number = 0, smallest_number = 0;

  print_greeting(quantity);

  for (i = 1; i <= quantity; i += 1)
  {
    printf("Enter number %d: ", i);

    if (scanf("%lf", &number))
    {
      running_sum += number;
      smallest_number = compute_smallest_number(number, smallest_number, i);
      largest_number = compute_largest_number(number, largest_number);
    }
    else
    {
      printf("Please only enter numbers! Let's try again...\n");
      i -= 1;
      number = 0.00;
    }

    clear_buffer();
  }

  print_statistics(running_sum, quantity, smallest_number, largest_number);

  return 0;
}

char get_char(void)
{
	// Variables
	int success = 0;
	char cont, invalid;

	printf("\nWould you like to recalculate your budget? (Y/N): ");
	do
	{
		invalid = ' '; // Prevents infinite loop
		scanf("%c%c", &cont, &invalid);

		cont = toupper(cont);

		// Checks if cont is a Y or N or if invalid is a newline character
		if (cont != 'Y' && cont != 'N' || invalid != '\n')
		{
			printf("Error! Please enter Y to recalculate or N to not recalculate: ");

			// If not a newline character clear the buffer
			if (invalid != '\n')
			{
				clear_buffer();
			}
		}
		else // Success
		{
			success = 1;
		}		
	} while (success == 0);

	return cont;
}

void update_student_ID(int student_id[], char name[], int *num)
{
	int i, id;
	do 
	{
		i = 0;

		printf("\n>>>Student ID: ");
		scanf("%d", &id);

		while(student_id[i] != id && i++ < (*num));

		if (i <= (*num))
		{
			printf("ERROR: %d has been used already!\n", id);
		}

	} while (i <= (*num));

	student_id[(*num)++] = id;

	clear_buffer();
	printf(">>>Name: ");
	gets(name);
}

static void load_virt_ext(char *vname) {
	/* Our find_regexp() is geared to work on buffers rather than streams, so we'll create a
	   stand-alone buffer. This also buys us proper handling of encodings. */
	buffer * vb = alloc_buffer(NULL);
	if (vb == NULL) return;
	clear_buffer(vb);
	vb->opt.auto_prefs = 0;
	vb->opt.do_undo = 0;
	vb->opt.case_search = 0;
	if (load_file_in_buffer(vb, vname) != OK) return;

	bool skip_first = false;
	vb->find_string = "^\\s*(\\w+)\\s+([0-9]+i?)\\s+(.+[^ \\t])\\s*$|^\\.([^ \\t/]+)\\s*$";
	vb->find_string_changed = 1;

	if ((virt_ext = realloc(virt_ext, (num_virt_ext + vb->num_lines) * sizeof *virt_ext))
			&& (extra_ext = realloc(extra_ext, (num_extra_exts + vb->num_lines) * sizeof *extra_ext))) {
		while (find_regexp(vb, NULL, skip_first, false) == OK) {
			skip_first = true;
			if (nth_regex_substring_nonempty(vb->cur_line_desc, 1)) {
				char * const ext          = nth_regex_substring(vb->cur_line_desc, 1);
				char * const max_line_str = nth_regex_substring(vb->cur_line_desc, 2);
				char * const regex        = nth_regex_substring(vb->cur_line_desc, 3);
				if (!ext || !max_line_str || !regex) break;

				errno = 0;
				char *endptr;
				int64_t max_line = strtoll(max_line_str, &endptr, 0);
				if (max_line < 1 || errno) max_line = INT64_MAX;

				int i;
				for(i = 0; i < num_virt_ext; i++)
					if (strcmp(virt_ext[i].ext, ext) == 0) {
						free(virt_ext[i].ext);
						free(virt_ext[i].regex);
						break;
					}

				virt_ext[i].ext = ext;
				virt_ext[i].max_line = max_line;
				virt_ext[i].regex = regex;
				virt_ext[i].case_sensitive = *endptr != 'i';
				free(max_line_str);
				if (i == num_virt_ext) num_virt_ext++;
			}
			else {
				char * const ext = nth_regex_substring(vb->cur_line_desc, 4);
				if (! ext) break;
				int i;
				for(i = 0; i < num_extra_exts; i++)
					if (strcmp(extra_ext[i], ext) == 0) break;
				if (i == num_extra_exts) extra_ext[num_extra_exts++] = ext;
				else free(ext);
			}
		}
	}

	vb->find_string = NULL; /* Or free_buffer() would free() it. */
	free_buffer(vb);
}