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).