void print_tree (tree_node* parent) {
	if((parent-> left_child)) {
		print_tree(parent-> left_child);
	}
	if((parent-> right_child)) {
		print_tree(parent-> right_child);
	}
	if(parent->points) {
		int size = parent->points->size;
		int* points =  parent->points->point_ids;
		for(int i =0; i < size; i++) {
			printf("%d \n", *(points + i));
		}
	}
}

void print_tree(Node* tree, int tabs){
	/* Tulostaa puurakenteen käänteisessä sisäjärjestyksessä. Puurakenne muodostuu
	tulostamalla sopiva määrä sisennysmerkkejä ennen jokaista avainarvoa. Parametri 
	tabs pitää sisällään sisennysmerkkien lukumäärän */
	int i = tabs;
	if (tree){
		print_tree(tree->ptrRight, tabs + 1);
		while (i>0){
			printf("\t");
			i--;
		}
		printf("%d(%d)\n", tree->key, tree->height);
		print_tree(tree->ptrLeft, tabs + 1);
	}
}

void print_tree(node *tree)
{

    printf("\nnumofcubes %d\n",tree->num_of_cubes);
    if(tree->type==0) printf("max\n");
    else printf("min\n");

    printf("score: %d\n\n",tree->score);
    if(tree->num_of_cubes<=0)
        return;
    print_tree((tree)->left);
    print_tree((tree)->right);


}

static void print_tree(tree t, int depth, int column)
{
	int laenge;

	if (NULL == t) 
		return;

	laenge = t->end - t->start;

	printf("%-*d <%-*.*s> (%d..%d)\n", 2 + column, depth, 
			laenge, laenge, t->start, t->from, t->to);

	print_tree(t->child, depth + 1, column + laenge);
	print_tree(t->next, depth, column);
}

int main(void) {
    tree s = prompt_tree();
    printf("s = ");
    print_tree(s);
    tree t = prompt_tree();
    printf("t = ");
    print_tree(t);
    tree r = baz(s, t);
    printf("baz(s, t) = ");
    print_tree(r);
    free_tree(r);
    free_tree(s);
    free_tree(t);
    return 0;
}

static void
print_tree (GNode *node, gint depth)
{
	GNode    *n;
	FakeNode *file;
	gint      i;

	for (i = 0; i < depth; i++) {
		g_print ("  ");
	}

	n = node;
	while (n) {
		file = n->data;
	
		g_print ("%s\n", file->name);

		if (file->directory) {
			print_tree (n->children, depth + 1);
		} else {
			g_print ("[%s]\n", file->content);
		}

		n = n->next;
	}
}

static FakeNode *
add_fake_node (GnomeVFSURI *uri, gboolean directory)
{
	GnomeVFSURI *parent_uri;
	FakeNode    *parent_file;
	const gchar *path, *name;
	FakeNode    *file;

	parent_uri = gnome_vfs_uri_get_parent (uri);
	parent_file = get_fake_node_from_uri (parent_uri);

	if (!parent_file) {
		return NULL;
	}
	
	path = gnome_vfs_uri_get_path (uri);
	name = strrchr (path, '/') + 1;

	g_print ("ADD FAKE: %s, dir: %d\n", name, directory);
	
	file = fake_node_new (name, NULL);

	file->gnode = g_node_append_data (parent_file->gnode, file);
	file->directory = directory;

	print_tree (root, 0);

	return file;
}

int main ()
{
	short flag = 11;							/// flag for menu
	leaf *root;									/// root of tree

	root = new leaf;
	root->parent = NULL;						/// totaly null root of tree
	root->son_l = NULL;							
	root->son_r = NULL;							
	root->val = NULL;							

	while(1)
	{
		switch (give_mFlag())					/// give flag
		{
		case 1: 
			create_tree(root);					/// create tree
			printf("\n....tree was created");
			break;
		case 2:
			print_tree(root);					/// print tree
			break;
		case 0:
			delete_tree(root);					/// destroy tree 
			printf("\n....tree was destroied"); 
			flag = EXIT_WHILE;					/// and exit from programm
			break;
		}
		if (flag == EXIT_WHILE) break;
	}

	getchar();
	getchar();
}

/* program execution begins here
 *
 */
int main(int argc, char* argv[]) {
    if( argc != 2 ) {
        fprintf(stderr, "ERROR: useage is ./ticker FILENAME\n");
        return -1;
    }
    struct tree* tree, *tempC = NULL, *tempT = malloc(sizeof(struct tree));
    if (!tempT) {
        fprintf(stderr, "ERROR: could not allocate space.\n");
        return -1;
    }
    memset(tempT, 0, sizeof(struct tree));
    tree = read_file(argv[1]);
    if (!tree) { // allocation or read failed somehow
        return -1;
    }
    user_input(tree);
    while( (tempC = pop_tree(tree)) && tempC != tree) {
        tree_insert(tempT, tempC->data, check_value);
        free(tempC);
    }
    tree_insert(tempT, tree->data, check_value);
    print_tree(tempT);
    free(tree);
    tree_destroy(tempT);

}

int main(int argc, char *argv[])
{
	struct block_device *bldev;
	FatVol vol;
	FatFile file;
	char *rootpath = argc > 2 ? argv[2] : "/";

	bldev = block_device_file_new(argc > 1 ? argv[1] : "fat32.img", "r+");
	assert(bldev != NULL);

	assert(fat_vol_init(bldev, &vol) == 0);
	fprintf(stderr, "Fat type is FAT%d\n", vol.type);

	fat_mkdir(&vol, "Directory1");
	fat_mkdir(&vol, "Directory2");
	fat_mkdir(&vol, "Directory3");
	assert(fat_chdir(&vol, "Directory1") == 0);
	fat_mkdir(&vol, "Directory1");
	fat_mkdir(&vol, "Directory2");
	fat_mkdir(&vol, "Directory3");
	if(fat_create(&vol, "Message file with a long name.txt", O_WRONLY, &file) == 0) {
		for(int i = 0; i < 100; i++) {
			char message[80];
			sprintf(message, "Here is a message %d\n", i);
			assert(fat_write(&file, message, strlen(message)) == (int)strlen(message));
		}
	}
	assert(fat_chdir(&vol, "..") == 0);
	assert(fat_open(&vol, ".", O_RDONLY, &file) == 0);
	print_tree(&vol, &file, rootpath[0] == '/' ? rootpath + 1 : rootpath);

	block_device_file_destroy(bldev);
}

int main(int argc, char *argv[])
{
        pid_t pid;
	int status;
	struct tree_node *root;

        if (argc != 2) {
                fprintf(stderr, "Usage: %s <input_tree_file>\n\n", argv[0]);
                exit(1);
        }

        root = get_tree_from_file(argv[1]);
        print_tree(root);

	pid=fork();
	if(pid<0){
		perror("main: fork");
		exit(1);
	}
	else if(pid==0){
		fork_procs(root);
		exit(1);
	}
		
	wait_for_ready_children(1);
	show_pstree(pid);
	kill(pid,SIGCONT);
        pid=wait(&status);
	explain_wait_status(pid,status);

	return 0;
}

void HuffmanEncoder::encode(dict d)
{
	ofstream out;
	out.open((path + ".ashf").c_str());

	vector < Code > word_concat;
	for (int i = 0; i < d.size(); i++)
	{
		if (d[i].c.q == -1 || d[i].c.r == -1)
			continue;
		word_concat.push_back(d[i].c);
	}

	// coding of min(i1, i2)
	vector < string > r_s;
	int k = 0;
	for (int i = 0; i < word_concat.size(); i++)
	{
		int q_log = get_log(word_concat[i].q);
		string kemp = "";
		for (int i = 0; i <= q_log; i++)
		{
			kemp += (1 << i) & word_concat[i].r ? "1" : "0";
		}
		reverse(kemp.begin(), kemp.end());
		r_s.push_back(kemp);

		int r = word_concat[i].q;
		word_concat[i].q -= k;
		k = r;
	}

	root = build_tree(word_concat);
	get_codes(root);
	print_tree(root);

	string long_string = "";
	int q = 0;
	for (int i = 0; i < word_concat.size(); i++)
	{
		string tempor = get_code(word_concat[i].q) + r_s[i] + (word_concat[i].d == true ? "1" : "0");
		long_string = long_string + tempor;
	}

	int l_str_size = long_string.size();
	int cur_p = 0;
	while (cur_p < l_str_size)
	{
		unsigned char c = 0;
		for (int i = 0; i < min(8, l_str_size - cur_p); i++)
		{
			int t = long_string[i + cur_p] == '0' ? 0 : 1;
			c += (t << i);
		}
		cur_p += 8;
		out << c;
	}

	out.close();
}

int main () {
	setlocale( LC_ALL,"Russian" );
	tree *t = NULL;
	char h;
	char searching[20];
	int flag;
	printf("Введите кол-во спортсенов: ");
	scanf("%d", &flag);
	do {
	   printf("Введите имя спортсмена: ");
	   scanf("%s", zappin.name);
	   printf("Введите вид спорта: ");
	   scanf("%s", zappin.sport);
	   printf("Введите кол-во очков: ");
	   scanf("%d", &zappin.score);
	   printf("\n");
	   add(t, zappin);
	   flag--;
	} while (flag);
	system("cls");
	print_tree(t);
			// Поиск
             
             printf("Для поиска спортсмена введите фамилию: ");
	         scanf("%s", searching);
	         search(t, searching);
	getch();
	return 0;
}

int main(int argc, char** argv) {
    if(argc <= 1) return 1;
    FILE *f = fopen(argv[1], "r");
    if (!f) {
        perror(argv[1]);
        return 1;
    }
    FILE *fp = stdout;
    if(argc == 3) {
        fp = fopen(argv[2], "w");
    }

    yyrestart(f);
#if YYDEBUG
    yydebug = 1;
#endif
    yyparse();
    if(!err) {
#ifdef DEBUG
        print_tree(root);
#endif
        main_parse(root);
        //print_code(&code, stdout);
        init_mips(fp);
        gen_mips(&code, fp);
    }
    return 0;
}

int main(int argc, char** argv)
{
   if (argc > 2)
      if (strcmp(argv[1], "-d") == 0) {
         debug = 1;
         debug_file = fopen(argv[2], "w");
      }

   char namestring[MAXNAME];

   printf("what will you define?\n");

   fgets(namestring, MAXNAME, stdin);
   *(strchr(namestring, '\n')) = '\0';

   struct node* root = setup_tree(namestring);

   if (debug)
      print_tree(root);

   printf("total cost for %s is %.2f\n", namestring, calculate_cost(root, 1));

   free_tree(root);

   if (debug)
      fclose(debug_file);

   return 0;
}

int main() {
    int a[] = {3, 4, 5, 1, 9, 2, 0, 4, 5};
    int m, n = sizeof(a) / sizeof(int);
    for (m = 1; m < n; m <<= 1);
    m <<= 1;
    node *tree = (node *)calloc(m, sizeof(node));
    puts("build");
    PRA(a, n);
    build(tree, a, 0, n-1, 1);
    for (int i = 0; i < n; i++) {
        for (int j = 0; j <= i; j++)
            a[j] += 1;
        // printf("(%d, %d)\n", 0, i);
        update(tree, a, 0, n-1, 1, 0, i, 1);
    }
    PRA(a, n);
    print_tree(tree, a, 0, n-1, 1);
    puts("query");
    int v;
    for (int i = 0; i < n; i++) {
        v = query(tree, a, 0, n-1, 1, 0, i);
        printf("(%d, %d): %d\n", 0, i, v);
    }
    for (int i = 0; i < n; i++) {
        v = query(tree, a, 0, n-1, 1, i, n-1);
        printf("(%d, %d): %d\n", i, n-1, v);
        assert(v == lsearch(a, i, n-1));
    }
    
    return 0;
}

int main()
{
	List * root;	/*定义语义树根结点*/
	root = tag_list();	/*递归下降分析返回根结点*/
	print_tree(0, root); /*打印树到屏幕*/
	return 0;
}

void print_tree(std::shared_ptr<dhc::graft::match::match> &root, int indent)
{
    if (root->type == static_cast<int>(dhc::lexer::type::WHITESPACE))
        return;

    auto tree = root->children();
    print_indent(indent);
    std::cout << '"' << root->flatten() << "\"" << std::endl;
    for (auto it = tree.begin(); it != tree.end(); ++it)
    {
        std::vector<std::shared_ptr<dhc::graft::match::match>> c = (*it)->children();
        if (c.size() == 0)
        {
            print_indent(indent + 4);
            std::string flat;
            (*it)->flatten().toUTF8String(flat);

            size_t pos = 0;
            while ((pos = flat.find("\n", pos)) != std::string::npos)
            {
                flat.replace(pos, 1, "\\n");
                pos += 2;
            }

            std::cout << '"' << flat << "\"" << ' ' << std::endl;
        }
        else
        {
            print_tree((*it), indent + 4);
        }
    }
}

int main() 
{
    //consume input data
    int departure = -1;
    int* tree = NULL;
    TIME* dist = NULL;
    citygraph _citys;

    if (consume_console_input(&_citys.matrix, &_citys.count))
    {
        printf("=>Input matrix as follows: \n");
        print_matrix(_citys.matrix, _citys.count);
        printf("=>Input departure city id : ");
        while(true)
        {
            scanf("%d", &departure);
            if(departure < 0 || departure >= _citys.count)
                printf("=>Departure city id should be in the range (0, %d), input again: ", _citys.count - 1);
            else
                break;
        } 
        assert(departure > -1 && departure < _citys.count);
        dist = dijkstra(_citys, &tree, departure);
        printf("=>The minimal time for a message to spread out from captiol to whole empire is %u ...\n", get_max_item(dist, _citys.count));

        print_tree(tree, _citys.count, departure);

        free(tree); tree = NULL;
        free(dist); dist = NULL;
        free_citygraph(_citys);
    }

    system("pause");
    return 0;
}

static int print_tree(git_repository *repo, const git_oid *tree_oid, int depth)
{
	static const char *indent = "                              ";
	git_tree *tree;
	unsigned int i;

	if (git_tree_lookup(&tree, repo, tree_oid) < GIT_SUCCESS)
		return GIT_ERROR;

	for (i = 0; i < git_tree_entrycount(tree); ++i) {
		const git_tree_entry *entry = git_tree_entry_byindex(tree, i);
		char entry_oid[40];

		git_oid_fmt(entry_oid, &entry->oid);
		printf("%.*s%o [%.*s] %s\n", depth*2, indent, entry->attr, 40, entry_oid, entry->filename);

		if (entry->attr == S_IFDIR) {
			if (print_tree(repo, &entry->oid, depth + 1) < GIT_SUCCESS) {
				git_tree_close(tree);
				return GIT_ERROR;
			}
		}
	}

	git_tree_close(tree);
	return GIT_SUCCESS;
}