program skaiciai;
{ 158 u‘davinys }

  procedure Skaityti (var b: text; var z: string);
    { Skaitomas vienas ‘odis z iž bylos b  }
    { Peskai‡ius paskutin eilut‚s ‘od eof(b) = true }
    var s: char;
  begin
    z := ''; s := ' ';
    while not eoln(b) and not eof(b) and (s = ' ') do
      read(b, s);
    if s <> ' ' then z := z + s;
    while not eoln(b) and not eof(b) and (s <> ' ') do
      begin
        read(b, s);
        if s <> ' ' then z := z + s
      end
  end;

  function SkaitvK (Skaitv: string): integer;
    { Skaitvardis --> skaitvard‘io kodas (beveik visada -- reikžm‚) }
    const SkaitvSk = 32;  { Skaitvard‘i— skai‡ius }
          Lent: array [1..SkaitvSk] of record        { Skaitvard‘i— kodai }
                                         s: string;  { Skaitvardis }
                                         k: integer  { Kodas }
                                       end =         { (da‘nai - ir reikžm‚) }
      ((s: 'vienas' ;         k: 1),
       (s: 'du';              k: 2),
       (s: 'trys';            k: 3),
       (s: 'keturi';          k: 4),
       (s: 'penki';           k: 5),
       (s: 'žeži';            k: 6),
       (s: 'septyni';         k: 7),
       (s: 'ažtuoni';         k: 8),
       (s: 'devyni';          k: 9),
       (s: 'dežimt';          k: 10),
       (s: 'vienuolika';      k: 11),
       (s: 'dvylika';         k: 12),
       (s: 'trylika';         k: 13),
       (s: 'keturiolika';     k: 14),
       (s: 'penkiolika';      k: 15),
       (s: 'žežiolika';       k: 16),
       (s: 'septyniolika';    k: 17),
       (s: 'ažtuoniolika';    k: 18),
       (s: 'devyniolika';     k: 19),
       (s: 'dvidežimt';       k: 20),
       (s: 'trisdežimt';      k: 30),
       (s: 'keturiasdežimt';  k: 40),
       (s: 'penkiasdežimt';   k: 50),
       (s: 'žežiasdežimt';    k: 60),
       (s: 'septyniasdežimt'; k: 70),
       (s: 'ažtuoniasdežimt'; k: 80),
       (s: 'devyniasdežimt';  k: 90),
       (s: 'žimtas';          k: 100),
       (s: 'žimtai';          k: 102),   { kodas <> reikžm‚ }
       (s: 't–kstantis';      k: 1000),
       (s: 't–kstan‡iai';     k: 1002),  { kodas <> reikžm‚ }
       (s: 't–kstan‡i—';      k: 1010)); { kodas <> reikžm‚ }

    var i: integer;
  begin
    SkaitvK := 0;
    for i := 1 to SkaitvSk do
      if Lent[i].s = Skaitv then SkaitvK := Lent[i].k
  end;

  procedure FormuotiSk(var prad: text; var VisasSk: longint);
    { Skaitvard‘iai --> Skai‡ius }
    var skaitv: string;          { Skaitvardis }
        kodas: integer;          { Skaitvard‘io kodas }
        tkst, vnt: longint;      { Skai‡iaus komponentai po 3 skaitmenis:    }
                                 { t–kstan‡iai (xxx000) ir vienetai (000xxx) }
        klaida: boolean;

  begin
    tkst := 0; vnt := 0; klaida := false;
    while not eoln(prad) do
      begin
        Skaityti(prad, skaitv);
        kodas := SkaitvK(skaitv);
        case kodas of
          0:      klaida := true;
          1..9:   if Vnt mod 10 = 0
                    then vnt := vnt + kodas
                    else klaida := true;
          10..90: if (Vnt mod 100) = 0
                    then vnt := vnt + kodas
                    else klaida := true;
          100:    if vnt <= 1                        { (1) žimtas }
                    then vnt := 100
                    else klaida := true;
          102:    if vnt in [2..9]                   { 2 žimtai }
                    then vnt := vnt * 100
                    else klaida := true;
          1000:   begin
                    if vnt = 0 then vnt := 1;        { nebuvo "vienas" }
                    if (tkst = 0)
                       and (vnt mod 10 = 1)          { ...1 t–kstantis      }
                        and (vnt div 10 mod 10 <> 1) { bet ne 11..19 t–kst. }
                    then begin tkst := vnt; vnt := 0 end
                    else klaida := true
                  end;
          1002:   if (tkst = 0)
                      and ((vnt mod 10) in [2..9])     { ... 2..9 t–kst., }
                      and (vnt div 10 mod 10 <> 1)     { bet ne 11..19 t. }
                    then begin tkst := vnt; vnt := 0 end
                    else klaida := true;
          1010:   if (tkst = 0)
                      and (vnt > 0)
                      and ((vnt mod 100) in [11..19])   { ...11..19 t–kst. }
                             or ((vnt mod 100 div 10 in [0..9])
                                  and (vnt mod 10 = 0)) { 10, 20, ..., 100 t. }
                    then begin tkst := vnt; vnt := 0 end
                    else klaida := true
        end; { case }
      end; { while }
      if klaida then VisasSk := 0
                else VisasSk := tkst*1000 + vnt;
      readln(prad)
  end;

  var prad, rez: text;
      n: integer;         { pradini— duomen— eilu‡i— -- skai‡i— skai‡ius }
      rezult: longint;    { iž skaitvard‘i— gautas skai‡ius }
      i: integer;

begin
  assign(prad, 'SKAI.DAT'); reset(prad);
  assign(rez,  'SKAI.REZ'); rewrite(rez);
  readln(prad, n);
  for i := 1 to n do
    begin
      FormuotiSk(prad, rezult);
      writeln(rez, rezult: 6);
    end;
  close(prad); close(rez)
end.
