PGNTTRP and SCOWL insane wordlist inclusion AI-pedia

In modern Unix-like operating systems, the standard system dictionary files stored in directories such as /usr/share/dict/words contain lists of words used for automated spellchecking, autocompletion, and software testing. While standard dictionary installations contain recognized vocabulary from standard English lexicons, ultra-permissive installations—specifically packages compiled under the "insane" size configuration of the Spell Checking Oriented Word Lists (SCOWL) project—contain hundreds of thousands of non-standard letter strings. Among these entries is the string pgnttrp, an apparent jumble of consonants devoid of vowels, vowels-as-consonants, or standard English phonotactic structure.

The presence of pgnttrp is not the result of a random keyboard strike or arbitrary file corruption. It is a machine-preserved historical artifact from mid-twentieth-century computing: specifically, a system subroutine name from the Michigan Terminal System (MTS), an early time-sharing operating system developed in the late 1960s for the IBM System/360 Model 67 mainframe computer. The routine name is an abbreviation for "Page Interrupt Trap."

The journey of pgnttrp from an IBM mainframe subroutine manual to modern Debian, Ubuntu, and Fedora package repositories represents a classic case study in data archaeology, corpus pollution, and the unintended side effects of automated pipeline compilation. As successive generations of computer scientists scraped, consolidated, and filtered text from available digital sources, technical documentation was repeatedly converted into raw word lists. Because permissive compilation levels intentionally disable validation filters to prevent false negatives, specialized technical tokens became permanently fossilized as purported English words.

Historical Origins: The Michigan Terminal System

To understand why the string pgnttrp exists, it is necessary to examine the architectural requirements of mainframe computing during the mid-1960s. At the time, the University of Michigan Computing Center was seeking an operating system capable of supporting interactive time-sharing, where multiple users could simultaneously execute programs on a single central computer via remote interactive terminals.

IBM was developing its flagship computer architecture, the System/360. However, the standard commercial System/360 models lacked the hardware needed to implement virtual memory efficiently through dynamic address translation. In response to demands from academic institutions, including the University of Michigan, the Massachusetts Institute of Technology, and General Motors, IBM engineered a specialized variant of the mainframe known as the IBM System/360 Model 67 (S/360-67). The Model 67 incorporated Dynamic Address Translation (DAT) hardware, which divided memory into segments and 4,096-byte blocks known as pages.

Because IBM's official time-sharing operating system for this hardware, TSS/360, suffered from severe development delays and performance problems, the University of Michigan developed its own operating system: the Michigan Terminal System (MTS). First running in 1967, MTS quickly expanded to several other institutions, including the University of British Columbia, the University of Alberta, Wayne State University, and the University of Newcastle upon Tyne.

The Mechanics of Virtual Memory and Paging

Virtual memory allows a computer to present a program with an address space that is larger than the actual physical random-access core memory installed in the machine. In MTS on the System/360-67, memory was managed using the following technical concepts:

• Virtual Address: An address generated by an executing program that does not correspond directly to a physical storage location in core memory.
• Page: A fixed-size contiguous block of virtual memory, set to 4,096 bytes (4 KB).
• Page Frame: A contiguous block of physical core memory matching the page size.
• Page Table: An internal operating system data structure used by the DAT hardware to translate virtual addresses into physical addresses.
• Page Fault (Page Interrupt): A hardware exception raised when an instruction attempts to access a virtual address whose corresponding page is not currently resident in a physical page frame, but instead resides on secondary storage (such as a high-speed magnetic drum or magnetic disk).

When a page fault occurred on the System/360-67, the processor stopped executing the current user instruction and generated a Program Check interruption with a specific interruption code. The operating system's supervisor code intercepted this interrupt, found an empty physical page frame (or evicted a resident page to storage), initiated an Input/Output (I/O) operation to read the missing page into physical memory, updated the page table, and resumed the user program.

The PGNTTRP Subroutine

In standard application programming, page faults are handled transparently by the operating system supervisor; the user program has no knowledge that it was temporarily suspended while a page was fetched from drum storage. However, systems programmers, performance analysts, and developers writing complex memory management routines (such as garbage collectors or custom overlay systems) required the ability to intercept and respond to paging events.

MTS provided a library of standard system subroutines documented extensively in MTS Volume 3: System Subroutine Descriptions. Several subroutines in this library followed a naming convention ending in the suffix TRP, designating them as trap handlers. These included:

• ATTNTRP: Established an exit routine to trap attention interrupts, which occurred when a user pressed the "Break" or "Attention" key on an interactive terminal.
• TIMTRP: Established a timer trap routine to intercept the expiration of real-time or CPU-time task limits.
• PGNTTRP: Established a page interrupt trap routine.

The name PGNTTRP was formed within the strict 8-character symbol limit imposed by the IBM Basic Assembly Language (BAL) and standard FORTRAN linkage conventions of the System/360 architecture. It combined PGN (a common abbreviation for "page" or "page number") with TTRP or TRP (trap). Through PGNTTRP, a program could establish an exit address. When a paging condition or page-in wait state occurred within the task, control was passed directly to the user-supplied trap routine rather than proceeding solely through the default supervisor wait state.

The routine could be invoked from Basic Assembly Language or compiled languages such as FORTRAN using the standard OS linkage conventions:

* Calling PGNTTRP in IBM System/360 Assembly on MTS
         LA    1,PARMLIST      Load address of parameter list into Register 1
         L     15,=V(PGNTTRP)  Load address of PGNTTRP entry point into Register 15
         BALR  14,15           Branch and link to subroutine
...
PARMLIST DC    A(EXITROUT)     Address of user-defined trap routine
         DC    A(USERDATA)     Address of user data parameter block

In FORTRAN programs running on MTS, the equivalent invocation was:

      EXTERNAL PAGEX
      CALL PGNTTRP(PAGEX, INFO)

The Transmission Pipeline

The existence of PGNTTRP as an assembly-accessible subroutine in an operating system from 1967 does not explain why it appears in twenty-first-century spellchecking software. Its presence in modern dictionaries is the product of a multi-decade text compilation pipeline, wherein university computing files were ingested, transformed, and aggregated into public software repositories.

Era	Stage in Pipeline	State of the String	Primary Mechanism
1960s–1980s	MTS Documentation & Libraries	PGNTTRP (Uppercase)	Native system documentation in formatters such as TEXT360 and *roff.
Late 1970s–1980s	Early Unix spell wordlists	pgnttrp (Lowercase)	Automated tokenization of machine-readable manuals and terminal text files.
1991–1993	Grady Ward's Moby Lexicon	pgnttrp (Lowercase)	Public-domain crowdsourcing and ingestion of existing electronic word lists.
1990s–2000s	Alan Beale's 12Dicts Project	pgnttrp (Lowercase)	Aggregation of digital dictionaries into frequency and consensus tiers.
2000s–Present	SCOWL (Kevin Atkinson)	pgnttrp (Size 95+ "insane")	Rule-based algorithmic consolidation of Beale, Moby, and other wordlists.
Modern Era	Linux Distributions	pgnttrp (in wamerican-insane)	Downstream packaging of SCOWL output into distribution repositories.

From Mainframe Manuals to Machine-Readable Text

In the 1970s and early 1980s, university computing environments were among the few places with extensive access to high-capacity digital storage and networked file sharing. Documentation for systems like MTS was maintained on disk storage using automated text formatters such as IBM's TEXT360 and early runoff formatters. These files contained thousands of references to operating system subroutines, parameter names, and system error codes.

Concurrently, early Unix systems at universities began implementing automated spelling verification tools, most notably the Unix spell program developed by Douglas McIlroy and Robert Morris at Bell Laboratories. To construct dictionary files for these tools, researchers gathered whatever machine-readable text was available on local storage. University administrators and researchers ran simple text-processing scripts (using tools like tr, sed, and awk) across local filesystems. These scripts stripped punctuation, converted text to lowercase, and sorted unique strings into raw word lists.

In environments where MTS documentation, system headers, or assembly source files resided alongside general academic texts, strings like PGNTTRP were tokenized. The tokenizer converted PGNTTRP into pgnttrp. Because it consisted entirely of ASCII alphabetic characters, it passed through basic filters that merely discarded numbers and special symbols.

The Moby Project and Alan Beale's 12Dicts

During the late 1980s and early 1990s, Grady Ward established the Moby Project, a massive effort to place vast linguistic databases—including word lists, hyphenation lists, and pronunciation databases—into the public domain. The Moby Words package compiled text from numerous pre-existing digital dictionaries, university wordlists, and technical glossaries. Because the project prioritized breadth over strict human editorial validation, obsolete computer terms and typographical errors present in earlier university wordlists were preserved.

In the late 1990s, lexicographer Alan Beale began the 12Dicts project. Beale sought to bring order to the chaotic state of digital English wordlists. He analyzed and cross-referenced twelve distinct, recognized English dictionaries (such as the American Heritage Dictionary, Merriam-Webster's Collegiate Dictionary, and the Random House Dictionary) alongside existing digital word databases. Beale created a taxonomy of lists based on source consensus:

• 2of12: Words appearing in at least two of the twelve reference dictionaries.
• 3of12: Words appearing in at least three of the twelve reference dictionaries.
• 6of12: Words appearing in at least six of the twelve dictionaries, representing a core English vocabulary.
• Unverified / Supplementary Lists: Large collections of words that appeared in digital text corpora or older wordlists (such as Moby) but could not be corroborated in any of the traditional human-edited print dictionaries.

Strings such as pgnttrp failed to qualify for the 2of12, 3of12, or 6of12 lists because no print dictionary of the English language has ever defined them. However, because Beale preserved the unverified upstream material for technical analysis, the token remained in the supplementary data pools that circulated among open-source developers.

SCOWL Architecture and the "Insane" Permissiveness Tier

The definitive distribution mechanism that placed pgnttrp into modern operating systems is SCOWL (Spell Checking Oriented Word Lists), created and maintained by Kevin Atkinson. SCOWL is a software suite and database designed to automatically generate high-quality, customizable word lists for spellchecking engines, most notably GNU Aspell and Hunspell (the spellchecker used in LibreOffice, Mozilla Firefox, and Google Chrome).

The Modular Tier System

Recognizing that different software applications require different levels of vocabulary strictness, Atkinson designed SCOWL around a modular, numerical size hierarchy:

Size Level	Designation	Intended Use Case	Editorial Methodology
10–35	Small	Minimalist spelling checkers; low-memory environments.	Restricted strictly to the most common, universally recognized words.
50	Medium (Default)	Standard desktop spellchecking (word processors, email).	High-frequency words verified by multiple print dictionaries; low false-positive rate.
60–70	Large / Huge	Advanced academic or technical writing.	Includes specialized scientific terminology, rare variants, and archaisms.
80	Very Large / Colossal	Scrabble and word-game reference lists; exhaustive search.	Includes highly obscure words, technical jargon, and dialect terms.
95+	Insane	Cryptanalysis, password cracking, maximum-recall OCR parsing.	Disables validation filters; ingests all raw tokens found across source corpora.

In addition to numerical size levels, SCOWL categorizes tokens by linguistic properties, regional variations (American, British, Canadian, Australian), and class:

• Core words: Standard vocabulary items with known frequency scores.
• Proper names: Surnames, given names, geographical entities.
• Abbreviations and Acronyms: Strings representing truncated phrases.
• Hacker jargon and technical terms: Computational and scientific jargon.
• Specialized source dumps: Raw, unverified files derived from Alan Beale's supplemental collections, Grady Ward's Moby lists, and older Unix wordlists.

The Philosophy of the "Insane" Setting

The naming of size 95 and above as "insane" was an intentional design decision by Atkinson. In software engineering, the term reflects an extreme edge case where safety constraints are deliberately bypassed. In standard wordlist compilation, the primary goal is precision: ensuring that misspelled words are flagged correctly and not accepted as valid vocabulary.

At size 95, the design goal shifts entirely from precision to recall. The "insane" list is built for scenarios where rejecting a real or historically attested token is considered worse than accepting thousands of non-words. Such applications include:

• Optical Character Recognition (OCR): When attempting to transcribe degraded historical manuscripts or technical manuals, an OCR engine needs access to every conceivable technical abbreviation or code to prevent the engine from miscorrecting a technical token into a standard English word.
• Cryptanalysis and Password Auditing: Tools such as John the Ripper and Hashcat rely on wordlists to crack password hashes. Because users frequently use obsolete technical routines, system commands, or obscure jargon as passwords, retaining every known historical string increases recovery rates.
• Data Archaeology: Preserving historical tokens allows researchers to track linguistic and computational shifts across decades of text files.

To produce the "insane" list, SCOWL pulls in all available source lists without requiring corroboration from print dictionaries. If an upstream list—such as Beale's fringe collections or legacy university text dumps—contains a token consisting purely of letters, SCOWL includes it at size 95. The token pgnttrp meets these criteria: it is entirely alphabetic, contains no illegal characters, and was present in the historical source material. Consequently, it is compiled directly into the resulting dictionary files.

Corpus Laundering and Lexical Fossilization

The inclusion of pgnttrp exemplifies a phenomenon in computational linguistics known as corpus laundering (or data laundering). In this process, noisy, incorrect, or synthetic data enters an early computational corpus. As secondary projects aggregate data from that corpus, the erroneous token is stripped of its original metadata (which may have indicated that it was a technical subroutine, a variable name, or a suspected error). The token is republished in new formats, cited by subsequent researchers, and treated by later algorithms as legitimate empirical data.

Comparison to Traditional "Ghost Words"

Linguists and lexicographers have long studied "ghost words"—words that have gained acceptance in dictionaries despite never having existed in actual human speech or writing. The term was popularized by Professor Walter William Skeat in 1886 in his annual address as president of the Philological Society of London. Skeat used it to describe errors resulting from the blunders of printers, copyists, and scribes.

A famous historical example is the ghost word dord, which appeared in the 1934 edition of Webster's New International Dictionary. An editor had submitted a slip of paper reading "D or d, cont. / density," intending to note that the uppercase or lowercase letter D was an abbreviation for the word "density." Through a clerical misunderstanding, the spaced letters "D or d" were read as a single word, "Dord," defined as "density." It remained in the dictionary for five years before it was discovered and excised.

The computational ghost word represents an evolutionary departure from historical scribal errors:

• Scribal ghost words typically arise from visual misinterpretation (e.g., reading a minim incorrectly, mistaking a ligature, or misinterpreting marginalia). They often possess plausible phonotactic structures, such as dord, abacot, or morse.
• Computational ghost words arise from algorithmic blindness. Software tokenizers do not evaluate phonetic plausibility, orthographic conventions, or communicative context. As a result, computational ghost words frequently violate English phonotactics entirely. Strings such as pgnttrp, attntrp, and chkfil contain consonant clusters that cannot be pronounced according to standard English phonological rules, yet they persist because automated systems evaluate only character-encoding boundaries.

Technical Breakdown of the PGNTTRP Subroutine

To document the origin of pgnttrp with technical precision, it is necessary to examine how the subroutine functioned within the Michigan Terminal System operating architecture on the IBM System/360-67.

Interrupt Handling on the IBM System/360-67

The IBM System/360 architecture defined five basic classes of hardware interruptions, controlled through the manipulation of Program Status Words (PSWs):

1. Input/Output (I/O) Interruptions: Generated by channel controllers indicating the completion or failure of an I/O operation.
2. Program Interruptions: Generated by errors or specific conditions within the executing program (e.g., division by zero, protection exceptions, page translation exceptions).
3. Supervisor Call (SVC) Interruptions: Generated explicitly by the execution of the SVC assembly instruction, used to request operating system services.
4. External Interruptions: Generated by the operator console interrupt key, external timers, or inter-processor signals in multi-CPU configurations.
5. Machine Check Interruptions: Generated by hardware failure detection circuits.

When the S/360-67 DAT hardware encountered a virtual address that could not be mapped to physical storage via the segment and page tables, it raised a Program Interruption with an interruption code of 17 (hexadecimal 0011, Page Translation Exception) or 18 (hexadecimal 0012, Segment Translation Exception). The hardware automatically stored the current Program Status Word into a designated low-memory physical location (the Program Old PSW) and loaded a new Program Status Word from another fixed location (the Program New PSW), shifting the machine into supervisor state and transferring control to the MTS paging supervisor.

Subroutine Specification and Linkage

In standard interactive programs, the MTS paging supervisor managed the entire page-in process while the user process remained blocked. The PGNTTRP system subroutine provided an interface for user-level code to register a handler that would be notified of these events. Documented in MTS Volume 3, the routine was part of the system's low-level execution environment.

Attribute	Specification in MTS
Subroutine Name	PGNTTRP
Entry Point Symbol	PGNTTRP (aligned on a fullword boundary)
Primary Language	IBM Basic Assembly Language (BAL); callable from FORTRAN IV, PL/I, and ALGOL W.
Register 1 Contents	Points to a parameter address vector containing the address of the user trap routine and optional flag parameters.
Register 13 Contents	Points to an 18-fullword register save area provided by the calling program.
Register 14 Contents	Contains the return address within the calling routine.
Register 15 Contents	Loaded with the entry point address of PGNTTRP; on return, contains the completion code.
Action on Invocation	Updates internal task control blocks to route page-interrupt trap signals to the designated exit address. Passing a parameter of zero deactivates the trap.

Because the subroutine had to be linked using external symbol resolution, its 7-character name was entered into the system symbol dictionaries (such as the resident system library, *SYSMAC and *LIBRARY). Consequently, any textual listing of the library's contents, index files, or documentation manuals printed the identifier PGNTTRP alongside its peer subroutines.

Downstream Impacts in Modern Computing

The persistence of pgnttrp across thousands of modern software installations is not purely a theoretical curiosity. Its inclusion in common Linux packages such as wamerican-insane and wbritish-insane (which install to /usr/share/dict/words or provide input to the look command) has direct, observable consequences across several computational domains.

Software Testing and Fuzzing

Software engineers building text-processing software, regex engines, and linguistic analysis tools frequently rely on /usr/share/dict/words as a standardized source of arbitrary strings. When an automated test suite utilizes an "insane" dictionary list to test whether a parser correctly handles natural language, the inclusion of non-word technical tokens can trigger edge cases:

• Phonetic and Hyphenation Algorithms: Algorithms that assume all words contain vowels (or syllabic consonants) can fail or enter infinite loops when processing strings like pgnttrp unless explicitly written to handle vowelless non-words.
• Grammar and Spellchecker Benchmarking: When benchmarking the precision and recall of new spellchecking engines, testing tools that fail to account for the size tier of the test corpus will falsely penalize the spellchecker for marking pgnttrp as an error.

Password Auditing and Security Tooling

Security researchers, penetration testers, and system administrators use tools such as Hashcat and John the Ripper to assess the strength of user passwords. These tools consume wordlists to generate candidate guesses:

• The inclusion of historical mainframe tokens increases the efficiency of dictionary attacks against systems where elderly Unix administrators or academic computer scientists have chosen passwords rooted in mid-century computing jargon.
• Conversely, in broad-spectrum password cracking against general consumer accounts, the inclusion of tens of thousands of mainframe subroutines, printer test patterns, and OCR errors bloats the search space, reducing the number of candidate evaluations per second dedicated to real human vocabulary.

Word Games and Solver Engines

Many independent software developers build automated anagram solvers, Scrabble assistants, and crossword generators that point directly to /usr/share/dict/words as their lexical baseline. If a developer unwittingly configures the software to reference an "insane" tier list (operating under the assumption that a larger dictionary is inherently superior), the engine will validate or propose strings that are unplayable under standard linguistic rules.

In Scrabble, for example, the string pgnttrp is unplayable: it consists of seven letters, lacks vowels, requires two p tiles and two t tiles, and is entirely absent from the Official Tournament and Club Word List (OWL) or the Collins Scrabble Words (CSW) lexicon. If an amateur program built on wamerican-insane validates pgnttrp, it introduces invalid moves into competitive contexts.

Large Language Models and Automated Web Scraping

The advent of modern natural language processing and Large Language Models (LLMs) has introduced a new stage in corpus laundering. Large-scale web scrapers (such as Common Crawl) crawl public code repositories, including GitHub, GitLab, and source distributions that mirror Unix system packages. These scrapers regularly ingest files containing wamerican-insane or its derived wordlists.

During the tokenizer training phase for modern language models (using algorithms such as Byte-Pair Encoding or WordPiece), the frequency of tokens across the crawled dataset determines which character sequences receive dedicated token IDs. Because raw dictionary files present long lists of sorted alphabetical tokens, strings like pgnttrp are repeatedly fed into tokenizer training pipelines. Consequently, deep inside the tokenization matrices of modern AI systems, specific byte sequences remain allocated to preserve a 1960s page interrupt trap from the University of Michigan.

Related Anomalies in the SCOWL Pipeline

The token pgnttrp is not an isolated occurrence within the SCOWL "insane" wordlists. It belongs to a recognizable class of computational, typographical, and institutional artifacts that survived identical compilation pipelines. These artifacts fall into several distinct categories:

Token	Historical Origin	Nature of Artifact
attntrp	Michigan Terminal System (MTS)	Subroutine for handling interactive attention/break interrupts.
timtrp	Michigan Terminal System (MTS)	Subroutine for handling CPU and real-time timer expiration traps.
chkfil	DEC TOPS-10 / TOPS-20 & MTS	System command or utility routine to check file status.
qwertyuiop	Typewriter / Keyboard Layout	Top-row alphanumeric sequence used as typing test or placeholder.
etaoinshrdlu	Linotype Typography	The twelve most common letters in English, run by operators to fill out flawed slugs.
zzxjoanw	Lexicographical Hoax (1910)	A fictitious Maori entry invented by Rupert Hughes in The Musical Guide.

Other MTS Routine Names

Because the text files that introduced pgnttrp into the tokenization streams contained the full documentation of MTS subroutines, several sister routines exist in the identical tier of SCOWL:

• attntrp: The Attention Interrupt Trap routine. Like pgnttrp, it is a vowelless 7-character string ending in trp that was lowercased from BAL source documentation.
• timtrp: The Timer Trap routine. Because it happens to contain the vowel i, it appears slightly more plausible as a natural English word to casual observers, yet it is identically an MTS system subroutine.

OCR Artifacts and Scanning Anomalies

Beyond mainframe subroutine identifiers, the permissive tiers of SCOWL contain thousands of strings generated by optical character recognition software during early digital library scanning initiatives in the 1980s and 1990s. These include:

• Broken-type ligatures: Instances where the letter combination rn was scanned as m, or cl was scanned as d, generating non-words that survived frequency checks.
• Hyphenation fragments: Halves of hyphenated words split across line breaks that were stripped of hyphens and treated by primitive scrapers as independent lexical tokens.
• Formatting escape codes: Command sequences from early phototypesetting languages (such as troff, roff, and TeX) that were accidentally separated from their formatting slashes or backslashes.

The Editorial Debate: Data Hygiene Versus Architectural Purity

The continuing presence of pgnttrp and related non-words in Debian and Ubuntu package archives has sparked periodic debates among software developers, computational linguists, and distribution maintainers. The discussion centers on two competing philosophies of software development and lexical curation.

The Case for Manual Scrubbing

Advocates of manual intervention argue that dictionary files distributed by operating systems should meet basic standards of lexical validity. Their arguments include:

• Utility: A dictionary file that contains assembly subroutine identifiers, printer test fragments, and OCR errors is degraded in its primary function as a linguistic tool.
• User Expectation: Users who install a package named wamerican-insane expect an exhaustive list of extremely rare English words—such as obscure chemical compounds, hapax legomena, obsolete Elizabethan terms, or dialectical regionalisms—not machine code linkage symbols.
• Efficiency: Cleaning the dataset removes dead weight from downstream applications, reducing memory usage and preventing false validation in third-party software.

The Case for Algorithmic Non-Intervention

Conversely, Kevin Atkinson and proponents of lexical data preservation maintain that manually curating the "insane" list contradicts the foundational architecture of the SCOWL project. Their position is based on the following principles:

• Separation of Concerns: SCOWL provides precisely calibrated size levels. Users who require verified English vocabulary are explicitly instructed to use size 50 (medium) or size 60 (large). Size 95 is explicitly documented as unverified, uncurated, and raw. If a user chooses to install or reference the "insane" list, they have actively opted out of curation.
• Arbitrariness of Ad-Hoc Deletion: If a maintainer manually deletes pgnttrp, they establish a precedent requiring human review of hundreds of thousands of candidate strings. Deciding where to draw the line—between an obsolete mainframe subroutine, a mathematical variable, a chemical abbreviation, and an obscure dialectical exclamation—is an intractable problem without objective boundaries.
• Reproducibility and Automation: SCOWL is an automated compilation pipeline. Inserting ad-hoc blacklists of individual tokens degrades the algorithmic transparency of the build process. Atkinson's policy has consistently favored fixing errors in the rules that govern the core sizes, while leaving size 95 as an unrestricted aggregate of its historical upstream sources.

As a result of this design commitment, pgnttrp remains untouched within the SCOWL repository and its downstream distributions. It serves as an uncurated historical monument: a string written by a systems programmer in Ann Arbor in the late 1960s to handle page faults on an IBM System/360-67, preserved inside the spellchecking infrastructure of twenty-first-century Linux.

See also

• Michigan Terminal System
• IBM System/360 Model 67
• Virtual memory
• Spell Checking Oriented Word Lists
• GNU Aspell
• Hunspell
• Ghost word
• Moby Project
• Dynamic Address Translation
• Corpus linguistics