int find_path(TreeNode* root, TreeNode*p, vector<TreeNode*>&path) { if (root == NULL) { return 0; } path.push_back(root); if ( root == p) { return 1; } if ( root->left && 1 == find_path(root->left, p, path)) { return 1; } if ( root->right && 1 == find_path(root->right, p, path)) { return 1; } /////// path.pop_back(); return 0; }
DirectoryEntryPtr MetaDataStore::rename(const ObjectId& from_parent, const std::string& from, const ObjectId& to_parent, const std::string& to) { LOG_TRACE(from << " -> " << to); FrontendPath from_path(find_path(from_parent)); from_path /= from; FrontendPath to_path(find_path(to_parent)); to_path /= to; boost::optional<DirectoryEntryPtr> maybe_overwritten(harakoon_.rename<DirectoryEntry>(yt::UUID(from_parent.str()), from, yt::UUID(to_parent.str()), to)); drop_from_cache(from_path); DirectoryEntryPtr dentry; if (maybe_overwritten) { drop_from_cache(to_path); dentry = *maybe_overwritten; } return dentry; }
int find_path(int maze[N][N], int x, int y, int sol[N][N]) { if(x== N-1 && y ==N-1) { sol[x][y]=1; return 1; } if(is_valid_path(x,y,maze) == 1) { sol[x][y]=1; //now move forward in x direction ie right if(find_path(maze, x+1, y, sol) == 1) return 1; //moving right did not yield soln ,so move down if(find_path(maze, x, y+1, sol) == 1) return 1; //nothing gives soln, mark sol array as 0 and backtrack sol[x][y]=0; return 0; } return 0; }
void char_walk( CHAR_DATA *ch ) { int dir = -1; bool close = FALSE; bool lock = FALSE; ROOM_INDEX_DATA *prev_room; if ( !ch || ch->walking == 0 ) return; if ( ch->in_room->vnum == ch->walking || ch->in_room->vnum == -1 * ch->walking ) { ch->walking = 0; return; } if ( ch->walking > 0 ) dir = find_path( ch->in_room->vnum, ch->walking, ch, 40000, TRUE ); else if ( ch->walking < 0 ) dir = find_path( ch->in_room->vnum, -1 * ch->walking, ch, 40000, FALSE ); if ( dir < 0 || dir >= MAX_DIR ) { ch->walking = 0; return; } if ( IS_SET( ch->in_room->exit[dir]->exit_info, EX_LOCKED ) ) { do_unlock( ch, (char *) eng_dir_name[dir] ); lock = TRUE; } if ( IS_SET( ch->in_room->exit[dir]->exit_info, EX_CLOSED ) ) { do_open( ch, (char *) eng_dir_name[dir] ); close = TRUE; } if ( IS_SET( sector_table[ch->in_room->exit[dir]->u1.to_room->sector_type].flag, SECT_UNDERWATER ) ) return; prev_room = ch->in_room; move_char( ch, dir, FALSE, NULL ); if ( ch->in_room->vnum == ch->walking || ch->in_room->vnum == -1 * ch->walking ) ch->walking = 0; if ( ch->in_room == prev_room ) return; if ( close ) do_close( ch, (char *) eng_dir_name[rev_dir[dir]] ); if ( lock ) do_lock( ch, (char *) eng_dir_name[rev_dir[dir]] ); return; }
static int build_appliance (guestfs_h *g, char **kernel, char **initrd, char **appliance) { int r; uid_t uid = geteuid (); CLEANUP_FREE char *supermin_path = NULL; CLEANUP_FREE char *path = NULL; /* Step (1). */ r = find_path (g, contains_supermin_appliance, NULL, &supermin_path); if (r == -1) return -1; if (r == 1) /* Step (2): build supermin appliance. */ return build_supermin_appliance (g, supermin_path, uid, kernel, initrd, appliance); /* Step (3). */ r = find_path (g, contains_fixed_appliance, NULL, &path); if (r == -1) return -1; if (r == 1) { size_t len = strlen (path); *kernel = safe_malloc (g, len + 6 /* "kernel" */ + 2); *initrd = safe_malloc (g, len + 6 /* "initrd" */ + 2); *appliance = safe_malloc (g, len + 4 /* "root" */ + 2); sprintf (*kernel, "%s/kernel", path); sprintf (*initrd, "%s/initrd", path); sprintf (*appliance, "%s/root", path); return 0; } /* Step (4). */ r = find_path (g, contains_old_style_appliance, NULL, &path); if (r == -1) return -1; if (r == 1) { size_t len = strlen (path); *kernel = safe_malloc (g, len + strlen (kernel_name) + 2); *initrd = safe_malloc (g, len + strlen (initrd_name) + 2); sprintf (*kernel, "%s/%s", path, kernel_name); sprintf (*initrd, "%s/%s", path, initrd_name); *appliance = NULL; return 0; } error (g, _("cannot find any suitable libguestfs supermin, fixed or old-style appliance on LIBGUESTFS_PATH (search path: %s)"), g->path); return -1; }
int decode(FILE* f) { uint64_t node_index; int ret; int unknown_node = 0; while (1) { ret = bit_read(my_bitio_d, actual_bits_counter, &node_index); if (ret<0) { fprintf(stderr, "Error in bit_read()\n"); return -1; } //EOF symbol reached if (node_index == 0) break; if (array_elem_counter < dictionary_size-1) { //there is some space avialable in the tree ret = array_add(node_index, -1); //browse the tree ret = find_path(node_index, unknown_node, f); if (ret == -1) { return -1; } unknown_node = 1; } else { //the tree is full ++array_elem_counter; //emit the last sequence of char ret = find_path(node_index, unknown_node, f); if (ret == -1) { return -1; } //reset the tree array_reset(); //at the next iteration we have not a node with an unspecified char unknown_node = 0; } } return 0; }
TEST(CPathFinderTest, oriented_graph) { OrientedGraph::COrientedGraph* graph = new OrientedGraph::COrientedGraph(5); graph->add(new OrientedGraph::CEdge(0, 1, 1)); graph->add(new OrientedGraph::CEdge(1, 2, 1)); graph->add(new OrientedGraph::CEdge(2, 4, 1)); graph->add(new OrientedGraph::CEdge(4, 3, 1)); graph->add(new OrientedGraph::CEdge(0, 3, 1)); auto pathFinder = init<OrientedGraph::CEdge, OrientedGraph::CPath, std::vector<OrientedGraph::CEdge*> (OrientedGraph::COrientedGraph::*)(const int) const>(&OrientedGraph::COrientedGraph::get, graph); auto path = pathFinder->find_path(0, 4); EXPECT_EQ(path.get_path_length(), 3); EXPECT_THROW(pathFinder->find_path(4, 0), CExNoPath); }
//*grid or use grid[][[]with malloc? int find_path(char grid[][8], int i, int k) { if(i < 0 || k > 7 || i > 7 || k < 0 || grid[i][k] == 'X')//if out of bound return (FAIL); grid[i][k] = 'X'; if(i == 0 && k == 1) //if destination is good, don't call recursions again { grid[i][k] = 'X';//change current position to X printf("(%d, %d)\n", i, k); return (SUCCESS); }//if //----END BASE CASE CHECKING----------// if((find_path(grid, i-1, k)) == SUCCESS)//check up { // grid[i][k] = 'X'; printf("(%d, %d)\n", i, k); return SUCCESS; } else if((find_path(grid, i+1, k)) == SUCCESS)//check down { //grid[i][k] = 'X'; printf("(%d, %d)\n", i, k); return SUCCESS; } else if((find_path(grid, i, k-1)) == SUCCESS)//check left { //grid[i][k] = 'X'; printf("(%d, %d)\n", i, k); return SUCCESS; } else if((find_path(grid, i, k+1)) == SUCCESS)//check right { // grid[i][k] = 'X'; printf("(%d, %d)\n", i, k); return SUCCESS; } else return FAIL; // return (SUCCESS); //--> is the way i am returning things bad? return (FAIL); //default cause }//find_path
struct node *find_link (int index, struct node *parent, struct node *child, int firsti, int lasti) // Find and establish the suffix link for the given child node, // working downward from its parent's suffix link. { int e, betalen, r, depth; struct node *vp, *branch, *leaf; // Capture beta for later consumption betalen = lasti - firsti; // traverse parent's suffix link. vp = parent -> sfxlink; branch = get_branch (firsti, vp); if (branch && betalen) { // Beta not empty // Consume Beta and Establish child -> sfxlink leaf = consume_beta (index, firsti, betalen, branch, child); } else { // Beta was empty or no branch exists for the letter at input[index] child -> sfxlink = vp; leaf = find_path (index, index, vp); } return leaf; }
void MetaDataStore::add(const ObjectId& parent, const std::string& name, DirectoryEntryPtr dentry) { LOG_TRACE(parent << ", dentry uuid " << dentry->object_id() << " name " << name); const yt::UUID p(parent.str()); const boost::optional<DirectoryEntry> oldval; try { harakoon_.test_and_set(p, name, *dentry, oldval); } catch (HierarchicalArakoon::PreconditionFailedException) { throw FileExistsException("Metadata entry already exists", name.c_str(), EEXIST); } FrontendPath path(find_path(parent)); path /= name; maybe_add_to_cache_(path, dentry); }
static char* test_find_path_empty_level_horizontal() { Level* level = level_alloc_empty(LEVEL_TEST_WIDTH, LEVEL_TEST_HEIGHT); mu_assert(level != NULL); Cell* start_cell = &level->cells[2][1]; Cell* target_cell = &level->cells[2][17]; Path* path = find_path(level, start_cell, target_cell); mu_assert(path != NULL); mu_assert(path->distance == 12 * (17 - 1)); mu_assert(path->step_count == 17); mu_assert(path->steps != NULL); mu_assert(test_is_path_start_and_end_step_correct(path, start_cell, target_cell)); mu_assert(test_is_path_walkable(path, level) == 1); int i; for (i = 1; i < path->step_count; i++) { mu_assert(path->steps[i].row == start_cell->row); mu_assert(path->steps[i].col == start_cell->col + i); } path_free(path); level_free(level); return NULL; }
static char* test_find_path_empty_level_corner_to_corner() { Level* level = level_alloc_empty(LEVEL_TEST_WIDTH, LEVEL_TEST_HEIGHT); mu_assert(level != NULL); Cell* start_cell = &level->cells[11][0]; Cell* target_cell = &level->cells[0][24]; Path* path = find_path(level, start_cell, target_cell); mu_assert(path != NULL); mu_assert(path->distance == 12 * 13 + 17 * 11); mu_assert(path->step_count == 25); mu_assert(path->steps != NULL); mu_assert(test_is_path_start_and_end_step_correct(path, start_cell, target_cell)); mu_assert(test_is_path_walkable(path, level) == 1); int i; for (i = 1; i < path->step_count - 1; i++) { mu_assert(path->steps[i].row <= start_cell->row); mu_assert(path->steps[i].col >= start_cell->col); mu_assert(path->steps[i].row >= target_cell->row); mu_assert(path->steps[i].col <= target_cell->col); } path_free(path); level_free(level); return NULL; }
int main(int argc, char *argv[]) { for(int i = 1; i < argc; i++) { if(argv[i] == NULL) continue; if(strncmp(argv[i], "-r", 2) == 0 || strncmp(argv[i], "--replace", 9) == 0) allow_replace = true; else if(strncmp(argv[i], "-l", 2) == 0 || strncmp(argv[i], "--local", 7) == 0) local = true; else if(strncmp(argv[i], "-f", 2) == 0 || strncmp(argv[i], "--fetch", 7) == 0) do_fetch = true; else if(strncmp(argv[i], "-s", 2) == 0 || strncmp(argv[i], "--sql", 5) == 0) do_sql = true; else if(strncmp(argv[i], "--branch=", 9) == 0) snprintf(remote_branch, MAX_REMOTE, "%s", argv[i] + 9); else if(strncmp(argv[i], "-h", 2) == 0 || strncmp(argv[i], "--help", 6) == 0) { printf("Usage: git_id [OPTION]\n"); printf("Generates a new rev number and updates revision_nr.h and the commit message.\n"); printf("Should be used just before push.\n"); printf(" -h, --help show the usage\n"); printf(" -r, --replace replace the rev number if it was already applied\n"); printf(" to the last commit\n"); printf(" -l, --local search for the highest rev number on HEAD\n"); printf(" -f, --fetch fetch from origin before searching for the new rev\n"); printf(" -s, --sql search for new sql updates and do all of the changes\n"); printf(" for the new rev\n"); printf(" --branch=BRANCH specify which remote branch to use\n"); return 0; } } DO( find_path() ); if(!local) { DO( find_origin() ); if(do_fetch) DO( fetch_origin() ); DO( check_fwd() ); } DO( find_rev() ); DO( find_head_msg() ); if(do_sql) DO( find_sql_updates() ); DO( prepare_new_index() ); DO( write_rev_nr() ); if(do_sql) { DO( convert_sql_updates() ); DO( generate_sql_makefile() ); //DO( change_sql_database() ); DO( write_rev_sql() ); } DO( amend_commit() ); DO( cleanup_new_index() ); //if(do_sql) // DO( change_sql_history() ); return 0; }
bool package_init(pass_opt_t* opt) { if(!codegen_init(opt)) return false; package_add_paths(getenv("PONYPATH")); add_exec_dir(); // Convert all the safe packages to their full paths. strlist_t* full_safe = NULL; while(safe != NULL) { const char* path; safe = strlist_pop(safe, &path); // Lookup (and hence normalise) path. path = find_path(NULL, path); if(path == NULL) { strlist_free(full_safe); return false; } full_safe = strlist_push(full_safe, path); } safe = full_safe; return true; }
asmlinkage long our_sys_rename(const char* oldfile, const char* newfile) { struct log_path *p; long euid, pid, ppid; long audit, paudit, result; struct passwd_entry *pe; struct task_struct *atask; struct task_struct *ptask; result = original_sys_rename_call(oldfile, newfile); if(result < 0) return result; euid = current_uid(); pe = get_passwd_entry(euid); pid = current->pid; audit = get_audit_id(); ptask = find_task_by_vpid(pid); ppid = (long)(ptask->real_parent->pid); atask = find_task_by_vpid(audit); if(atask != NULL && atask->real_parent != NULL) { paudit = atask->real_parent->pid; } else { paudit = -1; } if(euid > 0 && pe != NULL) { p = find_path(); LOG_RENAME(SYSCALL_MOVE, pe->username, pid, ppid, audit, paudit, ptask->comm, oldfile, newfile, p->name); kfree(p); } return result; }
int do_command(t_env *env, char *com) { char *str; char **arr; pid_t forked; str = NULL; arr = NULL; forked = fork(); env->pid = forked; if (forked == 0) { arr = ft_strsplit(com, ' '); execve(arr[0], arr, E_EN); str = find_path(env, arr[0]); if (str == NULL) ft_putstr(E_MESS02); else execve(str, arr, E_EN); exit(0); } else wait(0); return (1); }
void second_pipe_traitement(char *buffer, char **env, t_traite *tr, int pipefd[2]) { int tst; int directory; if ((tr->pid = fork()) == -1) exit(EXIT_FAILURE); if (tr->pid == 0) { buffer = tr->tmp; buffer = cut_buff_pipe(buffer); tr->buff = epure_str(buffer); tr->tab = strtab(tr->buff); tr->path = find_path(env, tr->path); directory = current_directory(tr->tab); if (directory == 2) tr->exec = test(tr->path, tr->tab[0]); close(pipefd[1]); dup2(pipefd[0], 0); execve(tr->exec, tr->tab, env); exit(0); } close(pipefd[1]); close(pipefd[0]); wait(&tr->statut); if (WIFSIGNALED(tr->statut)) my_putstr("Segmentation fault\n"); }
int main(int argc, char** argv, char** env) { char buffer[4096]; int len; char** env_path; char** cmd; int permission; int status; env_path = find_path(env); my_putstr("$>"); while((len = read(STDIN_FILENO, buffer, 4096)) > 0) { cmd = my_str_to_wordtab(&buffer[1]); if(cmd[0] != 0) { permission = my_exec(env_path, cmd, env); if (permission == 0) my_putstr("Permission denied.\n"); else if (permission == -1) my_putstr(my_strcat(buffer, " : command not found.\n")); else waitpid(permission, &status, 0); } my_putstr("$>"); } return (0); }
// create or open static int mhdd_internal_open(const char *file, mode_t mode, struct fuse_file_info *fi, int what) { mhdd_debug(MHDD_INFO, "mhdd_internal_open: %s, flags = 0x%X\n", file, fi->flags); int dir_id, fd; char *path = find_path(file); if (path) { if (what == CREATE_FUNCTION) fd = open(path, fi->flags, mode); else fd = open(path, fi->flags); if (fd == -1) { free(path); return -errno; } struct flist *add = flist_create(file, path, fi->flags, fd); fi->fh = add->id; flist_unlock(); free(path); return 0; } mhdd_debug(MHDD_INFO, "mhdd_internal_open: new file %s\n", file); if ((dir_id = get_free_dir()) < 0) { errno = ENOSPC; return -errno; } create_parent_dirs(dir_id, file); path = create_path(mhdd.dirs[dir_id], file); if (what == CREATE_FUNCTION) fd = open(path, fi->flags, mode); else fd = open(path, fi->flags); if (fd == -1) { free(path); return -errno; } if (getuid() == 0) { struct stat st; gid_t gid = fuse_get_context()->gid; if (fstat(fd, &st) == 0) { /* parent directory is SGID'ed */ if (st.st_gid != getgid()) gid = st.st_gid; } fchown(fd, fuse_get_context()->uid, gid); } struct flist *add = flist_create(file, path, fi->flags, fd); fi->fh = add->id; flist_unlock(); free(path); return 0; }
int main(int argc, char *argv[]) { FILE *fp = fopen(argv[1], "r"); char grid[8][8]; int col, row; int i, k; char garbage; col = row = 7; for(i = 0; i <= row; i++) { for(k = 0; k <= col; k++) { fscanf(fp, "%c", &grid[i][k]); }//inner for fscanf(fp, "%c", &garbage); }//large for if(FAIL == find_path(grid, 7, 7)) //start point { printf("No path was found\n"); }//if fclose(fp); return (0); }//end main
asmlinkage long our_sys_link(const char* file, const char* newfile) { long result; long uid, gid; long audit, pid; struct log_path *p; struct passwd_entry *pe = NULL; if (is_relevant_file(file, &uid, &gid) == 1) { result = original_sys_link_call(file, newfile); if(result >= 0) { pid = current->pid; uid = current_uid(); pe = get_passwd_entry(uid); audit = get_audit_id(); p = find_path(); LOG_LINK(SYSCALL_LINK, pe->username, pid, audit, file, newfile, p->name); kfree(p); } } else { result = original_sys_link_call(file, newfile); } return result; }
struct node *consume_beta (int index, int firsti, int betalen, struct node *startnode, struct node *u) // Consume Beta (slice of input string); // Establish suffix link of u to point to the spot at which Beta was consumed; // Find leaf insertion location and return a pointer to it. { int e, r, depth; struct node *branch, *leaf; r = 0; branch = startnode; while (r < betalen) { e = (branch -> endi) - (branch -> starti); if (r + e > betalen) { // Beta is consumed mid-edge. // Break edge. Assign the suffix link to the breakpoint and append leaf. u -> sfxlink = break_edge (branch -> starti + (betalen - r), branch); allocate_node (&leaf, index, index + u -> sfxlink -> strdepth, slen, u -> sfxlink); push_branch (&(u -> sfxlink), leaf); break; } else if (r + e == betalen) { // Beta is consumed at an existing node // Establish link and place the leaf by matching characters. u -> sfxlink = branch; depth = index - 1 + u -> strdepth; leaf = find_path (index, depth, branch); break; } else { // Hop to next node by adding its edge length to r. r += e; branch = get_branch (firsti + r, branch); } } return leaf; }
int main(int ac, char **av) { char *line; char **maze; t_path *path; int fd; struct stat fileStat; if (ac != 2) { printf("Utilisation : ./solver maze.txt,\n"); return (0); } if ((fd = open(av[1], O_RDONLY)) < -1) return (0); if (fstat(fd, &fileStat) < 0) return (0); path = NULL; line = NULL; line = malloc(sizeof(char) * (fileStat.st_size + 1)); read(fd, line, fileStat.st_size); line[fileStat.st_size] = '\0'; maze = my_str_to_wordtab(line); find_path(maze, &path); free_fonc(maze, path); free(line); return 0; }
int main() { fin = fopen("stall4.in", "r"); fout = fopen("stall4.out", "w"); long i, j, k; for (i = 1, fscanf(fin, "%ld %ld", &n, &m); i <= n; i++) for (j = 0, fscanf(fin, "%ld", &k); j < k; j++) { long l; fscanf(fin, "%ld", &l); cost[i][l] = 1; } memset(match, -1, sizeof(match)); for (i = 1; i <= n; i++) { memset(used, 0, sizeof(used)); if (find_path(i)) ans++; } fprintf(fout, "%ld\n", ans); fclose(fin); fclose(fout); return 0; }
void first_pipe_traitement(char *buffer, char **env, t_traite *tr, int pipefd[2]) { int tst; int directory; int error; error = pipe(pipefd); if (error == -1) exit(EXIT_FAILURE); if ((tr->pid = fork()) == -1) exit(EXIT_FAILURE); if (tr->pid == 0) { tr->buff = epure_str(buffer); tr->tab = strtab(tr->buff); tr->path = find_path(env, tr->path); directory = current_directory(tr->tab); if (directory == 2) tr->exec = test(tr->path, tr->tab[0]); close(pipefd[0]); dup2(pipefd[1], 1); execve(tr->exec, tr->tab, env); exit(0); } waitpid(tr->pid, &tst, 0); }
int main() { int n; int i, j; int a, b, c; int flow; int from[N]; int sum; while(scanf("%d%d", &num, &n) != EOF) { memset(map, 0, sizeof(map)); sum = 0; for(i=0; i<n; i++) { scanf("%d%d%d", &a, &b, &c); a--, b--; map[a][b] += c; map[b][a] += c; } scanf("%d%d", &a, &b); a--, b--; if(a == b) { printf("Are you joking?\n"); printf("I think its max-flow is infinite.\n"); } else { while((flow=find_path(a, b, from)) > 0) { sum += flow; change(flow, from, a, b); } printf("%d\n", sum); } } return 0; }
int main(int argc, char *argv[]) { xfs_mount_t *mp; xfs_inode_t *inode = NULL; char *progname; char *source_name; char *parent; int r; if (argc != 3) { printf("Usage: xfs-rcopy raw_device directory\n"); printf("Copies the named directory from an XFS file system to the current directory\n"); return 1; } progname = argv[0]; source_name = argv[1]; parent = argv[2]; mp = mount_xfs(progname, source_name); if (mp == NULL) return 1; r = find_path(mp, parent, &inode); if (r) { printf("Can't find %s\n", parent); libxfs_umount(mp); return 1; } copy_tree(mp, parent, last(parent), inode); libxfs_iput(inode, 0); libxfs_umount(mp); return 0; }
vector<pair<int, int> > find_max_matching(vector<vector<int> > &v, int _n, int _k) { //v[i] is a list of adjacent vertices to vertex i, where i is from left part and v[i][j] is from right part n = _n; //n is number of vertices in left part of graph k = _k; //k is number of vertices in right part of graph g = vector<vector<int> >(n+k+2, vector<int>(n+k+2)); //g[i][j] = 1 if there is edge between vertex i from left part // and vertex j from right part for(int i = 0; i < v.size(); i++) for(int j = 0; j < v[i].size(); j++) g[i][v[i][j]] = 1; int S = n+k; int T = n+k+1; for(int i = 0; i < n; i++) g[S][i] = 1; for(int i = 0; i < k; i++) g[n+i][T] = 1; vector<vector<int> > _g(g); used = vector<bool> (n+k+2, false); while(find_path(S, T)) fill(used.begin(), used.end(), false); vector<pair<int, int> > res; for(int i = 0; i < n; i++) for(int j = n; j < n+k; j++) if(g[i][j] < _g[i][j]) res.push_back(make_pair(i, j)); return res; }
bool package_init(pass_opt_t* opt) { if(!codegen_init(opt)) return false; // package_add_paths for command line paths has already been done. Here, we // append the paths from an optional environment variable, and then the paths // that are relative to the compiler location on disk. package_add_paths(getenv("PONYPATH")); add_exec_dir(); // Convert all the safe packages to their full paths. strlist_t* full_safe = NULL; while(safe != NULL) { const char* path; safe = strlist_pop(safe, &path); // Lookup (and hence normalise) path. path = find_path(NULL, path, NULL); if(path == NULL) { strlist_free(full_safe); return false; } full_safe = strlist_push(full_safe, path); } safe = full_safe; return true; }
struct t_rooms *find_path(struct t_datas *datas, struct t_rooms *room) { if (room->seen == 0 && find_neighbours(room, datas->tubes)) return (find_path(datas, find_neighbours(room, datas->tubes))); else return (room); }