@{
    println(x) { print(x, "\n"); }

    // now in C
    // treeCopy(x) {
    //   l = {};
    //   k = _keys(x);
    //   if (k == null) {
    //     return clone(x);
    //   } else {
    //     for (i in k) {
    //       l[k[i]] = clone(treeCopy(x[k[i]]));
    //     }
    //     return clone(l);
    //   }
    // }

    //------------ creation C structure ------------//

    newId(x, comm) { 
      if (comm == null) {
        { identifier: x, __proto__: C_id }; 
      } else {
        { identifier: x, comment: { text : comm, __proto__: Comment }, __proto__: C_id }; 
      }
    }

    newText(x) { { value: x, __proto__: C_string }; }
    
    newComment(com) { { text : com, __proto__: Comment }; }
    
    //--- Token ---//

    newToken(txt, com) { 
      if (com == null) return { text: txt, comment: newComment(""), __proto__: Token }; 
      { text: txt, comment: newComment(com), __proto__: Token }; 
    }

    newSemicolon(com) { newToken(";", com) }

    newComma() { newToken(",", " "); }

    newStar(com) { newToken("*", com); }

    newBinary(com) { newToken("=", com); }
    
    //--- Declaration ---//

    newStruct() { 
      { 
        declarators: null, 
        specifier: null, 
        semicolon: newSemicolon("\n"), 
        __proto__: C_declaration 
      } // TO FIX
    }

    newDeclarators() {}

    //--- TO FIX ---//

    newEnum(x) { { attributeL: null, expression: null, name: newId(x), __proto__: C_enum }; }

    newFunction() {}

    //-------------------- end ---------------------//

    // Get the last element of s
    last(s) {
      s[length(s)-1];
    }

    // adding the element e at the end of the list l
    append(s, e) {
      s[length(s)] = e;
    }

    push(s, e) {
      append(s, e);
    }

    pop(s, e) {
      if (e == null) {
        e = length(s) - 1
      }
      ret = s[e];
      t = {};
      for (i in s) {
        if (i == e) continue;
        append(t, s[i]);
      }
      s = treeCopy(t);
      ret;
    }

    // add or don't change an element in a dictionnary
    intern(s, e) {
      lo = 0;
      hi = length(s) - 1;
      while (lo <= hi) {
        mid = (lo+hi)/2;
        if (e > s[mid]) lo = mid + 1;
        else if (e < s[mid]) hi = mid - 1;
        else return e;
      }
      for (i = length(s); i > lo; i = i - 1) {
        s[i] = s[i-1];
      }
      return s[lo] = e;
    }

    fusion(s1, s2) {
      for (i in s2) {
        append(s1, s2[i]);
      }
      return s1;
      // return treeCopy(s1);
    }

    // If g then we add a filter on the application of the function f to each element of seq
    map(f, seq, g) {
      out = {};
      if (g) {
        for (i in seq) {
          e = seq[i];
          if (g(e)) { e = f(e); }
          append(out, e);
        }
      } else {
        for (i in seq) {
          append(out, f(seq[i]));
        }
      }
      out;
    }

    notToken(x)     { x.__proto__ != Token  }

    // Select element e of s if the the result of the application of f on e is true
    select(f, s) {
      out = {};
      for (i in s) {
        e = s[i];
        if (f(e)) { append(out, e); }
      }
      out;
    }

    // Select element e of s if the the result of the application of f on e is false
    reject(f, s) {
      out = {};
      for (i in s) {
        e = s[i];
        if (!f(e)) { append(out, e); }
      }
      out;
    }
    
    
    nil;
}