A GUI interface for OpenAI API A Simple, Fast Dominance Algorithm A quick introduction to regular expressions ANSI C streams ASCII ASCII encoding AVL trees Abstract stack checker values Accessing C global variables Accessing sequence elements Accessing the environment via the assoc protocol Action gestures Adding and removing sequence elements Additional bitwise arithmetic Additional generalizations Additional vocabulary roots file Address specifiers Adler-32 checksum Adobe Brackets support Affine Transformations of 2d Vectors Algebraic data types Alias analysis for stack operations, array elements and tuple slots Aliases that resemble DOT code Alien addresses Alien destructors Alien endian-aware types Alien expiry Alien object literal syntax All tips of the day Allocating registers for live intervals Allocation for alien node parameters Amazon S3 An example of XML processing An example of a custom Chloe component An introduction to encodings Appending sequences Application cookbook Application deployment Apply combinators Arithmetic Arithmetic functions Array syntax Arrays Arrow models Article index Assertions Assign representations to vregs Assigning registers to live intervals Association lists Associative mapping combinators Associative mapping conversions Associative mapping operations Associative mapping protocol Atom and RSS feed syndication Atom feed entry protocol Audio file loader Audio framework Audio generator protocol Audio listener protocol Audio playback engine Audio source protocol Authentication capabilities Authentication provider protocol Authentication providers Authentication realm configuration Authentication realms Automated log analysis BLAS interface matrix operations BLAS interface types BLAS interface vector operations BSD checksum Balloon Bomber Emulator Base16 conversions Base24 conversions Base32 conversions Base36 conversions Base45 conversions Base58 conversions Base62 conversions Base64 conversions Base85 conversions Base91 conversions Basic Linear Algebra Subroutines (BLAS) interface Basic authentication Basic block instructions Basic syntax cookbook Batch error reporting Bech32 conversions Bend Bidirectional assocs Binary Application Record Encoding (BARE) Binary and text streams Binary encoding Binary object serialization Binary search Binary search trees Bit arrays Bit sets Bit vectors Bitwise arithmetic Bitwise operations on floats Block Joining Block elements Bloom filters Boilerplate Chloe tags Boilerplate configuration Boilerplate example Boilerplate support Book layouts Boolean expressions Booleans Bootstrap initialization file Bootstrap primitives Bootstrap support Bootstrapping new images Border gadgets Boxes Boxes as references Branch stack effects Browsing documentation Buffer objects Building user interfaces Built-in classes Button gadgets Byte array syntax Byte arrays Byte arrays and the garbage collector Byte vectors Byte-array streams C library interface C standard library math functions C strings C type specifiers C value boxes C99 complex number types CFG construction utilities CFG node emitter for alien nodes CGI (Common Gateway Interface) CIE 1931 XYZ colors CIE 1931 xyY colors CIE 1976 LAB colors CIE 1976 LUV colors CMYK colors CPU architecture description model CPU x86 assembler CPU x86 compiler backend CPU x86 features CPU x86 registers and memory operands CRC16 checksum CRC32 checksum Calculations over periods of time Calendar Calendar facts Callables Calling C from Factor Calling Factor from C Calling Objective C code Calling arbitrary assembly code Calling less-specific methods Calling the optimizing compiler Canned HTTP responses Cartesian product operations Case mapping Changer syntax Changing variable values Channels Character and string syntax Character encodings and the HTTP client Character escape codes Character styles Checksumming with External Utilities Checksumming with Multiple Algorithms Checksums Chloe link and form tags Chloe templates Circular lists Circular sequences Class index Class linearization Class operations Class predicate words Classes Cleanup Phase Cleave combinators Client handler quotation Client stream parameters Clipboard protocol Cluster example Co-operative threads Cocoa application utilities Cocoa bridge Cocoa file dialogs Cocoa pasteboard utilities Cocoa view utilities Cocoa window utilities Code annotations Code generation from MR (machine representation) Coercive slot declarations Collation and weak comparison Collections Colon definitions Color protocol Colored circles example Colors Column sequences Combinator Connections Combinator stack effects Combinators Combinators Combinators for lists Combinators for manipulating lazy lists Combobox gadgets Comma-separated-values parsing and writing Command line arguments Command line switches for bootstrap Command line switches for general usage Command line switches for the VM Commands Common code used by several passes for def-use analysis Common error handling pitfalls Common parametric curves. Comparing intervals Comparing sequences Comparison conditions Comparisons GVN Compilation units Compilation units internals Compiler declarations Compiler errors Compiler implementation Compiler specialization hints Complete bipartite graphs Complete graphs Complex component virtual sequences Complex number syntax Complex numbers Complex virtual sequences Component Chloe tags Componentwise logic with SIMD vectors Compositional combinators Compress Factor image file for loading by the VM Compressing data with bzip3 Compression (ZLIB) Compression.bzip3.ffi Computing cumulative sequences Computing histograms Computing stack frame size and layout Concatenative Languages Concise Binary Object Representation (CBOR) Concurrent combinators Conditional combinators Configuring Atom feed actions Configuring the BLAS interface Connection pools Connection-oriented networking Constants Constants Constructing bit fields Constructing lazy lists Constructing regular expressions Constructing strict lists Continuation implementation details Continuations Control Flow Graph IR Control Pictures Control flow cookbook Control flow with sequences Control-flow Chloe tags Controlling the floating-point environment Conventional SSA Form Conventions Conversion of COLLADA assets Conversion of Wavefront OBJ assets Converting between numbers and strings Converting objects to human-readable strings Converting objects to summary strings Copy propagation Core Graphics types CouchDB Authentication Provider Count-down latches Counted loops Counting semaphores Coverage tool Coverage tool dummy test vocabulary Creating Tensors Creating a vocabulary for your first program Creating an editor integration Creating directories Creating instances of structs Creating intervals Crossreferencing word dependencies. Ctags file Ctrl-Break handler Cuckoo Filters Current working directory Curried dataflow combinators Custom database combinators Custom method combination Customizing gadget appearance Cycle graphs DELETE requests with the HTTP client DLL handles Database authentication provider Database library Database types Dataflow combinators Day names in English Dead code elimination Dead code elimination Deep sequence combinators Def/use chain construction Default input and output streams Deferred words and mutual recursion Defining our first word Defining struct classes Defining words Definition Dependency Management Definition cross referencing Definition icons Definition protocol Definition sanity checking Definitions Delay models Delegation Deleting, moving, and copying files Deploy tool caveats Deploy tool implementation Deploy tool usage Deployed resource files Deploying programs Deployment configuration Deployment flags Deprecation tracking Deques Derivative Syntax Derivatives Descriptive errors Destructive sequence operations Destructor tools Deterministic resource disposal Developer tools Developing UI backends Diffie-Hellman parameter file Directed graph utilities Directory hierarchy manipulation Directory listing Directory manipulation Disassembling words Disjoint sets Dispatch on XML tag names Displaying Images Distributed Concurrency Example Distributed message passing Division by zero Document elements Document locations Documents Double-linked lists Dual Numbers Dummy authentication provider Duplex streams Dynamic variables Dynamic variables cookbook EBNF EBNF Action EBNF Foreign Rules EBNF Rule: And EBNF Rule: Any EBNF Rule: Character Class EBNF Rule: Choice EBNF Rule: Group EBNF Rule: Ignore EBNF Rule: Not EBNF Rule: One or more EBNF Rule: Option EBNF Rule: Sequence EBNF Rule: Strings EBNF Rule: Zero or more EBNF Semantic Action EBNF Tokenizers EBNF Variable ELF nm EUC-KR encoding EditPad Pro support Editing slot values in the inspector Editor gadget commands Editor gadgets Editor integration Element types Elevate bugs and caveats Elevated permissions API Embedding API restrictions Embedding Factor into C applications Embedding of real numbers in complex numbers Encoding and decoding strings Encoding descriptors Encoding protocol English natural language transformations Enumeration types Enumerations Environment variables Ephemeral RSA key bits Equality Error index Escape analysis for tuple unboxing Etags file Evaluating strings at run time Evaluating strings with a different vocabulary search path Event-based XML parsing Examples of abbrev usage Examples of compositional combinator usage Examples of custom Chloe tags Examples of fried quotations Examples of lexical variables Examples of reading and writing files Exception handling Expansions of call( and execute( words Expressing conditionals with boolean logic Extending Chloe Extending Chloe with custom components Extending Chloe with custom tags Extending models Extending the prettyprinter Extending your first program Extra combinators Extra matrix operations Extra properties for special words Extra sets words FHTML templates FUEL command listener Factor cookbook Factor documentation Factor embedding API Factor handbook Factor image compression and uncompression Factor philosophy Farkup Farkup syntax tree nodes File drop gestures File system change descriptors File system change monitors File system metadata File types Files tools Final pass cleans up high-level IR Final stage of compilation generates machine code from dataflow IR Financial math Finite state machine example Flags Fletcher's checksum Flex borders Float syntax Floating point comparison operations Floats Fonts Form submission referrer checking Form validation with actions Form validators Formatted TTY Output Formatted output Formatted output on the default stream Formatted printing Formatted stream protocol Fortran ABIs Fortran FFI Fortran types Fowler-Noll-Vo checksum Frame layouts Framebuffer objects Free-form keyboard input Fried quotation philosophy Fried quotations Functionality specific to Windows Functionality specific to macOS Fundamental combinators Furnace Atom syndication support Furnace JSON support Furnace action configuration Furnace action lifecycle Furnace actions Furnace actions implementation Furnace alloy responder Furnace asides Furnace authentication Furnace authentication example Furnace boilerplate support Furnace conversation scope Furnace database support Furnace extension points Furnace framework Furnace page action example Furnace page actions Furnace persistence layer Furnace presentation layer Furnace redirection support Furnace sessions Furnace user administration tool Futures Fuzz Testing Fuzzy completion GB 18030 GC maps GC maps decoder GET requests with the HTTP client GIF Image Loader
GMail Client GNU Database Manager GPU state GPU-accelerated rendering GUI Layout Gadget geometry Gadget hierarchy and layouts Gadget line support Game controller input Game loop delegate Game loops Game worlds Garbage collection check insertion Generalized combinators Generalized sequence words Generalized shuffle words Generalized shuffle words and combinators Generating instructions for accessing the data and retain stacks Generating instructions for fixnum arithmetic Generating instructions for inline memory allocation Generating instructions for slot access Generating random integers Generating random passwords Generators Generic word introspection Generic words and methods Gesture handling differences between platforms Getting and setting editor contents Gilded Rose Glass layers Global stack analysis Global variables Globs Graphics context management Graphviz Graphviz attributes Graphviz data structures Graphviz gallery Graphviz notation Grayscale colors Grid layouts Grid lines Groups and clumps Gtk-based UI backend Guided tour of Factor HEAD requests with the HTTP client HSL colors HSV colors HTML components HTML elements HTML entities HTML form infrastructure HTML form values HTML forms HTML streams HTML template interface HTTP Download Utilities HTTP client HTTP client errors HTTP client post data HTTP cookies HTTP dispatcher examples HTTP dispatchers and virtual hosting HTTP headers HTTP post data HTTP protocol objects HTTP request variables HTTP requests HTTP responder filters HTTP responder redirection HTTP responses HTTP server HTTP server port remapping HTTP server responders HTTP server variables HTTP(S) proxy variables HTTP/2 HPACK HWB colors Hardware vector arithmetic (SIMD) Hash set syntax Hash sets Hashcash Hashtable implementation details Hashtable keys Hashtable syntax Hashtable utilities Hashtables Heaps Help coverage linting Help lint tool Help system Help system implementation Hex Strings Hexdump High-level optimizer operating on lexical tree SSA IR High-level tuple/database integration High-level tuple/database words History models Hooks for dynamic content Human-friendly sorting I/O encodings I/O timeout protocol IANA-registered encoding names ICMP ID3 tags IMAP library IRC Client ISO 2022-JP-1 encoding Image normalization Images Implementation details Implementing controls Implementing custom drawing logic Implementing layout gadgets Implementing models Implementing new gadgets Implementing sequence combinators In-memory authentication provider Incremental layouts Inferring alien words Infix notation Initial values of slots Initialization and startup Input and output Input/Output Input/output redirection Insert context saves Integer functions Integer syntax Integer virtual sequences Integers Integration with Emacs Intel 8080 CPU Emulator Interactive debugging of OpenGL applications Interference testing using SSA properties. Internet checksum Interpolating code results into literal values Intersection classes Interval arithmetic Interval maps Interval sets Intervals Introduction to SIMD support Introduction to brain-flak Invertible quotations JSON serialization KHash checksum Kakoune support Keyboard focus Keyboard gestures Korean Johab encoding L-system LCS, diffing and distance LD Cache LEB128 Encoding LZW compression LZW differences between TIFF and GIF Label gadgets Labeled gadgets Launch descriptors Launcher examples Launching processes Layout basics Lazy list I/O Lazy lists Leader book-keeping Learning the Tools Legacy 8-bit encodings Lexical variables Lexical variables and fry Lexical variables in literals Libraries Limitations of lexical variables Limited input streams Limiting connections Linear order example Linear order protocol Linear-scan register allocation Lines Link components Linked assocs Linked exceptions List gadgets Listing threads Lists Literal prettyprinting protocol Literals Live interval splitting Live interval state Live interval utilities Live ranges for interference testing Live ranges utilities Liveness analysis Load balancing and fail-over with Furnace Loader for Factor images Loading native libraries Local stack analysis Locked I/O buffers Locks Log analysis Log file parser Log files Log implementation Log levels Log rotation Logging connections Logging framework Logging messages Logic Login authentication Looking up and creating words Lookup and querying of assocs Looping combinators Low-level SIMD primitives Low-level database protocol Low-level database tutorial Low-level slot operations Lucas-Lehmer Mersenne Primality test Lunar Rescue Emulator MD5 checksum MD5 shadow passwords MIME types Macros Mailboxes Make philosophy Making sequences with variables Manipulating Tensors Manipulating lazy lists Manipulating lists Manual layouts Manual memory management Manually constructing an encoded stream Mapping between Factor and YAML types Markup element utilities Matching operations with regular expressions Mathematical functions Matrix operations Maybe classes MediaWiki API Memoization Memory-mapped file examples Memory-mapped files Merging sequences Message-passing concurrency MessagePack Metaprogramming Method chaining syntax Method inlining and dispatch elimination Method precedence MetroHash checksum Miller-Rabin probabilistic primality test Minesweeper Mirrors Miscellaneous Furnace features Miscellaneous vector functions Mixin classes Modeling transformations Models Modular arithmetic MongoDB factor integration Monitors on different platforms Month names in English Motivation for default streams Mouse gestures Multi-touch gestures Multiline Multithreading MurmurHash checksum Mutable lexical variables Mutual-exclusion locks N-based sequences Namespace combinators Namespace implementation details Nested structure Networking Networking examples Next steps Non-blocking I/O implementation Normalize IR created by high level IR builder to simplify subsequent passes Notation for setting Graphviz attributes Null streams Number protocol Number syntax Numbers Numeric ranges Numerical accuracy of SIMD primitives OPTIONS requests with the HTTP client Oauth2 Support Object exchange points Object memory tools Objects Ogg Vorbis audio streaming OpenCL OpenGL binding OpenGL error reporting OpenGL geometric primitives OpenGL utility words OpenSSL Binding OpenSSL checksums Operating system detection Operating system processes Operations Operations on sets Optimizing compiler Optional authentication features Ordering specifiers Output parameters in C PCRE binding POP3 client library POST requests with the HTTP client PUT requests with the HTTP client Pack layouts Packet-oriented networking Packing and Unpacking Binary Data Pair-wise sequence combinators Pane gadgets Paragraph styles Parallel copy Parameterized constructors Parse time evaluation Parse-time word lookup Parser algorithm Parsing Words Parsing command-line arguments Parsing raw tokens Parsing simple flat files Parsing words Partial continuations Partially-dispatched math operations, used by the compiler Passing data between Factor and C Passing pointers to C functions Passing specialized arrays to C functions Passing specialized vectors to C functions Passing structs to C functions Path finding using the A* algorithm Pathname presentations Pathname syntax Pathnames Pattern matching Peephole optimizations Per-node dispatch for escape analysis Persistent deques Persistent heaps Persistent sequence protocol Persistent vectors Piles Pipes Pitfalls to avoid Pixel format attributes Pixel formats Plain writer streams Plan9 acme editor support Playing with the stack Pointer and array types Polynomials Pools Popup menus Porter stemming algorithm Post-mortem error inspection Powers and logarithms Pre-made UI gadgets Predicate classes Preparing to deploy an application Presentation gadgets Presentations Presentations in the UI Preserving combinators Prettyprint control variables Prettyprinter limitations Prettyprinter section protocol Prettyprinter sections Prettyprinter stylesheet Prettyprinting more complex literals Prettyprinting numbers Prettyprinting stacks Prime numbers Primitive C types Primitive index Primitives Print the hierarchy of a class Printing definitions Printing markup elements Private words Process run-time timeouts Processes and Channels Processor detection Product models Product sequences Progress bar models Progress bars Promises Propagation for inline recursive combinators Propagation for read-only tuple slots and array lengths Propagation for straight-line code Properties of interval arithmetic Protected resources Protocol slots Python binding Quadtrees Quotation construction utilities Quotation syntax Quotations Quoted printable encoding Quoted words RIPEMD checksum RYB colors Random access result sets Random combinators Random protocol Range model protocol Range models Ratio syntax Rational numbers Raylib Raylib Live Coding Raylib and Threads Read-only slots Read-write locks Reading XML Reading ahead Reading and writing files Reading and writing memory directly Readline Readline listener Recaptcha example Recaptcha support for Furnace Record example Rectangles Recursive combinator stack effects Reference image Reference implementations Reference protocol Reference utilities References Reflection support for vocabulary search path Regular expression combinator rationale Regular expression combinators Regular expression options Regular expression syntax Regular expressions Regular expressions and the deploy tool Relative timestamps Relocatable VM objects Remote Channels Rendering Rendering Graphviz output Rendering graphs by layout engine Rendering graphs by output format Rendering text Reservoir Sampling Reshaping sequences Resizable sequence implementation Resolution of ambiguous word names Resource disposal anti-patterns Restartable errors Result sets Rewrite responder overview Roles Roman numerals Running code on startup Running hidden processes Running processes in the background Runtime code reloading Ryū Float to String Conversion SHA-2 checksum SIMD data in struct classes SIMD vector conversion SIMD vector types SIMD vector words SMTP client library SSA Destruction SSA construction SSL/TLS methods Safe prime numbers Sampling profiler Scaffold tool Scaling images in a gadget Scripting cookbook Scroller gadgets Search deques Searching directories Searching sequences Secure redirection Secure socket addresses Secure socket configuration Secure socket contexts Secure socket errors Secure sockets (SSL, TLS) Semaphore examples Sending and receiving messages Sequence combinators Sequence operations Sequence parser Sequence protocol Sequences as sets Sequential result sets Servers and Furnace Serving CGI scripts Serving static content Session manager configuration Session state serialization Set implementations Set-theoretic operations on assocs Set-theoretic operations on intervals Sets Setting breakpoints Setting environment variables Setting ports to listen on Setting process groups Setting process priority Setting up SMTP with gmail Shader objects Shift JIS Short-circuit combinators Shuffle word and definition cookbook Shuffle words Signal handlers Signals that can be handled by Factor Simple backtracking non-determinism Singleton classes Sizes and limits Skipping escape analysis pass for code which does not allocate Slate gadget Slider gadgets Slot accessors Slot class declarations Slots syntax sugar Smart arrow models Smart combinators Smart short-circuit combinators Snake Game Sorting by multiple keys Sorting sequences Source files Space Invaders Emulator Span elements Sparse propagation for branches Special mapping keys Special pathnames Specialized array examples Specialized array words Specialized arrays Specialized vector words Specialized vectors Specifying a command Specifying vertices Spider Spider tutorial Spill slot assignment Splay trees Splitting sequences Splitting trending sequences Spread combinators Stack Shuffling Stack checker errors Stack effect checking Stack effect checking escape hatches Stack effect declarations Stack effect inference implementation Stack effect row variables Stack effect syntax Stack effect tools Stack finalization Stack frames Stack machine model Stacks Standard Chloe tags Standard color database Starting and stopping threads Starting the UI Starting the UI tools Startup initialization file Statistics Status bars and mouse-over help Stepping through code Storing keys and values in assocs Straight-line stack effects Stream example Stream protocol Stream utilities Streams String buffer syntax String buffers String streams String word wrapping Strings Strongly-typed word definitions Struct and union types Struct class examples Struct classes Subclassing Objective C classes Subclassing worlds Subsequences and slices Suffix arrays SuperFastHash checksum Support for predicated value info Supported SIMD instruction sets and operations Symbolic links Symbols Synchronous sends Syntax Syntax extensions for XML Syntax for python calls from factor Syntax to control word lookup System interface TRACE requests with the HTTP client Table gadget configuration Table gadget example Table gadgets Table row actions Table row renderer protocol Table row selection Table styles Tagged pointers Tail-call optimization Temporary files Tensor Operators Tensors Terminfo Databases Testing image encoders and decoders Testing sequences Testing your first program Tests and Documentation Text styles Texture objects The Boyer-Moore algorithm The CA file and path The Game of 24 The Kaleidoscope language The Object System The UI coordinate system The Unused Vocabulary Linter The caret and mark The debugger The f object as a sequence The implementation The inspector The key file and password The language The lexer The list protocol The listener The parser The prettyprinter The process lifecycle The theory of regular expressions Thread implementation Thread-local state and variables Threaded server configuration Threaded server examples Threaded servers Throwing exceptions on stream exhaustion Time-Based One-Time Passwords Timers Timestamp arithmetic Timing code and collecting statistics Tips of the day Tom's Obvious Markup Language (TOML) Top level forms Top-level windows Track layouts Tracking memory allocations Translating Factor graphs into DOT Transposed assoc operations Treating sequences as stacks Trigonometric and hyperbolic functions Trimming sequences Triple-wise sequence combinators Tuple arrays Tuple constructors Tuple database protocol Tuple database tutorial Tuple examples Tuple introspection Tuple redefinition Tuple slot declarations Tuple subclassing Tuple subclassing example Tuple syntax Tuple unboxing Tuple-constructing combinators Tuples Type numbers UI application deployment tool UI backend window management UI browser UI developer tools UI error list tool UI framework UI gestures UI glossary UI initialization and the event loop UI inspector UI listener UI listener styling UI pen protocol UI tool keyboard shortcuts UI walker URL encoding and decoding URL implementation utilities URL objects URL rewrite responders UTF-16 encoding UTF-32 encoding UTF-8 encoding UUID (Universally Unique Identifier) Uncompress compressed Factor image files Unicode category syntax Unicode data tables Unicode normalization Unicode script properties Unicode support Uninitialized stack location clearing Uninterned words Union classes Unique files Unit testing Universally Unique Lexicographically Sortable Identifier Unix Process Scheduling Unix file attributes Unix file permissions Unix file timestamps Unix file user and group ids Unix groups Unix users Unrolled lists Unrolled sequence iteration combinators Unsafe array operations Unsafe combinators Unsafe sequence operations Upgrading existing connections User password recovery User profile deactivation User profile editing User profiles User registration Using destructors Using durations Utilities for generic word and method defining parsing words Utilities for traversing XML Utilities used by several optimization passes run in the later stages Utility words used by CFG optimization Utility words used by locals parsing words VM memory layout constants VM memory layouts Value info data type and operations Value numbering expression graph Value numbering utilities Variables for holding stack effect inference state Vector arithmetic Vector arithmetic with specialized arrays Vector component- and bit-wise logic Vector operations Vector shuffling, packing, and unpacking Vector syntax Vectors Vim support Virtual register representation selection Virtual sequence protocol Virtual sequences Virtual single-assignment registers Vocabularies Vocabularies Vocabularies cookbook Vocabulary authors Vocabulary hierarchy tools Vocabulary icons Vocabulary index Vocabulary loader Vocabulary metadata Vocabulary resource metadata Vocabulary roots Vocabulary tags Vreg Coalescing Watching variables in the listener What embedding looks like from Factor Wheel graphs When not to use tuple subclassing When the stack is not enough When to use destructive operations Where to go from here? Window controls Windowed sequences Wipe Word Timer Word aliasing Word and grapheme breaks Word annotations Word implementation details Word introspection Word lookup errors Word name clashes with C types Word object wrapping Word properties Word syntax Word wrapping Words Working with XML namespaces Working with binary data Working with code outside of the Factor source tree Working with memory-mapped data Wrapped Hashtable protocol Wrappers Writing XML Writing documentation Writing efficient SIMD code Writing new destructors Writing some logic in your first program XML data classes XML data constructors XML data types XML entities XML interpolation syntax XML literals XML parser XML parsing errors XML-RPC XxHash checksum YAML control variables YAML deserialization control YAML errors YAML serialization YAML serialization control YIQ colors YUV colors Year operations Yielding and suspending threads Your first program Z algorithm