Take me over? The maintainer of this distribution is looking for someone to take over! If you're interested then please contact them via email

NAME

Lingua::tlhInganHol::yIghun - "The Klingon Language: hey you, program in it!"

SYNOPSIS

use Lingua::tlhInganHol::yIghun; <<'u' nuqneH!

>> tIghItlh! { wa' yIQong! Dotlh 'oH yIHoH yInob qoj <mIw Sambe'> 'oH yIHegh jay'! <Qapla'!

> yIghItlh! } jaghmey tIqel!

DESCRIPTION

The Lingua::tlhInganHol::yIghun module allows you to write Perl in the original Klingon.

Introduction

The Klingon language was first explained to Terrans in 1984 by Earth-born linguist Dr Marc Okrand. Those who dare can learn more about it at the Klingon Language Institute (www.kli.org).

The word order in Klingon sentences is I-O-V-S: indirect object, (direct) object, verb, subject. For example:

luSpetna'vaD vay' vIghItlh jIH to-STDERR something write I

Naturally, commands given in the imperative form are far more common in Klingon. In imperative statements, such as those used for programming instructions, word order becomes I-O-V: indirect object, (direct) object, (imperative) verb:

luSpetna'vaD vay' yIghItlh! to-STDERR something (I order you to) write!

Thus, for programming, Klingon is inherently a Reverse Polish notation.

Variables

Klingon uses inflection to denote number. So the command:

luSpetna'vaD vay' yIghItlh!

is:

to-STDERR something write!

whereas:

to STDERR some things write!

is:

luSpetna'vaD vay'mey yIghItlh!

So in Klingon scalars and arrays can have the same root name (just as in regular Perl):

vay' ---> $something vay'mey ---> @something

The -mey suffix only refers to things incapable of speech. If the somethings had been articulate, the inflection would be:

luSpetna'vaD vay'pu' yIghItlh!

From a certain point-of-view, this parallels the difference between an array and a hash: arrays are subscripted mutely, with dumb integers; whereas hashes are subscripted eloquently, with quoted strings. Since hashes are thus in some sense "articulate", they are inflected with the -pu' suffix:

vay' ---> $something vay'mey ---> @something vay'pu' ---> %something

Standard variables

Some variables have special names. Specifically:

'oH $_ it

biH @_ them

chevwI' $/ that which separates

natlhwI $| that which drains

Subscripting arrays and hashes

Numerical subscripts are just ordinals. The command:

kill $starships[5][3];

means:

from starships, from the 5th of them, the 3rd of them, kill it!

which, in the Warrior's Tongue, is:

'ejDo'meyvo' vagh DIchvo' wej Dich yIHoH!

The DIch tag marks an ordinal number, whilst the ablative -vo' suffix marks something being subscripted (i.e. something that an element is taken from).

Note that the -mey suffix on the original 'ejDo'mey ( @starships ) array didn't change. This implies that the literal back-translation is:

kill @starships[5][3];

Thus Klingon shows its superiority, in that it already honours the new Perl 6 sigil conventions.

Hash indices have a different tag (Suq). So:

kill $enemies{"ancient"}{'human'};

which means:

from enemies, from the "ancient" ones, the 'human' one, kill him!

is coded as:

jaghpu'vo' <<ancient>> Suqvo' <human> Suq yIHoH!

Once again the -pu'"I'm-a-hash" suffix is retained when subscripting, so the literal back-translation is the Perl6ish:

kill %enemies{"ancient"}{'human'};

Element access through references

With references, the DIch or Suq tag still indicates what kind of thing is being subscripted. So there is no need for an explicit dereferencer. So:

jepaHDIlIwI'vo' <<stupid>> Suqvo' wa' DIch yIHoH!

can be translated:

kill $jeopardyPoster{"stupid"}[1]; # Perl 6 syntax

but also means:

kill $jeopardyPoster->{"stupid"}[1]; # Perl 5 syntax

Distinguishing lvalues

All the variables shown above were written in the (uninflected) accusative case. This is because they were used as direct objects (i.e. as data).

When variables are assigned to, they become indirect objects of the assignment (give the weapon to me). This means that targets of assignment (or any other form of modification) must be specified in the dative case, using the -vaD suffix:

'ejDo'meyvaD wa' 'uy' chen tInob! @starships = (1..1000000);

jaghpu'vaD (<<QIp>> wa' <<jIv>> cha') tInob! %enemies = (stupidity=>1, ignorance=>2);

jepaHDIlIwI'vo' wa' Dichvo' <<stupid>> SuqvaD ghur! ++$jeopardyPoster->[1]{"stupid"};

Variable declarations

Variable declarations also use suffixes for lexicals:

scalarwIj! ---> my $scalar; arraymeywIj! ---> my @array; hashpu'wI'! ---> my %hash;

for package variables:

scalarmaj! ---> our $scalar; arraymeymaj! ---> our @array; hashpu'ma'! ---> our %hash;

and for temporaries:

scalarvam! ---> local $scalar; arraymeyvam! ---> local @array; hashpu'vam! ---> local %hash;

Operators and other punctuation

In general, programming Perl in the original Klingon requires far less punctuation than in the Terran corruption.

The only punctuation components of the language are:

< and > These are pach poS (left claw) and pach niH (right claw). They delimit an uninterpolated character string. For example: <petaQ> yiHegh! ---> die 'scum'; << and >> These are pachmey poS (left claws) and pachmey niH (right claws). They delimit an interpolated character string. For example: <<petaQ

>> yiHegh! ---> die "scum

"; ( and ) These are 'etlh HivtaH and 'etlh HubtaH (attaching sword and defending sword). They are used as grouping expressions. For example: xvaD wa' (cha maH yIfunc) yIlogh yInob! ---> $x = 1*func(2,10) For standard operators and functions with fixed parameter lists, this kind of grouping is not needed due to the RPN ordering of Klingon: xvaD wa' cha maH yIchel yIlogh yInob! ---> $x = 1*(2+10) { and } These are betleH HivtaH and betleH HubtaH (attacking batleth and defending batleth). They are used to group complete statements. For example: x joq { 'oH yIghItlh! 'oHvaD yIghur! } yIvang! ---> $x && do{ print $_; $_++ } # This is the tajmey gho (circle of daggers), which is used to indicate the beginning of a comment (which then runs to the end of the line). Its use is widely reviled as a sign of weakness.

Operators

The Klingon binding of Perl does not use sniveling Terran symbols for important operations. It uses proper words. For example:

= yInob "give!" + tIchel "add!" - tIchelHa' "un-add!" ++... yIghur "increase!" ...++ yIghurQav "increase afterwards!" .. tIchen "form up!" eq rap'a' "the same?!" == mI'rap'a' "the same number?!"

For a complete list, see Appendix 2

Note that they all appear at the end of their argument lists:

Qapla' vum toDuj yIchel buDghach yichelHa' yInob! |_| |___| |____| |______________| |______| |_______| |____| |_________________________________| |____|

Most of the above examples begin with yI- or tI-. These prefixes indicate an imperative verb referring to one or many objects (respectively).

Hence, assignment is yInob (give it to...), whilst addition is tIchel (add them).

Of course, in the heat of coding there is often not time for these syntactic niceties, so Lingua::tlhIngan::yIghun allows you do just drop them (i.e. use "clipped Klingon") if you wish.

Numeric literals

Klingon uses a decimal numbering system. The digits are:

0 pagh 1 wa' 2 cha' 3 wej 4 loS 5 vagh 6 jav 7 Soch 8 chorgh 9 Hut

Powers of 10 are:

10 maH 100 vatlh 1000 SaD or SanID 10000 netlh 100000 bIp 1000000 'uy'

Numbers are formed by concatenating the appropriate digit and power of ten in a descending sequence. For example:

yearvaD wa'SaD Hutvatlh chorghmaH loS yInob! ---> $year = 1984;

Decimals are created by specifying the decimal mark (DoD) then enumerating post-decimal digits individually. For example:

pivaD wej DoD wa' loS wa' vagh yInob! ---> $pi = 3.1415;

References

References are created by prepending the query nuqDaq (where is...) to a referent. For example:

refvaD nuqDaq var yInob! ---> $ref = \$var;

To dereference, the appropriate -vetlh, -meyvetlh, or -pu'vetlh suffix (that..., those..., those ...) is used, depending on the type of the referent. For example:

refvetlh yIghItlh! ---> print ${$ref}; refmeyvetlh tIghItlh! ---> print @{$ref}; refpu'vetlh tIghItlh! ---> print %{$ref};

Conjunctives and disjunctives

Just as Terran Perl's conjunctive and disjunctive operators come in two precedences, so too do those of The Warrior's Perl.

When joining expressions, the high precedence operators (joq and je) are used:

x yImI'Suq joq yIghItlh! ---> print($x || get_num();) zvaD x yIy je yInob! ---> $z = ($x && y());

Unlike all other operators in Klingon, low-precedence conjunctives and disjunctives (i.e. those between complete commands) are infix, not postfix. The low precedence operators are qoj and 'ej:

x yIghItlh qoj yImI'Suq! ---> print($x) or get_num(); zvaD x yInob 'ej yIy! ---> ($z = $x) or y();

Note that (as the above exampe illustrate) changing precedence often necessitates a radical change in word order.

Object-oriented features

Klingon Perl does not pander to feeble Terran object-oriented sensibilities by treating objects and methods specially.

A method is a subroutine, so in Klingon Perl it is called exactly like a subroutine.

The first argument of a method is special, so in Klingon Perl it is explicitly marked it as being special.

For example, the procedural command:

Hich DoSmey yIbaH!

translates as:

fire($weapon,@targets);

To call the same subroutine as a method, with $weapons as its invocant object, it is necessary to mark the referent using the topicalizer 'e':

Hich'e' DoSmey yIbaH!

This then translates as:

$weapon->fire(@targets);

Likewise class methods are invoked by topicalizing the class name:

<<Jagh>>'e' yItogh yIghItlh!>

which is:

print "Enemy"->count();

To create an object, the DoQ (claim ownership of) command is used:

{ buvwIj bIH yInIH! # my $class = shift @_; De'pu'wI' bIH yInob! # %data = @_; nuqDaq De' buv yIDoQ yItatlh! # return bless \%data, $class; } chu' nab! # sub new

Comparisons

The equality comparison operators ( == , != , eq , ne ) are implemented as questions in Klingon:

x y rap'a' ---> $x eq $y ("x y are they the same?") x y mI'rap'a' ---> $x == $y ("x y are they the same number?") x y pIm'a' ---> $x ne $y ("x y are they different?") x y mI'pIm'a' ---> $x != $y ("x y are they different numbers?")

Inequalities are expressed with a different grammatical structure in Klingon. There is only one inequality operator, whose syntax is:

expr1 comparator law' expr2 comparator puS

Literally this means:

comparator(expr1) is many; comparator(expr2) is few

or, in other words:

comparator(expr1) > comparator(expr2)

The comparators tlhInganHol::yIghun supports are:

> : tIn < : mach >= : machbe' < : tInbe' gt : tlha' lt : nung ge : nungbe' le : tlha'be'

For example:

{ <<qapla>> yIghItlh } mebmey mach law' maH mach puS je Soj nungbe' law' <qagh> nungbe' puS teHchugh! print "qapla!" if @guests < 10 && $food ge 'qagh';

Flow control

The flow control directives are:

teHchugh if if is true teHchughbe' unless if is not true teHtaHvIS while while being true teHtaHvISbe' until while not being true tIqel for(each) consider them yIjaH goto go! yInargh last escape! yItaH next go on yInIDqa' redo try again

Builtin functions

Perl builtins are represented as imperative verbs in tlhInganHol::yIghun. Appendix 1 has the complete list.

As with operators, they may take yI- or tI- prefixes and are themselves postfix (the verb after it's arguments).

Note that there are a suitably large number of variations on the kill command.

User-defined subroutines

A user-defined subroutine is specified in a betleH delimited block, and given a name using the nab (procedure) specifier. For example:

{ <<Qapla'!

>> ghItlh! } doit nab!

means:

sub doit { print "Qapla'!

"; }

Such subroutines are then called using the (non-optional) yI- or tI- prefix:

yIdoit!

Anonymous subroutines are created by omitting the name:

refwIj { <<Qapla'!

>> ghItlh! } nab nob!

which is:

my $ref = sub { print "Qapla'!

"; }

Subroutine references can also be created by suffixing a subroutine name with -laHwI' (one who can...):

refwIj doitlaHwI' nob!

Either way, the subroutine is called through a reference by appending the -vetlh suffix (that...") and prepending the imperative yI- or tI-:

yIrefvetlh!

Pattern matching

Patterns (or nejwI') are specified using the same line-noise syntax as in Terran Perl.

To match against a pattern, the ghov verb (recognize) is used:

'oH <\d+> yIghov 'ej <<vItu'>> yIghItlh!

which means:

$_ =~ m/\d+/ and print "found it";

Note that the value being matched against must be explicitly specified, even if it is 'oH.

To substitute against a pattern, use tam (substitute):

De'vaD <\d+> <

> yItam!

which means:

$data =~ s/\d+/

/;

The container whose value is being substituted must be explicitly specified (again, even if it is 'oH). It is also the target of the action and thus takes the -vaD suffix.

Invective operator

Klingon is a language of great emotional depth. By comparison, programming in Terran languages is an insipid, bloodless experience.

Of particular note is the special programming construct: jay'. In Klingon it may be appended to a sentence to enhance it's emotional intensity. Thus:

qaSpu' nuq 'e' yIja'! Tell me what happened!

becomes:

qaSpu' nuq 'e' yIja' jay'! Tell me what the *#@& happened!

This useful and satisfying internal documentation technique can be used anywhere in a tlhInganHol::yIghun program. For example:

{ <<De' sambe'>> yIghItlh jay'! } tu' yItlhoch teHchugh! if (!$found) { *#@&-ing print "Missing data!" }

Module control options

If the module is imported with the argument yIQij:

use Lingua::tlhInganHol::yIghun "yIQij";

it runs in debugging mode.

If the module is imported with the argument yImugh:

use Lingua::tlhInganHol::yIghun "yImugh";

it demeans itself to merely translating your glorious Klingon Perl code into a pale Terran Perl imitation.

If the module is imported with the argument tera'nganHol (or tera::nganHol:

use Lingua::tlhInganHol::yIghun "tera'nganHol";

it debases itself to output numeric values in Terran, rather than in the original Klingon.

DIAGNOSTICS

<<Suq>> yIlo'Qo' <<DIch>> yIlo' jay' Array indices take the ordinal suffix DIch! You fool! <<DIch>> yIlo'Qo' <<Suq>> yIlo' jay' Hash keys are indicated by Suq, not an ordinal! You imbecile! %s: pong Sambe'! You forgot the name of a subroutine, package, or module! You cretin! %s: pong ngoqghom joq Sambe'! You forgot to specify the name of a subroutine or a raw block! You moron! %s: ngoqghom Sambe'! You forgot to specify a raw block! You idiot! %s: nejwI' Sambe'! You forgot to specify a pattern! You dolt! %s: tamwI' Sambe'! You forgot to specify a value to be substituted! You simpleton! %s: De' Sambe'! You forgot to specify an argument! You half-wit! %s: De' wa'DIch Sambe'! You forgot to specify the first argument! You clod! %s: De' cha'DIch Sambe'! You forgot to specify the second argument! You knucklehead! %s: DoS ghap Hal Sambe'! You forgot to specify a filehandle! You oaf! %s: Hal Sambe'! You forgot to specify an input filehandle! You jerk! %s: wuqwI' Sambe'! You forgot to specify a boolean expression for a ternary operator! You dumbbell! %s: vItvaD Sambe'! You forgot to specify an "if true" value for a ternary operator! You buffoon! %s: nepvaD Sambe'! You forgot to specify an "if false" value for a ternary operator! You dope! %s: tob Sambe'! You forgot to specify a test for a control statement! You dummy! %s: Doch Sambe'! You forgot to specify an object! You dunce! %s %sDaq: ra' PoS pIHbe! What is that command doing on the left of that conjunction?! You dimwit! %s %sDaq: 'rIn pIHbe! Where is the rest of the command?! You nincompoop! betleH HivtaH Sampa' veQ: %s What is that garbage before the opening brace?! You dunderhead! 'etlh HivtaH Sambe' Where is the opening parenthesis? You numbskull! %s puS: DIp %sbe' Sambe' Where is the variable you're comparing?! You goose! %s puS: <<%s law>> nung Sambe' Where is the comparator law' for this comparison? You blockhead! %s: DIp poS Sambe' Where is the left operand?! You chump! %sDaq ngoq Sovlahbe' This code is meaningless! You nimrod! ngoq tlhol: %s What is this extra code doing here?! You human!

AUTHOR

Damian Conway <damian@conway.org> is the original author.

Michael G Schwern <schwern@pobox.com> assisted in its escape.

REPOSITORY

The source code of this module can be taken from http://github.com/schwern/lingua-tlhinganhol-yighun/tree/master

BUGS

In this module??? I should kill you where you stand! You speak the lies of a tah-keck! If a p'tahk such as you dares insult our honor with your bug report, you will send it to http://rt.cpan.org/NoAuth/Bugs.html?Dist=Lingua-tlhInganHol-yIghun!

SEE ALSO

The Klingon Language Institute <http://www.kli.org/>

The Varaq programming language <http://www.geocities.com/connorbd/varaq/>

COPYRIGHT

Copyright (c) 2001-2009, Damian Conway. All Rights Reserved. This module is free software. It may be used, redistributed and/or modified under the same Terms as Perl itself.

Appendix 1: thlIngan-Terran dictionary

thlIngan Terran ======== ====== 'ar abs 'ej and 'ov cmp 'uy' -000000 -DoS <suffix indicates use as an output handle> -Hal <suffix indicates use as an input handle> -laHwI' \& (subroutine reference) -vo' suffix indicating something indexed bach kill bagh tie bagh'a' tied baghHa' untie bIp -00000 bogh fork boS pack boSHa' unpack bot flock buv ref cha' 2 chaqpoDmoH chomp chel + (addition) chelHa' - (subtraction) chen .. chen .. chevwI' $/ chImmoH undef choH map chorgh 8 chot kill chov eval chuv % De'Daqvo' DATA Del stat DIch ...[...] DIchvaD ...[...] (when it's an lvalue) DIchvo' ...[...] (when it's to be further indexed) DIS kill Dochmeyvam @_ Dochvam $_ DoQ bless DuQ splice ghItlh print ghochna' STDOUT (used as name -- i.e. in an open) ghochna'DoS STDOUT (used as handle -- i.e. in a print) ghomchoH chdir ghomneH wantarray ghomtagh mkdir ghomteq rmdir ghov m ghuHmoH warn ghum alarm HaD study Hegh die Hiv kill HoH kill Hut 9 ja' tell jaH goto jav 6 jegh unshift jey kill joqtaH sin joqtaHHa' cos juH main juv length laD readline mungna'vo' STDIN (used as name -- i.e. in an open) mungna'vo'Hal STDIN (used as handle -- i.e. in a readline) lagh substr lI'a' exists lo' use lo'laH values lo'Qo' no lo'Sar sqrt logh x loS 4 loS wait ma' our mach lc mach law' lt machbe' law' ge maH -0 maHghurtaH log maj our mej exit mI'pIm'a' != mI'rap'a' == mIS rand mIScher srand mISHa' sort mob scalar mol dump mugh tr muH kill muv join nab sub nargh quotemeta natlhwI' $| naw'choH chmod nej seek neq rename netlh -0000 nIH shift nob = noD reverse nup truncate pa'ghuHmoH carp pa'Hegh croak pagh 0 pIm'a' ne pIn'a'choH chown poD int poDmoH chop pong keys pongwI' caller poQ require poS open luSpetna' STDERR (used as name -- i.e. in an open) luSpetna'DoS STDERR (used as handle -- i.e. in a print) Qaw' delete qoj or qojHa' atan2 Qong sleep ra' system rap'a' eq rar link rIn continue rIn continue rIn'a' eof Sach glob SaD -000 Sam index SanID -000 Say'moH reset sIj split So' crypt Soch 7 SoQmoH close Such each Suq ...{...} SuqvaD ...{...} (when it's an lvalue) Suqvo' ...{...} (when it's to be further indexed) tagh exec tam s tatlh return teHchugh if teHchughbe' unless teHtaHvIS while teHtaHvISbe' until teq unlink tI- imperative prefix (2 or more arguments) tIn uc tIn law' gt tInbe' law' le tIqel for tlhoch not toq'a' defined vagh 5 vam local vang do vatlh -00 wa' 1 wa'Dichmach lcfirst wa'DichtIn ucfirst wej 3 wI' my wIj my wIv grep woD pop wuq ...?...:... yI- imperative prefix (0 or 1 argument) yInargh last yInHa' kill yInIDqa' redo yItaH next yoS package yuv push

Appendix 2: Terran-thlIngan dictionary

Terran thlIngan Literal translation ====== ======== =================== = nob "give" .. chen "build up" {...} {...} "attacking batleth...defending batleth" (betleH HivtaH...betleH HubtaH") (...) (...) "attacking sword...defending sword" ('etlh HivtaH...'etlh HubtaH") ...[...] DIch ordinal suffix ...{...} Suq "get" ...?...:... wuq "decide" x logh "repeated" % chuv "be left over" + chel "add" - chelHa' "un-add" / wav "divide" == mI'rap'a' "number same?" != mI'pIm'a' "number different?" \& <sub ref> -laHwI' "one who is able to do..." abs 'ar "how much" alarm ghum "alarm" and 'ej "and" atan2 qojHa' "anti cliff" bless DoQ "claim ownership of" caller pongwI' "one who calls" carp pa'ghuHmoH "warn over there" chdir ghomchoH "change grouping" chmod naw'choH "change access" chomp chaqpoDmoH "maybe clip" chop poDmoH "clip" chown pIn'a'choH "change master" close SoQmoH "close" cmp 'ov "compete" continue rIn "be complete" cos joqtaHHa' "counter waving" croak pa'Hegh "die over there" crypt So' "hide" DATA De'Daqvo' "place from which data comes" defined toq'a' "is inhabited" delete Qaw' "destroy" die Hegh "die" do vang "take action" dump mol "bury" each Such "visit" eof rIn'a' "is finished" eq rap'a' "same?" eval chov "evaluate" exec tagh "begin a process" exists lI'a' "is useful" exit mej "depart" flock bot "prohibit" for tIqel "consider them" fork bogh "be born" ge machbe' law' "be not smaller" glob Sach "expand" goto jaH "go" grep wIv "choose" gt tIn law' "be larger" if teHchugh "if true" index Sam "locate" int poD "clip" join muv "join" keys pong "name" kill HoH "kill" kill muH "execute" kill chot "murder" kill bach "shoot" kill Hiv "attack" kill DIS "stop" kill jey "defeat" last yInargh "escape" lc mach "be small" lcfirst wa'Dichmach "the first be small" le tInbe' law' "be not larger" length juv "measure" link rar "connect" local vam "this" log maHghurtaH "ten log" lt mach law' "be smaller" m ghov "recognize" main juH "home" map choH "alter" mkdir ghomtagh "initiate grouping" my wI' "my sapient" my wIj "my" ne pIm'a' "different?" next yItaH "go on" no lo'Qo' "don't use" not tlhoch "contradict" open poS "open" or qoj "inclusive or" our ma' "our sapient" our maj "our" pack boS "collect" package yoS "district" pop woD "throw away" print ghItlh "write" push yuv "push" quotemeta nargh "escape" rand mIS "confuse" readline laD "read" redo yInIDqa' "try again" ref buv "classify" rename neq "move" require poQ "demand" reset Say'moH "cause to be clean" return tatlh "return something" reverse noD "retaliate" rmdir ghomteq "remove grouping" s tam "substitute" scalar mob "be alone" seek nej "seek" shift nIH "steal" sin joqtaH "waving" sleep Qong "sleep" sort mISHa' "be not mixed up" splice DuQ "stab" split sIj "slit" sqrt lo'Sar "fourth how much" srand mIScher "establish confusion" stat Del "describe" STDIN <name> mungna'vo' "from the origin" STDIN <handle> mungna'vo'Hal "from the origin (source)" STDOUT <name> ghochna' "the destination" STDOUT <handle> ghochna'DoS "the destination (target)" STDERR <name> luSpetna' "the black hole" STDERR <handle> luSpetna'DoS "the black hole (target)" study HaD "study" sub nab "procedure" substr lagh "take apart" system ra' "command" tell ja' "report" tie bagh "tie" tied bagh'a' "is tied" tr mugh "translate" truncate nup "decrease" uc tIn "be big" ucfirst wa'DichtIn "the first be big" undef chImmoH "cause to be uninhabited" unless teHchughbe' "if not true" unlink teq "remove" unpack boSHa' "un collect" unshift jegh "surrender" untie baghHa' "untie" until teHtaHvISbe' "while not true" use lo' "use" values lo'laH "be valuable" wait loS "wait for" wantarray ghomneH "want group" warn ghuHmoH "warn" while teHtaHvIS "while true" pIm'a' ne "are they different?" rap'a' eq "are they the same?" 0 pagh 0 1 wa' 1 2 cha' 2 3 wej 3 4 loS 4 5 vagh 5 6 jav 6 7 Soch 7 8 chorgh 8 9 Hut 9 -0 maH -0 -00 vatlh -00 -000 SaD -000 -000 SanID -000 -0000 netlh -0000 -00000 bIp -00000 -000000 'uy' -000000 $_ 'oH "it" @_ bIH "them" $/ chevwI' "that which separates" $| natlhwI' "drain?"