AlexMog

oui, ça énerve mon groupe actuel epitech d'ailleurs XD

Voici: /* ** Code created by AlexMog ** Created the 10/04/2014 at 05:42pm. ** Last update by AlexMog the 10/04/2014 at 05:56pm. ** Please, leave the copyright. */ #include <string.h> char **explode(char *chaine, char *delimiter) { // Variable de retours char **ret; // Variable pour écupérer un mot char *word; // Taille totale des mots lus int size; // On initialise les variables (pour éviter tout conflits et valeurs aléatoires) ret = NULL; // On stoque le premier mot trouvé avant le délimiteur (voir man strtok) word = strtok(chaine, delimiter); size = 0; // Début de la boucle, tant qu'on a un mot, on continue (je n'ai pas mis de doWhile à cause du 2nd argument de strtok qui doit être mis à NULL (lire le man de strtok) while (word != NULL) { // On alloue la place naisséssaire en mémoire pour stocker (size + 2) cases (donc, on ajoute une nouvelle case dans notre tableau à chaque tour de boucle (c'est ce qu'on appelle un tableau dynamique, je ferais un cours dessus) ret = realloc(ret, (size + 2) * sizeof(char*)); // D'après le man de realloc, celui-ci retourne NULL en cas d'erreur, je vérifie donc qu'il n'y a eu aucune erreur if (ret == NULL) return (NULL); // Je copie le contenue de "word" (donc du mot trouvé) dans la case actuelle du tableau strcpy(ret[size], word); // Je récupère le prochain mot word = strtok(NULL, delimiter); // J'incrémente la taille du tableau ++size; } // Je vérifie si ret est NULL if (ret != NULL) // Si il ne l'est pas, c'est que le tableau a été remplis , j'ajoute donc un NULL à la dernière case du tableau, pour définir la fin de celui-ci // (Ce qui explique le size + 2 au niveau du realloc ret[size] = NULL; // Enfin, on renvois le tableau alloué (ne pas oublier de le free après utilisation ) return (ret); } J'espère avoir assez bien expliqué ^^

J'y penserais Tu es à epitech? ^^

Bonjour à tous, Je vais vous fournir une fonction "explode" qui vous permettra de découper une chaine de caractères grâce à un délimiteur. I - Manuel de "explode": NOM: explode - découpage de chaine de caractères. SYNOPSYS: char **explode(char *chaine, char *delimiteur); DESCRIPTION: La fonction explode vous permettera de découper la chaine "chaine" grâce au délimiteur "delimiteur". Plusieurs délimiteurs peuvent être utilisés en les mettant l'un à côté de l'autre (ex: " \t.,") ou un mot complet (ex: "coucou"). Attention: la chaine "chaine" sera modifiée après l'utilisation de explode. Si vous souhaitez la garder, pensez à la stocker! (ex: strdump). VALEUR RENVOYÉE: La fonction explode renverra un tableau de chaines de caractères contenant, dans chacune des cases, une des itérations trouvées. Si aucune itérations n'a été trouvée, explode renverra une version dumpée de la chaine chaine. Si une erreur survient, explode renverra NULL. VOIR AUSSI: strtok(3) COPYRIGHT: La fonction explode a été crée par AlexMog ainsi que cette page de manuel. II - Le code: /* ** Code created by AlexMog ** Created the 10/04/2014 at 05:42pm. ** Last update by AlexMog the 10/04/2014 at 05:56pm. ** Please, leave the copyright. */ #include <string.h> char **explode(char *chaine, char *delimiter) { char **ret; char *word; int size; ret = NULL; word = strtok(chaine, delimiter); size = 0; while (word != NULL) { ret = realloc(ret, (size + 2) * sizeof(char*)); if (ret == NULL) return (NULL); strcpy(ret[size], word); word = strtok(NULL, delimiter); ++size; } if (ret != NULL) ret[size] = NULL; return (ret); } J'espère que vous ferrez bon usage de ce code . N'hésitez pas à me faire vos retours en cas de bugs. Enjoy programming Cordialement, AlexMog.

Ma petite version: #include <unistd.h> #include <stdio.h> typedef struct s_user { char *name; char *last_name; unsigned int *age; char *city; } t_user; int read_data(t_user *user) { unsigned int readed; char buffer[100]; char *questions[] = {"Your name?", "Your last name?", "Your age?", "Your city?"}; int types[] = {0, 0, 1, 0}; int i; void *first_addr; first_addr = &user->name; i = 0; readed = 0; while (i < 4) { printf("%s\n", questions[i]); if ((readed = read(0, buffer, 15)) < 0) return (1); buffer[readed] = 0; printf("%c", '\n'); if (!types[i]) { if (((char*)(*first_addr) = malloc(strlen(buffer) * sizeof(char))) == NULL) return (1); memcpy((char*)(*fist_addr), buffer, strlen(buffer) * sizeof(char)); first_addr += sizeof(void*); } else { (unsigned int)(*first_addr) = atoi(buffer); first_addr += sizeof(int); } ++i; } return (0); } // Pointeur constant car non modifié void show_data(const t_user *user) { printf("First Name: %s\nName: %s\nAge: %d\nCity: %s\n", user->name, user->last_name, user->age, user->city); } int main(void) { t_user userdata; if (read_data(userdata)) { fprintf(stderr, "Error on reading."); return (1); } // J'envois un pointeur car je ne vais pas copier toute une structure dans la stack... Pouah! show_data(&userdata); return (0); }

Bonjour à tous, Nous passons encore à un autre niveau aujourd'hui, et nous allons voir ensemble la Récursivité, et la notion de Stack. I- La récursivité, c'est quoi? La récursivité, c'est un autre moyen de provoquer une "boucle" dans une fonction. C'est totalement différent de ce que je vous ai expliqué avant. Nous avions vu la partie "itérative" du C, qui corresponds à exécuter un programme, ligne par ligne. Ici, nous allons apprendre un peux plus les fonctions de la récursivité, et comment elle réagit sur la stack. C'est une façon de faire, pour qu'une fonction se rappelle elle-même. Prenons l'exemple suivant: int test(int a) { a++; if (a < 12) test(a); return (a); } int main(void) { my_putnbr(test(1));// my_putnbr est une fonction permettant d'afficher une valeur numérique. Vous devez la re-créer ou utiliser printf (ce qui est interdit par la norme! Re-créez la, ça vous apprendra pas mal de choses!) } La fonction "test" est ici récursive. Ce code nous affichera: 12 Vous l'aurez compris, la récursivité peut être utile dans plusieurs cas (pour annecdote, my_putnbr peut être codé en 3 lignes avec de la récursivité). Les fonctions récursives peuvent êtres comparées à des poupées russes s'emboitant. Ne vous perdez pas! Et ne vous inquiétez pas! Je vais mieux vous l'expliquer en vous expliquant le fonctionnement de la stack. II- La stack? DAFUQ? Je vais pouvoir vous expliquer une notion qui est assez floue dans le cerveau de beaucoup de développeurs: la stack. La stack est une mémoire assignée à votre programme pour la prise en charge de tout ce qui est "static" dans votre programme (d'où le nom "stack"). Lors du lancement de votre programme, la stack est vide. Si vous appelez la fonction "test" celle-ci va se rajouter dans la stack. Si, de la fonction "test", vous appelez la fonction "my_putstr" celle-ci va se rajouter dans la stack, de même pour la fonction "my_putchar" contenue dans la fonction "my_putstr" qui fera elle-même appel à la fonction "write" qui se rajoutera à son tour à la stack. La stack a donc constitué une liste d'exécution. On peut re-définir l'ordre d'exécution précédent comme ceci: Il ne faut pas oublier que la stack est une mémoire, et qu'elle va stocker tout ce qui est statique dans notre programme. Donc, si nous la sur-utilisons (une boucle infinie de fonctions par exemple: surempiler les poupées russes), nous risquons de faire segfault (segmentation fault) notre programme (C'est souvent une explication pour les programme qui segfault sans raisons). Lorsqu'une fonction finit son exécution, elle est supprimée de la stack. Pour vous faire un schéma, imaginez un tas de vaisselle: à chaque fois, vous rajoutez une assiette sale sur le tat, et lorsque vous faites la vaiselle, vous enlevez vos assiettes dans l'ordre contraire de celui de l'empilation. Reprenons la théorie: Une fonction récursive est une fonction qui se rappelle elle-même. Elle se rajoute donc sur la stack, puis se rappelle. Elle se rajoute donc encore une fois sur la stack, puis se rappelle...etc... Et là, deux choses peuvent avoir lieu: Soit on atteint la taille maximum de la stack (définie par le système), et on provoque un segfault, sinon, et c'est ce que vous devrez faire la plupart du temps en utilisant les récursifs, vous devez prévoir une condition d'arrêt du rappel de cette fonction, donc à un moment de votre récursivité, vous dites STOP, cette fois je ne me rappelle pas, car mon rôle est terminé. A ce moment là, vous allez libérer la stack de toutes les fonctions que vous avez au préalable ajouté. Le mieux, reste encore de vous montrer un exemple de ce qu'il ne faut pas faire: Créons un programme qui va afficher "hello" indéfiniment: void my_putchar(char c) { write(1, &c, 1); } void fg() { my_putchar('h'); my_putchar('e'); my_putchar('l'); my_putchar('l'); my_putchar('o'); my_putchar('\n'); fg(); } int main(void) { fg(); } Effectivement, on voit "hello" s'afficher plusieurs fois, mais si on laisse tourner notre programme jusqu'à ce que la stack soit remplie, on remarque de notre programme crash, et qu'un segfault est apparu. C'est l'exemple typique de ce que l'on peut attendre au niveau des problèmes liés à la récursivité. Un autre exemple, c'est notre légendaire my_putnbr: void my_put_nbr(int nb) { if (nb <= 9 && nb >= 0) my_putchar(nb + '0'); else { my_put_nbr(nb / 10); my_put_nbr(nb % 10); } } c'est typiquement la bonne utilisation de la récursivité. Voilà, j'espère vous avoir encore aidé au niveau de votre apprentissage avancé du C. Rendez-vous au prochain cours! Cours écrit par AlexMog. Contact: alexmog [at] live [point] fr

Normalement, ça ne devrais pas compiler Voici la correction: (par contre, c'est pas du tout sécu ton truc, y'a un risque de segfault énorme! ne faites JAMAIS confiance en ce qu'entre vos utilisateurs ) #include <stdio.h> #include <conio.h> struct Info { char Prenom[10]; char Nom[15]; int Age; char Ville[15]; }; // Le typpage "Info" n'existe pas. Le véritable typpage est "struct Info", puisque tu n'as absolument pas utilisé de typedef . On peut régler le problème en rajoutant un typedef, comme ici: // typedef s_ma_structure type_name; // Ici, tu utilise "struct Info &P", donc tu demande une référence de P, les références existent uniquement en C++ . Il faut donc envoyer un pointeur. Et ne surtout pas oublier de changer les "." par des "->" (car pointeurs) void DemandeInfo(struct Info *P) { printf("-----Saisi des donnees-----\n\n\n"); // ATTENTION! printf("Entrer votre prenom:"); scanf("%s",P->Prenom); printf("Entrer votre nom:"); scanf("%s",P->Nom); printf("Entrer votre age:"); scanf("%i",&P->Age); printf("Entrer votre ville actuelle:"); scanf("%s",P->Ville); } void AfficherInfo(struct Info *P) { printf("\n\n\n-----Affichage des donnees-----\n\n\n"); printf("Prenom: %s\n",P->Prenom); printf("Nom: %s\n",P->Nom); printf("Age: %i\n",P->Age); printf("Ville: %s\n",P->Ville); } int main() { struct Info Personne; // Ici, tu demande l'adresse de "Personne" et non pas le contenu DemandeInfo(&Personne); AfficherInfo(&Personne); getch(); return 0; } Ensuite, la norme UNI de C stipule ne pas utiliser les majuscules, SAUF au niveau des macros . C'est en C++ qu'on définit des majuscules UNIQUEMENT au début des objets (et non pas des attributs) et au niveau des nom des methodes (for exemple: getGetter())

Bravo les enfants

Bientôt Edge

Bravo Anaeria très joli travail!

Personnellement j'ai joué de la batterie pendant 9 ans, de la guitare et du piano en amateur ^^

Les enfants... N'oubliez pas LA base multi-plateforme: OpenGL Dans le meilleure des cas, je conseille C++ (MAIS ATTENTION! Uniquement si tu sais l'utiliser! (c'est pas le moment de faire de la merde avec ta mémoire!)) Au pire, avec un peu près n'importe quel langage tu peux faire un jeu correct. A toi de voir ce dont tu as besoin . For exemple, si tu as besoin d'une utilisation en ram minime, autant utiliser des langages natifs, tu y gagnera en temps d'exec aussi! (donc C/C++/ASM (oui, on a un étudiant qui a fait un mario en ASM u_u). Sinon, niveau lib graphiques, je conseille souvent la SFML2.1 + OpenGL (pour la 3D ) Si tu es plus intéréssé par du java, GDX devrais faire ton bonheur!

D'après ton code (je ne connait pas cette lib, mais le nom des fonctions est équivoque) tu as l'air de lui demander de re-créer une fenêtre. Renvois un peu ton code et la doc, il doit y avoir un moyen de lancer le tout dans une fenêtre.

D'après ton code (je ne connait pas cette lib, mais le nom des fonctions est équivoque) tu as l'air de lui demander de re-créer une fenêtre. Renvois un peu ton code et la doc, il doit y avoir un moyen de lancer le tout dans une fenêtre.

Exact! C'est ce que font pas mal d'écoles aux UK d'ailleurs , ils apprennent la programmation aux enfants de maternelle! On arrive dans une nouvelle génération les enfants préparez vos claviers...

ty pour ce tuto intéressent

Je vous conseille de lire les mans à ce niveau là

Hahahaha, l'salow! Merci merci :')

Bonjour à tous, Aujourd'hui, nous allons apprendre à assimiler la notion de pointeurs, de tableaux et de chaines de caractères. Je vais tenter de vous expliquer le fonctionnement d'un pointeur par des exemples variés. Pourquoi? Eh bien, par mon expérience, la notion de pointeurs est une chose qui m'a fait fuir à l'époque ou j'avais commencé le C, mais uniquement à cause de la difficulté à comprendre le principe. Je vais donc essayer d'être le plus claire possible. Ce qui nous amène donc à la première partie: I- Un pointeur, Kesako? Alors, un pointeur, ça n'a rien de bien méchant. C'est une variable, comme les autres, qui permet de contenir une adresse (généralement, l'adresse d'une autre variable, on parle bien sur des adresses MEMOIRE) Pour mieux comprendre, voyons ce qui se passe lors de la création d'une variable. Lorsque vous créez une variable, de type char par exemple, lors de l'exécution de votre programme, votre programme va prévoir une place en mémoire pour contenir votre variable. Cette place va être reconnue grâce à une adresse, qui peut être contenue dans un pointeur. Il faut se dire qu'un type char permet de contenir 8 bit de données (soit en valeur maximale numérique de 255), et qu'un type int peut contenir jusqu'à 32 bits de données (en fonction de la version de votre machine, sur un 64 bits, il aura 64 bits). (Vous comprenez mieux pourquoi les typages ont été inventés, et pourquoi il est important de bien choisir son type de variable). Donc, lorsque vous lancer votre programme, la machine va allouer un endroit dans la mémoire et lui donner une adresse qui permettera de dire "ICI, la variable X est stockée". Un pointeur va donc contenir l'adresse d'une variable, pour pouvoir modifier le contenu de la dite variable (vous verrez que la gestion d'adresses est importante lorsqu'on va jouer avec les tableaux). Donc, comprenons par l'exemple. Je vais créer un programme, qui définit une variable de type char a, et une autre variable b, qui sera un pointeur sur la variable a. void my_putchar(char c) { write(1, &c, 1); // Voir cours 1 pour cette fonction } int main(void) { char a; // Déclaration de la variable a char *b; // Déclaration du pointeur B, le * permet de définir au PC qu'il s'agit d'un pointeur. a = 'b'; // On assigne une valeur à la variable a. my_putchar(a); // ceci affichera: b b = &a; // On assigne à b l'adresse de a, le signe & permet de définir que l'on récupère l'adresse de a dans b *b = 'c' // On assigne enfin à l'adresse choisie la valeur 'c'. le * définit que l'on modifie le contenu de l'adresse mémoire et NON PAS l'adresse en elle même! my_putchar(*; // On affiche la valeur de b my_putchar(a); // On affiche la valeur de a, et on se rends bien compte qu'elle a changée! return (0); } Vous savez à présent ce qu'est un pointeur et comment l'utiliser. II- Les tableaux statiques: WTF is that shiet? Pour faire simple, un tableau, c'est un "regroupement" de variables du même typage, dont les adresses sont suivies les unes après les autres. Prenons pour exemple une "mémoire" vide: |00| |01| |10| |11| | | | | | | | | Pour l'instant elle ne contient aucune données, déclarons alors notre tableau de char, et ayant 3 de grandeur |00| |01| |10| |11| |yy| |xx| |xx| | | Dans notre cas, yy corresponds au début du tableau, et les xx représentent les valeurs contenues dans ce tableau. Comme vous pouvez le constater, les valeurs se suivent. Donc, en théorie, si on a un pointeur qui pointe sur l'adresse de yy, on peut parcourir notre tableau. On peut donc affirmer qu'un tableau n'est rien d'autre qu'un pointeur qui pointe sur la première valeur de celui-ci. Pour mieux comprendre, imaginons que je déclare un tableau comme ceci: char tab[3]; Lorsque je vais tenter d'accéder à la première valeur, je vais donc faire ceci: tab[0]; Eh bien, vous pouvez aussi y accéder en utilisant directement l'adresse de ce tableau *(tab + (0 * sizeof(char)); Je viens donc de vous démontrer que le contenu des [] n'est que le multiplicateur d'accès à la "case" du tableau. Il suffit d'ajouter à notre pointeur un multiple de la taille de son typage pour accéder à la valeur suivante! La démonstration est faite: Un tableau est un pointeur. Mais attention! Un tableau est un pointeur, mais un pointeur n'est PAS toujours un tableau. III- Les chaines de caractères: Tu voulais pas plutôt dire chaines de vélo?! Nous allons essayer de comprendre ensemble comment fonctionne une chaine de caractères. Et il n'y a pas de meilleurs langages que le C pour vous expliquer le principe même d'une chaine de caractères. Nous avions déjà vu dans le cours #1 qu'une chaine de caractères n'était rien d'autre qu'un tableau contenant, dans chacune de ses cases, un caractère. Par exemple: char tab[6]; tab[0] = 'c'; tab[1] = 'o'; tab[2] = 'u'; tab[3] = 'c'; tab[4] = 'o'; tab[5] = 'u'; le tableau que je viens de déclarer contiendra "coucou". La déclaration ci-dessus est fausse. Le problème étant que lorsqu'on va vouloir afficher cette chaine, on ne saura JAMAIS lorsqu'elle va s'arrêter, et donc, on risquera de provoquer ce qu'on appelle un "segfault" ou "segmentation fault" (ce qui corresponds à une tentative d'accès mémoire qui n'appartiens pas à votre logiciel). Il est donc primordial de dire à votre programme quand est-ce que cette chaine s'arrête. C'est en faite très simple à mettre en place, il suffit de rajouter, dans la dernière case, le caractère '\0' (qui signifie 0 en valeur numérique). Par exemple: char tab[7]; tab[0] = 'c'; tab[1] = 'o'; tab[2] = 'u'; tab[3] = 'c'; tab[4] = 'o'; tab[5] = 'u'; tab[6] = '\0'; Nous venons de définir une fin à notre tableau. Il existe d'autres façon de déclarer un tableau de caractères, comme ceci: char tab[] = "coucou"; Vous savez à présent comment fonctionne une chaine de caractères. Allons encore plus loin à présent. Je vous ai démontré toute à l'heure qu'un tableau était un pointeur. Je peux donc affirmer que je peut utiliser l'adresse principale d'un tableau pour déclarer une chaine de caractères. Voyez plutôt: char *machaine; machaine = "coucou"; Que c'est il passé ici? C'est très simple. Nous avons déclaré un espace de type "tableau de char" dans notre mémoire grâce aux guillemets que nous avons ajouté lors de la définition de la valeur du pointeur "machaine". Le pointeur pointe donc sur l'adresse du premier caractère. (ici, le premier 'c') Notre pointeur va donc pouvoir se comporter comme un tableau, puisqu'un tableau est un pointeur. Voyez par exemple: machaine[0]; //renvois c machaine[4]; //Renvois o machaine[7]; // provoquera un segfault // Ici, je change la valeur d'une des cases par une autre valeur: machaine[0] = 'A';// Ma chaine vaut donc "Aoucou"! // Je peut aussi procéder comme ceci: *(machaine + (0 * sizeof(char)) = 'A'; Voila, je viens de vous inculquer les bases de la gestion de pointeurs et de tableaux. A bientôt pour un prochain cours! Cours écrit par AlexMog. Contact: alexmog [at] live [point] fr

en soite, ce n'est que le moteur qui est présenté pour l'instant, je travaille sur les différentes entitées là

J'avais promis un premier aperçu jouable de KDM, le voici : http://labs-epimars.eu/kdm/killdaminions.zip

Alors, à savoir que ca dépends du moteur de jeu utilisé . Les jeux de plateforme sont souvent basés sur tout ce qui est "cell collision", pour faire simple, les objets sont stockés dans un pseudo double array (tableau à deux dimensions (ou une simple (avec un bon vieux modulo) qui représentent les X et les Y.) Le problème de ce genre de chose, c'est que la création des maps est très limitée (puisque case par case) mais le parsing est plutôt simpliste. On connait aussi la gestion par détection pure. La grosse différence, c'est que le cell collision permet de limiter l'utilisation CPU (on ne parcours que les cases autours du joueur) alors que la version Full collision est généralement gérée par la CG, car trop grosse pour le pross (effectivement ! On check tous les éléments du décors UN PAR UN). Bref, chaque chose à ses qualités et ses défauts, et tout cela se joue souvent au niveau de la vitesse d'exécution. dans chacun des cas, le parseur est différent en fonction des engines et en fonction du code général .

Bonjour à tous, Vous avez toujours rêvé de modder un jeu? Alors pourquoi ne pas vous lancer dans un jeu qui a été créé pour le modding? Une des particularités de KDM, c'est qu'il a été pensé pour du modding, et je compte bien sur la communauté pour faire grandir ce jeu . C'est donc un travail communautaire que vous propose KDM, et je vous fournirais bientôt un "developper java pack" pour ceux qui souhaitent développer leur mod et leur maps pour KDM . I- Le developper kit. LE DEVELOPPER KIT DEVRAIS ARRIVER DANS PEU DE TEMPS! II- Configurer Eclipse. Rien de plus simple, il suffit d'importer le dissier "project" dans eclipse. Ensuite, choisir "existing project" dans la liste "general": Enfin, sélectionner le dossier "project" Cliquez sur Finish, et c'est bon! Vous pouvez commencer à modder III- Qu'est-ce que je peux modder pour l'instant? C'est une grande question. Eh bien, pour l'instant, seules les entitées (et donc les maps) peuvent êtres modées. Plus tard, vous pourrez modder un peu tout ce qui est moddable, grâce à l'API qui vous sera fournie par KDM . N'oubliez pas de lancer souvent l'updater pour mettre à jour le developper kit, sinon votre mod ne sera peut être pas à jour . IV- L'API Entity 1- Créer une nouvelle entité Vous pouvez créer une entité directement via l'objet "Entity" qui existe déjà. Pour se faire, il faudra créer un nouveau package, comme ceci: Créons ensuite dedans, la classe d'entité que nous souhaitons: Attention, pour l'entité, le nom de votre entité doit commencer par "Entity", par exemple, ici je crée une entité "MyEntity" : Notre entité est maintenant crée, il faut la faire hériter de "Entity", comme ceci: Voilà, vous pouvez à présent vous amuser avec votre entité, une fois celle-ci finalisée, il vous suffira d'exporter un jar, et de le mettre dans le dossier "entities" du jeu Vous pouvez retrouver toutes les méthodes publiques et overridables de Entity en regardant la librairie de plus près: Et en ouvrant Entity: Bref, je vous conseille de jeter un coup d'oeil seul pour commencer, et je vous donnerais une documentation plus complète une fois que l'API sera plus avancée J'espère que vous serez nombreux à modder sur le jeu, et que vous aurez beaucoup de retours à me donner par rapport à ça . Cordialement, AlexMog.

Azad, cr'ée une section batch, car le shell != batch

Petite question Edge, ça ne te fais pas peur que XNA soit devenu obsolète? :/ Je veux dire, tu ne compte pas ré-essayer en utilisant une lib plus récente? (SFML par exemple est très sympa, enfin, si tu veux un framework au lieu d'une lib, y'en a plein ^^) J'ai peur que ton jeu ne soit plus adaptable pour plus tard :/ ce qui serait dommage! A toi de voir ^^