new_level(0, idiom).
new_level(idiom, lex).
new_level(lex, final).

            % Normalize capitlization, replacing 'word' records
            % with 'fr' records containing a capitalization marker.

apply(0, Behind, [word(W0, CF, _, T) | Ahead],
             Behind, [fr(W, Cap, CF, T) | Ahead]) :-
  name(W0, S0),
  capitalization(S0, S, Cap),
  name(W, S).

            % Same for arity-3 word records.

apply(0, Behind, [word(W0, CF, T) | Ahead],
             [fr(W, Cap, CF, T) | Behind], Ahead) :-
  name(W0, S0),
  capitalization(S0, S, Cap),
  name(W, S).

            % Replace 'eng' records by simple words

apply(final, Behind, [eng(W, Cap) | Ahead],
                 Behind, [Word | Ahead]) :-
  name(W, [C | String0]),
  (   Cap=uc                 % Upper-case word
   -> lower2upper([C | String0], String)
    ; Cap=cap,
      L is C-32,             % Capitalized initial character.
      String=[L | String0]
    ; String=[C | String0]   % Lower case -- no change.
  ),
  name(Word, String).

            % Apply a rule at the current level

apply(Level, Behind0, Ahead0, Behind, Ahead) :-
  rule(Level, In, Out),
  apply(Behind0, Ahead0, [], In, Out, Behind, Ahead, _).

% ----------------------------------------------------------------------

            % Replace In by Out if it is preceded by Left.

apply(Behind0, Ahead0, V0, Left\In, Out, Behind, Ahead, V) :- % Match
  !,                                                          % context
  match_lhs(rl, Left, Behind0, [], _, _),
  apply(Behind0, Ahead0, V0, In, Out, Behind, Ahead, V).

            % Replace In by Out if it is followed by Right.

apply(Behind0, Ahead0, V0, In/Right, Out, Behind, Ahead, V) :-
  !,
  apply(Behind0, Ahead0, V0, In, Out, Behind, Ahead, V),     % Center
  match_lhs(lr, Right, Ahead, [], _, _).                     % Right
                                                             % context
            % Replace In by Out.

apply(Behind0, Ahead0, V0, In, Out, Behind, Ahead, V) :-     % Center
  match_lhs(lr, In, Ahead0, V0, Ahead, V),                   % onlt
  insert_rhs(Out, Behind0, V, Behind).

% ----------------------------------------------------------------------

new_rules :-
  rule(_, [word(A, _, C, D)], [E], F, G),
  format("rule(lex, [fr(~q, C, ~q, ~q)], [eng(~q, C), ~q, ~q).~n",
         [A, C, D, E, F, G]),
  fail.

% ----------------------------------------------------------------------

rule(idiom, (fr(en,C,en,'PREP'), fr(cours,_,cours,n(_66327)), fr('d\'',_,de,'PREP_DE')),
            (eng(in, C))).
rule(idiom, (fr(ne,C,ne,'NEG'), fr(X,Y,Z,v(m,3,sg)), fr(pas,lc,pas,'ADV')),
            (eng('does not', C), fr(X,Y,Z,v(m,inf,_)))).
rule(idiom, (fr(ne,C,ne,'NEG'), fr(X,Y,Z,v(m,3,pl)), fr(pas,lc,pas,'ADV')),
            (eng('do not', C), fr(X,Y,Z,v(m,inf,_)))).
rule(idiom, (fr(tableau,C,tableau,n(sg)), fr(de,_,de,'PREP_DE'), fr(bord,_,bord,n(sg))),
             eng('dash board', C)).
rule(idiom, (fr(témoins,C,témoin,n(sg)), fr(lumineux,_,lumineux,adj(1,sg))),
            (eng(indicator,C), eng(light, lc))).
rule(idiom, (fr(témoins,C,témoin,n(pl)), fr(lumineux,_,lumineux,adj(1,pl))),
            (eng(indicator,C), eng(lights, lc))).
rule(idiom, (fr(A,C,B,n(N)), (fr(_,_,_,adj(1,N))>adj)*(0,inf), fr(X,_,Z,adj(1,N))),
            (fr(X,C,Z,adj(1,N)), +adj, fr(A,lc,B,n(N)))).
rule(idiom, (fr(A,C,B,n(_)), (fr(_,_,de,'PREP_DE'), fr(_,_,_,n(sg))>y)*(0,inf),
             fr(_,_,de,'PREP_DE'), fr(X,_,Z,n(sg))),
            (fr(X,C,Z,n(sg)), +y, fr(A,lc,B,n(_)))).
rule(idiom, (fr(_,C,ne,'NEG'), fr(X,_,Z,v(aux,P,sg)), fr(pas,lc,pas,'ADV')),
            (fr(X,C,Z, v(aux,P,sg)), eng(not, lc))).
rule(idiom, (fr(_,_,ne,'NEG'), x<_*(0,2), fr(X,Y,Z,v(m,_,sg)), fr(pas,C,pas,'ADV')),
            (eng('does not', C), +x, fr(X,Y,Z, v(m,inf,_)))).
rule(idiom, (fr(_,_,ne,'NEG'), x<_*(0,2), fr(X,Y,Z,v(m,_,pl)), fr(pas,C,pas,'ADV')),
            (eng('do not', C), +x, fr(X,Y,Z, v(m,inf,_)))).
rule(lex, (fr(il,C,il,'PRON'), fr(faut,_,falloir,v(m,3,sg))),
          eng('one must', 3, C)).
rule(lex, (fr(pour,C,pour,'PREP')/fr(_,_,_,v(m,inf,_))),
          eng(to, C)).
rule(lex, (fr('s\'',C,se,'PC'), fr(_,lc,arrêter,v(m,3,sg))),
          eng(stops, C)).
rule(lex, (fr('s\'',C,se,'PC'), fr(_,lc,arrêter,v(m,3,pl))),
          eng(stop, C)).
rule(lex, (fr('s\'',C,se,'PC'), fr(_,lc,allumer,v(m,3,sg))),
          eng('comes on', C)).
rule(lex, (fr('s\'',C,se,'PC'), fr(_,lc,allumer,v(m,_,_))),
          eng('come on', C)).
rule(lex, (fr('s\'',C,se,'PC'), fr(_,lc,'éteindre',v(m,3,pl))),
           eng('go out', C)).
rule(lex, (fr('s\'',C,se,'PC'), fr(_,lc,'éteindre',v(m,3,sg))),
           eng('goes out', C)).
rule(lex, (word(<,<,'PUNCT'), word(cs106,cs106,open,n(_66033)), word(>,>,'PUNCT')),
          eng('-', lc)).
rule(lex, (fr(aux,C,'à=le','PREP_A')/fr(pages,_,page,n(pl))),
          eng(on, C)).
rule(lex, (fr(en,C,en,'PREP'), fr(cours,_,cours,n(_)),fr(_,_,de,'PREP_DE')),
          eng(in, C)).
rule(lex, (fr('ci', C, 'ci', 'ADV'),  fr('<', _, '<', 'PUNCT'),
            fr('cs106', _, 'cs106', n(_)),
            fr('>', _, '>', 'PUNCT'),  fr('dessous', _, 'dessous', 'ADV')),
           eng(below, C)).
rule(lex, (fr(au,C,'à=le','PREP_A')/fr(voisinage,_,voisinage,n(sg))), eng('in the', C)).
rule(lex, fr(',', C, ',', 'CM'), eng(',', C)).
rule(lex, fr(-, C, -, 'PUNCT'), eng(-, C)).
rule(lex, fr('.', C, '.', 'SENT'), eng('.', C)).
rule(lex, fr('(\d+)', C, '\d+', 'NUM'), eng('$1', C)).
rule(lex, fr('2ème', C, '2ème', n(sg)), eng('2nd', C)).
rule(lex, fr('3ème', C, '3ème', adj(1, sg)), eng('3rd', C)).
rule(lex, fr(abaisser, C, abaisser, v(m, inf, _)), eng(lower, C)).
rule(lex, fr(_, C, acceptable, adj(1, _)), eng(acceptable, C)).
rule(lex, fr(_, C, accessoire, adj(1, _)), eng(accessory, C)).
rule(lex, fr(accessoire, C, accessoire, n(sg)), eng(accessory, C)).
rule(lex, fr(accessoires, C, accessoire, n(pl)), eng(accessories, C)).
rule(lex, fr(accoupler, C, accoupler, v(m, inf, _)), eng(couple, C)).
rule(lex, fr(accumule, C, accumuler, v(m, 3, sg)), eng(accumulates, C)).
rule(lex, fr(_, C, accélérateur, adj(1, _)), eng(accelerator, C)).
rule(lex, fr(accélérateur, C, accélérateur, n(sg)), eng(accelerator, C)).
rule(lex, fr(action, C, action, n(sg)), eng(action, C)).
rule(lex, fr(actionner, C, actionner, v(m, inf, _)), eng(activate, C)).
rule(lex, fr(actionnés, C, actionner, 'PAP_PL'), eng(activated, C)).
rule(lex, fr(afinde, C, afinde, 'PREP'), eng('in order to', C)).
rule(lex, fr(agir, C, agir, v(m, inf, _)), eng(act, C)).
rule(lex, fr(agira, C, agir, v(m, 3, sg)), eng('will act', C)).
rule(lex, fr(agit, C, agir, v(m, 3, sg)), eng(acts, C)).
rule(lex, fr(aide, C, aide, n(sg)), eng(halp, C)).
rule(lex, fr(aiguille, C, aiguille, n(sg)), eng(needle, C)).
rule(lex, fr(aiguilles, C, aiguille, n(pl)), eng(needles, C)).
rule(lex, fr(_, C, aigu, adj(1, _)), eng(sharp, C)).
rule(lex, fr(ainsi, C, ainsi, 'ADV'), eng(thus, C)).
rule(lex, fr(ainsique, C, ainsique, 'CONN'), eng('as well as', C)).
rule(lex, fr(air, C, air, n(sg)), eng(air, C)).
rule(lex, fr(aire, C, aire, n(sg)), eng(area, C)).
rule(lex, fr(aligner, C, aligner, v(m, inf, _)), eng(align, C)).
rule(lex, fr(alimentation, C, alimentation, n(sg)), eng(supply, C)).
rule(lex, fr(allume, C, allumer, v(m, 3, sg)), eng(light, C)).
rule(lex, fr(allument, C, allumer, v(m, 3, pl)), eng(light, C)).
rule(lex, fr(allumer, C, allumer, v(m, inf, _)), eng(light, C)).
rule(lex, fr(allumé, C, allumer, 'PAP_SG'), eng(lit, C)).
rule(lex, fr(allumés, C, allumer, 'PAP_PL'), eng(lit, C)).
rule(lex, fr(alors, C, alors, 'ADV'), eng(then, C)).
rule(lex, fr(alternateur, C, alternateur, n(sg)), eng(alternator, C)).
rule(lex, fr(alternativement, C, alternativement, 'ADV'), eng(alternatively, C)).
rule(lex, fr(_, C, ambiant, adj(1, _)), eng(ambiant, C)).
rule(lex, fr(amener, C, amener, v(m, inf, _)), eng(lead, C)).
rule(lex, fr(amplificateur, C, amplificateur, n(sg)), eng(amplifier, C)).
rule(lex, fr(ancrages, C, ancrage, n(pl)), eng('anchor points', C)).
rule(lex, fr(angle, C, angle, n(sg)), eng(angle, C)).
rule(lex, fr(anneau, C, anneau, n(sg)), eng(ring, C)).
rule(lex, fr(antenne, C, antenne, n(sg)), eng(antenna, C)).
rule(lex, fr(appareil, C, appareil, n(sg)), eng(set, C)).
rule(lex, fr(appel, C, appel, n(sg)), eng(call, C)).
rule(lex, fr(application, C, application, n(sg)), eng(application, C)).
rule(lex, fr(applique, C, appliquer, v(m, 3, sg)), eng(applies, C)).
rule(lex, fr(appuie, C, appuyer, v(m, 3, sg)), eng(presses, C)).
rule(lex, fr(après, C, après, 'PREP'), eng(after, C)).
rule(lex, fr(arbre, C, arbre, n(sg)), eng(tree, C)).
rule(lex, fr(arbres, C, arbre, n(pl)), eng(trees, C)).
rule(lex, fr(arrivée, C, arrivée, n(sg)), eng(arrival, C)).
rule(lex, fr(arrière, C, arrière, adj(1, _)), eng(rear, C)).
rule(lex, fr(arrière, C, arrière, 'ADV'), eng(backwards, C)).
rule(lex, fr(arrière, C, arrière, n(sg)), eng(rear, C)).
rule(lex, fr(arrêt, C, arrêt, n(sg)), eng(stop, C)).
rule(lex, fr(arrête, C, arrêter, v(m, 3, sg)), eng(stops, C)).
rule(lex, fr(arrêter, C, arrêter, v(m, inf, _)), eng(stop, C)).
rule(lex, fr(arrêté, C, arrêter, 'PAP_SG'), eng(stopped, C)).
rule(lex, fr(articulées, C, articuler, 'PAP_PL'), eng(articulated, C)).
rule(lex, fr(arêtes, C, arête, n(pl)), eng(cessations, C)).
rule(lex, fr(aspiration, C, aspiration, n(sg)), eng(aspiration, C)).
rule(lex, fr(asseoir, C, asseoir, v(m, inf, _)), eng(seat, C)).
rule(lex, fr(asseyant, C, asseoir, 'VERB_PRP'), eng(seating, C)).
rule(lex, fr(assis, C, assis, adj(1, _)), eng(sitting, C)).
rule(lex, fr(assis, C, asseoir, 'PAP_PL'), eng(sitting, C)).
rule(lex, fr(assis, C, asseoir, 'PAP_SG'), eng(sitting, C)).
rule(lex, fr(assurant, C, assurer, 'VERB_PRP'), eng(permitting, C)).
rule(lex, fr(assurent, C, assurer, v(m, 3, pl)), eng(permit, C)).
rule(lex, fr(assurer, C, assurer, v(m, inf, _)), eng(mermit, C)).
rule(lex, fr(atmosphère, C, atmosphère, n(sg)), eng(atmosphere, C)).
rule(lex, fr(attacher, C, attacher, v(m, inf, _)), eng(attach, C)).
rule(lex, fr(atteigne, C, atteindre, v(m, 3, sg)), eng(reaches, C)).
rule(lex, fr(atteint, C, atteindre, 'PAP_SG'), eng(reached, C)).
rule(lex, fr(attentifs, C, attentif, adj(1, pl)), eng(attentive, C)).
rule(lex, fr(attention, C, attention, n(sg)), eng(attention, C)).
rule(lex, fr(au, C, 'à=le', 'PREP_A'), eng('to the', C)).
rule(lex, fr(aucun, C, aucun, det(sg)), eng(any, C)).
rule(lex, fr(augmentation, C, augmentation, n(sg)), eng(augmentation, C)).
rule(lex, fr(aussi,C,aussi,'ADV'), eng(also, C)).
rule(lex, fr(autre, C, autre, adj(1, sg)), eng(other, C)).
rule(lex, fr(autres, C, autre, adj(1, pl)), eng(other, C)).
rule(lex, fr(aux, C, 'à=le', 'PREP_A'), eng(on, C), fr(pages,_,page,n(pl))).
rule(lex, fr(aux, C, 'à=le', 'PREP_A'), eng('to the', C)).
rule(lex, fr(auxiliaire, C, auxiliaire, adj(1, sg)), eng(auxiliary, C)).
rule(lex, fr(auxiliaire, C, auxiliaire, n(sg)), eng(auxiliary, C)).
rule(lex, fr(auxiliaires, C, auxiliaire, adj(1, pl)), eng(auxiliary, C)).
rule(lex, fr(avance, C, avance, n(sg)), eng(advance, C)).
rule(lex, fr(avant, C, avant, adj(1, _)), eng(front, C)).
rule(lex, fr(avant, C, avant, 'PREP'), eng('in front of', C)).
rule(lex, fr(avantde, C, avantde, 'PREP'), eng(before, C)).
rule(lex, fr(avec, C, avec, 'PREP'), eng(with, C)).
rule(lex, fr(avertisseur, C, avertisseur, adj(1, sg)), eng(indicator, C)).
rule(lex, fr(avertissement, C, avertissement, n(sg)), eng(notice, C)).
rule(lex, fr(avertisseur, C, avertisseur, n(sg)), eng(indicator, C)).
rule(lex, fr(avoir, C, avoir, v(aux, inf, _)), eng(have, C)).
rule(lex, fr(aérateur, C, aérateur, n(sg)), eng(aerator, C)).
rule(lex, fr(aérateurs, C, aérateur, n(pl)), eng(aerators, C)).
rule(lex, fr(aération, C, aération, n(sg)), eng(aeration, C)).
rule(lex, fr(aérer, C, aérer, v(m, inf, _)), eng(aerate, C)).
rule(lex, fr(aériens, C, aérien, adj(1, pl)), eng(air, C)).
rule(lex, fr(baisse, C, baisse, n(sg)), eng(lowering, C)).
rule(lex, fr(balai, C, balai, n(sg)), eng(sweep, C)).
rule(lex, fr(balayage, C, balayage, n(sg)), eng(sweeping, C)).
rule(lex, fr(bande, C, bande, n(sg)), eng(band, C)).
rule(lex, fr(bandes, C, bande, n(pl)), eng(bands, C)).
rule(lex, fr(barre, C, barre, n(sg)), eng(bar, C)).
rule(lex, fr(barres, C, barre, n(pl)), eng(bars, C)).
rule(lex, fr(bas, C, bas, adj(2, _)), eng(low, C)).
rule(lex, fr(bas, C, bas, n(_)), eng(stocking, C)).
rule(lex, fr(basculeur, C, basculeur, n(sg)), eng(shake, C)).
rule(lex, fr(basse, C, bas, adj(2, sg)), eng(low, C)).
rule(lex, fr(basse, C, basse, n(sg)), eng(base, C)).
rule(lex, fr(basses, C, bas, adj(2, pl)), eng(low, C)).
rule(lex, fr(bassin, C, bassin, n(sg)), eng(baisin, C)).
rule(lex, fr(batterie, C, batterie, n(sg)), eng(battery, C)).
rule(lex, fr(bleu, C, bleu, adj(1, sg)), eng(blue, C)).
rule(lex, fr(bloc, C, bloc, n(sg)), eng(blockage, C)).
rule(lex, fr(blocage, C, blocage, n(sg)), eng(blockage, C)).
rule(lex, fr(bloque, C, bloquer, v(m, 3, sg)), eng(blocks, C)).
rule(lex, fr(bloquer, C, bloquer, v(m, inf, _)), eng(block, C)).
rule(lex, fr(bloqué, C, bloquer, 'PAP_SG'), eng(blocked, C)).
rule(lex, fr(bon, C, bon, adj(2, sg)), eng(good, C)).
rule(lex, fr(bonne, C, bon, adj(2, sg)), eng(good, C)).
rule(lex, fr(bord, C, bord, n(sg)), eng(edge, C)).
rule(lex, fr(bouché, C, boucher, 'PAP_SG'), eng('clogged up', C)).
rule(lex, fr(boucle, C, boucle, n(sg)), eng(curl, C)).
rule(lex, fr(bouclée, C, boucler, 'PAP_SG'), eng(curled, C)).
rule(lex, fr(boue, C, boue, n(sg)), eng(mud, C)).
rule(lex, fr(boule, C, boule, n(sg)), eng(ball, C)).
rule(lex, fr(bout, C, bout, n(sg)), eng(end, C)).
rule(lex, fr(bouton, C, bouton, n(sg)), eng(button, C)).
rule(lex, fr(boutons, C, bouton, n(pl)), eng(buttons, C)).
rule(lex, fr(boîte, C, boîte, n(sg)), eng(box, C)).
rule(lex, fr(boîtes, C, boîte, n(pl)), eng(boxes, C)).
rule(lex, fr(branchement, C, branchement, n(sg)), eng(branching, C)).
rule(lex, fr(branché, C, branché, n(sg)), eng(branched, C)).
rule(lex, fr(branchée, C, brancher, 'PAP_SG'), eng(branched, C)).
rule(lex, fr(bras, C, bras, n(_)), eng(arm, C)).
rule(lex, fr(brin, C, brin, n(sg)), eng(brine, C)).
rule(lex, fr(brise, C, brise, n(sg)), eng(brise, C)).
rule(lex, fr(brise, C, briser, v(m, 3, sg)), eng(breaks, C)).
rule(lex, fr(brièvement, C, brièvement, 'ADV'), eng(briefly, C)).
rule(lex, fr(brève, C, bref, adj(1, sg)), eng(brief, C)).
rule(lex, fr(bâtiments, C, bâtiment, n(pl)), eng(buildings, C)).
rule(lex, fr(cabine, C, cabine, n(sg)), eng(cabin, C)).
rule(lex, fr(caoutchouc, C, caoutchouc, n(sg)), eng(rubber, C)).
rule(lex, fr(capacité, C, capacité, n(sg)), eng(capacity, C)).
rule(lex, fr(capté, C, capter, adj(1, sg)), eng(captured, C)).
rule(lex, fr(car, C, car, 'COORD'), eng(for, C)).
rule(lex, fr(cas, C, cas, n(_)), eng(case, C)).
rule(lex, fr(cassette, C, cassette, n(sg)), eng(cassett, C)).
rule(lex, fr(cassettes, C, cassette, n(pl)), eng(cassetts, C)).
rule(lex, fr(cause, C, cause, n(sg)), eng(cause, C)).
rule(lex, fr(causer, C, causer, v(m, inf, _)), eng(causes, C)).
rule(lex, fr(ce, C, ce, det(sg)), eng(this, C)).
rule(lex, fr(ce, C, ce, 'PRON'), eng(this, C)).
rule(lex, fr(ceinture, C, ceinture, n(sg)), eng(belt, C)).
rule(lex, fr(cela, C, cela, 'PRON'), eng(that, C)).
rule(lex, fr(celui, C, celui, 'PRON'), eng(this, C)).
rule(lex, fr(centrale, C, central, adj(1, sg)), eng(central, C)).
rule(lex, fr(centrale, C, centrale, n(sg)), eng(center, C)).
rule(lex, fr(certains, C, certain, det(pl)), eng(certain, C)).
rule(lex, fr(ces, C, ce, det(pl)), eng(these, C)).
rule(lex, fr(cesse, C, cesser, v(m, 3, sg)), eng(stops, C)).
rule(lex, fr(cet, C, ce, det(sg)), eng(this, C)).
rule(lex, fr(cette, C, ce, det(sg)), eng(this, C)).
rule(lex, fr(changement, C, changement, n(sg)), eng(shift, C)).
rule(lex, fr(changer, C, changer, v(m, inf, _)), eng(change, C)).
rule(lex, fr(chaque, C, chaque, det(sg)), eng(each, C)).
rule(lex, fr(charge, C, charge, n(sg)), eng(charge, C)).
rule(lex, fr(charge, C, charger, v(m, 3, sg)), eng(charges, C)).
rule(lex, fr(chauffage, C, chauffage, n(sg)), eng(heating, C)).
rule(lex, fr(chauffé, C, chauffer, 'PAP_SG'), eng(heated, C)).
rule(lex, fr(chaîne, C, chaîne, n(sg)), eng(chain, C)).
rule(lex, fr(chimiques, C, chimique, adj(1, pl)), eng(chemical, C)).
rule(lex, fr(choisir, C, choisir, v(m, inf, _)), eng(choose, C)).
rule(lex, fr(choix, C, choix, n(_)), eng(choice, C)).
rule(lex, fr(ci, C, ci, 'ADV'), eng(here, C)).
rule(lex, fr(cigare, C, cigare, n(sg)), eng(cigare, C)).
rule(lex, fr(cinq, C, cinq, 'NUM'), eng(five, C)).
rule(lex, fr(circuit, C, circuit, n(sg)), eng(circuit, C)).
rule(lex, fr(circulation, C, circulation, n(sg)), eng(circulation, C)).
rule(lex, fr(circule, C, circuler, v(m, 3, sg)), eng(circulates, C)).
rule(lex, fr(clignotante, C, clignotant, adj(1, sg)), eng(flashing, C)).
rule(lex, fr(clignotants, C, clignotant, n(pl)), eng(flashing, C)).
rule(lex, fr(clignote, C, clignoter, v(m, 3, sg)), eng(flashes, C)).
rule(lex, fr(clignotent, C, clignoter, v(m, 3, pl)), eng(flash, C)).
rule(lex, fr(climatisation, C, climatisation, n(sg)), eng('air conditioning', C)).
rule(lex, fr(clé, C, clé, n(sg)), eng(key, C)).
rule(lex, fr(codage, C, codage, n(sg)), eng(encoding, C)).
rule(lex, fr(coffret, C, coffret, n(sg)), eng(box, C)).
rule(lex, fr(coincer, C, coincer, v(m, inf, _)), eng(stick, C)).
rule(lex, fr(combine, C, combiner, v(m, 3, sg)), eng(combines, C)).
rule(lex, fr(combustible, C, combustible, n(sg)), eng(fuel, C)).
rule(lex, fr(commande, C, commande, n(sg)), eng(contorls, C)).
rule(lex, fr(commande, C, commander, v(m, 3, sg)), eng(control, C)).
rule(lex, fr(commandent, C, commander, v(m, 3, pl)), eng(control, C)).
rule(lex, fr(commander, C, commander, v(m, inf, _)), eng(contorl, C)).
rule(lex, fr(commandes, C, commande, n(pl)), eng(controls, C)).
rule(lex, fr(commandé, C, commander, adj(1, sg)), eng(controled, C)).
rule(lex, fr(commandé, C, commander, 'PAP_SG'), eng(controled, C)).
rule(lex, fr(commandée, C, commander, 'PAP_SG'), eng(controled, C)).
rule(lex, fr(comme, C, comme, 'COMME'), eng(as, C)).
rule(lex, fr(commesuit, C, commesuit, 'ADV'), eng('as follows', C)).
rule(lex, fr(commodément, C, commodément, 'ADV'), eng('in accordance with', C)).
rule(lex, fr(commutateur, C, commutateur, n(sg)), eng(switch, C)).
rule(lex, fr(commutateurs, C, commutateur, n(pl)), eng(switches, C)).
rule(lex, fr(compas, C, compas, n(_)), eng(compas, C)).
rule(lex, fr(complètement, C, complètement, 'ADV'), eng(completely, C)).
rule(lex, fr(comporte, C, comporter, v(m, 3, sg)), eng(includes, C)).
rule(lex, fr(comportent, C, comporter, v(m, 3, pl)), eng(behave, C)).
rule(lex, fr(compte, C, compte, n(sg)), eng(counter, C)).
rule(lex, fr(concessionnaire, C, concessionnaire, n(sg)), eng(dealer, C)).
rule(lex, fr(conditions, C, condition, n(pl)), eng(conditions, C)).
rule(lex, fr(conducteur, C, conducteur, n(sg)), eng(driver, C)).
rule(lex, fr(conduite, C, conduite, n(sg)), eng(conduct, C)).
rule(lex, fr(confort, C, confort, n(sg)), eng(comfort, C)).
rule(lex, fr(confortable, C, confortable, adj(1, sg)), eng(comfortable, C)).
rule(lex, fr(confortablement, C, confortablement, 'ADV'), eng(comfortably, C)).
rule(lex, fr(conjointement, C, conjointement, 'ADV'), eng(together, C)).
rule(lex, fr(connecté, C, connecter, 'PAP_SG'), eng(connected, C)).
rule(lex, fr(connectés, C, connecter, 'PAP_PL'), eng(connected, C)).
rule(lex, fr(connexions, C, connexion, n(pl)), eng(connections, C)).
rule(lex, fr(conseillé, C, conseiller, 'PAP_SG'), eng(recommended, C)).
rule(lex, fr(conseils, C, conseil, n(pl)), eng(recommendations, C)).
rule(lex, fr(console, C, console, n(sg)), eng(console, C)).
rule(lex, fr(constante, C, constant, adj(1, sg)), eng(constant, C)).
rule(lex, fr(constaté, C, constater, adj(1, sg)), eng(found, C)).
rule(lex, fr(constituer, C, constituer, v(m, inf, _)), eng(constitute, C)).
rule(lex, fr(consulter, C, consulter, v(m, inf, _)), eng(consult, C)).
rule(lex, fr(contenu,C,contenir,adj(1,sg)), eng(contained, C)).
rule(lex, fr(contenue,C,contenir,adj(1,sg)), eng(contained, C)).
rule(lex, fr(contient, C, contenir, v(m, 3, sg)), eng(contains, C)).
rule(lex, fr(contraire, C, contraire, adj(1, sg)), eng(contrary, C)).
rule(lex, fr(contre, C, contre, n(sg)), eng(reverse, C)).
rule(lex, fr(contre, C, contre, 'PREP'), eng(against, C)).
rule(lex, fr(contrôle, C, contrôle, n(sg)), eng(check, C)).
rule(lex, fr(contrôler, C, contrôler, v(m, inf, _)), eng(check, C)).
rule(lex, fr(corpulente, C, corpulent, adj(1, sg)), eng(corpulent, C)).
rule(lex, fr(correct, C, correct, adj(1, sg)), eng(correct, C)).
rule(lex, fr(correcte, C, correct, adj(1, sg)), eng(correct, C)).
rule(lex, fr(correctement, C, correctement, 'ADV'), eng(correctly, C)).
rule(lex, fr(correspondant, C, correspondre, 'VERB_PRP'), eng(corresponding, C)).
rule(lex, fr(correspondante, C, correspondant, adj(1, sg)), eng(corresponding, C)).
rule(lex, fr(corriger, C, corriger, v(m, inf, _)), eng(correct, C)).
rule(lex, fr(couche, C, couche, n(sg)), eng(layer, C)).
rule(lex, fr(coupe, C, couper, v(m, 3, sg)), eng(cuts, C)).
rule(lex, fr(coupe, C, coupe, n(sg)), eng(cut, C)).
rule(lex, fr(couper, C, couper, v(m, inf, _)), eng(cut, C)).
rule(lex, fr(coupure, C, coupure, n(sg)), eng(cut, C)).
rule(lex, fr(cours, C, cours, n(_)), eng(course, C)).
rule(lex, fr(course, C, course, n(sg)), eng(race, C)).
rule(lex, fr(courroie, C, courroie, n(sg)), eng(belt, C)).
rule(lex, fr(court, C, court, adj(2, sg)), eng(short, C)).
rule(lex, fr(coussin, C, coussin, n(sg)), eng(cushion, C)).
rule(lex, fr(couvercle, C, couvercle, n(sg)), eng(cover, C)).
rule(lex, fr(couverte, C, couverte, n(sg)), eng(cover, C)).
rule(lex, fr(croisement, C, croisement, n(sg)), eng(crossing, C)).
rule(lex, fr(cylindres, C, cylindre, n(pl)), eng(cylinders, C)).
rule(lex, fr(câblage, C, câblage, n(sg)), eng(wiring, C)).
rule(lex, fr(câble, C, câble, n(sg)), eng(wire, C)).
rule(lex, fr(câblée, C, câbler, 'PAP_SG'), eng(wired, C)).
rule(lex, fr(côté, C, côté, n(sg)), eng(side, C)).
rule(lex, fr('d\'', C, de, det(pl)), eng(of, C)).
rule(lex, fr('d\'', C, de, 'PREP_DE'), eng(of, C)).
rule(lex, fr('d\'abord', C, 'd\'abord', 'ADV'), eng(first, C)).
rule(lex, fr(danger, C, danger, n(sg)), eng(danger, C)).
rule(lex, fr(dans, C, dans, 'PREP'), eng(in, C)).
rule(lex, fr(de, C, de, det(pl)), eng(of, C)).
rule(lex, fr(de, C, de, 'PREP_DE'), eng(of, C)).
rule(lex, fr(delx, C, delx, 'ADV'), eng(above, C)).
rule(lex, fr(denouveau, C, denouveau, 'ADV'), eng(again, C)).
rule(lex, fr(deplus, C, deplus, 'ADV'), eng(more, C)).
rule(lex, fr(depuis, C, depuis, 'PREP'), eng(since, C)).
rule(lex, fr(derrière, C, derrière, 'PREP'), eng(behind, C)).
rule(lex, fr(des, C, 'de=le', 'PREP_DE'), eng('of the', C)).
rule(lex, fr(des, C, un, det(pl)), eng(some, C)).
rule(lex, fr(descendre, C, descendre, v(m, inf, _)), eng('go down', C)).
rule(lex, fr(descente, C, descente, n(sg)), eng(lowering, C)).
rule(lex, fr(desserrer, C, desserrer, v(m, inf, _)), eng(release, C)).
rule(lex, fr(desserré, C, desserrer, 'PAP_SG'), eng(released, C)).
rule(lex, fr(dessous, C, dessous, 'ADV'), eng(under, C)).
rule(lex, fr(dessus, C, dessus, 'ADV'), eng(above, C)).
rule(lex, fr(deux, C, deux, 'NUM'), eng(two, C)).
rule(lex, fr(deuxième, C, deuxième, adj(2, sg)), eng(second, C)).
rule(lex, fr(devra, C, devoir, v(m, 3, sg)), eng(should, C)).
rule(lex, fr(différent, C, différent, adj(1, sg)), eng(different, C)).
rule(lex, fr(différentiel, C, différentiel, adj(1, sg)), eng(differentiel, C)).
rule(lex, fr(différentiel, C, différentiel, n(sg)), eng(differentiel, C)).
rule(lex, fr(différentiels, C, différentiel, n(pl)), eng(differentiels, C)).
rule(lex, fr(dimensions, C, dimension, n(pl)), eng(dimension, C)).
rule(lex, fr(direction, C, direction, n(sg)), eng(direction, C)).
rule(lex, fr(directionnel, C, directionnel, adj(1, sg)), eng(direction, C)).
rule(lex, fr(diriger, C, diriger, v(m, inf, _)), eng(direct, C)).
rule(lex, fr(dirigé, C, diriger, adj(1, sg)), eng(directed, C)).
rule(lex, fr(disponibles, C, disponible, adj(1, pl)), eng(available, C)).
rule(lex, fr(dispositif, C, dispositif, n(sg)), eng(gadget, C)).
rule(lex, fr(distance, C, distance, n(sg)), eng(distance, C)).
rule(lex, fr(distributeur, C, distributeur, n(sg)), eng(distributer, C)).
rule(lex, fr(doit, C, devoir, v(m, 3, sg)), eng(should, C)).
rule(lex, fr(doivent, C, devoir, v(m, 3, pl)), eng(should, C)).
rule(lex, fr(donc, C, donc, 'ADV'), eng(then, C)).
rule(lex, fr(donne, C, donner, v(m, 3, sg)), eng(gives, C)).
rule(lex, fr(données, C, donnée, n(pl)), eng(given, C)).
rule(lex, fr(dos, C, dos, n(_)), eng(back, C)).
rule(lex, fr(dossier, C, dossier, n(sg)), eng(file, C)).
rule(lex, fr(doucement, C, doucement, 'ADV'), eng(slowly, C)).
rule(lex, fr(droit, C, droit, adj(1, sg)), eng(straight, C)).
rule(lex, fr(droite, C, droit, adj(1, sg)), eng(right, C)).
rule(lex, fr(droite, C, droite, n(sg)), eng(right, C)).
rule(lex, fr(du, C, 'de=le', 'PREP_DE'), eng('of the', C)).
rule(lex, fr(durée, C, durée, n(sg)), eng(duration, C)).
rule(lex, fr('dèsqu\'', C, dèsque, 'CONN'), eng(since, C)).
rule(lex, fr(débloquer, C, débloquer, v(m, inf, _)), eng(unblock, C)).
rule(lex, fr(déboucler, C, déboucler, v(m, inf, _)), eng(untwist, C)).
rule(lex, fr(déchargera, C, décharger, v(m, 3, sg)), eng(discharge, C)).
rule(lex, fr(déconseillé, C, déconseiller, 'PAP_SG'), eng('not recommended', C)).
rule(lex, fr(décrit, C, décrire, v(m, 3, sg)), eng(writes, C)).
rule(lex, fr(décrite, C, décrire, 'PAP_SG'), eng(described, C)).
rule(lex, fr(décrits, C, décrire, 'PAP_PL'), eng(described, C)).
rule(lex, fr(défaire, C, défaire, v(m, inf, _)), eng(undo, C)).
rule(lex, fr(défaut, C, défaut, n(sg)), eng(fault, C)).
rule(lex, fr(déflecteur, C, déflecteur, n(sg)), eng(deflecter, C)).
rule(lex, fr(déformer, C, déformer, v(m, inf, _)), eng(deform, C)).
rule(lex, fr(dégageant, C, dégager, 'VERB_PRP'), eng(uncouple, C)).
rule(lex, fr(dégagement, C, dégagement, n(sg)), eng(uncoupling, C)).
rule(lex, fr(dégager, C, dégager, v(m, inf, _)), eng(uncouple, C)).
rule(lex, fr(dégâts, C, dégât, n(pl)), eng(scratches, C)).
rule(lex, fr(déjâ, C, déjâ, 'ADV'), eng(already, C)).
rule(lex, fr(démarrage, C, démarrage, n(sg)), eng(starting, C)).
rule(lex, fr(démarre, C, démarrer, v(m, 3, sg)), eng(starts, C)).
rule(lex, fr(démarrer, C, démarrer, v(m, inf, _)), eng(start, C)).
rule(lex, fr(démarreur, C, démarreur, n(sg)), eng(starter, C)).
rule(lex, fr(déplacement, C, déplacement, n(sg)), eng(movement, C)).
rule(lex, fr(déplacer, C, déplacer, v(m, inf, _)), eng(move, C)).
rule(lex, fr(déplacé, C, déplacer, 'PAP_SG'), eng(moved, C)).
rule(lex, fr(dépôt, C, dépôt, n(sg)), eng(dépôt, C)).
rule(lex, fr(désaccoupler, C, désaccoupler, v(m, inf, _)), eng(uncouple, C)).
rule(lex, fr(désengagement, C, désengagement, n(sg)), eng(disengagement, C)).
rule(lex, fr(désengager, C, désengager, v(m, inf, _)), eng(disengage, C)).
rule(lex, fr(détachement, C, détachement, n(sg)), eng(separation, C)).
rule(lex, fr(détachent, C, détacher, v(m, 3, pl)), eng(separate, C)).
rule(lex, fr(détacheront, C, détacher, v(m, 3, pl)), eng('will separate', C)).
rule(lex, fr(détail, C, détail, n(sg)), eng(detail, C)).
rule(lex, fr(détails, C, détail, n(pl)), eng(detail, C)).
rule(lex, fr(détermine, C, déterminer, v(m, 3, sg)), eng(determines, C)).
rule(lex, fr(détresse, C, détresse, n(sg)), eng(emergency, C)).
rule(lex, fr(eau, C, eau, n(sg)), eng(water, C)).
rule(lex, fr(effectue, C, effectuer, v(m, 3, sg)), eng('carries out', C)).
rule(lex, fr(effectuer, C, effectuer, v(m, inf, _)), eng('carry out', C)).
rule(lex, fr(efficace, C, efficace, adj(1, sg)), eng(effective, C)).
rule(lex, fr(elle, C, il, 'PRON'), eng(it, C)).
rule(lex, fr(elles, C, il, 'PRON'), eng(they, C)).
rule(lex, fr(embrayage, C, embrayage, n(sg)), eng(clutch, C)).
rule(lex, fr(emplacement, C, emplacement, n(sg)), eng(placement, C)).
rule(lex, fr(emploi, C, emploi, n(sg)), eng(use, C)).
rule(lex, fr(empêcher, C, empêcher, v(m, inf, _)), eng(prevent, C)).
rule(lex, fr(en, C, en, 'PC'), eng(while, C)).
rule(lex, fr(en, C, en, 'PREP'), eng(in, C)).
rule(lex, fr(enarrière, C, enarrière, 'ADV'), eng(backwards, C)).
rule(lex, fr(enavant, C, enavant, 'ADV'), eng(forwards, C)).
rule(lex, fr(encequiconcerne, C, encequiconcerne, 'PREP'), eng(concerning, C)).
rule(lex, fr(encore, C, encore, 'ADV'), eng(still, C)).
rule(lex, fr(encrassement, C, encrassement, n(sg)), eng(smashing, C)).
rule(lex, fr(endommager, C, endommager, v(m, inf, _)), eng(damage, C)).
rule(lex, fr(endommagé, C, endommager, 'PAP_SG'), eng(damamged, C)).
rule(lex, fr(enfoncer, C, enfoncer, v(m, inf, _)), eng(sink, C)).
rule(lex, fr(enfoncée, C, enfoncer, 'PAP_SG'), eng(sunk, C)).
rule(lex, fr(engage, C, engager, v(m, 3, sg)), eng(engages, C)).
rule(lex, fr(engagement, C, engagement, n(sg)), eng(engagement, C)).
rule(lex, fr(engager, C, engager, v(m, inf, _)), eng(engage, C)).
rule(lex, fr(engagé, C, engager, 'PAP_SG'), eng(engaged, C)).
rule(lex, fr(engagée, C, engager, 'PAP_SG'), eng(engaged, C)).
rule(lex, fr(enregistre, C, enregistrer, v(m, 3, sg)), eng(records, C)).
rule(lex, fr(enregistrées, C, enregistrer, adj(1, pl)), eng(recorded, C)).
rule(lex, fr(ensemble, C, ensemble, 'ADV'), eng(together, C)).
rule(lex, fr(entend, C, entendre, v(m, 3, sg)), eng(hear, C)).
rule(lex, fr(entendons, C, entendre, 'VERB_P1P2'), eng(hear, C)).
rule(lex, fr(entièrement, C, entièrement, 'ADV'), eng(entirely, C)).
rule(lex, fr(entre, C, entrer, v(m, 3, sg)), eng(enters, C)).
rule(lex, fr(entretenir, C, entretenir, v(m, inf, _)), eng(maintain, C)).
rule(lex, fr(entretien, C, entretien, n(sg)), eng(maintenance, C)).
rule(lex, fr(entrée, C, entrée, n(sg)), eng(entrance, C)).
rule(lex, fr(environ, C, environ, 'ADV'), eng(about, C)).
rule(lex, fr(environnement, C, environnement, n(sg)), eng(environment, C)).
rule(lex, fr(escargot, C, escargot, n(sg)), eng(snail, C)).
rule(lex, fr(espaces, C, espace, n(pl)), eng(spaces, C)).
rule(lex, fr(essayer, C, essayer, v(m, inf, _)), eng(try, C)).
rule(lex, fr(essuie, C, essuie, n(sg)), eng(wiper, C)).
rule(lex, fr(est, C, est, n(sg)), eng(east, C)).
rule(lex, fr(est, C, 'être', v(aux, 3, sg)), eng(is, C)).
rule(lex, fr(et, C, et, 'COORD'), eng(and, C)).
rule(lex, fr('etc.', C, 'etc.', 'ADV'), eng('etc.', C)).
rule(lex, fr(excessive, C, excessif, adj(1, sg)), eng(excessive, C)).
rule(lex, fr(exclusivement, C, exclusivement, 'ADV'), eng(exclusively, C)).
rule(lex, fr(existant, C, existant, adj(1, sg)), eng(exist, C)).
rule(lex, fr(existe, C, exister, v(m, 3, sg)), eng(exists, C)).
rule(lex, fr(explication, C, explication, n(sg)), eng(explanation, C)).
rule(lex, fr(expliqué, C, expliquer, 'PAP_SG'), eng(explained, C)).
rule(lex, fr(expliquée, C, expliquer, 'PAP_SG'), eng(explained, C)).
rule(lex, fr(exploitation, C, exploitation, n(sg)), eng(use, C)).
rule(lex, fr(extrémité, C, extrémité, n(sg)), eng(extermity, C)).
rule(lex, fr(extrêmes, C, extrême, adj(2, pl)), eng(extreem, C)).
rule(lex, fr(extrêmes, C, extrême, n(pl)), eng(extemity, C)).
rule(lex, fr(extérieur, C, extérieur, n(sg)), eng(exterior, C)).
rule(lex, fr(extérieure, C, extérieur, adj(1, sg)), eng(exterior, C)).
rule(lex, fr(extérieures, C, extérieur, adj(1, pl)), eng(exterior, C)).
rule(lex, fr(extérieurs, C, extérieur, adj(1, pl)), eng(exterior, C)).
rule(lex, fr(face, C, face, n(sg)), eng(side, C)).
rule(lex, fr(face, C, face, 'PREP'), eng(facing, C)).
rule(lex, fr(faciliter, C, faciliter, v(m, inf, _)), eng(facilitate, C)).
rule(lex, fr(faire, C, faire, v(m, inf, _)), eng(make, C)).
rule(lex, fr(fait, C, faire, 'PAP_SG'), eng(does, C)).
rule(lex, fr(faut, C, falloir, v(m, 3, sg)), eng(must, C)).
rule(lex, fr(favoriser, C, favoriser, v(m, inf, _)), eng(favor, C)).
rule(lex, fr(façon, C, façon, n(sg)), eng(manner, C)).
rule(lex, fr(fenêtre, C, fenêtre, n(sg)), eng(window, C)).
rule(lex, fr(fenêtre, C, fenêtrer, v(m, 3, sg)), eng(window, C)).
rule(lex, fr(fenêtres, C, fenêtre, n(pl)), eng(windows, C)).
rule(lex, fr(fer, C, fer, n(sg)), eng(iron, C)).
rule(lex, fr(fermement, C, fermement, 'ADV'), eng(firmly, C)).
rule(lex, fr(fermer, C, fermer, v(m, inf, _)), eng(close, C)).
rule(lex, fr(fermée, C, fermer, 'PAP_SG'), eng(closed, C)).
rule(lex, fr(feux, C, feu, n(pl)), eng(lights, C)).
rule(lex, fr(fils, C, fils, n(_)), eng(wire, C)).
rule(lex, fr(filtre, C, filtre, n(sg)), eng(filter, C)).
rule(lex, fr(fin, C, fin, n(sg)), eng(end, C)).
rule(lex, fr(final, C, final, adj(1, sg)), eng(final, C)).
rule(lex, fr(fixe, C, fixe, adj(1, sg)), eng(fixed, C)).
rule(lex, fr(fixer, C, fixer, v(m, inf, _)), eng(fix, C)).
rule(lex, fr(flèche, C, flèche, n(sg)), eng(arrow, C)).
rule(lex, fr(flèches, C, flèche, n(pl)), eng(arrows, C)).
rule(lex, fr(fois, C, fois, n(_)), eng(time, C)).
rule(lex, fr(fonction, C, fonction, n(sg)), eng(function, C)).
rule(lex, fr(fonctionne, C, fonctionner, v(m, 3, sg)), eng(functions, C)).
rule(lex, fr(fonctionnement, C, fonctionnement, n(sg)), eng(functioning, C)).
rule(lex, fr(fonctionnent, C, fonctionner, v(m, 3, pl)), eng(function, C)).
rule(lex, fr(fonctionneront, C, fonctionner, v(m, 3, pl)), eng('will function', C)).
rule(lex, fr(fonctions, C, fonction, n(pl)), eng(functions, C)).
rule(lex, fr(force, C, force, n(sg)), eng(force, C)).
rule(lex, fr(forestière, C, forestier, adj(1, sg)), eng(forestary, C)).
rule(lex, fr(forme, C, forme, n(sg)), eng(form, C)).
rule(lex, fr(fourni, C, fournir, 'PAP_SG'), eng(supplied, C)).
rule(lex, fr(fournie, C, fournir, 'PAP_SG'), eng(supplied, C)).
rule(lex, fr(fragile, C, fragile, adj(1, sg)), eng(fragile, C)).
rule(lex, fr(frais, C, frais, adj(1, sg)), eng(cost, C)).
rule(lex, fr(frapper, C, frapper, v(m, inf, _)), eng(hit, C)).
rule(lex, fr(frein, C, frein, n(sg)), eng(brake, C)).
rule(lex, fr(freinage, C, freinage, n(sg)), eng(brake, C)).
rule(lex, fr(freiner, C, freiner, v(m, inf, _)), eng(brake, C)).
rule(lex, fr(freins, C, frein, n(pl)), eng(brakes, C)).
rule(lex, fr(froid, C, froid, adj(1, sg)), eng(cold, C)).
rule(lex, fr(froid, C, froid, n(sg)), eng(cold, C)).
rule(lex, fr(froids, C, froid, adj(1, pl)), eng(cold, C)).
rule(lex, fr(frotte, C, frotter, v(m, 3, sg)), eng(rubs, C)).
rule(lex, fr(fusibles, C, fusible, n(pl)), eng(fuses, C)).
rule(lex, fr(gamme, C, gamme, n(sg)), eng(range, C)).
rule(lex, fr(gammes, C, gamme, n(pl)), eng(ranges, C)).
rule(lex, fr(garantie, C, garantie, n(sg)), eng(guarantee, C)).
rule(lex, fr(garde, C, garde, n(sg)), eng(guard, C)).
rule(lex, fr(gauche, C, gauche, adj(1, sg)), eng(left, C)).
rule(lex, fr(gauche, C, gauche, n(sg)), eng(left, C)).
rule(lex, fr(gaz, C, gaz, n(_)), eng(gas, C)).
rule(lex, fr(genou, C, genou, n(sg)), eng(knee, C)).
rule(lex, fr(glace, C, glace, n(sg)), eng(ice, C)).
rule(lex, fr(glace, C, glacer, v(m, 3, sg)), eng(freeze, C)).
rule(lex, fr(glisser, C, glisser, v(m, inf, _)), eng(slide, C)).
rule(lex, fr(graves, C, grave, adj(1, pl)), eng(serious, C)).
rule(lex, fr(grille, C, grille, n(sg)), eng(grill, C)).
rule(lex, fr(gyrophare, C, gyrophare, n(sg)), eng('rotating beacon', C)).
rule(lex, fr(généraux, C, général, adj(1, pl)), eng(general, C)).
rule(lex, fr(haut, C, haut, adj(2, sg)), eng(high, C)).
rule(lex, fr(haute, C, haut, adj(2, sg)), eng(high, C)).
rule(lex, fr(hauteur, C, hauteur, n(sg)), eng(height, C)).
rule(lex, fr(hectares, C, hectare, n(pl)), eng(hectar, C)).
rule(lex, fr(hermétiquement, C, hermétiquement, 'ADV'), eng(hermetically, C)).
rule(lex, fr(heure, C, heure, n(sg)), eng(hour, C)).
rule(lex, fr(heures, C, heure, n(pl)), eng(hours, C)).
rule(lex, fr(honorée, C, honorer, 'PAP_SG'), eng(honored, C)).
rule(lex, fr(horaire, C, horaire, adj(1, sg)), eng(hour, C)).
rule(lex, fr(horizontalement, C, horizontalement, 'ADV'), eng(horizontally, C)).
rule(lex, fr(hors, C, hors, 'PREP'), eng(outside, C)).
rule(lex, fr(hostile, C, hostile, adj(1, sg)), eng(hostile, C)).
rule(lex, fr(huile, C, huile, n(sg)), eng(oil, C)).
rule(lex, fr(humide, C, humide, adj(1, sg)), eng(humid, C)).
rule(lex, fr(humidité, C, humidité, n(sg)), eng(humidity, C)).
rule(lex, fr(hydraulique, C, hydraulique, adj(1, sg)), eng(hydraulic, C)).
rule(lex, fr(i, C, i, 'NUM'), eng(i, C)).
rule(lex, fr(identifier, C, identifier, v(m, inf, _)), eng(identify, C)).
rule(lex, fr(ii, C, ii, 'NUM'), eng(ii, C)).
rule(lex, fr(iii, C, iii, 'NUM'), eng(iii, C)).
rule(lex, fr(il, C, il, 'PRON'), eng(it, C)).
rule(lex, fr(illustration, C, illustration, n(sg)), eng(illustration, C)).
rule(lex, fr(illustrations, C, illustration, n(pl)), eng(illustrations, C)).
rule(lex, fr(illustré, C, illustré, n(sg)), eng(illustrated, C)).
rule(lex, fr(illustrée, C, illustrer, 'PAP_SG'), eng(illustrated, C)).
rule(lex, fr(ils, C, il, 'PRON'), eng(they, C)).
rule(lex, fr(immédiatement, C, immédiatement, 'ADV'), eng(immediately, C)).
rule(lex, fr(important, C, important, adj(1, sg)), eng(important, C)).
rule(lex, fr(importe, C, importer, v(m, 3, sg)), eng(imports, C)).
rule(lex, fr(inclinaison, C, inclinaison, n(sg)), eng(slope, C)).
rule(lex, fr(incliner, C, incliner, v(m, inf, _)), eng(slope, C)).
rule(lex, fr(indicateur, C, indicateur, n(sg)), eng(indicator, C)).
rule(lex, fr(indicateur, C, indicateur, adj(1, sg)), eng(indicator, C)).
rule(lex, fr(indicateurs, C, indicateur, adj(1, pl)), eng(indicator, C)).
rule(lex, fr(indicateurs, C, indicateur, n(pl)), eng(indicators, C)).
rule(lex, fr(indique, C, indiquer, v(m, 3, sg)), eng(indicates, C)).
rule(lex, fr(indiquent, C, indiquer, v(m, 3, pl)), eng(indicate, C)).
rule(lex, fr(indiquer, C, indiquer, v(m, inf, _)), eng(indicate, C)).
rule(lex, fr(indiqué, C, indiquer, 'PAP_SG'), eng(indicated, C)).
rule(lex, fr(indiquée, C, indiquer, 'PAP_SG'), eng(indicated, C)).
rule(lex, fr(indiquées, C, indiquer, 'PAP_PL'), eng(indicated, C)).
rule(lex, fr(indiqués, C, indiquer, 'PAP_PL'), eng(indicated, C)).
rule(lex, fr(indispensable, C, indispensable, adj(1, sg)), eng(indispensible, C)).
rule(lex, fr(indéfiniment, C, indéfiniment, 'ADV'), eng(indefinitely, C)).
rule(lex, fr(indépendamment, C, indépendamment, 'ADV'), eng(independently, C)).
rule(lex, fr(indépendante, C, indépendant, adj(1, sg)), eng(independent, C)).
rule(lex, fr(informations, C, information, n(pl)), eng(information, C)).
rule(lex, fr(inférieur, C, inférieur, adj(1, sg)), eng(inferior, C)).
rule(lex, fr(inférieure, C, inférieur, adj(1, sg)), eng(inferior, C)).
rule(lex, fr(inférieures, C, inférieur, adj(1, pl)), eng(inferior, C)).
rule(lex, fr(injecteurs, C, injecteur, n(pl)), eng(injector, C)).
rule(lex, fr(installation, C, installation, n(sg)), eng(installation, C)).
rule(lex, fr(instructions, C, instruction, n(pl)), eng(instructions, C)).
rule(lex, fr(instrument, C, instrument, n(sg)), eng(instrument, C)).
rule(lex, fr(instruments, C, instrument, n(pl)), eng(instruments, C)).
rule(lex, fr(intermédiaire, C, intermédiaire, n(sg)), eng(intermeiary, C)).
rule(lex, fr(interrupteur, C, interrupteur, n(sg)), eng(switch, C)).
rule(lex, fr(intervalle, C, intervalle, n(sg)), eng(intervalle, C)).
rule(lex, fr(intérieur, C, intérieur, adj(1, sg)), eng(interior, C)).
rule(lex, fr(intérieur, C, intérieur, n(sg)), eng(interior, C)).
rule(lex, fr(intérieure, C, intérieur, adj(1, sg)), eng(interior, C)).
rule(lex, fr(inverseur, C, inverseur, n(sg)), eng(reverse, C)).
rule(lex, fr(inversion, C, inversion, n(sg)), eng(inversion, C)).
rule(lex, fr(irréparable, C, irréparable, adj(1, sg)), eng(irreperable, C)).
rule(lex, fr(isoler, C, isoler, v(m, inf, _)), eng(insulate, C)).
rule(lex, fr(jamais, C, jamais, 'ADV'), eng(never, C)).
rule(lex, fr(jauge, C, jauge, n(sg)), eng(guage, C)).
rule(lex, fr(jaune, C, jaune, adj(1, sg)), eng(yellow, C)).
rule(lex, fr(jaunes, C, jaune, adj(1, pl)), eng(yellow, C)).
rule(lex, fr(jet, C, jet, n(sg)), eng(jet, C)).
rule(lex, fr(jours, C, jour, n(pl)), eng(days, C)).
rule(lex, fr('jusqu\'', C, 'jusqu\'', 'PREP'), eng('up to', C)).
rule(lex, fr(km, C, km, n(_)), eng(km, C)).
rule(lex, fr('l\'', C, le, det(sg)), eng(the, C)).
rule(lex, fr('l\'', C, le, 'PC'), eng(it, C)).
rule(lex, fr('l\'on', C, on, 'PRON'), eng(one, C)).
rule(lex, fr('l\'un', C, 'l\'un', 'PRON'), eng(a, C)).
rule(lex, fr('l\'une', C, 'l\'un', 'PRON'), eng(a, C)).
rule(lex, fr(la, C, le, det(sg)), eng(the, C)).
rule(lex, fr(la, C, le, 'PC'), eng(it, C)).
rule(lex, fr(laissant, C, laisser, 'VERB_PRP'), eng(leaving, C)).
rule(lex, fr(laisser, C, laisser, v(m, inf, _)), eng(leave, C)).
rule(lex, fr(laissé, C, laisser, 'PAP_SG'), eng(left, C)).
rule(lex, fr(lampes, C, lampe, n(pl)), eng(bulbs, C)).
rule(lex, fr(laquelle, C, lequel, 'RELPRO'), eng(which, C)).
rule(lex, fr(latérales, C, latéral, adj(1, pl)), eng(lateral, C)).
rule(lex, fr(lave, C, lave, n(sg)), eng(washer, C)).
rule(lex, fr(le, C, le, det(sg)), eng(the, C)).
rule(lex, fr(le, C, le, 'PC'), eng(it, C)).
rule(lex, fr(lecaséchéant, C, lecaséchéant, 'ADV'), eng('given case', C)).
rule(lex, fr(lecteur, C, lecteur, n(sg)), eng(reader, C)).
rule(lex, fr(lecture, C, lecture, n(sg)), eng(reading, C)).
rule(lex, fr(lectures, C, lecture, n(pl)), eng(readings, C)).
rule(lex, fr(lelongde, C, lelongde, 'PREP'), eng(along, C)).
rule(lex, fr(lent, C, lent, adj(1, sg)), eng(slow, C)).
rule(lex, fr(lente, C, lent, adj(1, sg)), eng(slow, C)).
rule(lex, fr(lequel, C, lequel, 'RELPRO'), eng(which, C)).
rule(lex, fr(les, C, le, det(pl)), eng(the, C)).
rule(lex, fr(les, C, le, 'PC'), eng(them, C)).
rule(lex, fr(lettres, C, lettre, n(pl)), eng(letters, C)).
rule(lex, fr(leur, C, leur, det(sg)), eng(their, C)).
rule(lex, fr(leurs, C, leur, det(pl)), eng(their, C)).
rule(lex, fr(lever, C, lever, v(m, inf, _)), eng(raise, C)).
rule(lex, fr(levier, C, levier, n(sg)), eng(lever, C)).
rule(lex, fr(leviers, C, levier, n(pl)), eng(levers, C)).
rule(lex, fr(librement, C, librement, 'ADV'), eng(liberally, C)).
rule(lex, fr(libère, C, libérer, v(m, 3, sg)), eng(frees, C)).
rule(lex, fr(libérer, C, libérer, v(m, inf, _)), eng(free, C)).
rule(lex, fr(limite, C, limite, n(sg)), eng(limits, C)).
rule(lex, fr(limiter, C, limiter, v(m, inf, _)), eng(limit, C)).
rule(lex, fr(liquide, C, liquide, n(sg)), eng(liquid, C)).
rule(lex, fr(liste, C, liste, n(sg)), eng(list, C)).
rule(lex, fr(litres, C, litre, n(pl)), eng(liters, C)).
rule(lex, fr(livret, C, livret, n(sg)), eng(booklet, C)).
rule(lex, fr('lorsqu\'', C, lorsque, 'CONN'), eng(when, C)).
rule(lex, fr(lorsque, C, lorsque, 'CONN'), eng(when, C)).
rule(lex, fr(lourd, C, lourd, adj(1, sg)), eng(heavy, C)).
rule(lex, fr(lui, C, lui, 'PRON'), eng(him, C)).
rule(lex, fr(lumineux, C, lumineux, adj(1, _)), eng(luminous, C)).
rule(lex, fr(léger, C, léger, adj(1, sg)), eng(light, C)).
rule(lex, fr(légèrement, C, légèrement, 'ADV'), eng(slightly, C)).
rule(lex, fr('m\'', C, me, 'PC'), eng('me', C)).
rule(lex, fr(magasin, C, magasin, n(sg)), eng(store, C)).
rule(lex, fr(magnétique, C, magnétique, adj(1, sg)), eng(magnetic, C)).
rule(lex, fr(main, C, main, n(sg)), eng(hand, C)).
rule(lex, fr(maintenir, C, maintenir, v(m, inf, _)), eng(mantain, C)).
rule(lex, fr(maintenue, C, maintenir, 'PAP_SG'), eng(maintained, C)).
rule(lex, fr(maintien, C, maintien, n(sg)), eng(maintenance, C)).
rule(lex, fr(maintiendra, C, maintenir, v(m, 3, sg)), eng('will maintain', C)).
rule(lex, fr(maintient, C, maintenir, v(m, 3, sg)), eng(maintains, C)).
rule(lex, fr(mais, C, mais, 'COORD'), eng(but, C)).
rule(lex, fr(manche, C, manche, n(sg)), eng(sleeve, C)).
rule(lex, fr(manette, C, manette, n(sg)), eng(handle, C)).
rule(lex, fr(manivelle, C, manivelle, n(sg)), eng(handle, C)).
rule(lex, fr(manière, C, manière, n(sg)), eng(manner, C)).
rule(lex, fr(manoeuvre, C, manoeuvre, n(sg)), eng(manoeuvre, C)).
rule(lex, fr(manuellement, C, manuellement, 'ADV'), eng(manually, C)).
rule(lex, fr(marche, C, marche, n(sg)), eng(running, C)).
rule(lex, fr(marque, C, marque, n(sg)), eng(make, C)).
rule(lex, fr(mauvaise, C, mauvais, adj(2, sg)), eng(bad, C)).
rule(lex, fr(maximale, C, maximal, adj(1, sg)), eng(normal, C)).
rule(lex, fr(maximum, C, maximum, n(sg)), eng(maximum, C)).
rule(lex, fr(meilleur, C, meilleur, adj(1, sg)), eng(best, C)).
rule(lex, fr(meilleures, C, meilleur, adj(1, pl)), eng(best, C)).
rule(lex, fr(met, C, mettre, v(m, 3, sg)), eng(puts, C)).
rule(lex, fr(mettre, C, mettre, v(m, inf, _)), eng(put, C)).
rule(lex, fr(milieu, C, milieu, n(sg)), eng(middle, C)).
rule(lex, fr(mince, C, mince, adj(1, sg)), eng(thin, C)).
rule(lex, fr(mis, C, mettre, 'PAP_INV'), eng(put, C)).
rule(lex, fr(mises, C, mettre, 'PAP_PL'), eng(put, C)).
rule(lex, fr(mode, C, mode, n(sg)), eng(mode, C)).
rule(lex, fr(moins, C, moins, 'ADV'), eng(less, C)).
rule(lex, fr(moins, C, moins, n(_)), eng(means, C)).
rule(lex, fr(mois, C, mois, n(_)), eng(month, C)).
rule(lex, fr(moment, C, moment, n(sg)), eng(moment, C)).
rule(lex, fr(montage, C, montage, n(sg)), eng(mounting, C)).
rule(lex, fr(monter, C, monter, v(m, inf, _)), eng('get up', C)).
rule(lex, fr(montre, C, montre, n(sg)), eng(watch, C)).
rule(lex, fr(monté, C, monter, 'PAP_SG'), eng(mounted, C)).
rule(lex, fr(montée, C, monter, 'PAP_SG'), eng(mounted, C)).
rule(lex, fr(montée, C, montée, n(sg)), eng(mounted, C)).
rule(lex, fr(montées, C, monter, 'PAP_PL'), eng(mounted, C)).
rule(lex, fr(montés, C, monter, 'PAP_PL'), eng(mounted, C)).
rule(lex, fr(moteur, C, moteur, adj(1, sg)), eng(motor, C)).
rule(lex, fr(moteur, C, moteur, n(sg)), eng(motor, C)).
rule(lex, fr(motrices, C, moteur, adj(1, pl)), eng(driving, C)).
rule(lex, fr(motrices, C, motrice, n(pl)), eng(motors, C)).
rule(lex, fr(mou, C, mou, n(sg)), eng(moist, C)).
rule(lex, fr(mouvement, C, mouvement, n(sg)), eng(mouvement, C)).
rule(lex, fr(moyen, C, moyen, n(sg)), eng(means, C)).
rule(lex, fr(moyenne, C, moyen, adj(1, sg)), eng(middle, C)).
rule(lex, fr(moyenne, C, moyenner, v(m, 3, sg)), eng(medium, C)).
rule(lex, fr(muni, C, munir, adj(1, sg)), eng(supplied, C)).
rule(lex, fr(muni, C, munir, 'PAP_SG'), eng(supplied, C)).
rule(lex, fr(munie, C, munir, 'PAP_SG'), eng(supplied, C)).
rule(lex, fr(mètres, C, mètre, n(pl)), eng(meters, C)).
rule(lex, fr(mécaniquement, C, mécaniquement, 'ADV'), eng(mechanically, C)).
rule(lex, fr(mécanisme, C, mécanisme, n(sg)), eng(mechanism, C)).
rule(lex, fr(mémoire, C, mémoire, n(sg)), eng(memory, C)).
rule(lex, fr(métallique, C, métallique, adj(1, sg)), eng(metal, C)).
rule(lex, fr(même, C, même, adj(1, sg)), eng(same, C)).
rule(lex, fr(même, C, même, 'ADV'), eng(same, C)).
rule(lex, fr('n\'', C, ne, 'NEG'), eng(not, C)).
rule(lex, fr(ne, C, ne, 'NEG'), eng(not, C)).
rule(lex, fr(nepas, C, nepas, 'NEG'), eng(not, C)).
rule(lex, fr(nettoyage, C, nettoyage, n(sg)), eng(cleaning, C)).
rule(lex, fr(nettoyer, C, nettoyer, v(m, inf, _)), eng(clean, C)).
rule(lex, fr(nettoyé, C, nettoyer, 'PAP_SG'), eng(cleaned, C)).
rule(lex, fr(neutralisation, C, neutralisation, n(sg)), eng(neutralization, C)).
rule(lex, fr(neutralisée, C, neutraliser, adj(1, sg)), eng(neutralized, C)).
rule(lex, fr(niveau, C, niveau, n(sg)), eng(level, C)).
rule(lex, fr(nivellement, C, nivellement, n(sg)), eng(levelling, C)).
rule(lex, fr(nombreux, C, nombreux, adj(1, _)), eng(numerous, C)).
rule(lex, fr(nominale, C, nominal, adj(1, sg)), eng(nomional, C)).
rule(lex, fr(non, C, non, 'ADV'), eng(non, C)).
rule(lex, fr(normal, C, normal, adj(1, sg)), eng(normal, C)).
rule(lex, fr(normale, C, normal, adj(1, sg)), eng(normal, C)).
rule(lex, fr(note, C, note, n(sg)), eng(note, C)).
rule(lex, fr(note, C, noter, v(m, 3, sg)), eng(notes, C)).
rule(lex, fr(notice, C, notice, n(sg)), eng(notice, C)).
rule(lex, fr(nous, C, nous, 'PRON_P1P2'), eng(we, C)).
rule(lex, fr(nécessaire, C, nécessaire, adj(1, sg)), eng(necsessary, C)).
rule(lex, fr(nécessitent, C, nécessiter, v(m, 3, pl)), eng(require, C)).
rule(lex, fr(nécessité, C, nécessité, n(sg)), eng(required, C)).
rule(lex, fr(négatif, C, négatif, adj(1, sg)), eng(negative, C)).
rule(lex, fr(objet, C, objet, n(sg)), eng(object, C)).
rule(lex, fr(obligatoirement, C, obligatoirement, 'ADV'), eng(obligatorily, C)).
rule(lex, fr(observer, C, observer, v(m, inf, _)), eng(observe, C)).
rule(lex, fr(obtenir, C, obtenir, v(m, inf, _)), eng(get, C)).
rule(lex, fr(obtenu, C, obtenir, 'PAP_SG'), eng(gotten, C)).
rule(lex, fr(off, C, off, adj(1, _)), eng(off, C)).
rule(lex, fr(on, C, on, 'PRON'), eng(one, C)).
rule(lex, fr(ont, C, avoir, v(aux, 3, pl)), eng(have, C)).
rule(lex, fr(option, C, option, n(sg)), eng(option, C)).
rule(lex, fr(opérateur, C, opérateur, n(sg)), eng(operator, C)).
rule(lex, fr(orange, C, orange, adj(1, _)), eng(orange, C)).
rule(lex, fr(ordre, C, ordre, n(sg)), eng(order, C)).
rule(lex, fr(oreilles, C, oreille, n(pl)), eng(ears, C)).
rule(lex, fr(orientés, C, orienter, 'PAP_PL'), eng(directed, C)).
rule(lex, fr(origine, C, origine, n(sg)), eng(origine, C)).
rule(lex, fr(ou, C, ou, 'COORD'), eng(or, C)).
rule(lex, fr(outil, C, outil, n(sg)), eng(tool, C)).
rule(lex, fr(outils, C, outil, n(pl)), eng(tools, C)).
rule(lex, fr(ouvert, C, ouvrir, 'PAP_SG'), eng(opened, C)).
rule(lex, fr(ouverte, C, ouvrir, 'PAP_SG'), eng(opened, C)).
rule(lex, fr(ouverture, C, ouverture, n(sg)), eng(opening, C)).
rule(lex, fr(ouvrir, C, ouvrir, v(m, inf, _)), eng(open, C)).
rule(lex, fr(ouvrira, C, ouvrir, v(m, 3, sg)), eng('will open', C)).
rule(lex, fr(oxyde, C, oxyder, 'VERB_P1P2'), eng(oxidize, C)).
rule(lex, fr(oxyde, C, oxyder, v(m, 3, sg)), eng(oxidizes, C)).
rule(lex, fr(oxydes, C, oxyder, 'VERB_P1P2'), eng(oxidize, C)).
rule(lex, fr(o, C, o, 'CONN'), eng(where, C)).
rule(lex, fr(page, C, page, n(sg)), eng(page, C)).
rule(lex, fr(pages, C, page, n(pl)), eng(pages, C)).
rule(lex, fr(pair, C, pair, n(sg)), eng(pair, C)).
rule(lex, fr(panneau, C, panneau, n(sg)), eng(panel, C)).
rule(lex, fr(panneaux, C, panneau, n(pl)), eng(panels, C)).
rule(lex, fr(par, C, par, 'PREP'), eng(by, C)).
rule(lex, fr(parcourue, C, parcourir, adj(1, sg)), eng(covered, C)).
rule(lex, fr(parleur, C, parleur, n(sg)), eng(speaker, C)).
rule(lex, fr(parleurs, C, parleur, n(pl)), eng(speakers, C)).
rule(lex, fr(particules, C, particule, n(pl)), eng(particles, C)).
rule(lex, fr(particulières, C, particulier, adj(1, pl)), eng(particular, C)).
rule(lex, fr(partie, C, partie, n(sg)), eng(part, C)).
rule(lex, fr(partielle, C, partiel, adj(1, sg)), eng(partial, C)).
rule(lex, fr(partielles, C, partiel, adj(1, pl)), eng(partial, C)).
rule(lex, fr(pas, C, pas, 'ADV'), eng(not, C)).
rule(lex, fr(passe, C, passer, v(m, 3, sg)), eng(passes, C)).
rule(lex, fr(passer, C, passer, v(m, inf, _)), eng(pass, C)).
rule(lex, fr(pastille, C, pastille, n(sg)), eng(pastel, C)).
rule(lex, fr(patte, C, patte, n(sg)), eng(leg, C)).
rule(lex, fr(paume, C, paume, n(sg)), eng(palm, C)).
rule(lex, fr(pavillon, C, pavillon, n(sg)), eng(pavillion, C)).
rule(lex, fr(pays, C, pays, n(_)), eng(country, C)).
rule(lex, fr(pellicule, C, pellicule, n(sg)), eng(film, C)).
rule(lex, fr(pendant, C, pendant, 'PREP'), eng(during, C)).
rule(lex, fr(performances, C, performance, n(pl)), eng(prformances, C)).
rule(lex, fr(permet, C, permettre, v(m, 3, sg)), eng(allows, C)).
rule(lex, fr(permettre, C, permettre, v(m, inf, _)), eng(allow, C)).
rule(lex, fr(personne, C, personne, n(sg)), eng(person, C)).
rule(lex, fr(personne, C, personne, 'PRON'), eng(noone, C)).
rule(lex, fr(perte, C, perte, n(sg)), eng(loss, C)).
rule(lex, fr(pesticides, C, pesticide, n(pl)), eng(perticides, C)).
rule(lex, fr(petite, C, petit, adj(2, sg)), eng(little, C)).
rule(lex, fr(peut, C, pouvoir, v(m, 3, sg)), eng(can, C)).
rule(lex, fr(peuvent, C, pouvoir, v(m, 3, pl)), eng(can, C)).
rule(lex, fr(phare, C, phare, n(sg)), eng(headlight, C)).
rule(lex, fr(phares, C, phare, n(pl)), eng(headlights, C)).
rule(lex, fr(pied, C, pied, n(sg)), eng(foot, C)).
rule(lex, fr(pivotant, C, pivotant, adj(1, sg)), eng(turn, C)).
rule(lex, fr(pivotement, C, pivotement, n(sg)), eng(spindle, C)).
rule(lex, fr(pivoter, C, pivoter, v(m, inf, _)), eng(turn, C)).
rule(lex, fr(place, C, place, n(sg)), eng(room, C)).
rule(lex, fr(plafonnier, C, plafonnier, n(sg)), eng('overhead light', C)).
rule(lex, fr(planche, C, planche, n(sg)), eng(plank, C)).
rule(lex, fr(plancher, C, plancher, n(sg)), eng(floor, C)).
rule(lex, fr(plane, C, plan, adj(1, sg)), eng(flat, C)).
rule(lex, fr(plaques, C, plaque, n(pl)), eng(plates, C)).
rule(lex, fr(plate, C, plat, adj(1, sg)), eng(flat, C)).
rule(lex, fr(plupart, C, plupart, n(sg)), eng(majority, C)).
rule(lex, fr(plus, C, plus, 'ADV'), eng(more, C)).
rule(lex, fr(plus, C, plus, n(_)), eng(plus, C)).
rule(lex, fr(plusieurs, C, plusieurs, det(pl)), eng(several, C)).
rule(lex, fr(plusieurs, C, plusieurs, 'PRON'), eng(several, C)).
rule(lex, fr(poids, C, poids, n(_)), eng(weight, C)).
rule(lex, fr(poignée, C, poignée, n(sg)), eng(handle, C)).
rule(lex, fr(point, C, point, n(sg)), eng(point, C)).
rule(lex, fr(points, C, point, n(pl)), eng(points, C)).
rule(lex, fr(pointe, C, pointe, n(sg)), eng(pointe, C)).
rule(lex, fr(pont, C, pont, n(sg)), eng(bridge, C)).
rule(lex, fr(porte, C, porte, n(sg)), eng(door, C)).
rule(lex, fr(porte, C, porter, v(m, 3, sg)), eng(carries, C)).
rule(lex, fr(portée, C, portée, n(sg)), eng(reach, C)).
rule(lex, fr(positif, C, positif, adj(1, sg)), eng(positive, C)).
rule(lex, fr(position, C, position, n(sg)), eng(position, C)).
rule(lex, fr(positionner, C, positionner, v(m, inf, _)), eng(place, C)).
rule(lex, fr(positionnée, C, positionner, 'PAP_SG'), eng(placed, C)).
rule(lex, fr(positions, C, position, n(pl)), eng(positions, C)).
rule(lex, fr(possible, C, possible, adj(1, sg)), eng(possible, C)).
rule(lex, fr(possède, C, posséder, v(m, 3, sg)), eng(possesses, C)).
rule(lex, fr(poste, C, poste, n(sg)), eng(set, C)).
rule(lex, fr(pour, C, pour, 'PREP'), eng(for, C)).
rule(lex, fr(pourra, C, pouvoir, v(m, 3, sg)), eng('will be able to', C)).
rule(lex, fr(pousser, C, pousser, v(m, inf, _)), eng(push, C)).
rule(lex, fr(poussière, C, poussière, n(sg)), eng(dust, C)).
rule(lex, fr(poussiéreuse, C, poussiéreux, adj(1, sg)), eng(dusty, C)).
rule(lex, fr(poussiéreux, C, poussiéreux, adj(1, _)), eng(disty, C)).
rule(lex, fr(poussé, C, pousser, 'PAP_SG'), eng(pushed, C)).
rule(lex, fr(première, C, premier, adj(2, sg)), eng(first, C)).
rule(lex, fr(prend, C, prendre, v(m, 3, sg)), eng(takes, C)).
rule(lex, fr(pression, C, pression, n(sg)), eng(pressure, C)).
rule(lex, fr(principal, C, principal, adj(2, sg)), eng(principal, C)).
rule(lex, fr(principale, C, principal, adj(2, sg)), eng(principal, C)).
rule(lex, fr(principales, C, principal, adj(2, pl)), eng(principal, C)).
rule(lex, fr(prioritaire, C, prioritaire, adj(1, sg)), eng(priority, C)).
rule(lex, fr(prise, C, prise, n(sg)), eng(socket, C)).
rule(lex, fr(prises, C, prendre, 'PAP_PL'), eng(taken, C)).
rule(lex, fr(prises, C, prise, n(pl)), eng(sockets, C)).
rule(lex, fr(proche, C, proche, adj(2, sg)), eng(close, C)).
rule(lex, fr(procurer, C, procurer, v(m, inf, _)), eng(get, C)).
rule(lex, fr(procéder, C, procéder, v(m, inf, _)), eng(proceed, C)).
rule(lex, fr(procédé, C, procédé, n(sg)), eng(procedure, C)).
rule(lex, fr(produire, C, produire, v(m, inf, _)), eng(produce, C)).
rule(lex, fr(produits, C, produit, n(pl)), eng(products, C)).
rule(lex, fr(programmation, C, programmation, n(sg)), eng(programming, C)).
rule(lex, fr(progressivement, C, progressivement, 'ADV'), eng(progressively, C)).
rule(lex, fr(projecteurs, C, projecteur, n(pl)), eng(lights, C)).
rule(lex, fr(propriétaire, C, propriétaire, n(sg)), eng(owner, C)).
rule(lex, fr(protéger, C, protéger, v(m, inf, _)), eng(protect, C)).
rule(lex, fr(près, C, près, 'PREP'), eng(near, C)).
rule(lex, fr(pré, C, pré, n(sg)), eng(meadow, C)).
rule(lex, fr(précautions, C, précaution, n(pl)), eng(precautions, C)).
rule(lex, fr(prévu, C, prévoir, adj(1, sg)), eng(provided, C)).
rule(lex, fr(prévu, C, prévoir, 'PAP_SG'), eng(provided, C)).
rule(lex, fr(prévue, C, prévoir, adj(1, sg)), eng(provided, C)).
rule(lex, fr(prévue, C, prévoir, 'PAP_SG'), eng(provided, C)).
rule(lex, fr(prévus, C, prévoir, adj(1, pl)), eng(provided, C)).
rule(lex, fr(prévus, C, prévoir, 'PAP_PL'), eng(provided, C)).
rule(lex, fr(publique, C, public, adj(1, sg)), eng(public, C)).
rule(lex, fr(puis, C, puis, 'COORD'), eng(then, C)).
rule(lex, fr(puissance, C, puissance, n(sg)), eng(power, C)).
rule(lex, fr(puisse, C, pouvoir, v(m, 3, sg)), eng(can, C)).
rule(lex, fr(puissent, C, pouvoir, v(m, 3, pl)), eng(can, C)).
rule(lex, fr(pulvérisant, C, pulvériser, 'VERB_PRP'), eng(pulverizing, C)).
rule(lex, fr(pédale, C, pédale, n(sg)), eng(pedal, C)).
rule(lex, fr(pédale, C, pédaler, v(m, 3, sg)), eng(pedal, C)).
rule(lex, fr(pédales, C, pédale, n(pl)), eng(pedals, C)).
rule(lex, fr(pénétrer, C, pénétrer, v(m, inf, _)), eng(penetrate, C)).
rule(lex, fr('qu\'', C, que, 'CONJQUE'), eng(that, C)).
rule(lex, fr(qualité, C, qualité, n(sg)), eng(quality, C)).
rule(lex, fr(quand, C, quand, 'CONN'), eng(when, C)).
rule(lex, fr(quantité, C, quantité, n(sg)), eng(quantity, C)).
rule(lex, fr(quatre, C, quatre, 'NUM'), eng(four, C)).
rule(lex, fr(que, C, que, 'CONJQUE'), eng(that, C)).
rule(lex, fr(quel, C, quel, det(sg)), eng(which, C)).
rule(lex, fr(quelle, C, quel, det(sg)), eng(which, C)).
rule(lex, fr(qui, C, qui, 'RELPRO'), eng(that, C)).
rule(lex, fr(quoi, C, quoi, 'RELPRO'), eng(what, C)).
rule(lex, fr(radiateur, C, radiateur, n(sg)), eng(radiator, C)).
rule(lex, fr(radio, C, radio, n(sg)), eng(radio, C)).
rule(lex, fr(raison, C, raison, n(sg)), eng(raison, C)).
rule(lex, fr(rallonge, C, rallonge, n(sg)), eng(elongagates, C)).
rule(lex, fr(ramener, C, ramener, v(m, inf, _)), eng('bring back', C)).
rule(lex, fr(range, C, ranger, v(m, 3, sg)), eng(arrange, C)).
rule(lex, fr(rangement, C, rangement, n(sg)), eng(arrangement, C)).
rule(lex, fr(rapide, C, rapide, adj(1, sg)), eng(rapid, C)).
rule(lex, fr(rappeler, C, rappeler, v(m, inf, _)), eng(recall, C)).
rule(lex, fr(rappelé, C, rappeler, 'PAP_SG'), eng(recalled, C)).
rule(lex, fr(rapports, C, rapport, n(pl)), eng(relations, C)).
rule(lex, fr(rapprocher, C, rapprocher, v(m, inf, _)), eng('bring together', C)).
rule(lex, fr(rechercher, C, rechercher, v(m, inf, _)), eng(seek, C)).
rule(lex, fr(recommandations, C, recommandation, n(pl)), eng(recommendations, C)).
rule(lex, fr(recommande, C, recommander, v(m, 3, sg)), eng(recommentds, C)).
rule(lex, fr(recommandé, C, recommander, 'PAP_SG'), eng(recommended, C)).
rule(lex, fr(reculer, C, reculer, v(m, inf, _)), eng('back up', C)).
rule(lex, fr(refermer, C, refermer, v(m, inf, _)), eng(close, C)).
rule(lex, fr(refroidissement, C, refroidissement, n(sg)), eng(cooling, C)).
rule(lex, fr(relevant, C, relever, 'VERB_PRP'), eng(raising, C)).
rule(lex, fr(relever, C, relever, v(m, inf, _)), eng(raise, C)).
rule(lex, fr(relâche, C, relâcher, v(m, 3, sg)), eng(releases, C)).
rule(lex, fr(relâcher, C, relâcher, v(m, inf, _)), eng(release, C)).
rule(lex, fr(remettre, C, remettre, v(m, inf, _)), eng('put back', C)).
rule(lex, fr(remises, C, remettre, 'PAP_PL'), eng('put back', C)).
rule(lex, fr(remorque, C, remorque, n(sg)), eng(trailor, C)).
rule(lex, fr(remorque, C, remorquer, v(m, 3, sg)), eng(tows, C)).
rule(lex, fr(remorques, C, remorque, n(pl)), eng(trailors, C)).
rule(lex, fr(remplacer, C, remplacer, v(m, inf, _)), eng(replace, C)).
rule(lex, fr(remplies, C, remplir, 'PAP_PL'), eng(full, C)).
rule(lex, fr(repos, C, repos, n(_)), eng(rest, C)).
rule(lex, fr(reposant, C, reposer, 'VERB_PRP'), eng(resting, C)).
rule(lex, fr(repose, C, reposer, v(m, 3, sg)), eng(rest, C)).
rule(lex, fr(repousser, C, repousser, v(m, inf, _)), eng('push back', C)).
rule(lex, fr(reproduction, C, reproduction, n(sg)), eng(reproduction, C)).
rule(lex, fr(reproduit, C, reproduire, 'PAP_SG'), eng(reproduced, C)).
rule(lex, fr(représentant, C, représenter, 'VERB_PRP'), eng(representing, C)).
rule(lex, fr(repère, C, repère, n(sg)), eng(reference, C)).
rule(lex, fr(requis, C, requérir, adj(1, sg)), eng(required, C)).
rule(lex, fr(respectées, C, respecter, 'PAP_PL'), eng(respected, C)).
rule(lex, fr(resserrer, C, resserrer, v(m, inf, _)), eng(reset, C)).
rule(lex, fr(ressort, C, ressort, n(sg)), eng(spring, C)).
rule(lex, fr(ressort, C, ressortir, v(m, 3, sg)), eng('comes out', C)).
rule(lex, fr(reste, C, rester, v(m, 3, sg)), eng(remains, C)).
rule(lex, fr(rester, C, rester, v(m, inf, _)), eng(remain, C)).
rule(lex, fr(retirer, C, retirer, v(m, inf, _)), eng('take out', C)).
rule(lex, fr(retourne, C, retourner, v(m, 3, sg)), eng(returns, C)).
rule(lex, fr(retourner, C, retourner, v(m, inf, _)), eng(return, C)).
rule(lex, fr(revient, C, revenir, v(m, 3, sg)), eng('comes back', C)).
rule(lex, fr(revêtement, C, revêtement, n(sg)), eng(clothing, C)).
rule(lex, fr(risque, C, risque, n(sg)), eng(risk, C)).
rule(lex, fr(risque, C, risquer, v(m, 3, sg)), eng(risk, C)).
rule(lex, fr(risquent, C, risquer, v(m, 3, pl)), eng(risk, C)).
rule(lex, fr(roue, C, roue, n(sg)), eng(wheel, C)).
rule(lex, fr(roues, C, roue, n(pl)), eng(wheels, C)).
rule(lex, fr(rouge, C, rouge, adj(1, sg)), eng(red, C)).
rule(lex, fr(rouges, C, rouge, adj(1, pl)), eng(red, C)).
rule(lex, fr(rouler, C, rouler, v(m, inf, _)), eng(roll, C)).
rule(lex, fr(route, C, route, n(sg)), eng(road, C)).
rule(lex, fr(route, C, router, v(m, 3, sg)), eng(route, C)).
rule(lex, fr(réalisées, C, réaliser, 'PAP_PL'), eng(realized, C)).
rule(lex, fr(réchauffe, C, réchauffer, v(m, 3, sg)), eng(warms, C)).
rule(lex, fr(réducteur, C, réducteur, n(sg)), eng(reducer, C)).
rule(lex, fr(réduit, C, réduire, 'PAP_SG'), eng(reduced, C)).
rule(lex, fr(réelle, C, réel, adj(1, sg)), eng(real, C)).
rule(lex, fr(régime, C, régime, n(sg)), eng(speed, C)).
rule(lex, fr(réglable, C, réglable, adj(1, sg)), eng(adjustable, C)).
rule(lex, fr(réglables, C, réglable, adj(1, pl)), eng(adjustable, C)).
rule(lex, fr(réglage, C, réglage, n(sg)), eng(adjustment, C)).
rule(lex, fr(régler, C, régler, v(m, inf, _)), eng(adjust, C)).
rule(lex, fr(réglé, C, régler, 'PAP_SG'), eng(adjusted, C)).
rule(lex, fr(réglée, C, régler, 'PAP_SG'), eng(adjusted, C)).
rule(lex, fr(réglés, C, régler, 'PAP_PL'), eng(adjusted, C)).
rule(lex, fr(régulation, C, régulation, n(sg)), eng(regulation, C)).
rule(lex, fr(régulièrement, C, régulièrement, 'ADV'), eng(regularly, C)).
rule(lex, fr(réparations, C, réparation, n(pl)), eng(repairs, C)).
rule(lex, fr(réponse, C, réponse, n(sg)), eng(reply, C)).
rule(lex, fr(réservoir, C, réservoir, n(sg)), eng(tank, C)).
rule(lex, fr(résulte, C, résulter, v(m, 3, sg)), eng(results, C)).
rule(lex, fr(rétroviseur, C, rétroviseur, n(sg)), eng('rear-view mirror', C)).
rule(lex, fr(rétroviseurs, C, rétroviseur, n(pl)), eng('rear-view mirrors', C)).
rule(lex, fr('s\'', C, se, 'PC'), eng(self, C)).
rule(lex, fr(s, C, s, n(_)), eng(self, C)).
rule(lex, fr(sa, C, son, det(sg)), eng(its, C)).
rule(lex, fr(saisir, C, saisir, v(m, inf, _)), eng(grasp, C)).
rule(lex, fr(saleté, C, saleté, n(sg)), eng(dirt, C)).
rule(lex, fr(sans, C, sans, 'PREP'), eng(without, C)).
rule(lex, fr(se, C, se, 'PC'), eng(self, C)).
rule(lex, fr(sec, C, sec, adj(1, sg)), eng(dry, C)).
rule(lex, fr(sec, C, sec, 'ADV'), eng(dry, C)).
rule(lex, fr(secours, C, secours, n(_)), eng(help, C)).
rule(lex, fr(secteur, C, secteur, n(sg)), eng(sector, C)).
rule(lex, fr(section, C, section, n(sg)), eng(section, C)).
rule(lex, fr(sections, C, section, n(pl)), eng(sections, C)).
rule(lex, fr(selon, C, selon, 'PREP'), eng('according to', C)).
rule(lex, fr(sens, C, sens, n(_)), eng(directions, C)).
rule(lex, fr(sept, C, sept, 'NUM'), eng(seven, C)).
rule(lex, fr(sera, C, 'être', v(aux, 3, sg)), eng('will be', C)).
rule(lex, fr(serrage, C, serrage, n(sg)), eng(squeezing, C)).
rule(lex, fr(serrer, C, serrer, v(m, inf, _)), eng(squeeze, C)).
rule(lex, fr(serré, C, serrer, 'PAP_SG'), eng(squeezed, C)).
rule(lex, fr(serrée, C, serrer, 'PAP_SG'), eng(squeezed, C)).
rule(lex, fr(sert, C, servir, v(m, 3, sg)), eng(serves, C)).
rule(lex, fr(service, C, service, n(sg)), eng(service, C)).
rule(lex, fr(servir, C, servir, v(m, inf, _)), eng(serve, C)).
rule(lex, fr(seule, C, seul, adj(1, sg)), eng(alone, C)).
rule(lex, fr(seulement, C, seulement, 'ADV'), eng(only, C)).
rule(lex, fr(si, C, si, 'ADV'), eng(so, C)).
rule(lex, fr(si, C, si, 'CONN'), eng(if, C)).
rule(lex, fr(signal, C, signal, n(sg)), eng(signal, C)).
rule(lex, fr(signe, C, signe, n(sg)), eng(sign, C)).
rule(lex, fr(simple, C, simple, adj(2, sg)), eng(simplle, C)).
rule(lex, fr(simultanément, C, simultanément, 'ADV'), eng(simultaneously, C)).
rule(lex, fr(sinon, C, sinon, 'CONN'), eng(otherwise, C)).
rule(lex, fr(situé, C, situer, 'PAP_SG'), eng(located, C)).
rule(lex, fr(siège, C, siège, n(sg)), eng(seat, C)).
rule(lex, fr(sièges, C, siège, n(pl)), eng(seats, C)).
rule(lex, fr(soi, C, soi, 'PRON'), eng(oneself, C)).
rule(lex, fr(soins, C, soin, n(pl)), eng(concerns, C)).
rule(lex, fr(soit, C, soit, 'COORD'), eng(namely, C)).
rule(lex, fr(soit, C, 'être', v(aux, 3, sg)), eng(be, C)).
rule(lex, fr(soleil, C, soleil, n(sg)), eng(sun, C)).
rule(lex, fr(son, C, son, det(sg)), eng(its, C)).
rule(lex, fr(sonore, C, sonore, adj(1, sg)), eng(sound, C)).
rule(lex, fr(sont, C, 'être', v(aux, 3, pl)), eng(are, C)).
rule(lex, fr(sorte, C, sorte, n(sg)), eng(kind, C)).
rule(lex, fr(sortie, C, sortie, n(sg)), eng(exit, C)).
rule(lex, fr(sortir, C, sortir, v(m, inf, _)), eng(leave, C)).
rule(lex, fr(soufflerie, C, soufflerie, n(sg)), eng(blowing, C)).
rule(lex, fr(soulever, C, soulever, v(m, inf, _)), eng(raise, C)).
rule(lex, fr(source, C, source, n(sg)), eng(source, C)).
rule(lex, fr(sous, C, sous, 'PREP'), eng(under, C)).
rule(lex, fr(spécial, C, spécial, adj(1, sg)), eng(special, C)).
rule(lex, fr(standard, C, standard, adj(1, _)), eng(standard, C)).
rule(lex, fr(stationnement, C, stationnement, n(sg)), eng(parking, C)).
rule(lex, fr(subir, C, subir, v(m, inf, _)), eng(undergo, C)).
rule(lex, fr(suffisamment, C, suffisamment, 'ADV'), eng(sufficient, C)).
rule(lex, fr(suivantes, C, suivant, adj(1, pl)), eng(following, C)).
rule(lex, fr(suivants, C, suivant, adj(1, pl)), eng(following, C)).
rule(lex, fr(superficie, C, superficie, n(sg)), eng(surface, C)).
rule(lex, fr(supplémentaire, C, supplémentaire, adj(1, sg)), eng(supplementary, C)).
rule(lex, fr(support, C, support, n(sg)), eng(support, C)).
rule(lex, fr(supérieur, C, supérieur, adj(1, sg)), eng(upper, C)).
rule(lex, fr(supérieure, C, supérieur, adj(1, sg)), eng(upper, C)).
rule(lex, fr(sur, C, sur, 'PREP'), eng(on, C)).
rule(lex, fr(surchauffe, C, surchauffe, n(sg)), eng(overheat, C)).
rule(lex, fr(surveillance, C, surveillance, n(sg)), eng(surveillance, C)).
rule(lex, fr(suspension, C, suspension, n(sg)), eng(suspension, C)).
rule(lex, fr(symbole, C, symbole, n(sg)), eng(symbol, C)).
rule(lex, fr(symboles, C, symbole, n(pl)), eng(symbols, C)).
rule(lex, fr(système, C, système, n(sg)), eng(system, C)).
rule(lex, fr(sèchement, C, sèchement, 'ADV'), eng(dryly, C)).
rule(lex, fr(sécurité, C, sécurité, n(sg)), eng(security, C)).
rule(lex, fr(sélecteur, C, sélecteur, adj(1, sg)), eng(selector, C)).
rule(lex, fr(sélecteur, C, sélecteur, n(sg)), eng(selector, C)).
rule(lex, fr(sélecteurs, C, sélecteur, adj(1, pl)), eng(selector, C)).
rule(lex, fr(sélection, C, sélection, n(sg)), eng(selection, C)).
rule(lex, fr(sélectionne, C, sélectionner, v(m, 3, sg)), eng(chooses, C)).
rule(lex, fr(sélectionner, C, sélectionner, v(m, inf, _)), eng(choose, C)).
rule(lex, fr(sélectionné, C, sélectionner, 'PAP_SG'), eng(chosen, C)).
rule(lex, fr(sélectionnée, C, sélectionner, 'PAP_SG'), eng(chosen, C)).
rule(lex, fr(série, C, série, n(sg)), eng(series, C)).
rule(lex, fr(tableau, C, tableau, n(sg)), eng(table, C)).
rule(lex, fr(taille, C, taille, n(sg)), eng(size, C)).
rule(lex, fr(talon, C, talon, n(sg)), eng(thumb, C)).
rule(lex, fr(telle, C, tel, det(sg)), eng(such, C)).
rule(lex, fr(temps, C, temps, n(_)), eng(weather, C)).
rule(lex, fr(température, C, température, n(sg)), eng(temperature, C)).
rule(lex, fr(températures, C, température, n(pl)), eng(temperatures, C)).
rule(lex, fr(tendent, C, tendre, v(m, 3, pl)), eng(tend, C)).
rule(lex, fr(tendue, C, tendre, 'PAP_SG'), eng(extended, C)).
rule(lex, fr(tenir, C, tenir, v(m, inf, _)), eng(hold, C)).
rule(lex, fr(tension, C, tension, n(sg)), eng(tension, C)).
rule(lex, fr(terminé, C, terminer, 'PAP_SG'), eng(ended, C)).
rule(lex, fr(thermomètre, C, thermomètre, n(sg)), eng(thermometer, C)).
rule(lex, fr(tirer, C, tirer, v(m, inf, _)), eng(pull, C)).
rule(lex, fr(toit, C, toit, n(sg)), eng(roof, C)).
rule(lex, fr(tortue, C, tortue, n(sg)), eng(tortoise, C)).
rule(lex, fr(totale, C, total, adj(1, sg)), eng(total, C)).
rule(lex, fr(totales, C, total, adj(1, pl)), eng(total, C)).
rule(lex, fr(totalisateur, C, totalisateur, n(sg)), eng(counter, C)).
rule(lex, fr(toucher, C, toucher, v(m, inf, _)), eng(touch, C)).
rule(lex, fr(toujours, C, toujours, 'ADV'), eng(always, C)).
rule(lex, fr(tournant, C, tourner, 'VERB_PRP'), eng(turning, C)).
rule(lex, fr(tournants, C, tournant, n(pl)), eng(turning, C)).
rule(lex, fr(tourne, C, tourner, v(m, 3, sg)), eng(turns, C)).
rule(lex, fr(tourner, C, tourner, v(m, inf, _)), eng(turn, C)).
rule(lex, fr(tourné, C, tourner, 'PAP_SG'), eng(turned, C)).
rule(lex, fr(tours, C, tour, n(pl)), eng(revolutions, C)).
rule(lex, fr(tous, C, tout, det(pl)), eng(all, C)).
rule(lex, fr(tousles, C, toutle, det(pl)), eng('all the', C)).
rule(lex, fr(tout, C, tout, det(sg)), eng(all, C)).
rule(lex, fr(toutesles, C, toutle, det(pl)), eng('all the', C)).
rule(lex, fr(tracteur, C, tracteur, n(sg)), eng(tractor, C)).
rule(lex, fr(tracteurs, C, tracteur, n(pl)), eng(tractors, C)).
rule(lex, fr(traction, C, traction, n(sg)), eng(traction, C)).
rule(lex, fr(transmission, C, transmission, n(sg)), eng(transmission, C)).
rule(lex, fr(trappe, C, trappe, n(sg)), eng(trap, C)).
rule(lex, fr(travail, C, travail, n(sg)), eng(work, C)).
rule(lex, fr(travaille, C, travailler, v(m, 3, sg)), eng(works, C)).
rule(lex, fr(triangle, C, triangle, n(sg)), eng(triangle, C)).
rule(lex, fr(trois, C, trois, 'NUM'), eng(three, C)).
rule(lex, fr(troisième, C, troisième, adj(2, sg)), eng(third, C)).
rule(lex, fr(trop, C, trop, 'ADV'), eng(too, C)).
rule(lex, fr(trouve, C, trouver, v(m, 3, sg)), eng(finds, C)).
rule(lex, fr(trouvent, C, trouver, v(m, 3, pl)), eng(find, C)).
rule(lex, fr(trouvera, C, trouver, v(m, 3, sg)), eng('will find', C)).
rule(lex, fr(très, C, très, 'ADV'), eng(very, C)).
rule(lex, fr(type, C, type, n(sg)), eng(type, C)).
rule(lex, fr(types, C, type, n(pl)), eng(types, C)).
rule(lex, fr(témoin, C, témoin, n(sg)), eng('indicator light', C)).
rule(lex, fr(témoins, C, témoin, n(pl)), eng('indicator lights', C)).
rule(lex, fr(tête, C, tête, n(sg)), eng(head, C)).
rule(lex, fr(un, C, un, det(sg)), eng(a, C)).
rule(lex, fr(un, C, un, 'PRON'), eng(one, C)).
rule(lex, fr(une, C, un, det(sg)), eng(a, C)).
rule(lex, fr(unipolaire, C, unipolaire, adj(1, sg)), eng('single-pole', C)).
rule(lex, fr(unité, C, unité, n(sg)), eng(unit, C)).
rule(lex, fr(universels, C, universel, adj(1, pl)), eng(universal, C)).
rule(lex, fr(urgence, C, urgence, n(sg)), eng(emergency, C)).
rule(lex, fr(usine, C, usine, n(sg)), eng(factory, C)).
rule(lex, fr(utilisant, C, utiliser, 'VERB_PRP'), eng(using, C)).
rule(lex, fr(utilisation, C, utilisation, n(sg)), eng(use, C)).
rule(lex, fr(utilise, C, utiliser, v(m, 3, sg)), eng(uses, C)).
rule(lex, fr(utiliser, C, utiliser, v(m, inf, _)), eng(use, C)).
rule(lex, fr(utilisé, C, utiliser, 'PAP_SG'), eng(used, C)).
rule(lex, fr(utilisée, C, utiliser, 'PAP_SG'), eng(used, C)).
rule(lex, fr(utilisées, C, utiliser, 'PAP_PL'), eng(used, C)).
rule(lex, fr(utilisés, C, utiliser, 'PAP_PL'), eng(used, C)).
rule(lex, fr(veiller, C, veiller, v(m, inf, _)), eng('be careful', C)).
rule(lex, fr(ventilateur, C, ventilateur, n(sg)), eng(ventilator, C)).
rule(lex, fr(ventilation, C, ventilation, n(sg)), eng(ventialtion, C)).
rule(lex, fr(verre, C, verre, n(sg)), eng(glass, C)).
rule(lex, fr(verrou, C, verrou, n(sg)), eng(bolt, C)).
rule(lex, fr(verrouillage, C, verrouillage, n(sg)), eng(bolting, C)).
rule(lex, fr(verrouiller, C, verrouiller, v(m, inf, _)), eng(bolt, C)).
rule(lex, fr(verrouillée, C, verrouiller, 'PAP_SG'), eng(bolted, C)).
rule(lex, fr(verrouillées, C, verrouiller, 'PAP_PL'), eng(bolted, C)).
rule(lex, fr(vers, C, vers, 'PREP'), eng(towards, C)).
rule(lex, fr(vert, C, vert, adj(1, sg)), eng(green, C)).
rule(lex, fr(verte, C, vert, adj(1, sg)), eng(green, C)).
rule(lex, fr(vertes, C, vert, adj(1, pl)), eng(green, C)).
rule(lex, fr(verts, C, vert, adj(1, pl)), eng(green, C)).
rule(lex, fr(vient, C, venir, v(m, 3, sg)), eng(comes, C)).
rule(lex, fr(vitesse, C, vitesse, n(sg)), eng(speed, C)).
rule(lex, fr(vitesses, C, vitesse, n(pl)), eng(gears, C)).
rule(lex, fr(vitre, C, vitre, n(sg)), eng(window, C)).
rule(lex, fr(vitres, C, vitre, n(pl)), eng(windows, C)).
rule(lex, fr(vives, C, vif, adj(1, pl)), eng(alive, C)).
rule(lex, fr(voie, C, voie, n(sg)), eng(sees, C)).
rule(lex, fr(voir, C, voir, v(m, inf, _)), eng(see, C)).
rule(lex, fr(voisinage, C, voisinage, n(sg)), eng(neighborhood, C)).
rule(lex, fr(voiture, C, voiture, n(sg)), eng(car, C)).
rule(lex, fr(volant, C, volant, n(sg)), eng('steering wheel', C)).
rule(lex, fr(voyant, C, voyant, n(sg)), eng('indicator light', C)).
rule(lex, fr(voyant, C, voir, 'VERB_PRP'), eng(seeing, C)).
rule(lex, fr(voyants, C, voyant, adj(1, pl)), eng(light, C)).
rule(lex, fr(voyants, C, voyant, n(pl)), eng('indicator lights', C)).
rule(lex, fr(vérifier, C, vérifier, v(m, inf, _)), eng(check, C)).
rule(lex, fr(watts, C, watt, n(pl)), eng(watts, C)).
rule(lex, fr(x, C, x, 'NUM'), eng(x, C)).
rule(lex, fr(y, C, y, 'PC'), eng(y, C)).
rule(lex, fr(yeux, C, oeil, n(pl)), eng(eye, C)).
rule(lex, fr(zone, C, zone, n(sg)), eng(zone, C)).
rule(lex, fr(zéro, C, zéro, n(sg)), eng(zero, C)).
rule(lex, fr(à, C, à, 'PREP_A'), eng(to, C)).
rule(lex, fr('àceque', C, 'àceque', 'CONN'), eng('to what', C)).
rule(lex, fr('àcôtéde', C, 'àcôtéde', 'PREP'), eng(beside, C)).
rule(lex, fr('àcôtédes', C, 'àcôtéde=le', 'PREP_DE'), eng('beside the', C)).
rule(lex, fr('àfond', C, 'àfond', 'ADV'), eng(thoroughly, C)).
rule(lex, fr('àl\'arrièrede', C, 'àl\'arrièrede', 'PREP'), eng('at the back of', C)).
rule(lex, fr('àl\'arrièredu', C, 'àl\'arrièrede=le', 'PREP_DE'), eng('at the back of', C)).
rule(lex, fr(ˆpartirde, C, ˆpartirde, 'PREP'), eng(from, C)).
rule(lex, fr(ˆtravers, C, ˆtravers, 'PREP'), eng(accross, C)).
rule(lex, fr('échapper', C, 'échapper', v(m, inf, _)), eng(escape, C)).
rule(lex, fr('éclairage', C, 'éclairage', n(sg)), eng(lighting, C)).
rule(lex, fr('économie', C, 'économie', n(sg)), eng(economy, C)).
rule(lex, fr('économique', C, 'économique', adj(1, sg)), eng(economical, C)).
rule(lex, fr('également', C, 'également', 'ADV'), eng(equally, C)).
rule(lex, fr('électrique', C, 'électrique', adj(1, sg)), eng(electric, C)).
rule(lex, fr('électriques', C, 'électrique', adj(1, pl)), eng(electric, C)).
rule(lex, fr('éliminer', C, 'éliminer', v(m, inf, _)), eng(eliminate, C)).
rule(lex, fr('élément', C, 'élément', n(sg)), eng(element, C)).
rule(lex, fr('équipe', C, 'équiper', v(m, 3, sg)), eng(equips, C)).
rule(lex, fr('équipement', C, 'équipement', n(sg)), eng(equipment, C)).
rule(lex, fr('équipements', C, 'équipement', n(pl)), eng(equipment, C)).
rule(lex, fr('équipé', C, 'équiper', 'PAP_SG'), eng(equiped, C)).
rule(lex, fr('équipée', C, 'équiper', 'PAP_SG'), eng(equiped, C)).
rule(lex, fr('équipés', C, 'équiper', adj(1, pl)), eng(equiped, C)).
rule(lex, fr('équipés', C, 'équiper', 'PAP_PL'), eng(equiped, C)).
rule(lex, fr('éteignent', C, 'éteindre', v(m, 3, pl)), eng(extinguish, C)).
rule(lex, fr('éteindre', C, 'éteindre', v(m, inf, _)), eng(extinguish, C)).
rule(lex, fr('éteint', C, 'éteindre', v(m, 3, sg)), eng(extinguished, C)).
rule(lex, fr('éteints', C, 'éteindre', 'PAP_PL'), eng(extinguished, C)).
rule(lex, fr('évacuation', C, 'évacuation', n(sg)), eng(evacuaton, C)).
rule(lex, fr('éviter', C, 'éviter', v(m, inf, _)), eng(avoid, C)).
rule(lex, fr(être, C, être, v(aux, inf, _)), eng(be, C)).

rule(lex, fr(W, C, _, _), eng(W, C)).

capitalization(W0, W, uc) :-
  upper2lower(W0, W),
  !.
capitalization([U | W], [L | W], cap) :-
  U>64,
  U<91,
  L is U+32,
  \+ upper2lower(W, _),
  !.
capitalization(W, W, lc).

upper2lower([], []).
upper2lower([U | UT], [L | LT]) :-
  U>64,
  U<91,
  L is U+32,
  upper2lower(UT, LT).  

lower2upper([], []).
lower2upper([L | LT], [U | UT]) :-
  L>92,
  L<123,
  U is L-32,
  lower2upper(LT, UT).
