Warning: this is an htmlized version!
The original is here, and
the conversion rules are here.
;; (find-sh "cd ~/books/ && find * | sort")
;; (find-sh "cd ~/books/__comp/ && find * | sort")


;; «.abel»			(to "abel")
;; «.abelson-sussman»		(to "abelson-sussman")
;; «.aho»			(to "aho")
;; «.allen»			(to "allen")
;; «.baker»			(to "baker")
;; «.barras»			(to "barras")
;; «.barski»			(to "barski")
;; «.bentley»			(to "bentley")
;; «.bentley-pp»		(to "bentley-pp")
;; «.bentley-morepp»		(to "bentley-morepp")
;; «.bernardy-jansson-paterson»	(to "bernardy-jansson-paterson")
;; «.bernardy-lasson»		(to "bernardy-lasson")
;; «.blauth»			(to "blauth")
;; «.bournez»			(to "bournez")
;; «.brady»			(to "brady")
;; «.chlipala»			(to "chlipala")
;; «.choudhury-krishnaswami»	(to "choudhury-krishnaswami")
;; «.coquand»			(to "coquand")
;; «.crockford»			(to "crockford")
;; «.dershowitz-gurevich»	(to "dershowitz-gurevich")
;; «.dijkstra»			(to "dijkstra")
;; «.dreyer»			(to "dreyer")
;; «.dybjer»			(to "dybjer")
;; «.dybjer-paulin»		(to "dybjer-paulin")
;; «.eisenberg»			(to "eisenberg")
;; «.ellis-ritchie»		(to "ellis-ritchie")
;; «.escardo»			(to "escardo")
;; «.gersting»			(to "gersting")
;; «.graham»			(to "graham")
;; «.graham-common-lisp»	(to "graham-common-lisp")
;; «.graham-on-lisp»		(to "graham-on-lisp")
;; «.harper»			(to "harper")
;; «.hopcroft»			(to "hopcroft")
;; «.icon-book»			(to "icon-book")
;; «.ierusalimschy»		(to "ierusalimschy")
;; «.impagliazzo»		(to "impagliazzo")
;; «.kavvos»			(to "kavvos")
;; «.kernighan-plauger»		(to "kernighan-plauger")
;; «.knuth»			(to "knuth")
;; «.kurt»			(to "kurt")
;; «.levy»			(to "levy")
;; «.levy-slides2018»		(to "levy-slides2018")
;; «.levy-thpartsets»		(to "levy-thpartsets")
;; «.levy-lambdanotes»		(to "levy-lambdanotes")
;; «.libes»			(to "libes")
;; «.loeliger»			(to "loeliger")
;; «.marlow-peyton-jones»	(to "marlow-peyton-jones")
;; «.martin»			(to "martin")
;; «.mcbride»			(to "mcbride")
;; «.meyer»			(to "meyer")
;; «.milner»			(to "milner")
;; «.monnier»			(to "monnier")
;; «.monnier-typer»		(to "monnier-typer")
;; «.monnier-cuc»		(to "monnier-cuc")
;; «.monnier-smie»		(to "monnier-smie")
;; «.nanevski»			(to "nanevski")
;; «.norell»			(to "norell")
;; «.orchard»			(to "orchard")
;; «.orchard-codo»		(to "orchard-codo")
;; «.orchard-rice»		(to "orchard-rice")
;; «.ousterhout»		(to "ousterhout")
;; «.o_keefe»			(to "o_keefe")
;; «.paulson»			(to "paulson")
;; «.peyton-jones»		(to "peyton-jones")
;; «.pierce»			(to "pierce")
;; «.pierce-atitapl»		(to "pierce-atitapl")
;; «.plotkin»			(to "plotkin")
;; «.plotkin-partdiff»		(to "plotkin-partdiff")
;; «.reynolds»			(to "reynolds")
;; «.rutten»			(to "rutten")
;; «.queinnec»			(to "queinnec")
;; «.salus»			(to "salus")
;; «.scheinerman»		(to "scheinerman")
;; «.sedgewick»			(to "sedgewick")
;; «.seibel»			(to "seibel")
;; «.steele-common-lisp»	(to "steele-common-lisp")
;; «.stroustrup»		(to "stroustrup")
;; «.sussman-wisdom»		(to "sussman-wisdom")
;; «.wilkinson»			(to "wilkinson")
;; «.yanofsky-mannucci»		(to "yanofsky-mannucci")
;; «.zeilberger»		(to "zeilberger")

;; «.free-as-in-freedom»	(to "free-as-in-freedom")
;; «.levy-hackers»		(to "levy-hackers")
;; «.stallman»			(to "stallman")
;; «.kelty»			(to "kelty")

;; «.agda»			(to "agda")
;; «.agda-dtp»			(to "agda-dtp")
;; «.agda-verified»		(to "agda-verified")
;; «.awk»			(to "awk")
;; «.clojure»			(to "clojure")
;; «.coq»			(to "coq")
;; «.csound»			(to "csound")
;; «.css»			(to "css")
;; «.epigram-ppdt»		(to "epigram-ppdt")
;; «.git»			(to "git")
;; «.git-internals»		(to "git-internals")
;; «.git-progit»		(to "git-progit")
;; «.git-progit2»		(to "git-progit2")
;; «.git-fbu»			(to "git-fbu")
;; «.haskell»			(to "haskell")
;; «.haskell-hutton»		(to "haskell-hutton")
;; «.javascript»		(to "javascript")
;; «.latex»			(to "latex")
;; «.lilypond»			(to "lilypond")
;; «.make»			(to "make")
;; «.ocaml»			(to "ocaml")
;; «.penrose»			(to "penrose")
;; «.python»			(to "python")
;; «.python-downey»		(to "python-downey")
;; «.R»				(to "R")
;; «.ruby»			(to "ruby")
;; «.rubyforrails»		(to "rubyforrails")
;; «.rubynutshell»		(to "rubynutshell")
;; «.pragmaticruby»		(to "pragmaticruby")
;; «.scala»			(to "scala")
;; «.shell»			(to "shell")
;; «.smalltalk»			(to "smalltalk")
;; «.ssh»			(to "ssh")
;; «.unixtools»			(to "unixtools")
;; «.unusual-effectiveness»	(to "unusual-effectiveness")




;; «abel»  (to ".abel")
;; (find-books "__comp/__comp.el" "abel")
;; http://www.cse.chalmers.se/~abela/
;; http://www.cse.chalmers.se/~abela/foetus/
(code-pdf-page "abelfoetus" "~/books/__comp/abel__foetus_termination_checker_for_simple_functional_programs.pdf")
(code-pdf-text "abelfoetus" "~/books/__comp/abel__foetus_termination_checker_for_simple_functional_programs.pdf" 1)
;; (find-abelfoetuspage)
;; (find-abelfoetuspage        1  "Contents")
;; (find-abelfoetuspage (+ 1 189) "Index")
;; (find-abelfoetustext "")





;; «abelson-sussman» (to ".abelson-sussman")
;; (find-books "__comp/__comp.el" "abelson-sussman")
;; (find-books "__comp/__comp.el" "sussman-wisdom")
;; (find-LATEXfile "catsem-slides.bib" "SICP")
;; (find-es "scheme" "sicp-pdf")
;; https://web.mit.edu/alexmv/6.037/
;; https://web.mit.edu/alexmv/6.037/sicp.pdf
;; https://github.com/sarabander/sicp-pdf
(code-pdf-page "sicp" "~/books/__comp/abelson_sussman__structure_and_interpretation_of_computer_programs.pdf")
(code-pdf-text "sicp" "~/books/__comp/abelson_sussman__structure_and_interpretation_of_computer_programs.pdf" 21)
;; (find-sicppage)
;; (find-sicptext "")
;; (find-sicppage         3  "Contents")
;; (find-sicptext         3  "Contents")
;; (find-sicppage         9  "Unofficial Texinfo Format")
;; (find-sicppage        12  "Dedication")
;; (find-sicppage        13  "Foreword")
;; (find-sicppage        19  "Preface to the Second Edition")
;; (find-sicppage        21  "Preface to the First Edition")
;; (find-sicppage        25  "Acknowledgments")
;; (find-sicppage (+ 28   1) "1 Building Abstractions with Procedures")
;; (find-sicppage (+ 28   6) "1.1 The Elements of Programming")
;; (find-sicppage (+ 28   7) "1.1.1 Expressions")
;; (find-sicppage (+ 28  10) "1.1.2 Naming and the Environment")
;; (find-sicppage (+ 28  12) "1.1.3 Evaluating Combinations")
;; (find-sicppage (+ 28  15) "1.1.4 Compound Procedures")
;; (find-sicppage (+ 28  18) "1.1.5 The Substitution Model for Procedure Application")
;; (find-sicppage (+ 28  22) "1.1.6 Conditional Expressions and Predicates")
;; (find-sicppage (+ 28  28) "1.1.7 Example: Square Roots by Newton's Method")
;; (find-sicppage (+ 28  33) "1.1.8 Procedures as Black-Box Abstractions")
;; (find-sicppage (+ 28  40) "1.2 Procedures and the Processes ey Generate")
;; (find-sicppage (+ 28  41) "1.2.1 Linear Recursion and Iteration")
;; (find-sicppage (+ 28  42)   "Figure 1.3: A linear recursive process for computing 6!")
;; (find-sicptext (+ 28  42)   "Figure 1.3: A linear recursive process for computing 6!")
;; (find-sicppage (+ 28  47) "1.2.2 Tree Recursion")
;; (find-sicppage (+ 28  54) "1.2.3 Orders of Growth")
;; (find-sicppage (+ 28  57) "1.2.4 Exponentiation")
;; (find-sicppage (+ 28  62) "1.2.5 Greatest Common Divisors")
;; (find-sicppage (+ 28  65) "1.2.6 Example: Testing for Primality")
;; (find-sicppage (+ 28  74) "1.3 Formulating Abstractions with Higher-Order Procedures")
;; (find-sicppage (+ 28  76) "1.3.1 Procedures as Arguments")
;; (find-sicppage (+ 28  83) "1.3.2 Constructing Procedures Using lambda")
;; (find-sicppage (+ 28  89) "1.3.3 Procedures as General Methods")
;; (find-sicppage (+ 28  97) "1.3.4 Procedures as Returned Values")
;; (find-sicppage (+ 28 107) "2 Building Abstractions with Data")
;; (find-sicppage (+ 28 112) "2.1 Introduction to Data Abstraction")
;; (find-sicppage (+ 28 113) "2.1.1 Example: Arithmetic Operations for Rational Numbers")
;; (find-sicppage (+ 28 118) "2.1.2 Abstraction Barriers")
;; (find-sicppage (+ 28 122) "2.1.3 What Is Meant by Data?")
;; (find-sicppage (+ 28 126) "2.1.4 Extended Exercise: Interval Arithmetic")
;; (find-sicppage (+ 28 132) "2.2 Hierarchical Data and the Closure Property")
;; (find-sicppage (+ 28 134) "2.2.1 Representing Sequences")
;; (find-sicppage (+ 28 147) "2.2.2 Hierarchical Structures")
;; (find-sicppage (+ 28 154) "2.2.3 Sequences as Conventional Interfaces")
;; (find-sicppage (+ 28 172) "2.2.4 Example: A Picture Language")
;; (find-sicppage (+ 28 192) "2.3 Symbolic Data")
;; (find-sicppage (+ 28 192) "2.3.1 Quotation")
;; (find-sicppage (+ 28 197) "2.3.2 Example: Symbolic Differentiation")
;; (find-sicppage (+ 28 205) "2.3.3 Example: Representing Sets")
;; (find-sicppage (+ 28 218) "2.3.4 Example: Huffman Encoding Trees")
;; (find-sicppage (+ 28 229) "2.4 Multiple Representations for Abstract Data")
;; (find-sicppage (+ 28 232) "2.4.1 Representations for Complex Numbers")
;; (find-sicppage (+ 28 237) "2.4.2 Tagged data")
;; (find-sicppage (+ 28 242) "2.4.3 Data-Directed Programming and Additivity")
;; (find-sicppage (+ 28 254) "2.5 Systems with Generic Operations")
;; (find-sicppage (+ 28 255) "2.5.1 Generic Arithmetic Operations")
;; (find-sicppage (+ 28 262) "2.5.2 Combining Data of Different Types")
;; (find-sicppage (+ 28 274) "2.5.3 Example: Symbolic Algebra")
;; (find-sicppage (+ 28 294) "3 Modularity, Objects, and State")
;; (find-sicppage (+ 28 296) "3.1 Assignment and Local State")
;; (find-sicppage (+ 28 297) "3.1.1 Local State Variables")
;; (find-sicppage (+ 28 305) "3.1.2 The Benefits of Introducing Assignment")
;; (find-sicppage (+ 28 311) "3.1.3 The Costs of Introducing Assignment")
;; (find-sicppage (+ 28 320) "3.2 The Environment Model of Evaluation")
;; (find-sicppage (+ 28 322) "3.2.1 The Rules for Evaluation")
;; (find-sicppage (+ 28 327) "3.2.2 Applying Simple Procedures")
;; (find-sicppage (+ 28 330) "3.2.3 Frames as the Repository of Local State")
;; (find-sicppage (+ 28 337) "3.2.4 Internal Definitions")
;; (find-sicppage (+ 28 341) "3.3 Modeling with Mutable Data")
;; (find-sicppage (+ 28 342) "3.3.1 Mutable List Structure")
;; (find-sicppage (+ 28 353) "3.3.2 Representing eues")
;; (find-sicppage (+ 28 360) "3.3.3 Representing Tables")
;; (find-sicppage (+ 28 369) "3.3.4 A Simulator for Digital Circuits")
;; (find-sicppage (+ 28 386) "3.3.5 Propagation of Constraints")
;; (find-sicppage (+ 28 401) "3.4 Concurrency: Time Is of the Essence")
;; (find-sicppage (+ 28 403) "3.4.1 The Nature of Time in Concurrent Systems")
;; (find-sicppage (+ 28 410) "3.4.2 Mechanisms for Controlling Concurrency")
;; (find-sicppage (+ 28 428) "3.5 Streams")
;; (find-sicppage (+ 28 430) "3.5.1 Streams Are Delayed Lists")
;; (find-sicppage (+ 28 441) "3.5.2 Infinite Streams")
;; (find-sicppage (+ 28 453) "3.5.3 Exploiting the Stream Paradigm")
;; (find-sicppage (+ 28 470) "3.5.4 Streams and Delayed Evaluation")
;; (find-sicppage (+ 28 479) "3.5.5 Modularity of Functional Programs and Modularity of Objects")
;; (find-sicppage (+ 28 487) "4 Metalinguistic Abstraction")
;; (find-sicppage (+ 28 492) "4.1 The Metacircular Evaluator")
;; (find-sicppage (+ 28 495) "4.1.1 The Core of the Evaluator")
;; (find-sicppage (+ 28 501) "4.1.2 Representing Expressions")
;; (find-sicppage (+ 28 512) "4.1.3 Evaluator Data Structures")
;; (find-sicppage (+ 28 518) "4.1.4 Running the Evaluator as a Program")
;; (find-sicppage (+ 28 522) "4.1.5 Data as Programs")
;; (find-sicppage (+ 28 526) "4.1.6 Internal Definitions")
;; (find-sicppage (+ 28 534) "4.1.7 Separating Syntactic Analysis from Execution")
;; (find-sicppage (+ 28 541) "4.2 Variations on a Scheme -- Lazy Evaluation")
;; (find-sicppage (+ 28 542) "4.2.1 Normal Order and Applicative Order")
;; (find-sicppage (+ 28 544) "4.2.2 An Interpreter with Lazy Evaluation")
;; (find-sicppage (+ 28 555) "4.2.3 Streams as Lazy Lists")
;; (find-sicppage (+ 28 559) "4.3 Variations on a Scheme -- Nondeterministic Computing")
;; (find-sicppage (+ 28 561) "4.3.1 Amb and Search")
;; (find-sicppage (+ 28 567) "4.3.2 Examples of Nondeterministic Programs")
;; (find-sicppage (+ 28 578) "4.3.3 Implementing the amb Evaluator")
;; (find-sicppage (+ 28 594) "4.4 Logic Programming")
;; (find-sicppage (+ 28 599) "4.4.1 Deductive Information Retrieval")
;; (find-sicppage (+ 28 615) "4.4.2 How the Query System Works")
;; (find-sicppage (+ 28 627) "4.4.3 Is Logic Programming Mathematical Logic?")
;; (find-sicppage (+ 28 635) "4.4.4 Implementing the ery System")
;; (find-sicppage (+ 28 636) "4.4.4.1 The Driver Loop and Instantiation")
;; (find-sicppage (+ 28 638) "4.4.4.2 The Evaluator")
;; (find-sicppage (+ 28 642) "4.4.4.3 Find Assertions by Pattern Matching")
;; (find-sicppage (+ 28 645) "4.4.4.4 Rules and Unification")
;; (find-sicppage (+ 28 651) "4.4.4.5 Maintaining the Data Base")
;; (find-sicppage (+ 28 654) "4.4.4.6 Stream Operations")
;; (find-sicppage (+ 28 656) "4.4.4.7 Query Syntax Procedures")
;; (find-sicppage (+ 28 659) "4.4.4.8 Frames and Bindings")
;; (find-sicppage (+ 28 666) "5 Computing with Register Maines")
;; (find-sicppage (+ 28 668) "5.1 Designing Register Machines")
;; (find-sicppage (+ 28 672) "5.1.1 A Language for Describing Register Machines")
;; (find-sicppage (+ 28 678) "5.1.2 Abstraction in Machine Design")
;; (find-sicppage (+ 28 681) "5.1.3 Subroutines")
;; (find-sicppage (+ 28 686) "5.1.4 Using a Stack to Implement Recursion")
;; (find-sicppage (+ 28 695) "5.1.5 Instruction Summary")
;; (find-sicppage (+ 28 696) "5.2 A Register-Machine Simulator")
;; (find-sicppage (+ 28 698) "5.2.1 The Machine Model")
;; (find-sicppage (+ 28 704) "5.2.2 The Assembler")
;; (find-sicppage (+ 28 708) "5.2.3 Generating Execution Procedures for Instructions")
;; (find-sicppage (+ 28 718) "5.2.4 Monitoring Machine Performance")
;; (find-sicppage (+ 28 723) "5.3 Storage Allocation and Garbage Collection")
;; (find-sicppage (+ 28 724) "5.3.1 Memory as Vectors")
;; (find-sicppage (+ 28 731) "5.3.2 Maintaining the Illusion of Infinite Memory")
;; (find-sicppage (+ 28 741) "5.4 The Explicit-Control Evaluator")
;; (find-sicppage (+ 28 743) "5.4.1 The Core of the Explicit-Control Evaluator")
;; (find-sicppage (+ 28 751) "5.4.2 Sequence Evaluation and Tail Recursion")
;; (find-sicppage (+ 28 756) "5.4.3 Conditionals, Assignments, and Definitions")
;; (find-sicppage (+ 28 759) "5.4.4 Running the Evaluator")
;; (find-sicppage (+ 28 767) "5.5 Compilation")
;; (find-sicppage (+ 28 772) "5.5.1 Structure of the Compiler")
;; (find-sicppage (+ 28 779) "5.5.2 Compiling Expressions")
;; (find-sicppage (+ 28 788) "5.5.3 Compiling Combinations")
;; (find-sicppage (+ 28 797) "5.5.4 Combining Instruction Sequences")
;; (find-sicppage (+ 28 802) "5.5.5 An Example of Compiled Code")
;; (find-sicppage (+ 28 817) "5.5.6 Lexical Addressing")
;; (find-sicppage (+ 28 823) "5.5.7 Interfacing Compiled Code to the Evaluator")
;; (find-sicppage (+ 28 834) "References")
;; (find-sicppage (+ 28 844) "List of Exercises")
;; (find-sicppage (+ 28 846) "List of Figures")
;; (find-sicppage (+ 28 848) "Index")
;; (find-sicppage (+ 28 855) "Colophon")




;; «aho»  (to ".aho")
(code-djvu       "dragonbook" "~/books/__comp/aho_lam_sethi_ullman__compilers_principles_techniques_and_tools_2ed.djvu")
(code-djvutotext "dragonbook" "~/books/__comp/aho_lam_sethi_ullman__compilers_principles_techniques_and_tools_2ed.djvu" 23)
;; (ee-page-parameters "dragonbook" 23)
;; (find-dragonbookpage         8  "Contents")
;; (find-dragonbookpage (+ 23 391) "Index")
;; (find-dragonbookpage (+ 23 993) "Index")
;; (find-dragonbooktext (+ 23 993) "Index")

;; (find-dragonbookpage (+ 23 42) "2.2 Syntax Definition")
;; (find-dragonbookpage (+ 23 42) "2.2.1 Definition of Grammars")
;; (find-dragonbookpage (+ 23 44) "2.2.2 Derivations")
;; (find-dragonbookpage (+ 23 45) "2.2.3 Parse Trees")
;; (find-dragonbookpage (+ 23 47) "2.2.4 Ambiguity")
;; (find-dragonbookpage (+ 23 48) "2.2.5 Associativity of Operators")
;; (find-dragonbookpage (+ 23 48) "2.2.6 Precedence of Operators")
;; (find-dragonbookpage (+ 23 51) "2.2.7 Exercises for Section 2.2")
;; (find-dragonbookpage (+ 23 279) "4.8.1 Precedence and Associativity to Resolve Conflicts")

;; (find-dragonbookpage (+ 23 217) "4.4 Top-Down Parsing")
;; (find-dragonbookpage (+ 23 219) "4.4.1 Recursive-Descent Parsing")
;; (find-dragonbookpage (+ 23 220) "4.4.2 FIRST and FOLLOW")
;; (find-dragonbookpage (+ 23 222) "4.4.3 LL(1) Grammars")
;; (find-dragonbookpage (+ 23 226) "4.4.4 Nonrecursive Predictive Parsing")
;; (find-dragonbookpage (+ 23 228) "4.4.5 Error Recovery in Predictive Parsing")
;; (find-dragonbookpage (+ 23 231) "4.4.6 Exercises for Section 4.4")
;; (find-dragonbookpage (+ 23 233) "4.5 Bottom-Up Parsing")
;; (find-dragonbookpage (+ 23 234) "4.5.1 Reductions")
;; (find-dragonbookpage (+ 23 235) "4.5.2 Handle Pruning")
;; (find-dragonbookpage (+ 23 236) "4.5.3 Shift-Reduce Parsing")
;; (find-dragonbookpage (+ 23 238) "4.5.4 Conflicts During Shift-Reduce Parsing")
;; (find-dragonbookpage (+ 23 240) "4.5.5 Exercises for Section 4.5")
;; (find-dragonbookpage (+ 23 241) "4.6 Introduction to LR Parsing: Simple LR")
;; (find-dragonbookpage (+ 23 241) "4.6.1 Why LR Parsers?")
;; (find-dragonbookpage (+ 23 242) "4.6.2 Items and the LR(0) Automaton")
;; (find-dragonbookpage (+ 23 248) "4.6.3 The LR-Parsing Algorithm")
;; (find-dragonbookpage (+ 23 252) "4.6.4 Constructing SLR-Parsing Tables")
;; (find-dragonbookpage (+ 23 256) "4.6.5 Viable Prefixes")
;; (find-dragonbookpage (+ 23 257) "4.6.6 Exercises for Section 4.6")
;; (find-dragonbookpage (+ 23 259) "4.7 More Powerful LR Parsers")
;; (find-dragonbookpage (+ 23 260) "4.7.1 Canonical LR(1) Items")
;; (find-dragonbookpage (+ 23 261) "4.7.2 Constructing LR(1) Sets of Items")
;; (find-dragonbookpage (+ 23 265) "4.7.3 Canonical LR(1) Parsing Tables")
;; (find-dragonbookpage (+ 23 266) "4.7.4 Constructing LALR Parsing Tables")
;; (find-dragonbookpage (+ 23 270) "4.7.5 Efficient Construction of LALR Parsing Tables")
;; (find-dragonbookpage (+ 23 275) "4.7.6 Compaction of LR Parsing Tables")
;; (find-dragonbookpage (+ 23 277) "4.7.7 Exercises for Section 4.7")


;; «allen»  (to ".allen")
;; http://gigapedia.com/items/302606/anatomy-of-lisp--mcgraw-hill-computer-science-series-
(code-djvu "anatomyoflisp" "~/books/__comp/allen__anatomy_of_lisp.djvu")
;; (find-anatomyoflisppage         6  "Contents")
;; (find-anatomyoflisppage (+ 17 443) "Index")

;; «baker»  (to ".baker")
;; "Linear Logic and Permutation Stacks - The Forth Shall Be First"
;; https://dl.acm.org/doi/10.1145/181993.181999
;; http://home.pipeline.com/~hbaker1/ForthStack.html

;; «barras»  (to ".barras")
;; http://www.lix.polytechnique.fr/Labo/Bruno.Barras/publis.html
;; http://www.lix.polytechnique.fr/Labo/Bruno.Barras/publi/these_barras.pdf
(code-pdf-page "barras" "$S/http/www.lix.polytechnique.fr/Labo/Bruno.Barras/publi/these_barras.pdf")
(code-pdf-text "barras" "$S/http/www.lix.polytechnique.fr/Labo/Bruno.Barras/publi/these_barras.pdf")
;; (find-barraspage)
;; (find-barrastext)
;; (find-barraspage 5 "Table des matières")
;; (find-barrastext 5 "Table des matières")
;; (find-barraspage 116 "4.5 Les PTS Cumulatifs (CTS)")
;; (find-barrastext 116 "4.5 Les PTS Cumulatifs (CTS)")


;; «barski»  (to ".barski")
(code-xpdf      "barski" "~/books/__comp/barski__land_of_lisp.pdf")
(code-pdftotext "barski" "~/books/__comp/barski__land_of_lisp.pdf")
;; (find-barskipage      1  "Contents")
;; (find-barskipage (+ 1 1) "Index")
;; (find-barskitext "")

;; «bentley»  (to ".bentley")

;; «bentley-pp»  (to ".bentley-pp")
;; (find-books "__comp/__comp.el" "bentley-pp")
(code-pdf-page "bentleypp" "~/books/__comp/bentley__programming_pearls.pdf")
(code-pdf-text "bentleypp" "~/books/__comp/bentley__programming_pearls.pdf" 1)
;; (find-bentleypppage)
;; (find-bentleypppage        7  "Contents")
;; (find-bentleypppage (+ 8   1) "Part I: Preliminaries")
;; (find-bentleypppage (+ 7   3) "1.")
;; (find-bentleypppage (+ 7  11) "2. Aha")
;; (find-bentleypppage (+ 6  23) "3. Data structures programs")
;; (find-bentleypppage (+ 6  35) "4. Writing correct programs")
;; (find-bentleypppage (+ 6  49) "Part II: Performance")
;; (find-bentleypppage (+ 6  51) "5. Perspective on performance")
;; (find-bentleypppage (+ 5  59) "6. The back")
;; (find-bentleypppage (+ 5  69) "7. Algorithm design techniques")
;; (find-bentleypppage (+ 5  81) "8. Code tuning")
;; (find-bentleypppage (+ 5  93) "9. Squeezing space")
;; (find-bentleypppage (+ 5 105) "Part III: The product")
;; (find-bentleypppage (+ 4 107) "10. Sorting")
;; (find-bentleypppage (+ 4 117) "11. Searching")
;; (find-bentleypppage (+ 4 125) "12. Heaps")
;; (find-bentleypppage (+ 3 139) "13: A Spelling Checker" "translit A-Z a-z |")
;; (find-bentleypppage (+ 3 151) "Epilog")
;; (find-bentleypppage (+ 2 155) "Catalog of algorithms")
;; (find-bentleypppage (+ 2 159) "Hints for selected problems")
;; (find-bentleypppage (+ 2 163) "Solutions to selected problems")
;; (find-bentleypppage (+ 1 189) "Index")
;; (find-bentleypptext "")

;; «bentley-morepp»  (to ".bentley-morepp")
(code-djvu       "bentleympp" "~/books/__comp/bentley__more_programming_pearls__confessions_of_a_coder.djvu")
(code-djvutotext "bentleympp" "~/books/__comp/bentley__more_programming_pearls__confessions_of_a_coder.djvu" 2)
(code-pdf-page "bentleympp" "~/books/__comp/bentley__more_programming_pearls__confessions_of_a_coder.pdf")
(code-pdf-text "bentleympp" "~/books/__comp/bentley__more_programming_pearls__confessions_of_a_coder.pdf" 2)
;; (find-bentleympppage         6  "Contents")
;; (find-bentleympppage (+  0  83) "9. Little Languages")
;; (find-bentleympppage (+  0  92)   "Lynn Jelinski")
;; (find-bentleympptext              "Lynn Jelinski")
;; (find-bentleympppage (+ -1 203) "Index")
;; (find-bentleympptext "")



;; «bernardy-lasson»  (to ".bernardy-lasson")
;; (find-books "__comp/__comp.el" "bernardy-lasson")
;; Bernardy/Lasson: "Realizability and Parametricity in Pure Type Systems"
;; https://link.springer.com/chapter/10.1007/978-3-642-19805-2_8
(code-pdf-page "blrapipts" "~/books/__comp/bernardy_lasson__realizability_and_parametricity_in_pure_type_systems.pdf")
(code-pdf-text "blrapipts" "~/books/__comp/bernardy_lasson__realizability_and_parametricity_in_pure_type_systems.pdf" 1)
;; (find-blrapiptspage)
;; (find-blrapiptspage        1  "Contents")
;; (find-blrapiptspage (+ 1 189) "Index")
;; (find-blrapiptstext "")

;; «bernardy-jansson-paterson»  (to ".bernardy-jansson-paterson")
;; (find-books "__comp/__comp.el" "bernardy-jansson-paterson")
;; Bernardy/Jansson/Paterson: "Proofs for free: Parametricity for dependent types" (2012)
;; https://doi.org/10.1017/S0956796812000056
(code-pdf-page "bjpproofsforfree" "~/books/__comp/bernardy_jansson_paterson__proofs_for_free_parametricity_for_dependent_types.pdf")
(code-pdf-text "bjpproofsforfree" "~/books/__comp/bernardy_jansson_paterson__proofs_for_free_parametricity_for_dependent_types.pdf" 1)
;; (find-bjpproofsforfreepage)
;; (find-bjpproofsforfreepage        1  "Contents")
;; (find-bjpproofsforfreepage (+ 1 189) "Index")
;; (find-bjpproofsforfreetext "")



;; «blauth»  (to ".blauth")
(code-xpdf "blauthmd" "~/books/__comp/menezes__matematica_discreta_para_computacao_e_informatica.pdf")
;; (find-blauthmdpage           7  "Contents")
;; (find-blauthmdpage (+ -117 251) "Index")


;; «bournez»  (to ".bournez")
;; (find-books "__comp/__comp.el" "bournez")
;; https://www.sciencedirect.com/journal/journal-of-complexity/vol/23/issue/3
;; https://www.sciencedirect.com/science/article/pii/S0885064X07000246
(code-pdf-page "bournezpdec" "~/books/__comp/bournez_et_al__polynomial_differential_equations_compute_all_real_computable_functions_on_computable_compact_intervals.pdf")
(code-pdf-text "bournezpdec" "~/books/__comp/bournez_et_al__polynomial_differential_equations_compute_all_real_computable_functions_on_computable_compact_intervals.pdf" 1)
;; (find-bournezpdecpage)
;; (find-bournezpdecpage        1  "Contents")
;; (find-bournezpdecpage (+ 1 189) "Index")
;; (find-bournezpdectext "")

;; «brady»  (to ".brady")
;; (find-books "__comp/__comp.el" "brady")
;; (find-angg ".emacs" "idris-bradytdd")
(code-pdf-page "bradytdd" "~/books/__comp/brady__type-driven_development_with_idris.pdf")
(code-pdf-text "bradytdd" "~/books/__comp/brady__type-driven_development_with_idris.pdf" 26)
;; (find-bradytddpage)
;; (find-bradytddpage         7  "Contents")
;; (find-bradytddtext         7  "Contents")
;; (find-bradytddpage        23    "https://github.com/edwinb/")
;; (find-bradytddtext        23    "https://github.com/edwinb/")
;; (find-bradytddpage (+ 26   1) "PART 1: INTRODUCTION")
;; (find-bradytddpage (+ 26   3) "1 Overview")
;; (find-bradytddpage (+ 26  11)   "AnyList")
;; (find-bradytddtext (+ 26  11)   "AnyList")
;; (find-bradytddpage (+ 26  17)   "1.4.1   The interactive environment")
;; (find-bradytddtext (+ 26  17)   "1.4.1   The interactive environment")
;; (find-bradytddpage (+ 26  18)   "Type : Type 1")
;; (find-bradytddtext (+ 26  18)   "Type : Type 1")
;; (find-bradytddpage (+ 26  19)  "1.4.3      Compiling and running Idris programs")
;; (find-bradytddtext (+ 26  19)  "1.4.3      Compiling and running Idris programs")
;; (find-bradytddpage (+ 26  20)   "idris Hello.idr -o Hello")
;; (find-bradytddtext (+ 26  20)   "idris Hello.idr -o Hello")
;; (find-bradytddpage (+ 26  20)  "1.4.4   Incomplete definitions: working with holes")
;; (find-bradytddtext (+ 26  20)  "1.4.4   Incomplete definitions: working with holes")
;; (find-bradytddpage (+ 26  21)   "reload Hello.idr with the :r")
;; (find-bradytddtext (+ 26  21)   "reload Hello.idr with the :r")
;; (find-bradytddpage (+ 26  22)   "Calculating a type")
;; (find-bradytddtext (+ 26  22)   "Calculating a type")
;; (find-bradytddpage (+ 26  25) "2 Getting started with Idris")
;; (find-bradytddpage (+ 26  45)   "Modules and namespaces")
;; (find-bradytddtext (+ 26  45)   "Modules and namespaces")
;; (find-bradytddpage (+ 26  53) "PART 2: CORE IDRIS")
;; (find-bradytddpage (+ 26  55) "3 Interactive development with types")
;; (find-bradytddpage (+ 26  87) "4 User-defined data types")
;; (find-bradytddpage (+ 26 123) "5 Interactive programs: input and output processing")
;; (find-bradytddpage (+ 26 147) "6 Programming with first-class types")
;; (find-bradytddpage (+ 26 182) "7 Interfaces: using constrained generic types")
;; (find-bradytddpage (+ 26 208) "8 Equality: expressing relationships between data")
;; (find-bradytddpage (+ 26 236) "9 Predicates: expressing assumptions and contracts in types")
;; (find-bradytddpage (+ 26 258) "10 Views: extending pattern matching")
;; (find-bradytddpage (+ 26 289) "PART 3: IDRIS AND THE REAL WORLD")
;; (find-bradytddpage (+ 26 291) "11 Streams and processes: working with infinite data")
;; (find-bradytddpage (+ 26 324) "12 Writing programs with state")
;; (find-bradytddpage (+ 26 352) "13 State machines: verifying protocols in types")
;; (find-bradytddpage (+ 26 373) "14 Dependent state machines: handling feedback and errors")
;; (find-bradytddpage (+ 26 403) "15 Type-safe concurrent programming")
;; (find-bradytddtext "")


;; «chlipala» (to ".chlipala")
;; (find-books "__comp/__comp.el" "chlipala")
;; (find-LATEX "catsem-u.bib" "bib-Chlipala")
;; https://arxiv.org/pdf/1401.7694.pdf
;; https://arxiv.org/abs/1401.7694
;; Gross, Chlipala and Spivak: "Experience Implementing a Performant Category-Theory Library in Coq"
(code-pdf       "perfctcoq" "~/books/__comp/gross_chlipala_spivak__experience_implementing_a_performant_category-theory_library_in_coq.pdf")
(code-pdftotext "perfctcoq" "~/books/__comp/gross_chlipala_spivak__experience_implementing_a_performant_category-theory_library_in_coq.pdf" 1)
;; (find-perfctcoqpage)
;; (find-perfctcoqpage 4 "Record Category")
;; (find-perfctcoqtext 4 "Record Category")
;; (find-perfctcoqpage (+ 1 189) "Index")
;; (find-perfctcoqtext "")

;; Parameterized Higher Order Abstract Syntax
;; https://cstheory.stackexchange.com/questions/45924/phoas-with-extrinsic-typing
;; http://adam.chlipala.net/papers/PhoasICFP08/
;; http://adam.chlipala.net/papers/PhoasICFP08/PhoasICFP08.pdf
;; http://adam.chlipala.net/papers/ImpurePOPL10/


;; «choudhury-krishnaswami»  (to ".choudhury-krishnaswami")
;; (find-books "__comp/__comp.el" "choudhury-krishnaswami")
;; https://mail.google.com/mail/ca/u/0/#inbox/FMfcgxwHNCspzbpqktBfnCdvvfkGZwXx
;; Choudhury/Krishnaswami:
;; "Recovering Purity with Comonads and Capabilities: The marriage of purity and comonads"
;; https://arxiv.org/abs/1907.07283
;; https://arxiv.org/pdf/1907.07283.pdf
(code-pdf-page "recopucoca" "$S/https/arxiv.org/pdf/1907.07283.pdf")
(code-pdf-text "recopucoca" "$S/https/arxiv.org/pdf/1907.07283.pdf")
;; (find-recopucocapage)
;; (find-recopucocatext)


;; «coquand»  (to ".coquand")
;; (find-books "__comp/__comp.el" "coquand")
;; Thierry Coquand 1992: "Pattern Matching with Dependent Types"
;; https://wonks.github.io/type-theory-reading-group/
;; https://wonks.github.io/type-theory-reading-group/papers/proc92-coquand.pdf
(code-pdf-page "coquandpmdt" "$S/https/wonks.github.io/type-theory-reading-group/papers/proc92-coquand.pdf")
(code-pdf-text "coquandpmdt" "$S/https/wonks.github.io/type-theory-reading-group/papers/proc92-coquand.pdf")
;; (find-coquandpmdtpage)
;; (find-coquandpmdttext)



;; «crockford»  (to ".crockford")
;; (to "javascript")


;; «dershowitz-gurevich» (to ".dershowitz-gurevich")
;; (find-books "__comp/__comp.el" "dershowitz-gurevich")
;; (find-angg ".emacs.papers" "gurevich")
(code-pdf       "gurevchurch" "~/books/__comp/dershowitz_gurevich__proof_of_curch_s_thesis.pdf")
(code-pdftotext "gurevchurch" "~/books/__comp/dershowitz_gurevich__proof_of_curch_s_thesis.pdf" 1)
;; (find-gurevchurchpage)
;; (find-gurevchurchpage        1  "Contents")
;; (find-gurevchurchpage (+ 1 189) "Index")
;; (find-gurevchurchtext "")


;; «dijkstra»  (to ".dijkstra")
;; (find-books "__comp/__comp.el" "dijkstra")
(code-pdf-page "dijkstradip" "~/books/__comp/dijkstra__a_discipline_of_programming.pdf")
(code-pdf-text "dijkstradip" "~/books/__comp/dijkstra__a_discipline_of_programming.pdf" 1)
;; (find-dijkstradippage)
;; (find-dijkstradippage         4  "Contents")
;; (find-dijkstradippage (+ 15 111) "14. The problem of the Dutch national flag")
;; (find-dijkstradiptext "")


;; «dreyer»  (to ".dreyer")
;; (find-books "__comp/__comp.el" "dreyer")
;; https://people.mpi-sws.org/~dreyer/
;; https://people.mpi-sws.org/~dreyer/teaching.html
;; https://courses.ps.uni-saarland.de/sem_ws1920/ Semantics
;; https://courses.ps.uni-saarland.de/sem_ws1920/3/Resources
;; Parametricity and Modular Reasoning (course - lots of material):
;; https://wiki.mpi-sws.org/star/paramore


;; «dybjer»  (to ".dybjer")
;; (find-books "__comp/__comp.el" "dybjer")
;; (find-es "coq" "CIC")
;; http://www.cse.chalmers.se/~peterd/
;; http://www.cse.chalmers.se/~peterd/papers/inductive.html
;; https://plato.stanford.edu/entries/type-theory-intuitionistic/
;;
;; http://www.cse.chalmers.se/~peterd/papers/MartinLofFestschrift.pdf
(code-pdf-page "dybjermlfest" "$S/http/www.cse.chalmers.se/~peterd/papers/MartinLofFestschrift.pdf")
(code-pdf-text "dybjermlfest" "$S/http/www.cse.chalmers.se/~peterd/papers/MartinLofFestschrift.pdf")
;; (find-dybjermlfestpage)
;; (find-dybjermlfesttext)
;;
;;http://www.cse.chalmers.se/~peterd/papers/DependentTypesAtWork.pdf
(code-pdf-page "dybjerdtaw" "$S/http/www.cse.chalmers.se/~peterd/papers/DependentTypesAtWork.pdf")
(code-pdf-text "dybjerdtaw" "$S/http/www.cse.chalmers.se/~peterd/papers/DependentTypesAtWork.pdf")
;; (find-dybjerdtawpage)
;; (find-dybjerdtawtext)
;;
;; "Inductive familes" (1997)
;; http://www.cse.chalmers.se/~peterd/papers/Inductive_Families.pdf
(code-pdf-page "dybjerindfams" "$S/http/www.cse.chalmers.se/~peterd/papers/Inductive_Families.pdf")
(code-pdf-text "dybjerindfams" "$S/http/www.cse.chalmers.se/~peterd/papers/Inductive_Families.pdf")
;; (find-dybjerindfamspage)
;; (find-dybjerindfamspage 6 "3. A scheme for inductive definitions")
;; (find-dybjerindfamspage 6 "3.1.2. Examples")
;; (find-dybjerindfamstext)
;;
;; "Representing inductively defined sets by wellorderings in Martin-Löf's Type Theory"
;; http://www.cse.chalmers.se/~peterd/papers/Wellorderings.pdf
(code-pdf-page "dybjerwo" "$S/http/www.cse.chalmers.se/~peterd/papers/Wellorderings.pdf")
(code-pdf-text "dybjerwo" "$S/http/www.cse.chalmers.se/~peterd/papers/Wellorderings.pdf")
;; (find-dybjerwopage)
;; (find-dybjerwotext)
;;
;; "A Finite Axiomatization of Inductive-Recursive Definitions" (1999)
;; http://www.cse.chalmers.se/~peterd/papers/Finite_IR.pdf
(code-pdf-page "dybjerfir" "$S/http/www.cse.chalmers.se/~peterd/papers/Finite_IR.pdf")
(code-pdf-text "dybjerfir" "$S/http/www.cse.chalmers.se/~peterd/papers/Finite_IR.pdf")
;; (find-dybjerfirpage)
;; (find-dybjerfirtext)
;;
;; «dybjer-paulin»  (to ".dybjer-paulin")
;; http://www.cse.chalmers.se/~peterd/slides/PaulinHonorary2011.pdf (slides, 2011)
(code-pdf-page "dybjerpaulinh" "$S/http/www.cse.chalmers.se/~peterd/slides/PaulinHonorary2011.pdf")
(code-pdf-text "dybjerpaulinh" "$S/http/www.cse.chalmers.se/~peterd/slides/PaulinHonorary2011.pdf")
;; (find-dybjerpaulinhpage)
;; (find-dybjerpaulinhtext)



;; «eisenberg»  (to ".eisenberg")
;; (find-books "__comp/__comp.el" "eisenberg")
;; https://wonks.github.io/type-theory-reading-group/
;; https://www.cis.upenn.edu/~sweirich/papers/eisenberg-thesis.pdf
;; Richard A. Eisenberg: "Dependent Types in Haskell: Theory and Practice" (PhD Thesis)
(code-pdf-page "eisenbergphd" "$S/https/www.cis.upenn.edu/~sweirich/papers/eisenberg-thesis.pdf")
(code-pdf-text "eisenbergphd" "$S/https/www.cis.upenn.edu/~sweirich/papers/eisenberg-thesis.pdf" 15)
;; (find-eisenbergphdpage)
;; (find-eisenbergphdtext)
;; (find-eisenbergphdpage 7 "Contents")
;; (find-eisenbergphdtext 7 "Contents")
;; (find-eisenbergphdpage (+ 15 51) "Chapter 4" "Dependent Haskell")
;; (find-eisenbergphdtext (+ 15 51) "Chapter 4" "Dependent Haskell")



;; «ellis-ritchie»  (to ".ellis-ritchie")
;; (find-books "__comp/__comp.el" "ellis-ritchie")
;; https://web.mit.edu/ellisk/www/
;; https://people.csail.mit.edu/asolar/
;;
;; Ellis/Ritchie/Solar-Lezama/Tenenbaum: "Learning to Infer Graphics Programs from Hand-Drawn Images"
;; https://papers.nips.cc/paper/7845-learning-to-infer-graphics-programs-from-hand-drawn-images
;; https://papers.nips.cc/paper/7845-learning-to-infer-graphics-programs-from-hand-drawn-images.pdf
;; https://papers.nips.cc/paper/7845-learning-to-infer-graphics-programs-from-hand-drawn-images-supplemental.zip
;; (find-fline  "$S/https/papers.nips.cc/paper/")
;; (find-sh0 "cd $S/https/papers.nips.cc/paper/ && unzip -o 7845-*.zip")
;; https://papers.nips.cc/paper/supplement.pdf
;; https://media.nips.cc/nipsbooks/nipspapers/paper_files/nips31/reviews/2974.html
(code-pdf-page "ligpfromhand" "$S/https/papers.nips.cc/paper/7845-learning-to-infer-graphics-programs-from-hand-drawn-images.pdf")
(code-pdf-text "ligpfromhand" "$S/https/papers.nips.cc/paper/7845-learning-to-infer-graphics-programs-from-hand-drawn-images.pdf")
(code-pdf-page "ligpfromhandsup" "$S/https/papers.nips.cc/paper/supplement.pdf")
(code-pdf-text "ligpfromhandsup" "$S/https/papers.nips.cc/paper/supplement.pdf")
;; (find-ligpfromhandpage)
;; (find-ligpfromhandtext)
;; (find-ligpfromhandsuppage)
;; (find-ligpfromhandsuptext)




;; «escardo»  (to ".escardo")
;; https://www.cs.bham.ac.uk/~mhe/
;; https://www.cs.bham.ac.uk/~mhe/.talks/types2011/omniscient.pdf



;; «gersting»  (to ".gersting")
;; (find-angg ".emacs" "quadro")
(code-xpdf      "gersting" "~/books/__comp/gersting__fundamentos_matematicos_para_a_ciencia_da_computacao_3a_ed.pdf")
(code-pdftotext "gersting" "~/books/__comp/gersting__fundamentos_matematicos_para_a_ciencia_da_computacao_3a_ed.pdf")
;; (find-gerstingpage        13  "Sumário")
;; (find-gerstingpage (+ 20   1) "1 Lógica Formal")
;; (find-gerstingpage (+ 20   2) "1.1 Sentenças, Representação Simbólica e Tautologias")
;; (find-gerstingpage (+ 20  12) "1.2 Quantficadores, Predicados e Validade")
;; (find-gerstingpage (+ 20  20) "1.3 Lógica Proposicional")
;; (find-gerstingpage (+ 20  27) "1.4 Lógica de Predicados")
;; (find-gerstingpage (+ 20  33) "1.5 Programação Lógica e Prova de Correção")
;; (find-gerstingpage (+ 20  49) "2 Demonstrações, Recursão e Análise de Algoritmo")
;; (find-gerstingpage (+ 20  50) "2.1 Técnicas de Demonstração")
;; (find-gerstingpage (+ 20  56) "2.2 Indução")
;; (find-gerstingpage (+ 20  64)   "exercícios de indução")
;; (find-gerstingpage (+ 20  56) "2.3 Recursão e relação de recorrência")
;; (find-gerstingpage (+ 20  83) "2.4 análise de algoritmos")
;; (find-gerstingpage (+ 20 513) "Indice alfabetico")
;; (find-gerstingtext "")


;; «graham» (to ".graham")
;; (find-books "__comp/__comp.el" "graham")
;; http://paulgraham.com/rootsoflisp.html
;; http://lib.store.yahoo.net/lib/paulgraham/jmc.ps
;; (find-fline "$S/http/lib.store.yahoo.net/lib/paulgraham/")
(code-xpdf     "rootsoflisp" "$S/http/lib.store.yahoo.net/lib/paulgraham/jmc.pdf")
(code-pdf-text "rootsoflisp" "$S/http/lib.store.yahoo.net/lib/paulgraham/jmc.pdf")
;; (find-rootsoflisppage)
;; (find-rootsoflisptext)

;; http://paulgraham.com/articles.html
;; http://paulgraham.com/ds.html      Do things that don't scale
;; http://paulgraham.com/artistsship.html The other half of "Artists ship" - every check has a cost
;; http://paulgraham.com/lies.html    Lies we tell kids
;; http://paulgraham.com/goodart.html How art can be good
;; http://paulgraham.com/pypar.html   The Python paradox
;; http://paulgraham.com/icad.html    Revenge of the nerds
;; http://paulgraham.com/gh.html      Great hackers
;; http://paulgraham.com/gba.html     The word "Hacker"
;; http://paulgraham.com/hp.html      Hackers and painters
;; http://paulgraham.com/iflisp.html  If Lisp is so great
;; http://paulgraham.com/nerds.html   Why nerds are unpopular
;; http://paulgraham.com/hundred.html The hundred-year language
;; http://paulgraham.com/rootsoflisp.html The roots of Lisp

;; «graham-common-lisp»  (to ".graham-common-lisp")
;; (find-books "__comp/__comp.el" "graham-common-lisp")
(code-pdf-page "ansicommonlisp" "~/books/__comp/graham__ansi_common_lisp.pdf")
(code-pdf-text "ansicommonlisp" "~/books/__comp/graham__ansi_common_lisp.pdf" 1)
;; (find-ansicommonlisppage)
;; (find-ansicommonlisppage        12  "Contents")
;; (find-ansicommonlisppage (+ 1 189) "Index")
;; (find-ansicommonlisptext "")

;; «graham-on-lisp»  (to ".graham-on-lisp")
;; (find-books "__comp/__comp.el" "graham-on-lisp")
(code-pdf-page "grahamonlisp" "~/books/__comp/graham__on_lisp_advanced_techniques_for_common_lisp.pdf")
(code-pdf-text "grahamonlisp" "~/books/__comp/graham__on_lisp_advanced_techniques_for_common_lisp.pdf" 1)
;; (find-grahamonlisppage)
;; (find-grahamonlisppage        8  "Contents")
;; (find-grahamonlisppage (+ 1 189) "Index")
;; (find-grahamonlisptext "")









;; «harper»  (to ".harper")
;; (find-books "__comp/__comp.el" "harper")
(code-pdf-page "harper" "~/books/__comp/harper__practical_foundations_for_programming_languages.pdf")
(code-pdf-text "harper" "~/books/__comp/harper__practical_foundations_for_programming_languages.pdf" 4)
;; (find-harperpage)
;; (find-harpertext)
;; (find-harperpage        7  "Contents")
;; (find-harperpage (+ 20 3) "1 Abstract Syntax")
;; (find-harperpage (+ 20 3) "1.1 Abstract Syntax Trees")
;; (find-harperpage (+ 20 6) "1.2 Abstract Binding Trees")
;; (find-harperpage (+ 20 10) "1.3 Notes")
;; (find-harperpage (+ 20 12) "2 Inductive Definitions")
;; (find-harperpage (+ 20 12) "2.1 Judgments")
;; (find-harperpage (+ 20 12) "2.2 Inference Rules")
;; (find-harperpage (+ 20 14) "2.3 Derivations")
;; (find-harperpage (+ 20 15) "2.4 Rule Induction")
;; (find-harperpage (+ 20 17) "2.5 Iterated and Simultaneous Inductive Definitions")
;; (find-harperpage (+ 20 18) "2.6 Defining Functions by Rules")
;; (find-harperpage (+ 20 19) "2.7 Notes")
;; (find-harperpage (+ 20 21) "3 Hypothetical and General Judgments")
;; (find-harperpage (+ 20 21) "3.1 Hypothetical Judgments")
;; (find-harperpage (+ 20 24) "3.2 Hypothetical Inductive Definitions")
;; (find-harperpage (+ 20 26) "3.3 General Judgments")
;; (find-harperpage (+ 20 27) "3.4 Generic Inductive Definitions")
;; (find-harperpage (+ 20 28) "3.5 Notes")
;; (find-harperpage (+ 20 33) "4 Statics")
;; (find-harperpage (+ 20 33) "4.1 Syntax")
;; (find-harperpage (+ 20 34) "4.2 Type System")
;; (find-harperpage (+ 20 35) "4.3 Structural Properties")
;; (find-harperpage (+ 20 37) "4.4 Notes")
;; (find-harperpage (+ 20 39) "5 Dynamics")
;; (find-harperpage (+ 20 39) "5.1 Transition Systems")
;; (find-harperpage (+ 20 40) "5.2 Structural Dynamics")
;; (find-harperpage (+ 20 42) "5.3 Contextual Dynamics")
;; (find-harperpage (+ 20 44) "5.4 Equational Dynamics")
;; (find-harperpage (+ 20 46) "5.5 Notes")
;; (find-harperpage (+ 20 48) "6 Type Safety")
;; (find-harperpage (+ 20 48) "6.1 Preservation")
;; (find-harperpage (+ 20 49) "6.2 Progress")
;; (find-harperpage (+ 20 50) "6.3 Run-Time Errors")
;; (find-harperpage (+ 20 52) "6.4 Notes")
;; (find-harperpage (+ 20 53) "7 Evaluation Dynamics")
;; (find-harperpage (+ 20 53) "7.1 Evaluation Dynamics")
;; (find-harperpage (+ 20 54) "7.2 Relating Structural and Evaluation Dynamics")
;; (find-harperpage (+ 20 55) "7.3 Type Safety, Revisited")
;; (find-harperpage (+ 20 56) "7.4 Cost Dynamics")
;; (find-harperpage (+ 20 57) "7.5 Notes")
;; (find-harperpage (+ 20 61) "8 Function Definitions and Values")
;; (find-harperpage (+ 20 61) "8.1 First-Order Functions")
;; (find-harperpage (+ 20 62) "8.2 Higher-Order Functions")
;; (find-harperpage (+ 20 65) "8.3 Evaluation Dynamics and Definitional Equality")
;; (find-harperpage (+ 20 66) "8.4 Dynamic Scope")
;; (find-harperpage (+ 20 67) "8.5 Notes")
;; (find-harperpage (+ 20 69) "9 System T of Higher-Order Recursion")
;; (find-harperpage (+ 20 69) "9.1 Statics")
;; (find-harperpage (+ 20 70) "9.2 Dynamics")
;; (find-harperpage (+ 20 71) "9.3 Definability")
;; (find-harperpage (+ 20 73) "9.4 Undefinability")
;; (find-harperpage (+ 20 75) "9.5 Notes")
;; (find-harperpage (+ 20 79) "10 Product Types")
;; (find-harperpage (+ 20 79) "10.1 Nullary and Binary Products")
;; (find-harperpage (+ 20 81) "10.2 Finite Products")
;; (find-harperpage (+ 20 82) "10.3 Primitive Mutual Recursion")
;; (find-harperpage (+ 20 83) "10.4 Notes")
;; (find-harperpage (+ 20 85) "11 Sum Types")
;; (find-harperpage (+ 20 85) "11.1 Nullary and Binary Sums")
;; (find-harperpage (+ 20 86) "11.2 Finite Sums")
;; (find-harperpage (+ 20 88) "11.3 Applications of Sum Types")
;; (find-harperpage (+ 20 91) "11.4 Notes")
;; (find-harperpage (+ 20 95) "12 Constructive Logic")
;; (find-harperpage (+ 20 95) "12.1 Constructive Semantics")
;; (find-harperpage (+ 20 96) "12.2 Constructive Logic")
;; (find-harperpage (+ 20 100) "12.3 Proof Dynamics")
;; (find-harperpage (+ 20 101) "12.4 Propositions as Types")
;; (find-harperpage (+ 20 101) "12.5 Notes")
;; (find-harperpage (+ 20 104) "13 Classical Logic")
;; (find-harperpage (+ 20 105) "13.1 Classical Logic")
;; (find-harperpage (+ 20 109) "13.2 Deriving Elimination Forms")
;; (find-harperpage (+ 20 110) "13.3 Proof Dynamics")
;; (find-harperpage (+ 20 111) "13.4 Law of the Excluded Middle")
;; (find-harperpage (+ 20 113) "13.5 The Double-Negation Translation")
;; (find-harperpage (+ 20 114) "13.6 Notes")
;; (find-harperpage (+ 20 119) "14 Generic Programming")
;; (find-harperpage (+ 20 119) "14.1 Introduction")
;; (find-harperpage (+ 20 119) "14.2 Polynomial Type Operators")
;; (find-harperpage (+ 20 122) "14.3 Positive Type Operators")
;; (find-harperpage (+ 20 123) "14.4 Notes")
;; (find-harperpage (+ 20 125) "15 Inductive and Coinductive Types")
;; (find-harperpage (+ 20 125) "15.1 Motivating Examples")
;; (find-harperpage (+ 20 128) "15.2 Statics")
;; (find-harperpage (+ 20 130) "15.3 Dynamics")
;; (find-harperpage (+ 20 131) "15.4 Solving Type Equations")
;; (find-harperpage (+ 20 132) "15.5 Notes")
;; (find-harperpage (+ 20 137) "16 System F of Polymorphic Types")
;; (find-harperpage (+ 20 137) "16.1 Polymorphic Abstraction")
;; (find-harperpage (+ 20 140) "16.2 Polymorphic Definability")
;; (find-harperpage (+ 20 142) "16.3 Parametricity Overview")
;; (find-harperpage (+ 20 144) "16.4 Notes")
;; (find-harperpage (+ 20 146) "17 Abstract Types")
;; (find-harperpage (+ 20 146) "17.1 Existential Types")
;; (find-harperpage (+ 20 149) "17.2 Data Abstraction")
;; (find-harperpage (+ 20 150) "17.3 Definability of Existential Types")
;; (find-harperpage (+ 20 151) "17.4 Representation Independence")
;; (find-harperpage (+ 20 153) "17.5 Notes")
;; (find-harperpage (+ 20 154) "18 Higher Kinds")
;; (find-harperpage (+ 20 155) "18.1 Constructors and Kinds")
;; (find-harperpage (+ 20 156) "18.2 Constructor Equality")
;; (find-harperpage (+ 20 157) "18.3 Expressions and Types")
;; (find-harperpage (+ 20 158) "18.4 Notes")
;; (find-harperpage (+ 20 161) "19 System PCF of Recursive Functions")
;; (find-harperpage (+ 20 162) "19.1 Statics")
;; (find-harperpage (+ 20 163) "19.2 Dynamics")
;; (find-harperpage (+ 20 165) "19.3 Definability")
;; (find-harperpage (+ 20 167) "19.4 Finite and Infinite Data Structures")
;; (find-harperpage (+ 20 167) "19.5 Totality and Partiality")
;; (find-harperpage (+ 20 169) "19.6 Notes")
;; (find-harperpage (+ 20 171) "20 System FPC of Recursive Types")
;; (find-harperpage (+ 20 171) "20.1 Solving Type Equations")
;; (find-harperpage (+ 20 172) "20.2 Inductive and Coinductive Types")
;; (find-harperpage (+ 20 174) "20.3 Self-Reference")
;; (find-harperpage (+ 20 176) "20.4 The Origin of State")
;; (find-harperpage (+ 20 177) "20.5 Notes")
;; (find-harperpage (+ 20 181) "21 The Untyped -Calculus")
;; (find-harperpage (+ 20 181) "21.1 The -Calculus")
;; (find-harperpage (+ 20 182) "21.2 Definability")
;; (find-harperpage (+ 20 184) "21.3 Scott's Theorem")
;; (find-harperpage (+ 20 186) "21.4 Untyped Means Uni-Typed")
;; (find-harperpage (+ 20 187) "21.5 Notes")
;; (find-harperpage (+ 20 189) "22 Dynamic Typing")
;; (find-harperpage (+ 20 189) "22.1 Dynamically Typed PCF")
;; (find-harperpage (+ 20 192) "22.2 Variations and Extensions")
;; (find-harperpage (+ 20 194) "22.3 Critique of Dynamic Typing")
;; (find-harperpage (+ 20 195) "22.4 Notes")
;; (find-harperpage (+ 20 198) "23 Hybrid Typing")
;; (find-harperpage (+ 20 198) "23.1 A Hybrid Language")
;; (find-harperpage (+ 20 200) "23.2 Dynamic as Static Typing")
;; (find-harperpage (+ 20 201) "23.3 Optimization of Dynamic Typing")
;; (find-harperpage (+ 20 203) "23.4 Static versus Dynamic Typing")
;; (find-harperpage (+ 20 204) "23.5 Notes")
;; (find-harperpage (+ 20 207) "24 Structural Subtyping")
;; (find-harperpage (+ 20 207) "24.1 Subsumption")
;; (find-harperpage (+ 20 208) "24.2 Varieties of Subtyping")
;; (find-harperpage (+ 20 211) "24.3 Variance")
;; (find-harperpage (+ 20 215) "24.4 Dynamics and Safety")
;; (find-harperpage (+ 20 216) "24.5 Notes")
;; (find-harperpage (+ 20 219) "25 Behavioral Typing")
;; (find-harperpage (+ 20 220) "25.1 Statics")
;; (find-harperpage (+ 20 226) "25.2 Boolean Blindness")
;; (find-harperpage (+ 20 228) "25.3 Refinement Safety")
;; (find-harperpage (+ 20 229) "25.4 Notes")
;; (find-harperpage (+ 20 235) "26 Classes and Methods")
;; (find-harperpage (+ 20 235) "26.1 The Dispatch Matrix")
;; (find-harperpage (+ 20 238) "26.2 Class-Based Organization")
;; (find-harperpage (+ 20 239) "26.3 Method-Based Organization")
;; (find-harperpage (+ 20 240) "26.4 Self-Reference")
;; (find-harperpage (+ 20 242) "26.5 Notes")
;; (find-harperpage (+ 20 245) "27 Inheritance")
;; (find-harperpage (+ 20 245) "27.1 Class and Method Extension")
;; (find-harperpage (+ 20 246) "27.2 Class-Based Inheritance")
;; (find-harperpage (+ 20 248) "27.3 Method-Based Inheritance")
;; (find-harperpage (+ 20 249) "27.4 Notes")
;; (find-harperpage (+ 20 253) "28 Control Stacks")
;; (find-harperpage (+ 20 253) "28.1 Machine Definition")
;; (find-harperpage (+ 20 255) "28.2 Safety")
;; (find-harperpage (+ 20 256) "28.3 Correctness of the K Machine")
;; (find-harperpage (+ 20 259) "28.4 Notes")
;; (find-harperpage (+ 20 260) "29 Exceptions")
;; (find-harperpage (+ 20 260) "29.1 Failures")
;; (find-harperpage (+ 20 262) "29.2 Exceptions")
;; (find-harperpage (+ 20 263) "29.3 Exception Values")
;; (find-harperpage (+ 20 264) "29.4 Notes")
;; (find-harperpage (+ 20 266) "30 Continuations")
;; (find-harperpage (+ 20 266) "30.1 Overview")
;; (find-harperpage (+ 20 268) "30.2 Continuation Dynamics")
;; (find-harperpage (+ 20 269) "30.3 Coroutines from Continuations")
;; (find-harperpage (+ 20 272) "30.4 Notes")
;; (find-harperpage (+ 20 277) "31 Symbols")
;; (find-harperpage (+ 20 277) "31.1 Symbol Declaration")
;; (find-harperpage (+ 20 280) "31.2 Symbol References")
;; (find-harperpage (+ 20 282) "31.3 Notes")
;; (find-harperpage (+ 20 284) "32 Fluid Binding")
;; (find-harperpage (+ 20 284) "32.1 Statics")
;; (find-harperpage (+ 20 285) "32.2 Dynamics")
;; (find-harperpage (+ 20 286) "32.3 Type Safety")
;; (find-harperpage (+ 20 287) "32.4 Some Subtleties")
;; (find-harperpage (+ 20 288) "32.5 Fluid References")
;; (find-harperpage (+ 20 289) "32.6 Notes")
;; (find-harperpage (+ 20 291) "33 Dynamic Classification")
;; (find-harperpage (+ 20 291) "33.1 Dynamic Classes")
;; (find-harperpage (+ 20 293) "33.2 Class References")
;; (find-harperpage (+ 20 294) "33.3 Definability of Dynamic Classes")
;; (find-harperpage (+ 20 295) "33.4 Applications of Dynamic Classification")
;; (find-harperpage (+ 20 296) "33.5 Notes")
;; (find-harperpage (+ 20 301) "34 Modernized Algol")
;; (find-harperpage (+ 20 301) "34.1 Basic Commands")
;; (find-harperpage (+ 20 306) "34.2 Some Programming Idioms")
;; (find-harperpage (+ 20 307) "34.3 Typed Commands and Typed Assignables")
;; (find-harperpage (+ 20 310) "34.4 Notes")
;; (find-harperpage (+ 20 313) "35 Assignable References")
;; (find-harperpage (+ 20 313) "35.1 Capabilities")
;; (find-harperpage (+ 20 314) "35.2 Scoped Assignables")
;; (find-harperpage (+ 20 316) "35.3 Free Assignables")
;; (find-harperpage (+ 20 318) "35.4 Safety")
;; (find-harperpage (+ 20 320) "35.5 Benign Effects")
;; (find-harperpage (+ 20 321) "35.6 Notes")
;; (find-harperpage (+ 20 323) "36 Lazy Evaluation")
;; (find-harperpage (+ 20 323) "36.1 PCF By-Need")
;; (find-harperpage (+ 20 326) "36.2 Safety of PCF By-Need")
;; (find-harperpage (+ 20 328) "36.3 FPC By-Need")
;; (find-harperpage (+ 20 329) "36.4 Suspension Types")
;; (find-harperpage (+ 20 331) "36.5 Notes")
;; (find-harperpage (+ 20 335) "37 Nested Parallelism")
;; (find-harperpage (+ 20 335) "37.1 Binary Fork-Join")
;; (find-harperpage (+ 20 338) "37.2 Cost Dynamics")
;; (find-harperpage (+ 20 341) "37.3 Multiple Fork-Join")
;; (find-harperpage (+ 20 342) "37.4 Bounded Implementations")
;; (find-harperpage (+ 20 346) "37.5 Scheduling")
;; (find-harperpage (+ 20 348) "37.6 Notes")
;; (find-harperpage (+ 20 350) "38 Futures and Speculations")
;; (find-harperpage (+ 20 350) "38.1 Futures")
;; (find-harperpage (+ 20 351) "38.2 Speculations")
;; (find-harperpage (+ 20 352) "38.3 Parallel Dynamics")
;; (find-harperpage (+ 20 354) "38.4 Pipelining with Futures")
;; (find-harperpage (+ 20 356) "38.5 Notes")
;; (find-harperpage (+ 20 359) "39 Process Calculus")
;; (find-harperpage (+ 20 359) "39.1 Actions and Events")
;; (find-harperpage (+ 20 361) "39.2 Interaction")
;; (find-harperpage (+ 20 363) "39.3 Replication")
;; (find-harperpage (+ 20 364) "39.4 Allocating Channels")
;; (find-harperpage (+ 20 366) "39.5 Communication")
;; (find-harperpage (+ 20 369) "39.6 Channel Passing")
;; (find-harperpage (+ 20 371) "39.7 Universality")
;; (find-harperpage (+ 20 372) "39.8 Notes")
;; (find-harperpage (+ 20 375) "40 Concurrent Algol")
;; (find-harperpage (+ 20 375) "40.1 Concurrent Algol")
;; (find-harperpage (+ 20 378) "40.2 Broadcast Communication")
;; (find-harperpage (+ 20 380) "40.3 Selective Communication")
;; (find-harperpage (+ 20 382) "40.4 Free Assignables as Processes")
;; (find-harperpage (+ 20 383) "40.5 Notes")
;; (find-harperpage (+ 20 385) "41 Distributed Algol")
;; (find-harperpage (+ 20 385) "41.1 Statics")
;; (find-harperpage (+ 20 388) "41.2 Dynamics")
;; (find-harperpage (+ 20 390) "41.3 Safety")
;; (find-harperpage (+ 20 391) "41.4 Notes")
;; (find-harperpage (+ 20 395) "42 Modularity and Linking")
;; (find-harperpage (+ 20 395) "42.1 Simple Units and Linking")
;; (find-harperpage (+ 20 396) "42.2 Initialization and Effects")
;; (find-harperpage (+ 20 398) "42.3 Notes")
;; (find-harperpage (+ 20 399) "43 Singleton Kinds and Subkinding")
;; (find-harperpage (+ 20 399) "43.1 Overview")
;; (find-harperpage (+ 20 400) "43.2 Singletons")
;; (find-harperpage (+ 20 402) "43.3 Dependent Kinds")
;; (find-harperpage (+ 20 405) "43.4 Higher Singletons")
;; (find-harperpage (+ 20 407) "43.5 Notes")
;; (find-harperpage (+ 20 409) "44 Type Abstractions and Type Classes")
;; (find-harperpage (+ 20 410) "44.1 Type Abstraction")
;; (find-harperpage (+ 20 412) "44.2 Type Classes")
;; (find-harperpage (+ 20 414) "44.3 A Module Language")
;; (find-harperpage (+ 20 418) "44.4 First- and Second-Class")
;; (find-harperpage (+ 20 419) "44.5 Notes")
;; (find-harperpage (+ 20 422) "45 Hierarchy and Parameterization")
;; (find-harperpage (+ 20 422) "45.1 Hierarchy")
;; (find-harperpage (+ 20 425) "45.2 Abstraction")
;; (find-harperpage (+ 20 427) "45.3 Hierarchy and Abstraction")
;; (find-harperpage (+ 20 429) "45.4 Applicative Functors")
;; (find-harperpage (+ 20 431) "45.5 Notes")
;; (find-harperpage (+ 20 435) "46 Equality for System T")
;; (find-harperpage (+ 20 435) "46.1 Observational Equivalence")
;; (find-harperpage (+ 20 439) "46.2 Logical Equivalence")
;; (find-harperpage (+ 20 440) "46.3 Logical and Observational Equivalence Coincide")
;; (find-harperpage (+ 20 443) "46.4 Some Laws of Equality")
;; (find-harperpage (+ 20 444) "46.5 Notes")
;; (find-harperpage (+ 20 445) "47 Equality for System PCF")
;; (find-harperpage (+ 20 445) "47.1 Observational Equivalence")
;; (find-harperpage (+ 20 446) "47.2 Logical Equivalence")
;; (find-harperpage (+ 20 446) "47.3 Logical and Observational Equivalence Coincide")
;; (find-harperpage (+ 20 449) "47.4 Compactness")
;; (find-harperpage (+ 20 452) "47.5 Lazy Natural Numbers")
;; (find-harperpage (+ 20 453) "47.6 Notes")
;; (find-harperpage (+ 20 454) "48 Parametricity")
;; (find-harperpage (+ 20 454) "48.1 Overview")
;; (find-harperpage (+ 20 455) "48.2 Observational Equivalence")
;; (find-harperpage (+ 20 456) "48.3 Logical Equivalence")
;; (find-harperpage (+ 20 461) "48.4 Parametricity Properties")
;; (find-harperpage (+ 20 464) "48.5 Representation Independence, Revisited")
;; (find-harperpage (+ 20 465) "48.6 Notes")
;; (find-harperpage (+ 20 467) "49 Process Equivalence")
;; (find-harperpage (+ 20 467) "49.1 Process Calculus")
;; (find-harperpage (+ 20 469) "49.2 Strong Equivalence")
;; (find-harperpage (+ 20 472) "49.3 Weak Equivalence")
;; (find-harperpage (+ 20 473) "49.4 Notes")
;; (find-harperpage (+ 20 477) "A Background on Finite Sets")
;; (find-harperpage (+ 20 479) "Bibliography")
;; (find-harperpage (+ 20 487) "Index")
;; (find-harperpage (+ 20 4) "Index")
;; (find-harpertext "")



;; «hopcroft»  (to ".hopcroft")
(code-djvu "hopcroftmu" "~/books/__comp/hopcroft_motwani_ullman__introduction_to_automata_and_algorithms.djvu")
;; (find-hopcroftmupage         9  "Contents")
;; (find-hopcroftmupage (+ 16   1) "1. Automata: The Methods and the Madness")
;; (find-hopcroftmupage (+ 16   2) "1.1. Why study automata theory?")
;; (find-hopcroftmupage (+ 16   2) "1.1.1. Introduction to Finite Automata")
;; (find-hopcroftmupage (+ 16   4) "1.1.2. Structural Representations")
;; (find-hopcroftmupage (+ 16   5) "1.1.3. Automata and Complexity")
;; (find-hopcroftmupage (+ 16   5) "1.2. Introduction to Formal Proof")
;; (find-hopcroftmupage (+ 16   6) "1.2.1. Deductive Proofs")
;; (find-hopcroftmupage (+ 16   8) "1.2.2. Reduction to Definitions")
;; (find-hopcroftmupage (+ 16  10) "1.2.3. Other Theorem Forms")
;; (find-hopcroftmupage (+ 16  12)   "How Formal Do Proofs Have to Be?")
;; (find-hopcroftmupage (+ 16  13) "1.2.4. Theorems That Appear Not to Be If-Then Statements")
;; (find-hopcroftmupage (+ 16  13) "1.3. Additional Forms of Proof")
;; (find-hopcroftmupage (+ 16  14) "1.3.1. Proving Equivalences About Sets")
;; (find-hopcroftmupage (+ 16  14) "1.3.2. The Contrapositive")
;; (find-hopcroftmupage (+ 16  16) "1.3.3. Proof by Contradiction")
;; (find-hopcroftmupage (+ 16  17) "1.3.4. Counterexamples")
;; (find-hopcroftmupage (+ 16  19) "1.4. Inductive Proofs")
;; (find-hopcroftmupage (+ 16  19) "1.4.1. Inductions on Integers")
;; (find-hopcroftmupage (+ 16  22) "1.4.2. More General Forms of Integer Inductions")
;; (find-hopcroftmupage (+ 16  23) "1.4.3. Structural Inductions")
;; (find-hopcroftmupage (+ 16  26) "1.4.4. Mutual Inductions")
;; (find-hopcroftmupage (+ 16  28) "1.5. The Central Concepts of Automata Theory")
;; (find-hopcroftmupage (+ 16  28) "1.5.1. Alphabets")
;; (find-hopcroftmupage (+ 16  29) "1.5.2. Strings")
;; (find-hopcroftmupage (+ 16  30) "1.5.3. Languages")
;; (find-hopcroftmupage (+ 16  31) "1.5.4. Problems")
;; (find-hopcroftmupage (+ 16  34) "1.6. Summary of Chapter 1")
;; (find-hopcroftmupage (+ 16  35) "1.7. References for Chapter 1")
;; (find-hopcroftmupage (+ 16 171) "5.1.2. Definition of Context-Free Grammars")
;; (find-hopcroftmupage (+ 16 181) "5.2. Parse Trees")
;; (find-hopcroftmupage (+ 16 194) "5.3.2. The YACC Parser-Generator")
;; (find-hopcroftmupage (+ 16 195) "5.3.2." "An example of a grammar in the YACC notation")
;; (find-hopcroftmupage (+ 16 205) "5.4.1. Ambiguous Grammars")
;; (find-hopcroftmupage (+ 16 368) "9.1. A Language That Is Not Recursively Enumerable")
;; (find-hopcroftmupage (+ 16 513) "Index")



;; «icon-book»  (to ".icon-book")
;; (find-books "__comp/__comp.el" "icon-book")
;; https://www2.cs.arizona.edu/icon/ftp/doc/lb1up.pdf
(code-pdf-page "iconbook" "$S/https/www2.cs.arizona.edu/icon/ftp/doc/lb1up.pdf")
(code-pdf-text "iconbook" "$S/https/www2.cs.arizona.edu/icon/ftp/doc/lb1up.pdf")
;; (find-iconbookpage)
;; (find-iconbooktext)
;; (find-iconbookpage         5  "Contents")
;; (find-iconbooktext         5  "Contents")
;; (find-iconbookpage (+ 2   11) "FOREWORD")
;; (find-iconbookpage (+ 2   15) "INTRODUCTION")
;; (find-iconbookpage (+ 2   19) "ACKNOWLEDGMENTS")
;; (find-iconbookpage (+ 22   1) "1 GETTING STARTED")
;; (find-iconbookpage (+ 22   1)  "Program Structure")
;; (find-iconbookpage (+ 22   4)  "Success and Failure")
;; (find-iconbookpage (+ 22   6)  "Control Structures")
;; (find-iconbookpage (+ 22   7)  "Procedures")
;; (find-iconbookpage (+ 22   9)  "Expression Syntax")
;; (find-iconbookpage (+ 22  11)  "Preprocessing")
;; (find-iconbookpage (+ 22  12)  "Notes")
;; (find-iconbookpage (+ 22  17) "2 EXPRESSIONS")
;; (find-iconbookpage (+ 22  17)  "Sequential Evaluation")
;; (find-iconbookpage (+ 22  18)  "Goal-Directed Evaluation")
;; (find-iconbookpage (+ 22  20)  "Iteration")
;; (find-iconbookpage (+ 22  20)  "Integer Sequences")
;; (find-iconbookpage (+ 22  21)  "Alternation")
;; (find-iconbookpage (+ 22  22)  "Conjunction")
;; (find-iconbookpage (+ 22  23)  "Loops")
;; (find-iconbookpage (+ 22  25)  "Selection Expressions")
;; (find-iconbookpage (+ 22  28)  "Comparison Operations")
;; (find-iconbookpage (+ 22  28)  "Assignment")
;; (find-iconbookpage (+ 22  30)  "Values, Variables, and Results")
;; (find-iconbookpage (+ 22  30)  "Argument Evaluation")
;; (find-iconbookpage (+ 22  31)  "Procedure Returns")
;; (find-iconbookpage (+ 22  32)  "Notes")
;; (find-iconbookpage (+ 22  37) "3 STRING SCANNING")
;; (find-iconbookpage (+ 22  37)  "The Concept of Scanning")
;; (find-iconbookpage (+ 22  38)  "String Positions")
;; (find-iconbookpage (+ 22  39)  "String Analysis")
;; (find-iconbookpage (+ 22  40)  "Csets")
;; (find-iconbookpage (+ 22  41)  "String-Analysis Functions")
;; (find-iconbookpage (+ 22  43)  "Scanning Environments")
;; (find-iconbookpage (+ 22  44)  "Scanning Keywords")
;; (find-iconbookpage (+ 22  44)  "Augmented String Scanning")
;; (find-iconbookpage (+ 22  45)  "Notes")
;; (find-iconbookpage (+ 22  47) "4 CHARACTERS, CSETS, AND STRINGS")
;; (find-iconbookpage (+ 22  47)  "Characters")
;; (find-iconbookpage (+ 22  48)  "Strings")
;; (find-iconbookpage (+ 22  50)  "Lexical Comparison")
;; (find-iconbookpage (+ 22  51)  "String Construction")
;; (find-iconbookpage (+ 22  52)  "String-Valued Functions")
;; (find-iconbookpage (+ 22  56)  "Substrings")
;; (find-iconbookpage (+ 22  60)  "Csets")
;; (find-iconbookpage (+ 22  61)  "String Analysis")
;; (find-iconbookpage (+ 22  61)  "Conversion between Csets and Strings")
;; (find-iconbookpage (+ 22  62)  "Notes")
;; (find-iconbookpage (+ 22  63) "5 NUMERICAL COMPUTATION AND BIT OPERATIONS")
;; (find-iconbookpage (+ 22  63)  "Numeric Literals")
;; (find-iconbookpage (+ 22  64)  "Arithmetic")
;; (find-iconbookpage (+ 22  65)  "Numerical Comparison")
;; (find-iconbookpage (+ 22  65)  "Mathematical Computations")
;; (find-iconbookpage (+ 22  66)  "Random Numbers")
;; (find-iconbookpage (+ 22  66)  "Bit Operations")
;; (find-iconbookpage (+ 22  67)  "Notes")
;; (find-iconbookpage (+ 22  71) "6 STRUCTURES")
;; (find-iconbookpage (+ 22  71)  "Records")
;; (find-iconbookpage (+ 22  72)  "Lists")
;; (find-iconbookpage (+ 22  79)  "Sets")
;; (find-iconbookpage (+ 22  81)  "Tables")
;; (find-iconbookpage (+ 22  83)  "Properties of Structures")
;; (find-iconbookpage (+ 22  84)  "Notes")
;; (find-iconbookpage (+ 22  87) "7 EXPRESSION EVALUATION")
;; (find-iconbookpage (+ 22  87)  "Backtracking")
;; (find-iconbookpage (+ 22  90)  "Bounded Expressions")
;; (find-iconbookpage (+ 22  92)  "Mutual Evaluation")
;; (find-iconbookpage (+ 22  93)  "Limiting Generation")
;; (find-iconbookpage (+ 22  94)  "Repeated Alternation")
;; (find-iconbookpage (+ 22  95)  "Notes")
;; (find-iconbookpage (+ 22  97) "8 PROCEDURES")
;; (find-iconbookpage (+ 22  97)  "Procedure Declarations")
;; (find-iconbookpage (+ 22  99)  "Scope")
;; (find-iconbookpage (+ 22 101)  "Procedure Invocation")
;; (find-iconbookpage (+ 22 103)  "Variables and Dereferencing")
;; (find-iconbookpage (+ 22 105)  "Notes")
;; (find-iconbookpage (+ 22 109) "9 CO-EXPRESSIONS")
;; (find-iconbookpage (+ 22 109)  "Co-Expression Operations")
;; (find-iconbookpage (+ 22 113)  "Using Co-Expressions")
;; (find-iconbookpage (+ 22 115)  "Programmer-Defined Control Structures")
;; (find-iconbookpage (+ 22 118)  "Other Features of Co-Expressions")
;; (find-iconbookpage (+ 22 122)  "Notes")
;; (find-iconbookpage (+ 22 123) "10 DATA TYPES")
;; (find-iconbookpage (+ 22 123)  "Type Determination")
;; (find-iconbookpage (+ 22 124)  "Type Conversion")
;; (find-iconbookpage (+ 22 127)  "The Null Value")
;; (find-iconbookpage (+ 22 128)  "Comparing Values")
;; (find-iconbookpage (+ 22 130)  "Copying Values")
;; (find-iconbookpage (+ 22 131)  "Notes")
;; (find-iconbookpage (+ 22 133) "11 INPUT AND OUTPUT")
;; (find-iconbookpage (+ 22 133)  "Files")
;; (find-iconbookpage (+ 22 135)  "Input")
;; (find-iconbookpage (+ 22 136)  "Output")
;; (find-iconbookpage (+ 22 138)  "Text Files and Binary Files")
;; (find-iconbookpage (+ 22 140)  "Pipes")
;; (find-iconbookpage (+ 22 141)  "Keyboard Functions")
;; (find-iconbookpage (+ 22 141)  "Random-Access Input and Output")
;; (find-iconbookpage (+ 22 141)  "Operations on Files")
;; (find-iconbookpage (+ 22 142)  "Notes")
;; (find-iconbookpage (+ 22 143) "12 AN OVERVIEW OF GRAPHICS")
;; (find-iconbookpage (+ 22 143)  "Window Operations and Attributes")
;; (find-iconbookpage (+ 22 145)  "Drawing")
;; (find-iconbookpage (+ 22 149)  "Text")
;; (find-iconbookpage (+ 22 151)  "Color")
;; (find-iconbookpage (+ 22 153)  "Images")
;; (find-iconbookpage (+ 22 155)  "Events")
;; (find-iconbookpage (+ 22 157)  "Dialogs")
;; (find-iconbookpage (+ 22 158)  "Visual Interfaces")
;; (find-iconbookpage (+ 22 159)  "Other Features")
;; (find-iconbookpage (+ 22 160)  "Notes")
;; (find-iconbookpage (+ 22 161) "13 OTHER FEATURES")
;; (find-iconbookpage (+ 22 161)  "Sorting Structures")
;; (find-iconbookpage (+ 22 163)  "String Names")
;; (find-iconbookpage (+ 22 164)  "String Invocation")
;; (find-iconbookpage (+ 22 166)  "Dynamic Loading")
;; (find-iconbookpage (+ 22 166)  "Storage Management")
;; (find-iconbookpage (+ 22 169)  "Miscellaneous Facilities")
;; (find-iconbookpage (+ 22 171)  "Notes")
;; (find-iconbookpage (+ 22 173) "14 RUNNING AN ICON PROGRAM")
;; (find-iconbookpage (+ 22 173)  "Basics")
;; (find-iconbookpage (+ 22 174)  "Input and Output Redirection")
;; (find-iconbookpage (+ 22 175)  "Command-Line Arguments")
;; (find-iconbookpage (+ 22 175)  "Environment Variables")
;; (find-iconbookpage (+ 22 176)  "Notes")
;; (find-iconbookpage (+ 22 177) "15 LIBRARIES")
;; (find-iconbookpage (+ 22 177)  "Using Procedure Libraries")
;; (find-iconbookpage (+ 22 178)  "The Icon Program Library")
;; (find-iconbookpage (+ 22 184)  "Creating New Library Modules")
;; (find-iconbookpage (+ 22 185)  "Notes")
;; (find-iconbookpage (+ 22 187) "16 ERRORS AND DIAGNOSTIC FACILITIES")
;; (find-iconbookpage (+ 22 187)  "Errors")
;; (find-iconbookpage (+ 22 189)  "Error Conversion")
;; (find-iconbookpage (+ 22 190)  "String Images")
;; (find-iconbookpage (+ 22 192)  "Program Information")
;; (find-iconbookpage (+ 22 192)  "Tracing")
;; (find-iconbookpage (+ 22 195)  "The Values of Variables")
;; (find-iconbookpage (+ 22 197)  "Variables and Names")
;; (find-iconbookpage (+ 22 198)  "Notes")
;; (find-iconbookpage (+ 22 201) "17 PROGRAMMING WITH GENERATORS")
;; (find-iconbookpage (+ 22 201)  "Nested Iteration")
;; (find-iconbookpage (+ 22 203)  "Goal-Directed Evaluation and Searching")
;; (find-iconbookpage (+ 22 210)  "Recursive Generators")
;; (find-iconbookpage (+ 22 211) "18 STRING SCANNING AND PATTERN MATCHING")
;; (find-iconbookpage (+ 22 211)  "Arithmetic Expressions")
;; (find-iconbookpage (+ 22 216)  "Pattern Matching")
;; (find-iconbookpage (+ 22 220)  "Grammars and Languages")
;; (find-iconbookpage (+ 22 227) "19 USING STRUCTURES")
;; (find-iconbookpage (+ 22 227)  "Trees")
;; (find-iconbookpage (+ 22 231)  "Dags")
;; (find-iconbookpage (+ 22 233)  "Graphs")
;; (find-iconbookpage (+ 22 235)  "Two-Way Tables")
;; (find-iconbookpage (+ 22 237) "20 MAPPINGS AND LABELINGS")
;; (find-iconbookpage (+ 22 237)  "Mapping Techniques")
;; (find-iconbookpage (+ 22 242)  "Labelings")
;; (find-iconbookpage (+ 22 247) "A SYNTAX")
;; (find-iconbookpage (+ 22 248)  "Programs")
;; (find-iconbookpage (+ 22 252)  "Language Elements")
;; (find-iconbookpage (+ 22 255)  "Program Layout")
;; (find-iconbookpage (+ 22 257)  "Precedence and Associativity")
;; (find-iconbookpage (+ 22 261) "B CHARACTERS")
;; (find-iconbookpage (+ 22 261)  "Glyphs")
;; (find-iconbookpage (+ 22 268)  "ASCII Control Characters")
;; (find-iconbookpage (+ 22 269) "C PREPROCESSING")
;; (find-iconbookpage (+ 22 269)  "Include Directives")
;; (find-iconbookpage (+ 22 270)  "Line Directives")
;; (find-iconbookpage (+ 22 270)  "Define Directives")
;; (find-iconbookpage (+ 22 271)  "Undefine Directives")
;; (find-iconbookpage (+ 22 271)  "Predefined Symbols")
;; (find-iconbookpage (+ 22 271)  "Substitution")
;; (find-iconbookpage (+ 22 272)  "Conditional Compilation")
;; (find-iconbookpage (+ 22 272)  "Error Directives")
;; (find-iconbookpage (+ 22 273) "D LANGUAGE REFERENCE MANUAL")
;; (find-iconbookpage (+ 22 275)  "Functions")
;; (find-iconbookpage (+ 22 295)  "Prefix Operations")
;; (find-iconbookpage (+ 22 298)  "Infix Operations")
;; (find-iconbookpage (+ 22 303)  "Other Operations")
;; (find-iconbookpage (+ 22 306)  "Keywords")
;; (find-iconbookpage (+ 22 311)  "Control Structures")
;; (find-iconbookpage (+ 22 314)  "Generators")
;; (find-iconbookpage (+ 22 315) "E COMMAND-LINE OPTIONS")
;; (find-iconbookpage (+ 22 317) "F ENVIRONMENT VARIABLES")
;; (find-iconbookpage (+ 22 319) "G ERROR MESSAGES")
;; (find-iconbookpage (+ 22 319)  "Preprocessor Errors")
;; (find-iconbookpage (+ 22 320)  "Syntax Errors")
;; (find-iconbookpage (+ 22 321)  "Linking Error")
;; (find-iconbookpage (+ 22 321)  "Run-Time Errors")
;; (find-iconbookpage (+ 22 323) "H PLATFORM-SPECIFIC DIFFERENCES")
;; (find-iconbookpage (+ 22 324)  "Character Sets")
;; (find-iconbookpage (+ 22 325)  "Language Features")
;; (find-iconbookpage (+ 22 326)  "Other Issues")
;; (find-iconbookpage (+ 22 329) "I SAMPLE PROGRAMS")
;; (find-iconbookpage (+ 22 329)  "Command-Line Options")
;; (find-iconbookpage (+ 22 331)  "Structure Images")
;; (find-iconbookpage (+ 22 334)  "Concordances")
;; (find-iconbookpage (+ 22 337)  "Animal Game")
;; (find-iconbookpage (+ 22 341)  "Randomly Generated Sentences")
;; (find-iconbookpage (+ 22 348)  "N Queens")
;; (find-iconbookpage (+ 22 350)  "N Queens Displayed Graphically")
;; (find-iconbookpage (+ 22 355) "J ICON RESOURCES")
;; (find-iconbookpage (+ 22 357) "GLOSSARY")
;; (find-iconbookpage (+ 22 369) "REFERENCES")
;; (find-iconbookpage (+ 22 373) "INDEX")



;; «ierusalimschy»  (to ".ierusalimschy")
;; (find-books "__comp/__comp.el" "ierusalimschy")
;; (find-angg ".emacs.papers" "lua")
(code-pdf-page "pil2" "~/books/__comp/ierusalimschy__programming_in_lua_2nd_ed.pdf")
(code-pdf-text "pil2" "~/books/__comp/ierusalimschy__programming_in_lua_2nd_ed.pdf" 19)
(code-pdf-page "pil3" "~/books/__comp/ierusalimschy__programming_in_lua_3rd_ed.pdf")
(code-pdf-text "pil3" "~/books/__comp/ierusalimschy__programming_in_lua_3rd_ed.pdf" 19)
;; (find-pil3page)
;; (find-pil3page         8  "Contents")
;; (find-pil3page (+ 19   1) "I. The Language")
;; (find-pil3page (+ 19 339) "Index")
;; (find-pil3page (+ 19 1) "I The Language")
;; (find-pil3page (+ 19 3) "1 Getting Started")
;; (find-pil3page (+ 19 4) "1.1 Chunks")
;; (find-pil3page (+ 19 5) "1.2 Some Lexical Conventions")
;; (find-pil3page (+ 19 6) "1.3 Global Variables")
;; (find-pil3page (+ 19 6) "1.4 The Stand-Alone Interpreter")
;; (find-pil3page (+ 19 8) "Exercises")
;; (find-pil3page (+ 19 9) "2 Types and Values")
;; (find-pil3page (+ 19 10) "2.1 Nil")
;; (find-pil3page (+ 19 10) "2.2 Booleans")
;; (find-pil3page (+ 19 10) "2.3 Numbers")
;; (find-pil3page (+ 19 11) "2.4 Strings")
;; (find-pil3page (+ 19 15) "2.5 Tables")
;; (find-pil3page (+ 19 18) "2.6 Functions")
;; (find-pil3page (+ 19 18) "2.7 Userdata and Threads")
;; (find-pil3page (+ 19 18) "Exercises")
;; (find-pil3page (+ 19 21) "3 Expressions")
;; (find-pil3page (+ 19 21) "3.1 Arithmetic Operators")
;; (find-pil3page (+ 19 22) "3.2 Relational Operators")
;; (find-pil3page (+ 19 23) "3.3 Logical Operators")
;; (find-pil3page (+ 19 23) "3.4 Concatenation")
;; (find-pil3page (+ 19 24) "3.5 The Length Operator")
;; (find-pil3page (+ 19 25) "3.6 Precedence")
;; (find-pil3page (+ 19 26) "3.7 Table Constructors")
;; (find-pil3page (+ 19 28) "Exercises")
;; (find-pil3page (+ 19 29) "4 Statements")
;; (find-pil3page (+ 19 29) "4.1 Assignment")
;; (find-pil3page (+ 19 30) "4.2 Local Variables and Blocks")
;; (find-pil3page (+ 19 32) "4.3 Control Structures")
;; (find-pil3page (+ 19 36) "4.4 break, return, and goto")
;; (find-pil3page (+ 19 38) "Exercises")
;; (find-pil3page (+ 19 41) "5 Functions")
;; (find-pil3page (+ 19 42) "5.1 Multiple Results")
;; (find-pil3page (+ 19 46) "5.2 Variadic Functions")
;; (find-pil3page (+ 19 48) "5.3 Named Arguments")
;; (find-pil3page (+ 19 49) "Exercises")
;; (find-pil3page (+ 19 51) "6 More about Functions")
;; (find-pil3page (+ 19 53) "6.1 Closures")
;; (find-pil3page (+ 19 56) "6.2 Non-Global Functions")
;; (find-pil3page (+ 19 58) "6.3 Proper Tail Calls")
;; (find-pil3page (+ 19 59) "Exercises")
;; (find-pil3page (+ 19 61) "7 Iterators and the Generic for")
;; (find-pil3page (+ 19 61) "7.1 Iterators and Closures")
;; (find-pil3page (+ 19 63) "7.2 The Semantics of the Generic for")
;; (find-pil3page (+ 19 64) "7.3 Stateless Iterators")
;; (find-pil3page (+ 19 66) "7.4 Iterators with Complex State")
;; (find-pil3page (+ 19 67) "7.5 True Iterators")
;; (find-pil3page (+ 19 68) "Exercises")
;; (find-pil3page (+ 19 71) "8 Compilation, Execution, and Errors")
;; (find-pil3page (+ 19 71) "8.1 Compilation")
;; (find-pil3page (+ 19 75) "8.2 Precompiled Code")
;; (find-pil3page (+ 19 76) "8.3 C Code")
;; (find-pil3page (+ 19 77) "8.4 Errors")
;; (find-pil3page (+ 19 79) "8.5 Error Handling and Exceptions")
;; (find-pil3page (+ 19 79) "8.6 Error Messages and Tracebacks")
;; (find-pil3page (+ 19 81) "Exercises")
;; (find-pil3page (+ 19 83) "9 Coroutines")
;; (find-pil3page (+ 19 83) "9.1 Coroutine Basics")
;; (find-pil3page (+ 19 86) "9.2 Pipes and Filters")
;; (find-pil3page (+ 19 89) "9.3 Coroutines as Iterators")
;; (find-pil3page (+ 19 91) "9.4 Non-Preemptive Multithreading")
;; (find-pil3page (+ 19 95) "Exercises")
;; (find-pil3page (+ 19 97) "10 Complete Examples")
;; (find-pil3page (+ 19 97) "10.1 The Eight-Queen Puzzle")
;; (find-pil3page (+ 19 99) "10.2 Most Frequent Words")
;; (find-pil3page (+ 19 101) "10.3 Markov Chain Algorithm")
;; (find-pil3page (+ 19 102) "Exercises")
;; (find-pil3page (+ 19 105) "II Tables and Objects")
;; (find-pil3page (+ 19 107) "11 Data Structures")
;; (find-pil3page (+ 19 107) "11.1 Arrays")
;; (find-pil3page (+ 19 108) "11.2 Matrices and Multi-Dimensional Arrays")
;; (find-pil3page (+ 19 110) "11.3 Linked Lists")
;; (find-pil3page (+ 19 110) "11.4 Queues and Double Queues")
;; (find-pil3page (+ 19 111) "11.5 Sets and Bags")
;; (find-pil3page (+ 19 113) "11.6 String Buffers")
;; (find-pil3page (+ 19 114) "11.7 Graphs")
;; (find-pil3page (+ 19 116) "Exercises")
;; (find-pil3page (+ 19 117) "12 Data Files and Persistence")
;; (find-pil3page (+ 19 117) "12.1 Data Files")
;; (find-pil3page (+ 19 119) "12.2 Serialization")
;; (find-pil3page (+ 19 125) "Exercises")
;; (find-pil3page (+ 19 127) "13 Metatables and Metamethods")
;; (find-pil3page (+ 19 128) "13.1 Arithmetic Metamethods")
;; (find-pil3page (+ 19 131) "13.2 Relational Metamethods")
;; (find-pil3page (+ 19 132) "13.3 Library-Defined Metamethods")
;; (find-pil3page (+ 19 133) "13.4 Table-Access Metamethods")
;; (find-pil3page (+ 19 138) "Exercises")
;; (find-pil3page (+ 19 139) "14 The Environment")
;; (find-pil3page (+ 19 139) "14.1 Global Variables with Dynamic Names")
;; (find-pil3page (+ 19 141) "14.2 Global-Variable Declarations")
;; (find-pil3page (+ 19 142) "14.3 Non-Global Environments")
;; (find-pil3page (+ 19 144) "14.4 Using")
;; (find-pil3page (+ 19 147) "14.5 and")
;; (find-pil3page (+ 19 148) "Exercises")
;; (find-pil3page (+ 19 151) "15 Modules and Packages")
;; (find-pil3page (+ 19 153) "15.1 The require Function")
;; (find-pil3page (+ 19 156) "15.2 The Basic Approach for Writing Modules in Lua")
;; (find-pil3page (+ 19 158) "15.3 Using Environments")
;; (find-pil3page (+ 19 159) "15.4 Submodules and Packages")
;; (find-pil3page (+ 19 161) "Exercises")
;; (find-pil3page (+ 19 163) "16 Object-Oriented Programming")
;; (find-pil3page (+ 19 165) "16.1 Classes")
;; (find-pil3page (+ 19 166) "16.2 Inheritance")
;; (find-pil3page (+ 19 168) "16.3 Multiple Inheritance")
;; (find-pil3page (+ 19 170) "16.4 Privacy")
;; (find-pil3page (+ 19 172) "16.5 The Single-Method Approach")
;; (find-pil3page (+ 19 173) "Exercises")
;; (find-pil3page (+ 19 175) "17 Weak Tables and Finalizers")
;; (find-pil3page (+ 19 175) "17.1 Weak Tables")
;; (find-pil3page (+ 19 177) "17.2 Memoize Functions")
;; (find-pil3page (+ 19 179) "17.3 Object Attributes")
;; (find-pil3page (+ 19 179) "17.4 Revisiting Tables with Default Values")
;; (find-pil3page (+ 19 180) "17.5 Ephemeron Tables")
;; (find-pil3page (+ 19 181) "17.6 Finalizers")
;; (find-pil3page (+ 19 185) "Exercises")
;; (find-pil3page (+ 19 187) "III The Standard Libraries")
;; (find-pil3page (+ 19 189) "18 The Mathematical Library")
;; (find-pil3page (+ 19 190) "Exercises")
;; (find-pil3page (+ 19 191) "19 The Bitwise Library")
;; (find-pil3page (+ 19 194) "Exercises")
;; (find-pil3page (+ 19 195) "20 The Table Library")
;; (find-pil3page (+ 19 195) "20.1 Insert and Remove")
;; (find-pil3page (+ 19 196) "20.2 Sort")
;; (find-pil3page (+ 19 197) "20.3 Concatenation")
;; (find-pil3page (+ 19 198) "Exercises")
;; (find-pil3page (+ 19 199) "21 The String Library")
;; (find-pil3page (+ 19 199) "21.1 Basic String Functions")
;; (find-pil3page (+ 19 201) "21.2 Pattern-Matching Functions")
;; (find-pil3page (+ 19 204) "21.3 Patterns")
;; (find-pil3page (+ 19 208) "21.4 Captures")
;; (find-pil3page (+ 19 209) "21.5 Replacements")
;; (find-pil3page (+ 19 213) "21.6 Tricks of the Trade")
;; (find-pil3page (+ 19 216) "21.7 Unicode")
;; (find-pil3page (+ 19 218) "Exercises")
;; (find-pil3page (+ 19 221) "22 The I/O Library")
;; (find-pil3page (+ 19 221) "22.1 The Simple I/O Model")
;; (find-pil3page (+ 19 224) "22.2 The Complete I/O Model")
;; (find-pil3page (+ 19 228) "22.3 Other Operations on Files")
;; (find-pil3page (+ 19 229) "Exercises")
;; (find-pil3page (+ 19 231) "23 The Operating System Library")
;; (find-pil3page (+ 19 231) "23.1 Date and Time")
;; (find-pil3page (+ 19 233) "23.2 Other System Calls")
;; (find-pil3page (+ 19 235) "Exercises")
;; (find-pil3page (+ 19 237) "24 The Debug Library")
;; (find-pil3page (+ 19 237) "24.1 Introspective Facilities")
;; (find-pil3page (+ 19 242) "24.2 Hooks")
;; (find-pil3page (+ 19 243) "24.3 Profiles")
;; (find-pil3page (+ 19 245) "Exercises")
;; (find-pil3page (+ 19 247) "IV The C API")
;; (find-pil3page (+ 19 249) "25 An Overview of the C API")
;; (find-pil3page (+ 19 250) "25.1 A First Example")
;; (find-pil3page (+ 19 253) "25.2 The Stack")
;; (find-pil3page (+ 19 258) "25.3 Error Handling with the C API")
;; (find-pil3page (+ 19 260) "Exercises")
;; (find-pil3page (+ 19 261) "26 Extending Your Application")
;; (find-pil3page (+ 19 261) "26.1 The Basics")
;; (find-pil3page (+ 19 263) "26.2 Table Manipulation")
;; (find-pil3page (+ 19 267) "26.3 Calling Lua Functions")
;; (find-pil3page (+ 19 269) "26.4 A Generic Call Function")
;; (find-pil3page (+ 19 270) "Exercises")
;; (find-pil3page (+ 19 273) "27 Calling C from Lua")
;; (find-pil3page (+ 19 273) "27.1 C Functions")
;; (find-pil3page (+ 19 275) "27.2 Continuations")
;; (find-pil3page (+ 19 278) "27.3 C Modules")
;; (find-pil3page (+ 19 280) "Exercises")
;; (find-pil3page (+ 19 281) "28 Techniques for Writing C Functions")
;; (find-pil3page (+ 19 281) "28.1 Array Manipulation")
;; (find-pil3page (+ 19 283) "28.2 String Manipulation")
;; (find-pil3page (+ 19 286) "28.3 Storing State in C Functions")
;; (find-pil3page (+ 19 292) "Exercises")
;; (find-pil3page (+ 19 293) "29 User-Defined Types in C")
;; (find-pil3page (+ 19 294) "29.1 Userdata")
;; (find-pil3page (+ 19 296) "29.2 Metatables")
;; (find-pil3page (+ 19 299) "29.3 Object-Oriented Access")
;; (find-pil3page (+ 19 300) "29.4 Array Access")
;; (find-pil3page (+ 19 301) "29.5 Light Userdata")
;; (find-pil3page (+ 19 302) "Exercises")
;; (find-pil3page (+ 19 305) "30 Managing Resources")
;; (find-pil3page (+ 19 305) "30.1 A Directory Iterator")
;; (find-pil3page (+ 19 307) "30.2 An XML Parser")
;; (find-pil3page (+ 19 316) "Exercises")
;; (find-pil3page (+ 19 319) "31 Threads and States")
;; (find-pil3page (+ 19 319) "31.1 Multiple Threads")
;; (find-pil3page (+ 19 323) "31.2 Lua States")
;; (find-pil3page (+ 19 331) "Exercises")
;; (find-pil3page (+ 19 333) "32 Memory Management")
;; (find-pil3page (+ 19 333) "32.1 The Allocation Function")
;; (find-pil3page (+ 19 335) "32.2 The Garbage Collector")
;; (find-pil3page (+ 19 338) "Exercises")
;; (find-pil3page (+ 19 339) "Index")
;; (find-pil3text "")

;; (find-pil2page         8  "Contents")
;; (find-pil2page (+ 19   1) "I. The Language")
;; (find-pil2page (+ 19   3)  "1. Getting Started")
;; (find-pil2page (+ 19   9)  "2. Types and Values")
;; (find-pil2page (+ 19  19)  "3. Expressions")
;; (find-pil2page (+ 19  27)  "4. Statements")
;; (find-pil2page (+ 19  35)  "5. Functions")
;; (find-pil2page (+ 19  41)   "Lua 5.0" "..." "arg" "n field")
;; (find-pil2page (+ 19  45)  "6. More About Functions")
;; (find-pil2page (+ 19  55)  "7. Iterators and the Generic for")
;; (find-pil2page (+ 19  63)  "8. Compilation, Execution, and Errors")
;; (find-pil2page (+ 19  70)   "8.5    Error Messages and Tracebacks")
;; (find-pil2text (+ 19  70)   "8.5    Error Messages and Tracebacks")
;; (find-pil2page (+ 19  73)  "9. Coroutines")
;; (find-pil2page (+ 19  87)  "10. Complete Examples")
;; (find-pil2page (+ 19  95) "II. Tables and Objects")
;; (find-pil2page (+ 19  97)  "11. Data Structures")
;; (find-pil2page (+ 19 107)  "12. Data Files and Persistence")
;; (find-pil2page (+ 19 117)  "13. Metatables and Metamethods")
;; (find-pil2page (+ 19 129)  "14. The Environment")
;; (find-pil2page (+ 19 137)  "15. Modules and Packages")
;; (find-pil2page (+ 19 138)   "15.1 The require Function")
;; (find-pil2text (+ 19 138)   "15.1 The require Function")
;; (find-pil2page (+ 19 149)  "16. Object-Oriented Programming")
;; (find-pil2page (+ 19 161)  "17. Weak Tables")
;; (find-pil2page (+ 19 167) "III. The Standard Libraries")
;; (find-pil2page (+ 19 169)  "18. The Mathematical Library")
;; (find-pil2page (+ 19 171)  "19. The Table Library")
;; (find-pil2page (+ 19 175)  "20. The String Library")
;; (find-pil2page (+ 19 193)  "21. The I/O Library")
;; (find-pil2page (+ 19 201)  "22. The Operating System Library")
;; (find-pil2page (+ 19 205)  "23. The Debug Library")
;; (find-pil2page (+ 19 215) "IV. The C API")
;; (find-pil2page (+ 19 217)  "24. An Overview of the C API")
;; (find-pil2page (+ 19 223)    "lua_type")
;; (find-pil2page (+ 19 229)  "25. Extending Your Application")
;; (find-pil2page (+ 19 241)  "26. Calling C from Lua")
;; (find-pil2page (+ 19 244)  "26.1. C Functions")
;; (find-pil2page (+ 19 244)  "26.2. C Modules")
;; (find-pil2page (+ 19 247)  "27. Techniques for Writing C Functions")
;; (find-pil2page (+ 19 259)  "28. User-Defined Types in C")
;; (find-pil2page (+ 19 269)  "29. Managing Resources")
;; (find-pil2page (+ 19 281)  "30. Threads and States")
;; (find-pil2page (+ 19 293)  "31. Memory Management")
;; (find-pil2page (+ 19 299) "Index")
;; (find-pil2text "")


;; «impagliazzo»  (to ".impagliazzo")
;; (find-books "__comp/__comp.el" "impagliazzo")
(code-pdf-page "fiveworlds" "~/books/__comp/impagliazzo__a_personal_view_of_average-case_complexity.pdf")
(code-pdf-text "fiveworlds" "~/books/__comp/impagliazzo__a_personal_view_of_average-case_complexity.pdf" 1)
;; (find-fiveworldspage)
;; (find-fiveworldstext "")
;; (find-fiveworldspage 3 "2.1 Algorithmica")
;; (find-fiveworldstext 3 "2.1 Algorithmica")
;; (find-fiveworldspage 5 "2.2 Heuristica")
;; (find-fiveworldstext 5 "2.2 Heuristica")
;; (find-fiveworldspage 6 "2.3 Pessiland")
;; (find-fiveworldstext 6 "2.3 Pessiland")
;; (find-fiveworldspage 7 "2.4 Minicrypt")
;; (find-fiveworldstext 7 "2.4 Minicrypt")
;; (find-fiveworldspage 8 "2.5 Cryptomania")
;; (find-fiveworldstext 8 "2.5 Cryptomania")



;; «kavvos»  (to ".kavvos")
;; G. A. Kavvos: Intensionality, Intensional Recursion, and the Gödel-Löb axiom
;; https://arxiv.org/abs/1703.01288
;; https://arxiv.org/pdf/1703.01288.pdf
(code-pdf-page "kavvos" "$S/https/arxiv.org/pdf/1703.01288.pdf")
(code-pdf-text "kavvos" "$S/https/arxiv.org/pdf/1703.01288.pdf")
;; (find-kavvospage)
;; (find-kavvostext)



;; «kernighan-plauger»  (to ".kernighan-plauger")
;; (find-books "__comp/__comp.el" "kernighan-plauger")
;; https://en.wikipedia.org/wiki/The_Elements_of_Programming_Style
(code-pdf-page "kernighanp" "~/books/__comp/kernighan_plauger__the_elements_of_programming_style.pdf")
(code-pdf-text "kernighanp" "~/books/__comp/kernighan_plauger__the_elements_of_programming_style.pdf" 13)
;; (find-kernighanppage)
;; (find-kernighanppage         6  "Contents")
;; (find-kernighanppage (+ 13   1) "1. Introduction")
;; (find-kernighanppage (+ 13   2)   "Write clearly")
;; (find-kernighanptext (+ 13   2)   "Write clearly")
;; (find-kernighanppage (+ 13   9) "2. Expression")
;; (find-kernighanppage (+ 13  31) "3. Control structure")
;; (find-kernighanppage (+ 13  52)   "Choose a data representation" "that makes the program simple")
;; (find-kernighanptext (+ 13  52)   "Choose a data representation" "that makes the program simple")
;; (find-kernighanppage (+ 13  59) "4. Program structure")
;; (find-kernighanppage (+ 13  83) "5. Input and output")
;; (find-kernighanppage (+ 13 101) "6. Common blunders")
;; (find-kernighanppage (+ 13 123) "7. Efficiency and instrumentation")
;; (find-kernighanppage (+ 13 141) "8. Documentation")
;; (find-kernighanppage (+ 13 155) "Epilogue")
;; (find-kernighanppage (+ 13 157) "Supplementary Reading")
;; (find-kernighanppage (+ 13 159) "Summary of rules")
;; (find-kernighanppage (+ 13 163) "Index")
;; (find-kernighanptext "")

(code-pdf-page "kernighanpst" "~/books/__comp/kernighan_plauger__software_tools.pdf")
(code-pdf-text "kernighanpst" "~/books/__comp/kernighan_plauger__software_tools.pdf" 1)
;; (find-kernighanpstpage)
;; (find-kernighanpstpage        7  "Contents")
;; (find-kernighanpstpage (+ 7   1) "Introduction")
;; (find-kernighanpstpage (+ 7   7) "1. Getting started")
;; (find-kernighanpsttext "")

(code-pdf-page "kernighanpstpas" "~/books/__comp/kernighan_plauger__software_tools_in_pascal.pdf")
(code-pdf-text "kernighanpstpas" "~/books/__comp/kernighan_plauger__software_tools_in_pascal.pdf" 1)
;; (find-kernighanpstpaspage)
;; (find-kernighanpstpaspage        1  "Contents")
;; (find-kernighanpstpaspage (+ 1 189) "Index")
;; (find-kernighanpstpastext "")





;; «knuth»  (to ".knuth")
(code-djvu       "knuthlitprog" "~/books/__comp/knuth__literate_programming.djvu")
(code-djvutotext "knuthlitprog" "~/books/__comp/knuth__literate_programming.djvu")
;; (find-knuthlitprogpage        1  "Contents")
;; (find-knuthlitprogpage (+ 0 359) "Index")
;; (find-knuthlitprogtext "")


;; «kurt»  (to ".kurt")
;; (find-books "__comp/__comp.el" "kurt")
(code-pdf-page "gethaskell" "~/books/__comp/kurt__get_programming_with_haskell.pdf")
(code-pdf-text "gethaskell" "~/books/__comp/kurt__get_programming_with_haskell.pdf" 1)
;; (find-gethaskellpage)
;; (find-gethaskellpage        1  "Contents")
;; (find-gethaskellpage (+ 1 189) "Index")
;; (find-gethaskelltext "")



;; «levy» (to ".levy")
;; (find-books "__comp/__comp.el" "levy")
(code-pdf       "CBPV" "~/books/__comp/levy__call-by-push-value.pdf")
(code-pdftotext "CBPV" "~/books/__comp/levy__call-by-push-value.pdf" 37)
;; (find-CBPVpage)
;; (find-CBPVpage         6  "Contents")
;; (find-CBPVtext         6  "Contents")
;; (find-CBPVpage (+ 37   3) "1. Call-by-Value and Call-by-Name")
;; (find-CBPVpage (+ 37   8) "1.5 The Principles Of Call-By-Value and Call-By-Name")
;; (find-CBPVpage (+ 37  10) "1.6 Call-By-Value")
;; (find-CBPVpage (+ 37  18) "1.7 Call-By-Name")
;; (find-CBPVpage (+ 37  20) "1.7.3 CBN vs. Lazy")
;; (find-CBPVpage (+ 37  27) "2. Call-By-Push-Value: A Subsuming Paradigm")
;; (find-CBPVpage (+ 37  32) "2.3.2 CK-Machine")
;; (find-CBPVpage (+ 29 337) "References")
;; (find-CBPVtext (+ 29 337) "References")
;; (find-CBPVpage (+ 28 345) "Index")
;; (find-CBPVpage (+ 28 347) "Index" "dismantling")
;; (find-CBPVtext "")

;; "What is a monoid? How I learnt to stop worrying and love skewness":
;; http://conferences.inf.ed.ac.uk/ct2019/slides/83.pdf

;; «levy-slides2018»  (to ".levy-slides2018")
;; (find-books "__comp/__comp.el" "levy-slides2018")
;; https://www.cs.bham.ac.uk/~pbl/
;; https://www.cs.bham.ac.uk/~pbl/mgsfastlam.pdf
;; "lambda-calculus, effects and call-by-push-value" (slides, 2018)
(code-pdf-page "pbl2018" "$S/https/www.cs.bham.ac.uk/~pbl/mgsfastlam.pdf")
(code-pdf-text "pbl2018" "$S/https/www.cs.bham.ac.uk/~pbl/mgsfastlam.pdf")
;; (find-pbl2018page)
;; (find-pbl2018text)
;; (find-pbl2018page  8 "Typing rules for bool")
;; (find-pbl2018text  8 "Typing rules for bool")
;; (find-pbl2018page 72 "Evaluation order for let")
;; (find-pbl2018text 72 "Evaluation order for let")
;; (find-pbl2018page 85 "Where this story comes from")
;; (find-pbl2018text 85 "Where this story comes from")
;; (find-pbl2018page 86 "Let E = {CRASH, BANG} be a set of \"errors\"")
;; (find-pbl2018text 86 "Let E = {CRASH, BANG} be a set of \"errors\"")
;; (find-pbl2018page 109 "Fine-Grain Call-By-Value")
;; (find-pbl2018text 109 "Fine-Grain Call-By-Value")
;; (find-pbl2018page 118 "Nullary functions" "thunks")
;; (find-pbl2018text 118 "Nullary functions" "thunks")
;; (find-pbl2018page 124 "Solution: E-pointed sets")
;; (find-pbl2018text 124 "Solution: E-pointed sets")
;; (find-pbl2018page 129 "Notation for E-pointed sets")
;; (find-pbl2018text 129 "Notation for E-pointed sets")
;; (find-pbl2018page 130 "Summary of call-by-name semantics")
;; (find-pbl2018text 130 "Summary of call-by-name semantics")
;; (find-pbl2018page 131 "Summary of call-by-value semantics")
;; (find-pbl2018text 131 "Summary of call-by-value semantics")
;; (find-pbl2018page 134 "Call-By-Push-Value Types")
;; (find-pbl2018text 134 "Call-By-Push-Value Types")
;; (find-pbl2018page 139 "The type F A")
;; (find-pbl2018text 139 "The type F A")
;; (find-pbl2018page 141 "The type U B")
;; (find-pbl2018text 141 "The type U B")
;; (find-pbl2018page 152 "Decomposing CBV into CBPV")
;; (find-pbl2018text 152 "Decomposing CBV into CBPV")
;; (find-pbl2018page 154 "Decomposing CBN into CBPV")
;; (find-pbl2018text 154 "Decomposing CBN into CBPV")
;; (find-pbl2018page 188 "Adjunction between values and stacks")
;; (find-pbl2018text 188 "Adjunction between values and stacks")
;; (find-pbl2018page 224 "Summary: adjunctions between values and stacks")
;; (find-pbl2018text 224 "Summary: adjunctions between values and stacks")

;; «levy-thpartsets»  (to ".levy-thpartsets")
;; "A Theory of Particular Sets" (2019):
;; https://arxiv.org/abs/1905.02718
;; https://arxiv.org/pdf/1905.02718.pdf
(code-pdf-page "levytpartsets" "$S/https/arxiv.org/pdf/1905.02718.pdf")
(code-pdf-text "levytpartsets" "$S/https/arxiv.org/pdf/1905.02718.pdf")
;; (find-levytpartsetspage)
;; (find-levytpartsetstext)

;; «levy-lambdanotes»  (to ".levy-lambdanotes")
;; Paul Blain Levy: "Typed lambda-calculus: course notes"
;; https://www.cs.bham.ac.uk/~pbl/mgsall.pdf
(code-pdf-page "pbllambdanotes" "$S/https/www.cs.bham.ac.uk/~pbl/mgsall.pdf")
(code-pdf-text "pbllambdanotes" "$S/https/www.cs.bham.ac.uk/~pbl/mgsall.pdf")
;; (find-pbllambdanotespage)
;; (find-pbllambdanotestext)


;; «libes» (to ".libes")
(code-xpdf     "eexpect" "~/books/__comp/libes__exploring_expect.pdf")
(code-pdf-text "eexpect" "~/books/__comp/libes__exploring_expect.pdf")
;; (find-eexpectpage)
;; (find-eexpectpage 2)
;; (find-eexpectpage 9 "Chapters")
;; (find-eexpecttext)


;; «loeliger»  (to ".loeliger")
;; (find-books "__comp/__comp.el" "loeliger")
;; https://archive.org/stream/R.G.LoeligerThreadedInterpretiveLanguagesTheirDesignAndImplementationByteBooks1981
(code-pdf-page "loeligertils" "~/books/__comp/loeliger__threaded_interpretive_languages_their_design_and_implementation.pdf")
(code-pdf-text "loeligertils" "~/books/__comp/loeliger__threaded_interpretive_languages_their_design_and_implementation.pdf" 1)
;; (find-loeligertilspage)
;; (find-loeligertilspage        8  "Contents")
;; (find-loeligertilspage (+ 15 1) "1. OVERVIEW")
;; (find-loeligertilspage (+ 15 1) "1.1 Introduction")
;; (find-loeligertilspage (+ 15 2) "1.2 What is a TIL?")
;; (find-loeligertilspage (+ 15 3) "1.3 The Elements")
;; (find-loeligertilspage (+ 15 6) "1.4 The Attributes")
;; (find-loeligertilspage (+ 15 7) "1.5 Implementation Notes")
;; (find-loeligertilspage (+ 15 9) "2. HOW A TIL WORKS")
;; (find-loeligertilspage (+ 15 9) "2.1 Operator's View")
;; (find-loeligertilspage (+ 15 12) "2.2 Dictionary Format")
;; (find-loeligertilspage (+ 15 14) "2.3 Outer Interpreter")
;; (find-loeligertilspage (+ 15 18) "2.4 Inner Interpreter")
;; (find-loeligertilspage (+ 15 21) "2.5 Defining Words and the Compiler Mode")
;; (find-loeligertilspage (+ 15 25) "2.6 Vocabularies")
;; (find-loeligertilspage (+ 15 26) "2.7 Synthesis")
;; (find-loeligertilspage (+ 15 28) "3. HUP, TWO, THREE, FOUR")
;; (find-loeligertilspage (+ 15 28) "3.1 An Inner Interpreter for a Generic Computer")
;; (find-loeligertilspage (+ 15 32) "3.2 An Inner Interpreter for the Z80")
;; (find-loeligertilspage (+ 15 38) "3.3 Double Time")
;; (find-loeligertilspage (+ 15 39) "4. THE TOWER OF BABEL REVISITED")
;; (find-loeligertilspage (+ 15 39) "4.1 Naming Conventions")
;; (find-loeligertilspage (+ 15 40) "4.2 Data Types")
;; (find-loeligertilspage (+ 15 48) "4.3 Operator Keywords")
;; (find-loeligertilspage (+ 15 72) "4.6 Vocabulary Keywords")
;; (find-loeligertilspage (+ 15 73) "4.7 Babblings")
;; (find-loeligertilspage (+ 15 74) "ROUTINES, ROUTINES, ROUTINES")
;; (find-loeligertilspage (+ 15 74) "5.1 Core TIL Design Notes")
;; (find-loeligertilspage (+ 15 77) "5.2 Outer Interpreter Design")
;; (find-loeligertilspage (+ 15 87) "5.3 Routine Routines")
;; (find-loeligertilspage (+ 15 99) "5.4 Doing It")
;; (find-loeligertilspage (+ 15 100) "5.5 Arithmetic Routines")
;; (find-loeligertilspage (+ 15 103) "WORDS, WORDS, AND MORE WORDS")
;; (find-loeligertilspage (+ 15 103) "6.1 The Word")
;; (find-loeligertilspage (+ 15 174) "6.2 A Classy Cross Reference")
;; (find-loeligertilspage (+ 15 179) "6.3 Sum Total")
;; (find-loeligertilspage (+ 15 180) "7. EXTENSION PLEASE")
;; (find-loeligertilspage (+ 15 180) "7.1 Introductions")
;; (find-loeligertilspage (+ 15 182) "7.2 Assemblers")
;; (find-loeligertilspage (+ 15 210) "7.3 Virtual Memory")
;; (find-loeligertilspage (+ 15 220) "7.4 Editor")
;; (find-loeligertilspage (+ 15 224) "7.5 Cross Compilation")
;; (find-loeligertilspage (+ 15 226) "7.6 Widget Sorters")
;; (find-loeligertilspage (+ 15 228) "7.7 Floatingpoint")
;; (find-loeligertilspage (+ 15 233) "7.8 Extension Summary")
;; (find-loeligertilspage (+ 15 234) "LIFE WITH A TIL")
;; (find-loeligertilspage (+ 15 234) "8.1 Starting Out")
;; (find-loeligertilspage (+ 15 235) "8.2 Program Structure")
;; (find-loeligertilspage (+ 15 239) "8.3 Program Design")
;; (find-loeligertilspage (+ 15 241) "8.4 Entry and Test")
;; (find-loeligertilspage (+ 15 243) "8.5 Tricks of the Trade")
;; (find-loeligertilspage (+ 15 244) "Bibliography and Notes")
;; (find-loeligertilspage (+ 15 248) "Index")
;; (find-loeligertilstext "")



;; «marlow-peyton-jones»  (to ".marlow-peyton-jones")
;; (find-books "__comp/__comp.el" "marlow-peyton-jones")
;; https://link.springer.com/chapter/10.1007/978-1-4471-3215-8_6
(code-pdf-page "mpjretrosp" "~/books/__comp/marlow_peyton-jones__the_glasgow_haskell_compiler_a_retrospective.pdf")
(code-pdf-text "mpjretrosp" "~/books/__comp/marlow_peyton-jones__the_glasgow_haskell_compiler_a_retrospective.pdf" 1)
;; (find-mpjretrosppage)
;; (find-mpjretrosppage        1  "Contents")
;; (find-mpjretrosppage (+ 1 189) "Index")
;; (find-mpjretrosptext "")
;; (find-mpjretrosppage 9 "2.3.4    Desugaring, and the Core language")
;; (find-mpjretrosptext 9 "2.3.4    Desugaring, and the Core language")
;; (find-mpjretrosppage 11 "3.1    The intermediate language")
;; (find-mpjretrosptext 11 "3.1    The intermediate language")


;; «martin»  (to ".martin")
;; (find-books "__comp/__comp.el" "martin")
(code-pdf-page "cleancode" "~/books/__comp/martin__clean_code_a_handbook_of_agile_software_craftsmanship.pdf")
(code-pdf-text "cleancode" "~/books/__comp/martin__clean_code_a_handbook_of_agile_software_craftsmanship.pdf" 1)
;; (find-cleancodepage)
;; (find-cleancodepage        1  "Contents")
;; (find-cleancodepage (+ 1 189) "Index")
;; (find-cleancodetext "")


;; «mcbride»  (to ".mcbride")
;; (find-books "__comp/__comp.el" "mcbride")
;; http://strictlypositive.org/
;; http://strictlypositive.org/calculus/
;; http://strictlypositive.org/vfl.pdf
(code-pdf-page "viewfromtheleft" "$S/http/strictlypositive.org/vfl.pdf")
(code-pdf-text "viewfromtheleft" "$S/http/strictlypositive.org/vfl.pdf")
;; (find-viewfromtheleftpage)
;; (find-viewfromtheleftpage 44 "References")
;; (find-viewfromthelefttext)



;; «meyer»  (to ".meyer")
;; (find-books "__comp/__comp.el" "meyer")
;; https://doi.org/10.1016/S0019-9958(82)80087-9
(code-pdf-page "wiamolc" "~/books/__comp/meyer__what_is_a_model_of_the_lambda_calculus.pdf")
(code-pdf-text "wiamolc" "~/books/__comp/meyer__what_is_a_model_of_the_lambda_calculus.pdf" -86)
;; (find-wiamolcpage)
;; (find-wiamolcpage (+ -86 87) "1. Introduction")
;; (find-wiamolctext (+ -86 87) "1. Introduction")
;; (find-wiamolcpage (+ -86 88) "can quickly lead to contradiction")
;; (find-wiamolctext (+ -86 88) "can quickly lead to contradiction")
;; (find-wiamolctext "")



;; «milner»  (to ".milner")
;; (find-books "__comp/__comp.el" "milner")
;; (find-books "__logic/__logic.el" "logic-and-alg-spec")
;; Robin Milner: "The Polyadic pi-Calculus: a Tutorial"
;; https://www.lfcs.inf.ed.ac.uk/reports/91/ECS-LFCS-91-180/
;; https://www.lfcs.inf.ed.ac.uk/reports/91/ECS-LFCS-91-180/ECS-LFCS-91-180.ps
;; https://www.lfcs.inf.ed.ac.uk/reports/91/ECS-LFCS-91-180/ECS-LFCS-91-180.pdf
;; (find-sh "cd $S/https/www.lfcs.inf.ed.ac.uk/reports/91/ECS-LFCS-91-180/ && ps2pdf ECS-LFCS-91-180.ps")
(code-pdf-page "polypiput" "$S/https/www.lfcs.inf.ed.ac.uk/reports/91/ECS-LFCS-91-180/ECS-LFCS-91-180.pdf")
(code-pdf-text "polypiput" "$S/https/www.lfcs.inf.ed.ac.uk/reports/91/ECS-LFCS-91-180/ECS-LFCS-91-180.pdf")
;; (find-polypiputpage)
;; (find-polypiputtext)



;; «monnier»  (to ".monnier")
;; (find-books "__comp/__comp.el" "monnier")
(code-pdf-page "typintla" "~/books/__comp/shao_league_monnier__implementing_typed_intermediate_languages.pdf")
(code-pdf-text "typintla" "~/books/__comp/shao_league_monnier__implementing_typed_intermediate_languages.pdf" 1)
;; (find-typintlapage)
;; (find-typintlapage        1  "Contents")
;; (find-typintlapage (+ 1 189) "Index")
;; (find-typintlatext "")
;;
;; «monnier-typer»  (to ".monnier-typer")
;; (find-books "__comp/__comp.el" "monnier-typer")
;; (find-es "ocaml" "typer")
;; http://www.iro.umontreal.ca/~monnier/typer-jfla2019.pdf
(code-pdf-page "monniertyper" "$S/http/www.iro.umontreal.ca/~monnier/typer-jfla2019.pdf")
(code-pdf-text "monniertyper" "$S/http/www.iro.umontreal.ca/~monnier/typer-jfla2019.pdf")
;; (find-monniertyperpage)
;; (find-monniertypertext)
;; (find-monniertyperpage 15 "References")
;; (find-monniertypertext 15 "References")
;; (find-monniertyperpage 16 "[Flo63]" "operator precedence")
;; (find-monniertypertext 16 "[Flo63]" "operator precedence")
;;
;; «monnier-cuc»  (to ".monnier-cuc")
;; (find-books "__comp/__comp.el" "monnier-cuc")
;; "Inductive Types Deconstructed: The Calculus of United Constructions" (2019)
;; http://www.iro.umontreal.ca/~monnier/itd-tyde-2019.pdf
(code-pdf-page "monniercuc" "$S/http/www.iro.umontreal.ca/~monnier/itd-tyde-2019.pdf")
(code-pdf-text "monniercuc" "$S/http/www.iro.umontreal.ca/~monnier/itd-tyde-2019.pdf" -51)
;; (find-monniercucpage)
;; (find-monniercuctext)
;; (find-monniercucpage (+ -51 61) "Figure 12. Mapping CUC to CIC")
;; (find-monniercuctext (+ -51 61) "Figure 12. Mapping CUC to CIC")
;;
;; «monnier-smie»  (to ".monnier-smie")
;; (find-books "__comp/__comp.el" "monnier-smie")
;; http://www.iro.umontreal.ca/~monnier/smie.pdf
(code-pdf-page "monniersmie" "$S/http/www.iro.umontreal.ca/~monnier/smie.pdf")
(code-pdf-text "monniersmie" "$S/http/www.iro.umontreal.ca/~monnier/smie.pdf")
;; (find-monniersmiepage)
;; (find-monniersmietext)



;; «nanevski»  (to ".nanevski")
;; (find-books "__comp/__comp.el" "nanevski")
;; https://software.imdea.org/~aleks/
;; https://software.imdea.org/~aleks/thesis/CMU-CS-04-151.pdf
;; Aleksandar Nanevski: "Functional Programming with Names and Necessity" (PhD thesis, 2004)
(code-pdf-page "nanevskiphd" "$S/https/software.imdea.org/~aleks/thesis/CMU-CS-04-151.pdf")
(code-pdf-text "nanevskiphd" "$S/https/software.imdea.org/~aleks/thesis/CMU-CS-04-151.pdf")
;; (find-nanevskiphdpage)
;; (find-nanevskiphdtext)
;;
;; Aleksandar Nanevski: "A Modal Calculus for Effect Handling" (2003)
;; https://software.imdea.org/~aleks/papers/effects/CMU-CS-03-149.pdf
(code-pdf-page "nanevskimceh" "$S/https/software.imdea.org/~aleks/papers/effects/CMU-CS-03-149.pdf")
(code-pdf-text "nanevskimceh" "$S/https/software.imdea.org/~aleks/papers/effects/CMU-CS-03-149.pdf")
;; (find-nanevskimcehpage)
;; (find-nanevskimcehtext)
;;
;; Nanevski/Morrisett/Birkedal: "Polymorphism and Separation in Hoare Type Theory" (2006)
;; https://software.imdea.org/~aleks/papers/hoarelogic/icfp06.pdf
(code-pdf-page "nanevskipshtt" "$S/https/software.imdea.org/~aleks/papers/hoarelogic/icfp06.pdf")
(code-pdf-text "nanevskipshtt" "$S/https/software.imdea.org/~aleks/papers/hoarelogic/icfp06.pdf")
;; (find-nanevskipshttpage)
;; (find-nanevskipshtttext)


;; «norell»  (to ".norell")
;; (find-books "__comp/__comp.el" "norell")
;; http://www.cse.chalmers.se/~ulfn/
;; https://twitter.com/ulfnorell?lang=en
;; http://doi.org/10.1145/2500365.2500609
;;
;; Ulf Norell: "Towards a practical programming language based on
;; dependent type theory" (PhD Thesis, 2007, about Agda)
;; https://en.wikiversity.org/wiki/Foundations_of_Functional_Programming/UTT-%CE%A3
;; http://www.cse.chalmers.se/~ulfn/papers/thesis.html
;; http://www.cse.chalmers.se/~ulfn/papers/thesis.pdf
(code-pdf-page "norellphd" "$S/http/www.cse.chalmers.se/~ulfn/papers/thesis.pdf")
(code-pdf-text "norellphd" "$S/http/www.cse.chalmers.se/~ulfn/papers/thesis.pdf")
;; (find-norellphdpage)
;; (find-norellphdtext)
;; (find-norellphdpage 7 "Contents")
;; (find-norellphdtext 7 "Contents")
;; (find-norellphdpage 15 "Figure 1.1: The syntax of UTT_Sigma")
;; (find-norellphdtext 15 "Figure 1.1: The syntax of UTT")
;; (find-norellphdpage 32 "2.1.4      Unification")
;; (find-norellphdtext 32 "2.1.4      Unification")



;; Bove/Dybjer/Norell: "A Brief Overview of Agda - A Functional Language with Dependent Types" (2009)
;; http://www.cse.chalmers.se/~ulfn/papers/tphols09/tutorial.pdf
(code-pdf-page "agdatut09" "$S/http/www.cse.chalmers.se/~ulfn/papers/tphols09/tutorial.pdf")
(code-pdf-text "agdatut09" "$S/http/www.cse.chalmers.se/~ulfn/papers/tphols09/tutorial.pdf")
;; (find-agdatut09page)
;; (find-agdatut09text)
;; (find-agdatut09page 1 "1    Introduction")
;; (find-agdatut09text 1 "1    Introduction")
;; (find-agdatut09page 2 "2    Agda Features")
;; (find-agdatut09text 2 "2    Agda Features")
;; (find-agdatut09page 3 "3   Agda and some Related Languages")
;; (find-agdatut09text 3 "3   Agda and some Related Languages")
;; (find-agdatut09page 3 "4   Example: Equational Proofs in Commutative Monoids")
;; (find-agdatut09text 3 "4   Example: Equational Proofs in Commutative Monoids")
;; (find-agdatut09page 6 "References")
;; (find-agdatut09text 6 "References")

;; "Type checking in the presence of meta-variables":
;; http://www.cse.chalmers.se/~ulfn/papers/meta-variables.pdf

;; (find-books "__comp/__comp.el" "norell")
;; https://doi.org/10.1145/2500365.2500610 (one page long)
(code-pdf-page "norellipdt" "~/books/__comp/norell__interactive_programming_with_dependent_types.pdf")
(code-pdf-text "norellipdt" "~/books/__comp/norell__interactive_programming_with_dependent_types.pdf" 1)
;; (find-norellipdtpage)
;; (find-norellipdtpage        1  "Contents")
;; (find-norellipdtpage (+ 1 189) "Index")
;; (find-norellipdttext "")

;; "Dependently Typed Programming in Agda"
;; https://link.springer.com/chapter/10.1007/978-3-642-04652-0_5




;; «orchard»  (to ".orchard")
;; (find-books "__comp/__comp.el" "orchard")
;; https://www.cs.kent.ac.uk/people/staff/dao7/
;; Orchard/Mycroft: "Categorical Programming for Data Types with Restricted Parametricity"
;; https://www.doc.ic.ac.uk/~dorchard/drafts/tfp-structures-orchard12.pdf
(code-pdf-page "orchardcprp" "$S/https/www.doc.ic.ac.uk/~dorchard/drafts/tfp-structures-orchard12.pdf")
(code-pdf-text "orchardcprp" "$S/https/www.doc.ic.ac.uk/~dorchard/drafts/tfp-structures-orchard12.pdf")
;; (find-orchardcprppage)
;; (find-orchardcprptext)

;; «orchard-rice»  (to ".orchard-rice")
;; Orchard/Rice: "A computational science agenda for programming language research" (2014)
;; https://www.cs.kent.ac.uk/people/staff/dao7/publ/iccs14-orchard-rice.pdf
;; See also:
;; https://philbull.wordpress.com/2020/05/10/why-you-can-ignore-reviews-of-scientific-code-by-commercial-software-developers/
;; https://www.akitaonrails.com/2020/05/07/o-modelo-do-imperial-college-sobre-a-covid-19-pode-estar-errado
(code-pdf-page "orchardrice" "$S/https/www.cs.kent.ac.uk/people/staff/dao7/publ/iccs14-orchard-rice.pdf")
(code-pdf-text "orchardrice" "$S/https/www.cs.kent.ac.uk/people/staff/dao7/publ/iccs14-orchard-rice.pdf")
;; (find-orchardricepage)
;; (find-orchardricetext)

;; «orchard-codo»  (to ".orchard-codo")
;; Orchard/Mycroft: "A Notation for Comonads"
;; https://www.cs.kent.ac.uk/people/staff/dao7/publ/codo-notation-orchard-ifl12.pdf
(code-pdf-page "orchardcodo" "$S/https/www.cs.kent.ac.uk/people/staff/dao7/publ/codo-notation-orchard-ifl12.pdf")
(code-pdf-text "orchardcodo" "$S/https/www.cs.kent.ac.uk/people/staff/dao7/publ/codo-notation-orchard-ifl12.pdf")
;; (find-orchardcodopage)
;; (find-orchardcodotext)

;; <orchard-four-Rs>
;; https://www.cs.kent.ac.uk/people/staff/dao7/publ/onwards-essay-orchard11.pdf
(code-pdf-page "orchard4rs" "$S/https/www.cs.kent.ac.uk/people/staff/dao7/publ/onwards-essay-orchard11.pdf")
(code-pdf-text "orchard4rs" "$S/https/www.cs.kent.ac.uk/people/staff/dao7/publ/onwards-essay-orchard11.pdf")
;; (find-orchard4rspage)
;; (find-orchard4rstext)








;; «ousterhout»  (to ".ousterhout")
;; (find-books "__comp/__comp.el" "ousterhout")
(code-pdf-page "tcltk" "~/books/__comp/ousterhout__tcl_and_the_tk_toolkit.pdf")
(code-pdf-text "tcltk" "~/books/__comp/ousterhout__tcl_and_the_tk_toolkit.pdf" 0)
;; (ee-page-parameters "tcltk" 8)
;; (ee-page-parameters "tcltk" 16)
;; (find-tcltktext "")
;; (find-tcltkpage      3  "Contents")
;; (find-tcltkpage    143  "Contents")
;; (find-tcltkpage    271  "Contents")
;; (find-tcltkpage    341  "Contents")
;; (find-tcltkpage (+  8   1) "1. Introduction")
;; (find-tcltkpage (+  8   1)  "1.1 Introduction")
;; (find-tcltkpage (+  8   3)  "1.2 Organization of the book")
;; (find-tcltkpage (+  8   4)  "1.3 Notation")
;; (find-tcltkpage (+  8   5) "2. An Overview of Tcl and Tk")
;; (find-tcltkpage (+  8   5)  "2.1 Getting started")
;; (find-tcltkpage (+  8   7)  "2.2 Hello world with Tk")
;; (find-tcltkpage (+  8   9)  "2.3 Script files")
;; (find-tcltkpage (+  8  10)  "2.4 Variables and substitutions")
;; (find-tcltktext (+  8  10)  "2.4 Variables and substitutions")
;; (find-tcltkpage (+  8  11)  "2.5 Control structures")
;; (find-tcltkpage (+  8  13)  "2.6 Event bindings")
;; (find-tcltkpage (+  8  15)  "2.7 Subprocesses")
;; (find-tcltkpage (+  8  18)  "2.8 Additional features of Tcl and Tk")
;; (find-tcltkpage (+  8  18)  "2.9 Extensions and applications")
;; (find-tcltkpage (+  8  19)  "2.9.1 Expect")
;; (find-tcltkpage (+  8  19)  "2.9.2 Extended Tcl")
;; (find-tcltkpage (+  8  20)  "2.9.3 XF")
;; (find-tcltkpage (+  8  20)  "2.9.4 Distributed programming")
;; (find-tcltkpage (+  8  22)  "2.9.5 Ak")
;; (find-tcltkpage (+  8  25) "3. Tcl Language Syntax")
;; (find-tcltkpage (+  8  25)  "3.1 Scripts, commands, and words")
;; (find-tcltkpage (+  8  26)  "3.2 Evaluating a command")
;; (find-tcltkpage (+  8  28)  "3.3 Variable substitution")
;; (find-tcltkpage (+  8  29)  "3.4 Command substitution")
;; (find-tcltkpage (+  8  30)  "3.5 Backslash substitution")
;; (find-tcltkpage (+  8  30)  "3.6 Quoting with double-quotes")
;; (find-tcltkpage (+  8  32)  "3.7 Quoting with braces")
;; (find-tcltkpage (+  8  33)  "3.8 Comments")
;; (find-tcltkpage (+  8  33)  "3.9 Normal and exceptional returns")
;; (find-tcltkpage (+  8  34)  "3.10 More on substitutions")
;; (find-tcltkpage (+  8  37) "4. Variables")
;; (find-tcltkpage (+  8  37)  "4.1 Simple variables and the set command")
;; (find-tcltkpage (+  8  38)  "4.2 Arrays")
;; (find-tcltkpage (+  8  39)  "4.3 Variable substitution")
;; (find-tcltkpage (+  8  40)  "4.4 Removing variables: unset")
;; (find-tcltkpage (+  8  41)  "4.5 Multi-dimensional arrays")
;; (find-tcltkpage (+  8  41)  "4.6 The incr and append commands")
;; (find-tcltkpage (+  8  42)  "4.7 Preview of other variable facilities")
;; (find-tcltkpage (+  8  43) "5. Expressions")
;; (find-tcltkpage (+  8  43)  "5.1 Numeric operands")
;; (find-tcltkpage (+  8  44)  "5.2 Operators and precedence")
;; (find-tcltkpage (+  8  44)  "5.2.1 Arithmetic operators")
;; (find-tcltkpage (+  8  46)  "5.2.2 Relational operators")
;; (find-tcltkpage (+  8  46)  "5.2.3 Logical operators")
;; (find-tcltkpage (+  8  46)  "5.2.4 Bitwise operators")
;; (find-tcltkpage (+  8  46)  "5.2.5 Choice operator")
;; (find-tcltkpage (+  8  47)  "5.3 Math functions")
;; (find-tcltkpage (+  8  47)  "5.4 Substitutions")
;; (find-tcltkpage (+  8  49)  "5.5 String manipulation")
;; (find-tcltkpage (+  8  49)  "5.6 Types and conversions")
;; (find-tcltkpage (+  8  50)  "5.7 Precision")
;; (find-tcltkpage (+  8  51) "6. Lists")
;; (find-tcltkpage (+  8  51)  "6.1 Basic list structure and the lindex command")
;; (find-tcltkpage (+  8  53)  "6.2 Creating lists: concat, list, and llength")
;; (find-tcltkpage (+  8  54)  "6.3 Modifying lists: linsert, lreplace, lrange, and lappend")
;; (find-tcltkpage (+  8  56)  "6.4 Searching lists: lsearch")
;; (find-tcltkpage (+  8  56)  "6.5 Sorting lists: lsort")
;; (find-tcltkpage (+  8  57)  "6.6 Converting between strings and lists: split and join")
;; (find-tcltkpage (+  8  58)  "6.7 Lists and commands")
;; (find-tcltkpage (+  8  61) "7. Control Flow")
;; (find-tcltkpage (+  8  61)  "7.1 The if command")
;; (find-tcltkpage (+  8  63)  "7.2 Looping commands: while, for, and foreach")
;; (find-tcltkpage (+  8  65)  "7.3 Loop control: break and continue")
;; (find-tcltkpage (+  8  65)  "7.4 The switch command")
;; (find-tcltkpage (+  8  67)  "7.5 Eval")
;; (find-tcltkpage (+  8  68)  "7.6 Executing from files: source")
;; (find-tcltkpage (+  8  69) "8. Procedures")
;; (find-tcltkpage (+  8  69)  "8.1 Procedure basics: proc and return")
;; (find-tcltkpage (+  8  71)  "8.2 Local and global variables")
;; (find-tcltkpage (+  8  72)  "8.3 Defaults and variable numbers of arguments")
;; (find-tcltkpage (+  8  73)  "8.4 Call by reference: upvar")
;; (find-tcltkpage (+  8  74)  "8.5 Creating new control structures: uplevel")
;; (find-tcltkpage (+  8  77) "9. Errors and Exceptions")
;; (find-tcltkpage (+  8  77)  "9.1 What happens after an error?")
;; (find-tcltkpage (+  8  79)  "9.2 Generating errors from Tcl scripts")
;; (find-tcltkpage (+  8  80)  "9.3 Trapping errors with catch")
;; (find-tcltkpage (+  8  81)  "9.4 Exceptions in general")
;; (find-tcltkpage (+  8  85) "10. String Manipulation")
;; (find-tcltkpage (+  8  85)  "10.1 Glob-style pattern matching")
;; (find-tcltkpage (+  8  88)  "10.2 Pattern matching with regular expressions")
;; (find-tcltkpage (+  8  90)  "10.3 Using regular expressions for substitutions")
;; (find-tcltkpage (+  8  91)  "10.4 Generating strings with format")
;; (find-tcltkpage (+  8  93)  "10.5 Parsing strings with scan")
;; (find-tcltkpage (+  8  94)  "10.6 Extracting characters: string index and string range")
;; (find-tcltkpage (+  8  94)  "10.7 Searching and comparison")
;; (find-tcltkpage (+  8  95)  "10.8 Length, case conversion, and trimming")
;; (find-tcltkpage (+  8  97) "11. Accessing Files")
;; (find-tcltkpage (+  8  97)  "11.1 File names")
;; (find-tcltkpage (+  8  99)  "11.2 Basic file I/O")
;; (find-tcltkpage (+  8 101)  "11.3 Output buffering")
;; (find-tcltkpage (+  8 101)  "11.4 Random access to files")
;; (find-tcltkpage (+  8 102)  "11.5 The current working directory")
;; (find-tcltkpage (+  8 102)  "11.6 Manipulating file names: glob and file")
;; (find-tcltkpage (+  8 105)  "11.7 File information commands")
;; (find-tcltkpage (+  8 107)  "11.8 Errors in system calls")
;; (find-tcltkpage (+  8 109) "12. Processes")
;; (find-tcltkpage (+  8 109)  "12.1 Invoking subprocesses with exec")
;; (find-tcltkpage (+  8 112)  "12.2 I/O to and from a command pipeline")
;; (find-tcltkpage (+  8 113)  "12.3 Process ids")
;; (find-tcltkpage (+  8 113)  "12.4 Environment variables")
;; (find-tcltkpage (+  8 113)  "12.5 Terminating the Tcl process with exit")
;; (find-tcltkpage (+  8 115) "13. Managing Tcl Internals")
;; (find-tcltkpage (+  8 115)  "13.1 Querying the elements of an array")
;; (find-tcltkpage (+  8 117)  "13.2 The info command")
;; (find-tcltkpage (+  8 117)  "13.2.1 Information about variables")
;; (find-tcltkpage (+  8 120)  "13.2.2 Information about procedures")
;; (find-tcltkpage (+  8 121)  "13.2.3 Information about commands")
;; (find-tcltkpage (+  8 122)  "13.2.4 Tclversion and library")
;; (find-tcltkpage (+  8 122)  "13.3 Timing command execution")
;; (find-tcltkpage (+  8 123)  "13.4 Tracing operations on variables")
;; (find-tcltkpage (+  8 125)  "13.5 Renaming and deleting commands")
;; (find-tcltkpage (+  8 126)  "13.6 Unknown commands")
;; (find-tcltkpage (+  8 128)  "13.7 Auto-loading")
;; (find-tcltkpage (+  8 131) "14. History")
;; (find-tcltkpage (+  8 131)  "14.1 The history list")
;; (find-tcltkpage (+  8 133)  "14.2 Specifying events")
;; (find-tcltkpage (+  8 133)  "14.3 Re-executing commands from the history list")
;; (find-tcltkpage (+  8 134)  "14.4 Shortcuts implemented by unknown")
;; (find-tcltkpage (+  8 134)  "14.5 Current event number: history nextid")
;; (find-tcltkpage       147 "PART II: WRITING SCRIPTS FOR TK")
;; (find-tcltkpage (+ 16 133) "14. An Introduction to Tk")
;; (find-tcltkpage (+ 16 134)  "14.1 Widgets and windows")
;; (find-tcltkpage (+ 16 136)  "14.2 Screens, decorations, and toplevel windows")
;; (find-tcltkpage (+ 16 137)  "14.3 Applications and processes")
;; (find-tcltkpage (+ 16 138)  "14.4 Scripts and events")
;; (find-tcltkpage (+ 16 138)  "14.5 Wish: a windowing shell")
;; (find-tcltkpage (+ 16 139)  "14.6 Widget creation commands")
;; (find-tcltkpage (+ 16 140)  "14.7 Geometry managers")
;; (find-tcltkpage (+ 16 141)  "14.8 Widget commands")
;; (find-tcltkpage (+ 16 142)  "14.9 Commands for interconnection")
;; (find-tcltkpage (+ 16 145) "15. Tour Of The Tk Widgets")
;; (find-tcltkpage (+ 16 145)  "15.1 Frames and toplevels")
;; (find-tcltkpage (+ 16 146)  "15.2 Labels, buttons, checkbuttons, and radiobuttons")
;; (find-tcltkpage (+ 16 148)  "15.3 Menus and menubuttons")
;; (find-tcltkpage (+ 16 150)  "15.3.1 Pull-down menus")
;; (find-tcltkpage (+ 16 150)  "15.3.2 Pop-up menus")
;; (find-tcltkpage (+ 16 150)  "15.3.3 Cascaded menus")
;; (find-tcltkpage (+ 16 151)  "15.3.4 Keyboard traversal and accelerators")
;; (find-tcltkpage (+ 16 151)  "15.4 Listboxes")
;; (find-tcltkpage (+ 16 152)  "15.5 Entries")
;; (find-tcltkpage (+ 16 153)  "15.6 Scrollbars")
;; (find-tcltkpage (+ 16 154)  "15.7 Text")
;; (find-tcltkpage (+ 16 155)  "15.8 Canvases")
;; (find-tcltkpage (+ 16 157)  "15.9 Scales")
;; (find-tcltkpage (+ 16 157)  "15.10 Messages")
;; (find-tcltkpage (+ 16 159) "16. Configuration Options")
;; (find-tcltkpage (+ 16 159)  "16.1 How options are set")
;; (find-tcltkpage (+ 16 161)  "16.2 Colors")
;; (find-tcltkpage (+ 16 163)  "16.3 Screen distances")
;; (find-tcltkpage (+ 16 164)  "16.4 Reliefs")
;; (find-tcltkpage (+ 16 164)  "16.5 Fonts")
;; (find-tcltkpage (+ 16 166)  "16.6 Bitmaps")
;; (find-tcltkpage (+ 16 166)  "16.7 Cursors")
;; (find-tcltkpage (+ 16 167)  "16.8 Anchors")
;; (find-tcltkpage (+ 16 169)  "16.9 Script options and scrolling")
;; (find-tcltkpage (+ 16 171)  "16.10 Variables")
;; (find-tcltkpage (+ 16 171)  "16.11 Time intervals")
;; (find-tcltkpage (+ 16 171)  "16.12 The configure widget command")
;; (find-tcltkpage (+ 16 173)  "16.13 The option database")
;; (find-tcltkpage (+ 16 173)  "16.13.1 Patterns")
;; (find-tcltkpage (+ 16 175)  "16.13.2 RESOURCE_MANAGER property and .Xdefaults file")
;; (find-tcltkpage (+ 16 175)  "16.13.3 Priorities")
;; (find-tcltkpage (+ 16 176)  "16.13.4 The option command")
;; (find-tcltkpage (+ 16 179) "17. Geometry Managers: The Placer")
;; (find-tcltkpage (+ 16 179)  "17.1 An overview of geometry management")
;; (find-tcltkpage (+ 16 182)  "17.2 Controlling positions with the placer")
;; (find-tcltkpage (+ 16 185)  "17.3 Controlling the size of a slave")
;; (find-tcltkpage (+ 16 185)  "17.4 Selecting the master window")
;; (find-tcltkpage (+ 16 186)  "17.5 Border modes")
;; (find-tcltkpage (+ 16 186)  "17.6 More on the place command")
;; (find-tcltkpage (+ 16 187)  "17.7 Controlling the size of the master")
;; (find-tcltkpage (+ 16 189) "18. The Packer")
;; (find-tcltkpage (+ 16 189)  "18.1 Packer basics")
;; (find-tcltkpage (+ 16 193)  "18.2 Packer configuration options")
;; (find-tcltkpage (+ 16 196)  "18.3 Hierarchical packing")
;; (find-tcltkpage (+ 16 197)  "18.4 Other options to the pack command")
;; (find-tcltkpage (+ 16 199) "19. Bindings")
;; (find-tcltkpage (+ 16 199)  "19.1 An overview of the bind command")
;; (find-tcltkpage (+ 16 201)  "19.2 Event patterns")
;; (find-tcltkpage (+ 16 203)  "19.3 Sequences of events")
;; (find-tcltkpage (+ 16 203)  "19.4 Conflict resolution")
;; (find-tcltkpage (+ 16 204)  "19.5 Substitutions in scripts")
;; (find-tcltkpage (+ 16 205)  "19.6 When are events processed?")
;; (find-tcltkpage (+ 16 205)  "19.7 Background errors: tkerror")
;; (find-tcltkpage (+ 16 206)  "19.8 Other uses of bindings")
;; (find-tcltkpage (+ 16 207) "20. The Selection")
;; (find-tcltkpage (+ 16 207)  "20.1 Selections, retrievals, and targets")
;; (find-tcltkpage (+ 16 209)  "20.2 Locating and clearing the selection")
;; (find-tcltkpage (+ 16 210)  "20.3 Supplying the selection with Tcl scripts")
;; (find-tcltkpage (+ 16 213) "21. The Input Focus")
;; (find-tcltkpage (+ 16 213)  "21.1 Focus model: explicit vs. implicit")
;; (find-tcltkpage (+ 16 214)  "21.2 Setting the input focus")
;; (find-tcltkpage (+ 16 215)  "21.3 Clearing the focus")
;; (find-tcltkpage (+ 16 215)  "21.4 The default focus")
;; (find-tcltkpage (+ 16 216)  "21.5 Keyboard accelerators")
;; (find-tcltkpage (+ 16 217) "22. Window Managers")
;; (find-tcltkpage (+ 16 219)  "22.1 Window sizes")
;; (find-tcltkpage (+ 16 220)  "22.2 Gridded windows")
;; (find-tcltkpage (+ 16 222)  "22.3 Window positions")
;; (find-tcltkpage (+ 16 222)  "22.4 Window states")
;; (find-tcltkpage (+ 16 223)  "22.5 Decorations")
;; (find-tcltkpage (+ 16 223)  "22.6 Window manager protocols")
;; (find-tcltkpage (+ 16 224)  "22.7 Special handling: transients, groups, and override-redirect")
;; (find-tcltkpage (+ 16 225)  "22.8 Session management")
;; (find-tcltkpage (+ 16 225)  "22.9 A warning about window managers")
;; (find-tcltkpage (+ 16 227) "23. The Send Command")
;; (find-tcltkpage (+ 16 227)  "23.1 Basics")
;; (find-tcltkpage (+ 16 228)  "23.2 Hypertools")
;; (find-tcltkpage (+ 16 229)  "23.3 Application names")
;; (find-tcltkpage (+ 16 229)  "23.4 Security issues")
;; (find-tcltkpage (+ 16 231) "24. Modal Interactions")
;; (find-tcltkpage (+ 16 231)  "24.1 Grabs")
;; (find-tcltkpage (+ 16 233)  "24.2 Keyboard handling during grabs")
;; (find-tcltkpage (+ 16 233)  "24.3 Waiting: the tkwait command")
;; (find-tcltkpage (+ 16 237) "25. Odds and Ends")
;; (find-tcltkpage (+ 16 237)  "25.1 Destroying windows")
;; (find-tcltkpage (+ 16 238)  "25.2 Time delays")
;; (find-tcltkpage (+ 16 239)  "25.3 The update command")
;; (find-tcltkpage (+ 16 240)  "25.4 Information about windows")
;; (find-tcltkpage (+ 16 240)  "25.5 The tk command: color models")
;; (find-tcltkpage (+ 16 241)  "25.6 Variables managed by Tk")
;; (find-tcltkpage (+ 16 243) "26. Examples")
;; (find-tcltkpage (+ 16 243)  "26.1 A procedure that generates dialog boxes")
;; (find-tcltkpage (+ 16 247)  "26.2 A remote-control application")
;; (find-tcltkpage       275  "PART III: WRITING TCL APPLICATIONS IN C")
;; (find-tcltkpage (+ 20 257) "27. Philosophy")
;; (find-tcltkpage (+ 20 257)  "27.1 C vs. Tcl: primitives")
;; (find-tcltkpage (+ 20 259)  "27.2 Object names")
;; (find-tcltkpage (+ 20 260)  "27.3 Commands: action-oriented vs. object-oriented")
;; (find-tcltkpage (+ 20 261)  "27.4 Application prefixes")
;; (find-tcltkpage (+ 20 262)  "27.5 Representing information")
;; (find-tcltkpage (+ 20 263) "28. Interpreters and Script Evaluation")
;; (find-tcltkpage (+ 20 263)  "28.1 Interpreters")
;; (find-tcltkpage (+ 20 263)  "28.2 A simple Tcl application")
;; (find-tcltkpage (+ 20 266)  "28.3 Other evaluation procedures")
;; (find-tcltkpage (+ 20 266)  "28.4 Deleting interpreters")
;; (find-tcltkpage (+ 20 269) "29. Creating New Tcl Commands")
;; (find-tcltkpage (+ 20 269)  "29.1 Command procedures")
;; (find-tcltkpage (+ 20 271)  "29.2 Registering commands")
;; (find-tcltkpage (+ 20 272)  "29.3 The result protocol")
;; (find-tcltkpage (+ 20 273)  "29.4 Procedures for managing the result")
;; (find-tcltkpage (+ 20 275)  "29.5 ClientData and deletion callbacks")
;; (find-tcltkpage (+ 20 278)  "29.6 Deleting commands")
;; (find-tcltkpage (+ 20 279) "30. Parsing")
;; (find-tcltkpage (+ 20 279)  "30.1 Numbers and booleans")
;; (find-tcltkpage (+ 20 282)  "30.2 Expression evaluation")
;; (find-tcltkpage (+ 20 283)  "30.3 Manipulating lists")
;; (find-tcltkpage (+ 20 285) "31. Exceptions")
;; (find-tcltkpage (+ 20 285)  "31.1 Completion codes.")
;; (find-tcltkpage (+ 20 288)  "31.2 Augmenting the stack trace in errorInfo")
;; (find-tcltkpage (+ 20 290)  "31.3 Setting errorCode")
;; (find-tcltkpage (+ 20 291) "32. Accessing Tcl Variables")
;; (find-tcltkpage (+ 20 291)  "32.1 Naming variables")
;; (find-tcltkpage (+ 20 293)  "32.2 Setting variable values")
;; (find-tcltkpage (+ 20 295)  "32.3 Reading variables")
;; (find-tcltkpage (+ 20 296)  "32.4 Unsetting variables")
;; (find-tcltkpage (+ 20 296)  "32.5 Setting and unsetting variable traces")
;; (find-tcltkpage (+ 20 297)  "32.6 Trace callbacks")
;; (find-tcltkpage (+ 20 299)  "32.7 Whole-array traces")
;; (find-tcltkpage (+ 20 299)  "32.8 Multiple traces")
;; (find-tcltkpage (+ 20 299)  "32.9 Unset callbacks")
;; (find-tcltkpage (+ 20 300)  "32.10 Non-existent variables")
;; (find-tcltkpage (+ 20 300)  "32.11 Querying trace information")
;; (find-tcltkpage (+ 20 301) "33. Hash Tables")
;; (find-tcltkpage (+ 20 303)  "33.1 Keys and values")
;; (find-tcltkpage (+ 20 303)  "33.2 Creating and deleting hash tables")
;; (find-tcltkpage (+ 20 304)  "33.3 Creating entries")
;; (find-tcltkpage (+ 20 305)  "33.4 Finding existing entries")
;; (find-tcltkpage (+ 20 306)  "33.5 Searching")
;; (find-tcltkpage (+ 20 307)  "33.6 Deleting entries")
;; (find-tcltkpage (+ 20 307)  "33.7 Statistics")
;; (find-tcltkpage (+ 20 309) "34. String Utilities")
;; (find-tcltkpage (+ 20 309)  "34.1 Dynamic strings")
;; (find-tcltkpage (+ 20 312)  "34.2 Command completeness")
;; (find-tcltkpage (+ 20 313)  "34.3 String matching")
;; (find-tcltkpage (+ 20 315) "35. POSIX Utilities")
;; (find-tcltkpage (+ 20 315)  "35.1 Tilde expansion")
;; (find-tcltkpage (+ 20 317)  "35.2 Generating messages")
;; (find-tcltkpage (+ 20 318)  "35.3 Creating subprocesses")
;; (find-tcltkpage (+ 20 319)  "35.4 Background processes")
;; (find-tcltkpage       343 "PART IV: TK'S C INTERFACES")
;; (find-tcltkpage (+ 22 323) "36. Introduction")
;; (find-tcltkpage (+ 22 324)  "36.1 What's in a widget?")
;; (find-tcltkpage (+ 22 325)  "36.2 Widgets are event-driven")
;; (find-tcltkpage (+ 22 325)  "36.3 Tk vs. Xlib")
;; (find-tcltkpage (+ 22 326)  "36.4 Square: an example widget")
;; (find-tcltkpage (+ 22 328)  "36.5 Design for re-usability")
;; (find-tcltkpage (+ 22 329) "37. Creating Windows")
;; (find-tcltkpage (+ 22 329)  "37.1 Tk_Window structures")
;; (find-tcltkpage (+ 22 329)  "37.2 Creating Tk_Windows")
;; (find-tcltkpage (+ 22 331)  "37.3 Setting a window's class")
;; (find-tcltkpage (+ 22 332)  "37.4 Deleting windows")
;; (find-tcltkpage (+ 22 332)  "37.5 Basic operations on Tk_Windows")
;; (find-tcltkpage (+ 22 333)  "37.6 Create procedures")
;; (find-tcltkpage (+ 22 336)  "37.7 Delayed window creation")
;; (find-tcltkpage (+ 22 337) "38. Configuring Widgets")
;; (find-tcltkpage (+ 22 337)  "38.1 Tk_ConfigureWidget")
;; (find-tcltkpage (+ 22 339)  "38.1.1 Tk_ConfigSpec tables")
;; (find-tcltkpage (+ 22 341)  "38.1.2 Invoking Tk_ConfigureWidget")
;; (find-tcltkpage (+ 22 342)  "38.1.3 Errors")
;; (find-tcltkpage (+ 22 342)  "38.1.4 Reconfiguring")
;; (find-tcltkpage (+ 22 342)  "38.1.5 Tk_ConfigureInfo")
;; (find-tcltkpage (+ 22 343)  "38.1.6 Tk_FreeOptions")
;; (find-tcltkpage (+ 22 343)  "38.1.7 Other uses for configuration tables")
;; (find-tcltkpage (+ 22 343)  "38.2 Resource caches")
;; (find-tcltkpage (+ 22 344)  "38.2.1 Graphics contexts")
;; (find-tcltkpage (+ 22 345)  "38.2.2 Other resources")
;; (find-tcltkpage (+ 22 346)  "38.3 Tk_Uids")
;; (find-tcltkpage (+ 22 346)  "38.4 Other translators")
;; (find-tcltkpage (+ 22 347)  "38.5 Changing window attributes")
;; (find-tcltkpage (+ 22 348)  "38.6 The square configure procedure")
;; (find-tcltkpage (+ 22 349)  "38.7 The square widget command procedure")
;; (find-tcltkpage (+ 22 353) "39. Events")
;; (find-tcltkpage (+ 22 353)  "39.1 X events")
;; (find-tcltkpage (+ 22 357)  "39.2 File events")
;; (find-tcltkpage (+ 22 359)  "39.3 Timer events")
;; (find-tcltkpage (+ 22 360)  "39.4 Idle callbacks")
;; (find-tcltkpage (+ 22 361)  "39.5 Generic event handlers")
;; (find-tcltkpage (+ 22 362)  "39.6 Invoking the event dispatcher")
;; (find-tcltkpage (+ 22 365) "40. Displaying Widgets")
;; (find-tcltkpage (+ 22 365)  "40.1 Delayed redisplay")
;; (find-tcltkpage (+ 22 367)  "40.2 Double-buffering with pixmaps")
;; (find-tcltkpage (+ 22 367)  "40.3 Drawing procedures")
;; (find-tcltkpage (+ 22 371) "41. Destroying Widgets")
;; (find-tcltkpage (+ 22 371)  "41.1 Basics")
;; (find-tcltkpage (+ 22 372)  "41.2 Delayed cleanup")
;; (find-tcltkpage (+ 22 377) "42. Managing the Selection")
;; (find-tcltkpage (+ 22 377)  "42.1 Selection handlers")
;; (find-tcltkpage (+ 22 380)  "42.2 Claiming the selection")
;; (find-tcltkpage (+ 22 381)  "42.3 Retrieving the selection")
;; (find-tcltkpage (+ 22 383) "43. Geometry Management")
;; (find-tcltkpage (+ 22 383)  "43.1 Requesting a size for a widget")
;; (find-tcltkpage (+ 22 385)  "43.2 Internal borders")
;; (find-tcltkpage (+ 22 386)  "43.3 Grids")
;; (find-tcltkpage (+ 22 387)  "43.4 Geometry managers")
;; (find-tcltkpage (+ 22 388)  "43.5 Claiming ownership")
;; (find-tcltkpage (+ 22 388)  "43.6 Retrieving geometry information")
;; (find-tcltkpage (+ 22 389)  "43.7 Mapping and setting geometry")


;; (find-tcltktext "")

;; (find-tcltktext "")






;; «o_keefe» (to ".o_keefe")
;; (find-books "__comp/__comp.el" "o_keefe")
;; https://doi.org/10.1016/j.entcs.2003.12.014
;; Greg O'Keefe: "Towards a Readable Formalisation of Category Theory" (2004)
(code-pdf       "okeefereadable" "~/books/__comp/o_keefe__towards_a_readable_formalisation_of_category_theory.pdf")
(code-pdftotext "okeefereadable" "~/books/__comp/o_keefe__towards_a_readable_formalisation_of_category_theory.pdf" 212)
;; (find-okeefereadablepage)
;; (find-okeefereadablepage        1  "Contents")
;; (find-okeefereadablepage (+ 1 189) "Index")
;; (find-okeefereadabletext "")

;; «paulson»  (to ".paulson")
;; http://gigapedia.com/items/28928/ml-for-the-working-programmer
(code-djvu "mlwp" "~/books/__comp/paulson__ml_for_the_working_programmer.djvu")
;; (find-mlwppage         3  "Contents")
;; (find-mlwppage (+ 15 469) "Index")




;; «peyton-jones» (to ".peyton-jones")
;; (find-books "__comp/__comp.el" "peyton-jones")
;; https://www.microsoft.com/en-us/research/people/simonpj/
;; https://www.microsoft.com/en-us/research/publication/the-implementation-of-functional-programming-languages/
;; https://www.microsoft.com/en-us/research/wp-content/uploads/1987/01/slpj-book-1987-small.pdf
;; (find-fline "$S/https/www.microsoft.com/en-us/research/wp-content/uploads/1987/01/")
(code-xpdf     "impfpl" "$S/https/www.microsoft.com/en-us/research/wp-content/uploads/1987/01/slpj-book-1987-small.pdf")
;; (find-impfplpage)
;; (find-impfplpage         4  "Contents")
;; (find-impfplpage (+ 13   1) "1. Introduction")
;; (find-impfplpage (+ 13 439) "Index")

;; https://www.microsoft.com/en-us/research/publication/a-quick-look-at-impredicativity/
;; https://www.microsoft.com/en-us/research/uploads/prod/2020/01/quick-look-icfp20.pdf
;; (find-fline "$S/https/www.microsoft.com/en-us/research/uploads/prod/2020/01/")
(code-pdf-page "spjquicklooki" "$S/https/www.microsoft.com/en-us/research/uploads/prod/2020/01/quick-look-icfp20.pdf")
(code-pdf-text "spjquicklooki" "$S/https/www.microsoft.com/en-us/research/uploads/prod/2020/01/quick-look-icfp20.pdf")
;; (find-spjquicklookipage)
;; (find-spjquicklookitext)

;; https://www.microsoft.com/en-us/research/academic-program/write-great-research-paper/
;; https://www.microsoft.com/en-us/research/academic-program/write-great-research-paper/#!other-resources
;; https://www.microsoft.com/en-us/research/wp-content/uploads/2016/07/How-to-write-a-great-research-paper.pdf
;; (find-fline "$S/https/www.microsoft.com/en-us/research/wp-content/uploads/2016/07/")
;; (find-pdf-page "$S/https/www.microsoft.com/en-us/research/wp-content/uploads/2016/07/How-to-write-a-great-research-paper.pdf")
;; (find-pdf-text "$S/https/www.microsoft.com/en-us/research/wp-content/uploads/2016/07/How-to-write-a-great-research-paper.pdf")






;; «pierce»  (to ".pierce")
;; (find-books "__comp/__comp.el" "pierce")
;; https://www.cis.upenn.edu/~bcpierce/tapl/
(code-pdf-page "tapl" "~/books/__comp/pierce__types_and_programming_languages.pdf")
(code-pdf-text "tapl" "~/books/__comp/pierce__types_and_programming_languages.pdf" 22)
;; (find-taplpage)
;; (find-taplpage (+ 22   1) "1 Introduction")
;; (find-taplpage (+ 22   1) "1.1 Types in Computer Science")
;; (find-taplpage (+ 22   4) "1.2 What Type Systems Are Good For")
;; (find-taplpage (+ 22   9) "1.3 Type Systems and Language Design")
;; (find-taplpage (+ 22  10) "1.4 Capsule History")
;; (find-taplpage (+ 22  12) "1.5 Related Reading")
;; (find-taplpage (+ 22  15) "2 Mathematical Preliminaries")
;; (find-taplpage (+ 22  15) "2.1 Sets, Relations, and Functions")
;; (find-taplpage (+ 22  16) "2.2 Ordered Sets")
;; (find-taplpage (+ 22  18) "2.3 Sequences")
;; (find-taplpage (+ 22  19) "2.4 Induction")
;; (find-taplpage (+ 22  20) "2.5 Background Reading")
;; (find-taplpage (+ 22  21) "I Untyped Systems")
;; (find-taplpage (+ 22  23) "3 Untyped Arithmetic Expressions")
;; (find-taplpage (+ 22  23) "3.1 Introduction")
;; (find-taplpage (+ 22  26) "3.2 Syntax")
;; (find-taplpage (+ 22  29) "3.3 Induction on Terms")
;; (find-taplpage (+ 22  32) "3.4 Semantic Styles")
;; (find-taplpage (+ 22  34) "3.5 Evaluation")
;; (find-taplpage (+ 22  43) "3.6 Notes")
;; (find-taplpage (+ 22  45) "4 An ML Implementation of Arithmetic Expressions")
;; (find-taplpage (+ 22  46) "4.1 Syntax")
;; (find-taplpage (+ 22  47) "4.2 Evaluation")
;; (find-taplpage (+ 22  49) "4.3 The Rest of the Story")
;; (find-taplpage (+ 22  51) "5 The Untyped Lambda-Calculus")
;; (find-taplpage (+ 22  52) "5.1 Basics")
;; (find-taplpage (+ 22  58) "5.2 Programming in the Lambda-Calculus")
;; (find-taplpage (+ 22  68) "5.3 Formalities")
;; (find-taplpage (+ 22  73) "5.4 Notes")
;; (find-taplpage (+ 22  75) "6 Nameless Representation of Terms")
;; (find-taplpage (+ 22  76) "6.1 Terms and Contexts")
;; (find-taplpage (+ 22  78) "6.2 Shifting and Substitution")
;; (find-taplpage (+ 22  80) "6.3 Evaluation")
;; (find-taplpage (+ 22  83) "7 An ML Implementation of the Lambda-Calculus")
;; (find-taplpage (+ 22  83) "7.1 Terms and Contexts")
;; (find-taplpage (+ 22  85) "7.2 Shifting and Substitution")
;; (find-taplpage (+ 22  87) "7.3 Evaluation")
;; (find-taplpage (+ 22  88) "7.4 Notes")
;; (find-taplpage (+ 22  89) "II Simple Types")
;; (find-taplpage (+ 22  91) "8 Typed Arithmetic Expressions")
;; (find-taplpage (+ 22  91) "8.1 Types")
;; (find-taplpage (+ 22  92) "8.2 The Typing Relation")
;; (find-taplpage (+ 22  95) "8.3 Safety = Progress + Preservation")
;; (find-taplpage (+ 22  99) "9 Simply Typed Lambda-Calculus")
;; (find-taplpage (+ 22  99) "9.1 Function Types")
;; (find-taplpage (+ 22 100) "9.2 The Typing Relation")
;; (find-taplpage (+ 22 104) "9.3 Properties of Typing")
;; (find-taplpage (+ 22 108) "9.4 The Curry-Howard Correspondence")
;; (find-taplpage (+ 22 109) "9.5 Erasure and Typability")
;; (find-taplpage (+ 22 111) "9.6 Curry-Style vs. Church-Style")
;; (find-taplpage (+ 22 111) "9.7 Notes")
;; (find-taplpage (+ 22 113) "10 An ML Implementation of Simple Types")
;; (find-taplpage (+ 22 113) "10.1 Contexts")
;; (find-taplpage (+ 22 115) "10.2 Terms and Types")
;; (find-taplpage (+ 22 115) "10.3 Typechecking")
;; (find-taplpage (+ 22 117) "11 Simple Extensions")
;; (find-taplpage (+ 22 117) "11.1 Base Types")
;; (find-taplpage (+ 22 118) "11.2 The Unit Type")
;; (find-taplpage (+ 22 119) "11.3 Derived Forms: Sequencing and Wildcards")
;; (find-taplpage (+ 22 121) "11.4 Ascription")
;; (find-taplpage (+ 22 124) "11.5 Let Bindings")
;; (find-taplpage (+ 22 126) "11.6 Pairs")
;; (find-taplpage (+ 22 128) "11.7 Tuples")
;; (find-taplpage (+ 22 129) "11.8 Records")
;; (find-taplpage (+ 22 132) "11.9 Sums")
;; (find-taplpage (+ 22 136) "11.10 Variants")
;; (find-taplpage (+ 22 142) "11.11 General Recursion")
;; (find-taplpage (+ 22 146) "11.12 Lists")
;; (find-taplpage (+ 22 149) "12 Normalization")
;; (find-taplpage (+ 22 149) "12.1 Normalization for Simple Types")
;; (find-taplpage (+ 22 152) "12.2 Notes")
;; (find-taplpage (+ 22 153) "13 References")
;; (find-taplpage (+ 22 153) "13.1 Introduction")
;; (find-taplpage (+ 22 159) "13.2 Typing")
;; (find-taplpage (+ 22 159) "13.3 Evaluation")
;; (find-taplpage (+ 22 162) "13.4 Store Typings")
;; (find-taplpage (+ 22 165) "13.5 Safety")
;; (find-taplpage (+ 22 170) "13.6 Notes")
;; (find-taplpage (+ 22 171) "14 Exceptions")
;; (find-taplpage (+ 22 172) "14.1 Raising Exceptions")
;; (find-taplpage (+ 22 173) "14.2 Handling Exceptions")
;; (find-taplpage (+ 22 175) "14.3 Exceptions Carrying Values")
;; (find-taplpage (+ 22 179) "III Subtyping")
;; (find-taplpage (+ 22 181) "15 Subtyping")
;; (find-taplpage (+ 22 181) "15.1 Subsumption")
;; (find-taplpage (+ 22 182) "15.2 The Subtype Relation")
;; (find-taplpage (+ 22 188) "15.3 Properties of Subtyping and Typing")
;; (find-taplpage (+ 22 191) "15.4 The Top and Bottom Types")
;; (find-taplpage (+ 22 193) "15.5 Subtyping and Other Features")
;; (find-taplpage (+ 22 200) "15.6 Coercion Semantics for Subtyping")
;; (find-taplpage (+ 22 206) "15.7 Intersection and Union Types")
;; (find-taplpage (+ 22 207) "15.8 Notes")
;; (find-taplpage (+ 22 209) "16 Metatheory of Subtyping")
;; (find-taplpage (+ 22 210) "16.1 Algorithmic Subtyping")
;; (find-taplpage (+ 22 213) "16.2 Algorithmic Typing")
;; (find-taplpage (+ 22 218) "16.3 Joins and Meets")
;; (find-taplpage (+ 22 220) "16.4 Algorithmic Typing and the Bottom Type")
;; (find-taplpage (+ 22 221) "17 An ML Implementation of Subtyping")
;; (find-taplpage (+ 22 221) "17.1 Syntax")
;; (find-taplpage (+ 22 221) "17.2 Subtyping")
;; (find-taplpage (+ 22 222) "17.3 Typing")
;; (find-taplpage (+ 22 225) "18 Case Study: Imperative Objects")
;; (find-taplpage (+ 22 225) "18.1 What Is Object-Oriented Programming?")
;; (find-taplpage (+ 22 228) "18.2 Objects")
;; (find-taplpage (+ 22 229) "18.3 Object Generators")
;; (find-taplpage (+ 22 229) "18.4 Subtyping")
;; (find-taplpage (+ 22 230) "18.5 Grouping Instance Variables")
;; (find-taplpage (+ 22 231) "18.6 Simple Classes")
;; (find-taplpage (+ 22 233) "18.7 Adding Instance Variables")
;; (find-taplpage (+ 22 234) "18.8 Calling Superclass Methods")
;; (find-taplpage (+ 22 234) "18.9 Classes with Self")
;; (find-taplpage (+ 22 235) "18.10 Open Recursion through Self")
;; (find-taplpage (+ 22 237) "18.11 Open Recursion and Evaluation Order")
;; (find-taplpage (+ 22 241) "18.12 A More Efficient Implementation")
;; (find-taplpage (+ 22 244) "18.13 Recap")
;; (find-taplpage (+ 22 245) "18.14 Notes")
;; (find-taplpage (+ 22 247) "19 Case Study: Featherweight Java")
;; (find-taplpage (+ 22 247) "19.1 Introduction")
;; (find-taplpage (+ 22 249) "19.2 Overview")
;; (find-taplpage (+ 22 251) "19.3 Nominal and Structural Type Systems")
;; (find-taplpage (+ 22 254) "19.4 Definitions")
;; (find-taplpage (+ 22 261) "19.5 Properties")
;; (find-taplpage (+ 22 262) "19.6 Encodings vs. Primitive Objects")
;; (find-taplpage (+ 22 263) "19.7 Notes")
;; (find-taplpage (+ 22 265) "IV Recursive Types")
;; (find-taplpage (+ 22 267) "20 Recursive Types")
;; (find-taplpage (+ 22 268) "20.1 Examples")
;; (find-taplpage (+ 22 275) "20.2 Formalities")
;; (find-taplpage (+ 22 279) "20.3 Subtyping")
;; (find-taplpage (+ 22 279) "20.4 Notes")
;; (find-taplpage (+ 22 281) "21 Metatheory of Recursive Types")
;; (find-taplpage (+ 22 282) "21.1 Induction and Coinduction")
;; (find-taplpage (+ 22 284) "21.2 Finite and Infinite Types")
;; (find-taplpage (+ 22 286) "21.3 Subtyping")
;; (find-taplpage (+ 22 288) "21.4 A Digression on Transitivity")
;; (find-taplpage (+ 22 290) "21.5 Membership Checking")
;; (find-taplpage (+ 22 295) "21.6 More Efficient Algorithms")
;; (find-taplpage (+ 22 298) "21.7 Regular Trees")
;; (find-taplpage (+ 22 299) "21.8 -Types")
;; (find-taplpage (+ 22 304) "21.9 Counting Subexpressions")
;; (find-taplpage (+ 22 309) "21.10 Digression: An Exponential Algorithm")
;; (find-taplpage (+ 22 311) "21.11 Subtyping Iso-Recursive Types")
;; (find-taplpage (+ 22 312) "21.12 Notes")
;; (find-taplpage (+ 22 315) "V Polymorphism")
;; (find-taplpage (+ 22 317) "22 Type Reconstruction")
;; (find-tapltext (+ 22 317) "22 Type Reconstruction")
;; (find-taplpage (+ 22 317) "22.1 Type Variables and Substitutions")
;; (find-taplpage (+ 22 319) "22.2 Two Views of Type Variables")
;; (find-taplpage (+ 22 321) "22.3 Constraint-Based Typing")
;; (find-taplpage (+ 22 326) "22.4 Unification")
;; (find-taplpage (+ 22 329) "22.5 Principal Types")
;; (find-taplpage (+ 22 330) "22.6 Implicit Type Annotations")
;; (find-taplpage (+ 22 331) "22.7 Let-Polymorphism")
;; (find-taplpage (+ 22 336) "22.8 Notes")
;; (find-taplpage (+ 22 339) "23 Universal Types")
;; (find-taplpage (+ 22 339) "23.1 Motivation")
;; (find-taplpage (+ 22 340) "23.2 Varieties of Polymorphism")
;; (find-taplpage (+ 22 341) "23.3 System F")
;; (find-taplpage (+ 22 344) "23.4 Examples")
;; (find-taplpage (+ 22 353) "23.5 Basic Properties")
;; (find-taplpage (+ 22 354) "23.6 Erasure, Typability, and Type Reconstruction")
;; (find-taplpage (+ 22 357) "23.7 Erasure and Evaluation Order")
;; (find-taplpage (+ 22 358) "23.8 Fragments of System F")
;; (find-taplpage (+ 22 359) "23.9 Parametricity")
;; (find-taplpage (+ 22 360) "23.10 Impredicativity")
;; (find-taplpage (+ 22 361) "23.11 Notes")
;; (find-taplpage (+ 22 363) "24 Existential Types")
;; (find-taplpage (+ 22 363) "24.1 Motivation")
;; (find-taplpage (+ 22 368) "24.2 Data Abstraction with Existentials")
;; (find-taplpage (+ 22 377) "24.3 Encoding Existentials")
;; (find-taplpage (+ 22 379) "24.4 Notes")
;; (find-taplpage (+ 22 381) "25 An ML Implementation of System F")
;; (find-taplpage (+ 22 381) "25.1 Nameless Representation of Types")
;; (find-taplpage (+ 22 382) "25.2 Type Shifting and Substitution")
;; (find-taplpage (+ 22 383) "25.3 Terms")
;; (find-taplpage (+ 22 385) "25.4 Evaluation")
;; (find-taplpage (+ 22 386) "25.5 Typing")
;; (find-taplpage (+ 22 389) "26 Bounded Quantification")
;; (find-taplpage (+ 22 389) "26.1 Motivation")
;; (find-taplpage (+ 22 391) "26.2 Definitions")
;; (find-taplpage (+ 22 396) "26.3 Examples")
;; (find-taplpage (+ 22 400) "26.4 Safety")
;; (find-taplpage (+ 22 406) "26.5 Bounded Existential Types")
;; (find-taplpage (+ 22 408) "26.6 Notes")
;; (find-taplpage (+ 22 411) "27 Case Study: Imperative Objects, Redux")
;; (find-taplpage (+ 22 417) "28 Metatheory of Bounded Quantification")
;; (find-taplpage (+ 22 417) "28.1 Exposure")
;; (find-taplpage (+ 22 418) "28.2 Minimal Typing")
;; (find-taplpage (+ 22 421) "28.3 Subtyping in Kernel F<:")
;; (find-taplpage (+ 22 424) "28.4 Subtyping in Full F<:")
;; (find-taplpage (+ 22 427) "28.5 Undecidability of Full F<:")
;; (find-taplpage (+ 22 432) "28.6 Joins and Meets")
;; (find-taplpage (+ 22 435) "28.7 Bounded Existentials")
;; (find-taplpage (+ 22 436) "28.8 Bounded Quantification and the Bottom Type")
;; (find-taplpage (+ 22 437) "VI Higher-Order Systems")
;; (find-taplpage (+ 22 439) "29 Type Operators and Kinding")
;; (find-taplpage (+ 22 440) "29.1 Intuitions")
;; (find-taplpage (+ 22 445) "29.2 Definitions")
;; (find-taplpage (+ 22 449) "30 Higher-Order Polymorphism")
;; (find-taplpage (+ 22 449) "30.1 Definitions")
;; (find-taplpage (+ 22 450) "30.2 Example")
;; (find-taplpage (+ 22 453) "30.3 Properties")
;; (find-taplpage (+ 22 461) "30.4 Fragments of F")
;; (find-taplpage (+ 22 462) "30.5 Going Further: Dependent Types")
;; (find-taplpage (+ 22 467) "31 Higher-Order Subtyping")
;; (find-taplpage (+ 22 467) "31.1 Intuitions")
;; (find-taplpage (+ 22 469) "31.2 Definitions")
;; (find-taplpage (+ 22 472) "31.3 Properties")
;; (find-taplpage (+ 22 472) "31.4 Notes")
;; (find-taplpage (+ 22 475) "32 Case Study: Purely Functional Objects")
;; (find-taplpage (+ 22 475) "32.1 Simple Objects")
;; (find-taplpage (+ 22 476) "32.2 Subtyping")
;; (find-taplpage (+ 22 477) "32.3 Bounded Quantification")
;; (find-taplpage (+ 22 479) "32.4 Interface Types")
;; (find-taplpage (+ 22 480) "32.5 Sending Messages to Objects")
;; (find-taplpage (+ 22 481) "32.6 Simple Classes")
;; (find-taplpage (+ 22 482) "32.7 Polymorphic Update")
;; (find-taplpage (+ 22 485) "32.8 Adding Instance Variables")
;; (find-taplpage (+ 22 486) "32.9 Classes with "Self"")
;; (find-taplpage (+ 22 488) "32.10 Notes")
;; (find-taplpage (+ 22 491) "Appendices")
;; (find-taplpage (+ 22 493) "A Solutions to Selected Exercises")
;; (find-taplpage (+ 22 565) "B Notational Conventions")
;; (find-taplpage (+ 22 565) "B.1 Metavariable Names")
;; (find-taplpage (+ 22 565) "B.2 Rule Naming Conventions")
;; (find-taplpage (+ 22 566) "B.3 Naming and Subscripting Conventions")
;; (find-taplpage (+ 22 567) "References")
;; (find-taplpage (+ 22 605) "Index")
;; (find-tapltext (+ 22 605) "Index")
;; (find-taplpage (+ 22 621) "  type reconstruction")
;; (find-tapltext (+ 22 621) "  type reconstruction")
;; (find-tapltext "")

;; «pierce-atitapl»  (to ".pierce-atitapl")
;; (find-books "__comp/__comp.el" "pierce-atitapl")
(code-pdf-page "atitapl" "~/books/__comp/pierce__advanced_topics_in_types_and_programming_languages.pdf")
(code-pdf-text "atitapl" "~/books/__comp/pierce__advanced_topics_in_types_and_programming_languages.pdf" 15)
;; (find-atitaplpage)
;; (find-atitaplpage         6  "Contents")
;; (find-atitapltext         6  "Contents")
;; (find-atitaplpage (+ 15   1) "I Precise Type Analyses")
;; (find-atitaplpage (+ 15   3) "1 Substructural Type Systems")
;; (find-atitaplpage (+ 15   4) "1.1 Structural Properties")
;; (find-atitaplpage (+ 15   6) "1.2 A Linear Type System")
;; (find-atitaplpage (+ 15  17) "1.3 Extensions and Variations")
;; (find-atitaplpage (+ 15  30) "1.4 An Ordered Type System")
;; (find-atitaplpage (+ 15  36) "1.5 Further Applications")
;; (find-atitaplpage (+ 15  40) "1.6 Notes")
;; (find-atitaplpage (+ 15  45) "2 Dependent Types")
;; (find-atitaplpage (+ 15  45) "2.1 Motivations")
;; (find-atitaplpage (+ 15  50) "2.2 Pure First-Order Dependent Types")
;; (find-atitaplpage (+ 15  54) "2.3 Properties")
;; (find-atitaplpage (+ 15  56) "2.4 Algorithmic Typing and Equality")
;; (find-atitaplpage (+ 15  61) "2.5 Dependent Sum Types")
;; (find-atitaplpage (+ 15  64) "2.6 The Calculus of Constructions")
;; (find-atitaplpage (+ 15  71) "2.7 Relating Abstractions: Pure Type Systems")
;; (find-atitaplpage (+ 15  74) "2.8 Programming with Dependent Types")
;; (find-atitaplpage (+ 15  83) "2.9 Implementation of Dependent Types")
;; (find-atitaplpage (+ 15  86) "2.10 Further Reading")
;; (find-atitaplpage (+ 15  87) "3 Effect Types and Region-Based Memory Management")
;; (find-atitaplpage (+ 15 141) "4 Typed Assembly Language")
;; (find-atitaplpage (+ 15 177) "5 Proof-Carrying Code")
;; (find-atitaplpage (+ 15 223) "6 Logical Relations and a Case Study in Equivalence Checking")
;; (find-atitaplpage (+ 15 245) "7 Typed Operational Reasoning")
;; (find-atitaplpage (+ 15 293) "8 Design Considerations for ML-Style Module Systems")
;; (find-atitaplpage (+ 15 347) "9 Type Definitions")
;; (find-atitaplpage (+ 15 351) "9.1 Definitions in the Typing Context")
;; (find-atitaplpage (+ 15 358) "9.2 Definitions in Module Interfaces")
;; (find-atitaplpage (+ 15 367) "9.3 Singleton Kinds")
;; (find-atitaplpage (+ 15 384) "9.4 Notes")
;; (find-atitaplpage (+ 15 389) "10 The Essence of ML Type Inference")
;; (find-atitaplpage (+ 15 389) "10.1 What Is ML?")
;; (find-atitaplpage (+ 15 407) "10.2 Constraints")
;; (find-atitaplpage (+ 15 422) "10.3 HM(X)")
;; (find-atitaplpage (+ 15 429) "10.4 Constraint Generation")
;; (find-atitaplpage (+ 15 434) "10.5 Type Soundness")
;; (find-atitaplpage (+ 15 438) "10.6 Constraint Solving")
;; (find-atitaplpage (+ 15 451) "10.7 From ML-the-Calculus to ML-the-Language")
;; (find-atitaplpage (+ 15 460) "10.8 Rows")
;; (find-atitaplpage (+ 15 491) "A Solutions to Selected Exercises")
;; (find-atitaplpage (+ 15 535) "References")
;; (find-atitaplpage (+ 15 567) "Index")
;; (find-atitapltext "")


;; «plotkin»  (to ".plotkin")
;; http://homepages.inf.ed.ac.uk/gdp/
;; http://homepages.inf.ed.ac.uk/gdp/publications/
;; http://homepages.inf.ed.ac.uk/gdp/publications/Framework_Def_Log.pdf
(code-pdf-page "plotkinLF" "$S/http/homepages.inf.ed.ac.uk/gdp/publications/Framework_Def_Log.pdf")
(code-pdf-text "plotkinLF" "$S/http/homepages.inf.ed.ac.uk/gdp/publications/Framework_Def_Log.pdf")
;; (find-plotkinLFpage)
;; (find-plotkinLFtext)

;; «plotkin-partdiff»  (to ".plotkin-partdiff")
;; (find-books "__comp/__comp.el" "plotkin-partdiff")
;; Gordon Plotkin: A complete axiomatisation of partial differentiation
;; http://math.ucr.edu/home/baez/ACT@UCR/index.html#plotkin
;; http://math.ucr.edu/home/baez/mathematical/ACTUCR/Plotkin_Partial_Differentiation.pdf
;; http://math.ucr.edu/home/baez/mathematical/ACTUCR/Plotkin_Partial_Differentiation.mp4
;; https://www.youtube.com/watch?v=j_w6GNUIQDo&w=560&h=315
(code-pdf-page "plotkincapd" "$S/http/math.ucr.edu/home/baez/mathematical/ACTUCR/Plotkin_Partial_Differentiation.pdf")
(code-pdf-text "plotkincapd" "$S/http/math.ucr.edu/home/baez/mathematical/ACTUCR/Plotkin_Partial_Differentiation.pdf")
;; (find-plotkincapdpage)
;; (find-plotkincapdtext)

;;
;; Fiore-Plotkin-Turi: Abstract Syntax and Variable Binding
;; http://homepages.inf.ed.ac.uk/gdp/publications/Abstract_Syn.pdf
;;
;; Mitchell/Plotkin: "Abstract Types Have Existential Type" (1988)
;; http://homepages.inf.ed.ac.uk/gdp/publications/Abstract_existential.pdf
(code-pdf-page "plotkinathet" "$S/http/homepages.inf.ed.ac.uk/gdp/publications/Abstract_existential.pdf")
(code-pdf-text "plotkinathet" "$S/http/homepages.inf.ed.ac.uk/gdp/publications/Abstract_existential.pdf")
;; (find-plotkinathetpage)
;; (find-plotkinathettext)


;; «reynolds»  (to ".reynolds")
;; (find-books "__comp/__comp.el" "reynolds")
(code-pdf-page "reynoldstpl" "~/books/__comp/reynolds__theories_of_programming_languages.pdf")
(code-pdf-text "reynoldstpl" "~/books/__comp/reynolds__theories_of_programming_languages.pdf" 13)
;; (find-reynoldstplpage)
;; (find-reynoldstplpage        6  "Contents")
;; (find-reynoldstplpage (+ 1 189) "Index")
;; (find-reynoldstpltext "")

;; (find-reynoldstplpage (+ 13 0) "Preface")
;; (find-reynoldstplpage (+ 13 0) "1 Predicate Logic")
;; (find-reynoldstplpage (+ 13 0) "1.1 Abstract Syntax")
;; (find-reynoldstplpage (+ 13 0) "1.2 Denotational Semantics of Predicate Logic")
;; (find-reynoldstplpage (+ 13 0) "1.3 Validity and Inference")
;; (find-reynoldstplpage (+ 13 0) "1.4 Binding and Substitution")
;; (find-reynoldstplpage (+ 13 0) "2 The Simple Imperative Language")
;; (find-reynoldstplpage (+ 13 0) "2.1 Syntax")
;; (find-reynoldstplpage (+ 13 0) "2.2 Denotational Semantics")
;; (find-reynoldstplpage (+ 13 0) "2.3 Domains and Continuous Functions")
;; (find-reynoldstplpage (+ 13 0) "2.4 The Least Fixed-Point Theorem")
;; (find-reynoldstplpage (+ 13 0) "2.5 Variable Declarations and Substitution")
;; (find-reynoldstplpage (+ 13 0) "2.6 Syntactic Sugar: The for Command")
;; (find-reynoldstplpage (+ 13 0) "2.7 Arithmetic Errors")
;; (find-reynoldstplpage (+ 13 0) "2.8 Soundness and Full Abstraction")
;; (find-reynoldstplpage (+ 13 0) "3 Program Specifications and Their Proofs")
;; (find-reynoldstplpage (+ 13 0) "3.1 Syntax and Semantics of Specifications")
;; (find-reynoldstplpage (+ 13 0) "3.2 Inference Rules")
;; (find-reynoldstplpage (+ 13 0) "3.3 Rules for Assignment and Sequential Composition")
;; (find-reynoldstplpage (+ 13 0) "3.4 Rules for while Commands")
;; (find-reynoldstplpage (+ 13 0) "3.5 Further Rules")
;; (find-reynoldstplpage (+ 13 0) "3.6 Computing Fibonacci Numbers")
;; (find-reynoldstplpage (+ 13 0) "3.7 Fast Exponentiation")
;; (find-reynoldstplpage (+ 13 0) "3.8 Complications and Limitations")
;; (find-reynoldstplpage (+ 13 0) "4 Arrays")
;; (find-reynoldstplpage (+ 13 0) "4.1 Abstract Syntax")
;; (find-reynoldstplpage (+ 13 0) "4.2 Denotational Semantics")
;; (find-reynoldstplpage (+ 13 0) "4.3 Binary Search")
;; (find-reynoldstplpage (+ 13 0) "4.4 Inference Rules for Arrays")
;; (find-reynoldstplpage (+ 13 93) "4.5 Higher-Order Assertions About Arrays")
;; (find-reynoldstplpage (+ 13 97) "5 Failure, Input-Output, and Continuations")
;; (find-reynoldstplpage (+ 13 97) "5.1 The fail Command")
;; (find-reynoldstplpage (+ 13 101) "5.2 Intermediate Output and a Domain of Sequences")
;; (find-reynoldstplpage (+ 13 107) "5.3 The Physical Argument for Continuity")
;; (find-reynoldstplpage (+ 13 109) "5.4 Products and Disjoint Unions of Predomains")
;; (find-reynoldstplpage (+ 13 111) "5.5 Recursive Domain Isomorphisms")
;; (find-reynoldstplpage (+ 13 113) "5.6 Intermediate Input and a Domain of Resumptions")
;; (find-reynoldstplpage (+ 13 115) "5.7 Continuation Semantics")
;; (find-reynoldstplpage (+ 13 118) "5.8 Continuation Semantics of Extensions")
;; (find-reynoldstplpage (+ 13 126) "6 Transition Semantics")
;; (find-reynoldstplpage (+ 13 126) "6.1 Configurations and the Transition Relation")
;; (find-reynoldstplpage (+ 13 127) "6.2 Inference Rules for the Simple Language")
;; (find-reynoldstplpage (+ 13 131) "6.3 Transition Semantics of fail")
;; (find-reynoldstplpage (+ 13 132) "6.4 Input and Output")
;; (find-reynoldstplpage (+ 13 136) "7 Nondeterminism and Guarded Commands")
;; (find-reynoldstplpage (+ 13 137) "7.1 Syntax and Transition Semantics")
;; (find-reynoldstplpage (+ 13 139) "7.2 Bounded Nondeterminism and Powerdomains")
;; (find-reynoldstplpage (+ 13 144) "7.3 Semantic Equations")
;; (find-reynoldstplpage (+ 13 147) "7.4 Program Specification and Proof")
;; (find-reynoldstplpage (+ 13 149) "7.5 Weakest Preconditions")
;; (find-reynoldstplpage (+ 13 155) "8 Shared-Variable Concurrency")
;; (find-reynoldstplpage (+ 13 155) "8.1 Concurrent Composition")
;; (find-reynoldstplpage (+ 13 157) "8.2 Critical Regions")
;; (find-reynoldstplpage (+ 13 159) "8.3 Mutual Exclusion and Conditional Critical Regions")
;; (find-reynoldstplpage (+ 13 161) "8.4 Deadlock")
;; (find-reynoldstplpage (+ 13 162) "8.5 Fairness")
;; (find-reynoldstplpage (+ 13 164) "8.6 Resumption Semantics")
;; (find-reynoldstplpage (+ 13 165) "8.7 Transition Traces")
;; (find-reynoldstplpage (+ 13 171) "8.8 Stuttering and Mumbling")
;; (find-reynoldstplpage (+ 13 181) "9 Communicating Sequential Processes")
;; (find-reynoldstplpage (+ 13 181) "9.1 Syntax")
;; (find-reynoldstplpage (+ 13 183) "9.2 Transition Semantics")
;; (find-reynoldstplpage (+ 13 187) "9.3 Possible Restrictions")
;; (find-reynoldstplpage (+ 13 188) "9.4 Examples")
;; (find-reynoldstplpage (+ 13 189) "9.5 Deadlock")
;; (find-reynoldstplpage (+ 13 189) "9.6 Fairness")
;; (find-reynoldstplpage (+ 13 194) "10 The Lambda Calculus")
;; (find-reynoldstplpage (+ 13 196) "10.1 Syntax")
;; (find-reynoldstplpage (+ 13 197) "10.2 Reduction")
;; (find-reynoldstplpage (+ 13 201) "10.3 Normal-Order Evaluation")
;; (find-reynoldstplpage (+ 13 206) "10.4 Eager Evaluation")
;; (find-reynoldstplpage (+ 13 208) "10.5 Denotational Semantics")
;; (find-reynoldstplpage (+ 13 216) "10.6 Programming in the Lambda Calculus")
;; (find-reynoldstplpage (+ 13 222) "11 An Eager Functional Language")
;; (find-reynoldstplpage (+ 13 222) "11.1 Concrete Syntax")
;; (find-reynoldstplpage (+ 13 223) "11.2 Evaluation Semantics")
;; (find-reynoldstplpage (+ 13 228) "11.3 Definitions, Patterns, and Recursion")
;; (find-reynoldstplpage (+ 13 231) "11.4 Lists")
;; (find-reynoldstplpage (+ 13 232) "11.5 Examples")
;; (find-reynoldstplpage (+ 13 235) "11.6 Direct Denotational Semantics")
;; (find-reynoldstplpage (+ 13 242) "11.7 Dynamic Binding")
;; (find-reynoldstplpage (+ 13 251) "12 Continuations in a Functional Language")
;; (find-reynoldstplpage (+ 13 251) "12.1 Continuation Semantics")
;; (find-reynoldstplpage (+ 13 255) "12.2 Continuations as Values")
;; (find-reynoldstplpage (+ 13 257) "12.3 Continuations as a Programming Technique")
;; (find-reynoldstplpage (+ 13 258) "12.4 Deriving a First-Order Semantics")
;; (find-reynoldstplpage (+ 13 264) "12.5 First-Order Semantics Summarized")
;; (find-reynoldstplpage (+ 13 269) "12.6 Relating First-Order and Continuation Semantics")
;; (find-reynoldstplpage (+ 13 273) "13 Iswim-like Languages")
;; (find-reynoldstplpage (+ 13 273) "13.1 Aliasing, References, and States")
;; (find-reynoldstplpage (+ 13 276) "13.2 Evaluation Semantics")
;; (find-reynoldstplpage (+ 13 278) "13.3 Continuation Semantics")
;; (find-reynoldstplpage (+ 13 282) "13.4 Some Syntactic Sugar")
;; (find-reynoldstplpage (+ 13 282) "13.5 First-Order Semantics")
;; (find-reynoldstplpage (+ 13 284) "13.6 Examples")
;; (find-reynoldstplpage (+ 13 287) "13.7 Exceptions")
;; (find-reynoldstplpage (+ 13 289) "13.8 Backtracking")
;; (find-reynoldstplpage (+ 13 291) "13.9 Input and Output")
;; (find-reynoldstplpage (+ 13 293) "13.10 Some Complications")
;; (find-reynoldstplpage (+ 13 298) "14 A Normal-Order Language")
;; (find-reynoldstplpage (+ 13 298) "14.1 Evaluation Semantics")
;; (find-reynoldstplpage (+ 13 301) "14.2 Syntactic Sugar")
;; (find-reynoldstplpage (+ 13 302) "14.3 Examples")
;; (find-reynoldstplpage (+ 13 304) "14.4 Direct Denotational Semantics")
;; (find-reynoldstplpage (+ 13 306) "14.5 Reduction Revisited")
;; (find-reynoldstplpage (+ 13 307) "14.6 Lazy Evaluation")
;; (find-reynoldstplpage (+ 13 315) "15 The Simple Type System")
;; (find-reynoldstplpage (+ 13 316) "15.1 Types, Contexts, and Judgements")
;; (find-reynoldstplpage (+ 13 318) "15.2 Inference Rules")
;; (find-reynoldstplpage (+ 13 324) "15.3 Explicit Typing")
;; (find-reynoldstplpage (+ 13 327) "15.4 The Extrinsic Meaning of Types")
;; (find-reynoldstplpage (+ 13 334) "15.5 The Intrinsic View")
;; (find-reynoldstplpage (+ 13 339) "15.6 Set-Theoretic Semantics")
;; (find-reynoldstplpage (+ 13 341) "15.7 Recursive Types")
;; (find-reynoldstplpage (+ 13 349) "16 Subtypes and Intersection Types")
;; (find-reynoldstplpage (+ 13 349) "16.1 Inference Rules for Subtyping")
;; (find-reynoldstplpage (+ 13 352) "16.2 Named Products and Sums")
;; (find-reynoldstplpage (+ 13 354) "16.3 Intersection Types")
;; (find-reynoldstplpage (+ 13 358) "16.4 Extrinsic Semantics")
;; (find-reynoldstplpage (+ 13 362) "16.5 Generic Operators")
;; (find-reynoldstplpage (+ 13 365) "16.6 Intrinsic Semantics")
;; (find-reynoldstplpage (+ 13 379) "17 Polymorphism")
;; (find-reynoldstplpage (+ 13 380) "17.1 Syntax and Inference Rules")
;; (find-reynoldstplpage (+ 13 383) "17.2 Polymorphic Programming")
;; (find-reynoldstplpage (+ 13 390) "17.3 Extrinsic Semantics")
;; (find-reynoldstplpage (+ 13 398) "18 Module Specification")
;; (find-reynoldstplpage (+ 13 398) "18.1 Type Definitions")
;; (find-reynoldstplpage (+ 13 401) "18.2 Existential Quantification and Modules")
;; (find-reynoldstplpage (+ 13 406) "18.3 Implementing One Abstraction in Terms of Another")
;; (find-reynoldstplpage (+ 13 415) "19 Algol-like Languages")
;; (find-reynoldstplpage (+ 13 416) "19.1 Data Types and Phrase Types")
;; (find-reynoldstplpage (+ 13 419) "19.2 Phrases and Type Inference Rules")
;; (find-reynoldstplpage (+ 13 423) "19.3 Examples")
;; (find-reynoldstplpage (+ 13 426) "19.4 Arrays and Declarators")
;; (find-reynoldstplpage (+ 13 428) "19.5 A Semantics Embodying the Stack Discipline")
;; (find-reynoldstplpage (+ 13 434) "19.6 The Semantics of Variables")
;; (find-reynoldstplpage (+ 13 436) "19.7 The Semantics of Procedures")
;; (find-reynoldstplpage (+ 13 439) "19.8 Some Extensions and Simplifications")
;; (find-reynoldstplpage (+ 13 447) "Appendix: Mathematical Background")
;; (find-reynoldstplpage (+ 13 448) "A.1 Sets")
;; (find-reynoldstplpage (+ 13 450) "A.2 Relations")
;; (find-reynoldstplpage (+ 13 452) "A.3 Functions")
;; (find-reynoldstplpage (+ 13 456) "A.4 Relations and Functions Between Sets")
;; (find-reynoldstplpage (+ 13 459) "A.5 More About Products and Disjoint Unions")
;; (find-reynoldstplpage (+ 13 462) "A.6 More About Relations")
;; (find-reynoldstplpage (+ 13 467) "Bibliography")
;; (find-reynoldstplpage (+ 13 483) "Index")


;; «rutten»  (to ".rutten")
;; (find-books "__comp/__comp.el" "rutten")
;; "Behavioural differential equations: a coinductive calculus of streams, automata, and power series"
;; https://homepages.cwi.nl/~janr/
;; https://homepages.cwi.nl/~janr/papers/
;; https://homepages.cwi.nl/~janr/papers/files-of-papers/tcs308.pdf
(code-pdf-page "rutten" "$S/https/homepages.cwi.nl/~janr/papers/files-of-papers/tcs308.pdf")
(code-pdf-text "rutten" "$S/https/homepages.cwi.nl/~janr/papers/files-of-papers/tcs308.pdf")
;; (find-ruttenpage)
;; (find-ruttentext)





;; «queinnec»  (to ".queinnec")
;; http://pagesperso-systeme.lip6.fr/Christian.Queinnec/WWW/LiSP.html
(code-djvu       "queinnec" "~/books/__comp/queinnec__lisp_in_small_pieces.djvu")
(code-djvutotext "queinnec" "~/books/__comp/queinnec__lisp_in_small_pieces.djvu")
;; (find-queinnecpage         3  "Contents")
;; (find-queinnecpage (+ 18 495) "Index")
;; (find-queinnectext "")

;; «salus» (to ".salus")
;; (find-books "__comp/__comp.el" "salus")
(code-pdf-page "salus" "~/books/__comp/salus__a_quarter_century_of_UNIX.pdf")
(code-pdf-text "salus" "~/books/__comp/salus__a_quarter_century_of_UNIX.pdf" 13)
;; (find-saluspage)
;; (find-saluspage        12  "Contents")
;; (find-saluspage (+ 13   1) "Introduction")
;; (find-saluspage (+ 13   3) "Genesis")
;; (find-saluspage (+ 13   5) "0. Prelude to space")
;; (find-saluspage (+ 13   7) "1. Summer 1969-")
;; (find-saluspage (+ 13  12) "2. Calculating and computing")
;; (find-saluspage (+ 13  22) "3. Opearting systems")
;; (find-saluspage (+ 13  25) "4. Project MAC:")
;; (find-saluspage (+ 13  31) "Part 2: Birth of a system")
;; (find-saluspage (+ 13  33) "5. The PDP-11")
;; (find-saluspage (+ 13  38) "6. First edition")
;; (find-saluspage (+ 13  44) "7. C and pipes")
;; (find-saluspage (+ 13  54) "8. The first paper")
;; (find-saluspage (+ 13  56) "9. The law - part I")
;; (find-saluspage (+ 13  63) "Part 3: What makes UNIX Unix?")
;; (find-saluspage (+ 13  65) "10. The users")
;; (find-saluspage (+ 13  73) "11. Why Unix?")
;; (find-saluspage (+ 13  78) "12. Style and tools")
;; (find-saluspage (+ 13  92) "13. PWB and MERT")
;; (find-saluspage (+ 13  95) "14. Utilities")
;; (find-saluspage (+ 13 117) "Part 4: Unix spreads and blossoms")
;; (find-saluspage (+ 13 119) "15. The users - part II")
;; (find-saluspage (+ 21 137) "16. Berkeley Unix - part I")
;; (find-saluspage (+ 21 146) "17. Version 7")
;; (find-saluspage (+ 21 153) "18. Berkeley Unix - part II")
;; (find-saluspage (+ 21 173) "19. Commercial Unix")
;; (find-saluspage (+ 21 181) "20. DEC")
;; (find-saluspage (+ 21 189) "21. The law - part 2")
;; (find-saluspage (+ 21 191) "Part 5: The Unix industry")
;; (find-saluspage (+ 21 193) "22. /usr/group")
;; (find-saluspage (+ 21 198) "23. Sun and JAWS")
;; (find-saluspage (+ 21 202) "24. Standards")
;; (find-saluspage (+ 21 207) "Part 6: The currents of change")
;; (find-saluspage (+ 21 209) "25. Duelling Unixes")
;; (find-saluspage (+ 21 213) "26. Offspring systems")
;; (find-saluspage (+ 21 216) "27. OSF and UI")
;; (find-saluspage (+ 21 219) "28. Berkeley Unix: after the VAX")
;; (find-saluspage (+ 21 222) "29. The law: part III")
;; (find-saluspage (+ 21 227) "Finale")
;; (find-saluspage (+ 21 229) "Finale: what made it work?")
;; (find-saluspage (+ 21 235) "Further reading")
;; (find-saluspage (+ 21 239) "Who's who and what's what")
;; (find-saluspage (+ 21 249) "Index")
;; (find-salustext "")


;; «scheinerman»  (to ".scheinerman")
(code-xpdf "scheinerman" "~/books/__comp/scheinerman__matematica_discreta_uma_introducao.pdf")
(code-djvu "scheinerman" "~/books/__comp/scheinerman__matematica_discreta_uma_introducao.djvu")
(code-djvu "scheinerman" "~/books/__comp/scheinerman__matematica_discreta_uma_introducao__bw.djvu")
;; (find-scheinermanpage      1  "Contents")
;; (find-scheinermanpage (+ 1 1) "Index")
;; (find-scheinermantext "")

;; (find-scheinermanpage (+    8   1) "Capítulo 1. Fundamentos")
;; (find-scheinermanpage (+    8   1)  "Seção 1. Definição")
;; (find-scheinermanpage (+    7   7)  "Seção 2. Teorema")
;; (find-scheinermanpage (+    6  16)  "Seção 3. Prova")
;; (find-scheinermanpage (+    6  20)   "Esquema de prova 1" "se-então")
;; (find-scheinermanpage (+    6  22)   "Omitindo passos")
;; (find-scheinermanpage (+    4  25)  "Seção 4. Contra-exemplo")
;; (find-scheinermanpage (+    4  27)  "Seção 5. Álgebra de Boole")
;; (find-scheinermanpage (+    4  29)   "Equivalência lógica")
;; (find-scheinermanpage (+    0  33)   "(exercícios)")
;; (find-scheinermanpage (+    0  35) "Capítulo 2. Coleções")
;; (find-scheinermanpage (+    0  35)  "Seção 6. Listas")
;; (find-scheinermanpage (+   -6  44)  "Seção 7. Fatorial")
;; (find-scheinermanpage (+   -6  49)  "Seção 8. Conjuntos I: Introdução, Subconjuntos")
;; (find-scheinermanpage (+   -7  56)  "Seção 9. Quantificadores")
;; (find-scheinermanpage (+  -10  62)  "Seção 10. Conjuntos II: Operações")
;; (find-scheinermanpage (+  -10  77) "Capítulo 3. Contagem e Relações")
;; (find-scheinermanpage (+  -10  77)  "Seção 11. Relações")
;; (find-scheinermanpage (+  -10  83)   "Ilustração de relações")
;; (find-scheinermanpage (+  -10  84)  "Seção 12. Relações de Equivalência")
;; (find-scheinermanpage (+  -10  93)  "Seção 13. Partições")
;; (find-scheinermanpage (+  -15 100)  "Seção 14. Coeficientes Binomiais")
;; (find-scheinermanpage (+  -23 116)  "Seção 15. Contagem de Multiconjuntos")
;; (find-scheinermanpage (+  -23 124)  "Seção 16. Inclusão-Exclusão")
;; (find-scheinermanpage (+  -25 135) "Capítulo 4. Mais Provas")
;; (find-scheinermanpage (+  -25 135)  "Seção 17. Contradição")
;; (find-scheinermanpage (+  -25 143)  "Seção 18. Contra-exemplo Mínimo")
;; (find-scheinermanpage (+  -27 155)    "(indução - exercícios preliminares)")
;; (find-scheinermanpage (+  -27 156)  "Seção 19. Indução")
;; (find-scheinermanpage (+  -27 165)    "(indução - exercícios mais sérios)")
;; (find-scheinermanpage (+  -27 169) "Capítulo 5. Funções")
;; (find-scheinermanpage (+  -27 170)  "Seção 20. Funções")
;; (find-scheinermanpage (+  -29 184)  "Seção 21. O Princípio da Casa do Pombo")
;; (find-scheinermanpage (+  -31 191)  "Seção 22. Composição")
;; (find-scheinermanpage (+  -31 197)  "Seção 23. Permutações")
;; (find-scheinermanpage (+  -31 212)  "Seção 24. Simetria")
;; (find-scheinermanpage (+  -31 219)  "Seção 25. Tipos de Notação")
;; (find-scheinermanpage (+  -38 227) "Capítulo 6. Probabilidade")
;; (find-scheinermanpage (+  -38 228)  "Seção 26. Espaço Amostral")
;; (find-scheinermanpage (+  -38 232)  "Seção 27. Eventos")
;; (find-scheinermanpage (+  -41 241)  "Seção 28. Probabilidade Condicional e Independência")
;; (find-scheinermanpage (+  -41 252)  "Seção 29. Variáveis Aleatórias")
;; (find-scheinermanpage (+  -55 258)  "Seção 30. Esperança")
;; (find-scheinermanpage (+  -55 279) "Capítulo 7. Teoria dos Números")
;; (find-scheinermanpage (+  -55 279)  "Seção 31. Divisão")
;; (find-scheinermanpage (+  -55 285)  "Seção 32. Máximo Divisor Comum")
;; (find-scheinermanpage (+  -64 296)  "Seção 33. Aritmética Modular")
;; (find-scheinermanpage (+  -64 308)  "Seção 34. O Teorema do Resto Chinês")
;; (find-scheinermanpage (+  -64 314)  "Seção 35. Fatoração")
;; (find-scheinermanpage (+  -69 325) "Capítulo 8. Álgebra")
;; (find-scheinermanpage (+  -69 325)  "Seção 36. Grupos")
;; (find-scheinermanpage (+  -69 336)  "Seção 37. Isomorfismo de Grupos")
;; (find-scheinermanpage (+  -69 343)  "Seção 38. Subgrupos")
;; (find-scheinermanpage (+  -78 352)  "Seção 39. O Pequeno Teorema de Fermat")
;; (find-scheinermanpage (+  -78 361)  "Seção 40. Criptografia de Chave Pública I: Introdução")
;; (find-scheinermanpage (+  -78 366)  "Seção 41. Criptografia de Chave Pública II: O Método de Rabin")
;; (find-scheinermanpage (+  -78 373)  "Seção 42. Criptografia de Chave Pública III: RSA")
;; (find-scheinermanpage (+  -90 381) "Capítulo 9. Grafos")
;; (find-scheinermanpage (+  -93 381)  "Seção 43. Fundamentos da Teoria dos Grafos")
;; (find-scheinermanpage (+  -95 394)  "Seção 44. Subgrafos")
;; (find-scheinermanpage (+ -100 402)  "Seção 45. Conexão")
;; (find-scheinermanpage (+ -102 411)  "Seção 46. Árvores")
;; (find-scheinermanpage (+ -105 422)  "Seção 47. Grafos Eulerianos")
;; (find-scheinermanpage (+ -107 428)  "Seção 48. Coloração")
;; (find-scheinermanpage (+ -109 439)  "Seção 49. Grafos Planares")
;; (find-scheinermanpage (+ -115 453) "Capítulo 10. Conjuntos Parcialmente Ordenados")
;; (find-scheinermanpage (+ -115 453)  "Seção 50. Fundamentos dos Conjuntos Parcialmente Ordenados")
;; (find-scheinermanpage (+ -115 454)   "diagrama de Hasse")
;; (find-scheinermanpage (+ -119 461)  "Seção 51. Max e Min")
;; (find-scheinermanpage (+ -119 464)  "Seção 52. Ordens Lineares")
;; (find-scheinermanpage (+ -121 468)  "Seção 53. Extensões Lineares")
;; (find-scheinermanpage (+ -125 477)  "Seção 54. Dimensão")
;; (find-scheinermanpage (+ -129 485)  "Seção 55. Reticulados")
;; (find-scheinermanpage (+ -129 493) "Apêndices")
;; (find-scheinermanpage (+ -132 493) "Apêndice A. Muitas Sugestões e Comentários, Algumas Respostas")
;; (find-scheinermanpage (+ -116 515) "Apêndice B. Glossário")
;; (find-scheinermanpage (+ -117 522) "Apêndice C. Fundamentos")
;; (find-scheinermanpage (+ -118 525) "Esquemas de prova")
;; (find-scheinermanpage (+ -118 527) "Índice remissivo")


;; «sedgewick»  (to ".sedgewick")
(code-xpdf "sedgewick" "~/books/__comp/sedgewick__algorithms_in_c.pdf")
(code-djvu "sedgewick" "~/books/__comp/sedgewick__algorithms_in_c.djvu")
;; (find-sedgewickpage        12  "Contents")
;; (find-sedgewickpage (+ 15 647) "Index")

;; 1st edition, 1983:
;; http://thepiratebay.se/torrent/4870389/Algorithms_-_Robert_Sedgewick
;; (find-xpdfpage "sedgewick" "~/books/__comp/sedgewick__algorithms.pdf")



;; «seibel»  (to ".seibel")
;; http://gigapedia.com/items/374054/coders-at-work---reflections-on-the-craft-of-programming
(code-xpdf      "codersatwork" "~/books/__comp/seibel__coders_at_work.pdf")
(code-pdftotext "codersatwork" "~/books/__comp/seibel__coders_at_work.pdf")
;; (find-codersatworkpage         8  "Contents")
;; (find-codersatworkpage (+ 16 449) "Ken Thompson")
;; (find-codersatworkpage (+ 16 607) "Index")
;; (find-codersatworktext "")
;; (find-codersatworktext  13 "believe that they know what they were talking about")
;; (find-codersatworktext  16 "Fuck off!")
;; (find-codersatworktext  20 "which ten percent of the language is safe to use")
;; (find-codersatworktext  45 "three orders of magnitude wrong")
;; (find-codersatworktext  47 "There are no user-serviceable parts anymore")
;; (find-codersatworktext  71 "And then they reply.")
;; (find-codersatworktext  88 "same people writing the air-traffic-control system")
;; (find-codersatworktext 124 "write in your native language")
;; (find-codersatworktext 130 "Windows programmers")
;; (find-codersatworktext 292 "Getting along with people")
;; (find-codersatworktext 332 "It was possible to do a core dump and inspect every word")
;; (find-codersatworktext 366 "ha ha, this proof has a bug in it")
;; (find-codersatworktext 378 "so good they eat their children")
;; (find-codersatworktext 379 "their role is to prepare people to work in an industry")
;; (find-codersatworktext 494 "not thinking at all before you start")
;; (find-codersatworktext 502 "So that was the excuse for C")
;; (find-codersatworktext 507 "an awful lot of them come from farm kids")
;; (find-codersatworktext 510 "it was a profession")



;; «steele-common-lisp»  (to ".steele-common-lisp")
;; (find-books "__comp/__comp.el" "steele-common-lisp")
(code-pdf-page "steelecommonlisp" "~/books/__comp/steele__common_lisp_the_language_2nd_ed.pdf")
(code-pdf-text "steelecommonlisp" "~/books/__comp/steele__common_lisp_the_language_2nd_ed.pdf" 1)
;; (find-steelecommonlisppage)
;; (find-steelecommonlisppage        1  "Contents")
;; (find-steelecommonlisppage (+ 1 189) "Index")
;; (find-steelecommonlisptext "")



;; «stroustrup»  (to ".stroustrup")
(code-djvu       "stroustrupdaecpp" "~/books/__comp/stroustrup__the_design_and_evolution_of_C++.djvu")
(code-djvutotext "stroustrupdaecpp" "~/books/__comp/stroustrup__the_design_and_evolution_of_C++.djvu")
;; (find-stroustrupdaecpppage      1  "Contents")
;; (find-stroustrupdaecpppage (+ 1 1) "Index")
;; (find-stroustrupdaecpptext "")


;; «sussman-wisdom»  (to ".sussman-wisdom")
;; (find-books "__comp/__comp.el" "sussman-wisdom")
;; https://en.wikipedia.org/wiki/Structure_and_Interpretation_of_Classical_Mechanics
;; https://groups.csail.mit.edu/mac/users/gjs/6946/
(code-pdf-page "sicm" "~/books/__comp/sussman_wisdom__structure_and_interpretation_of_classical_mechanics.pdf")
(code-pdf-text "sicm" "~/books/__comp/sussman_wisdom__structure_and_interpretation_of_classical_mechanics.pdf" 20)
;; (find-sicmpage)
;; (find-sicmpage         6  "Contents")
;; (find-sicmtext         6  "Contents")
;; (find-sicmpage        12  "mathematical pedagogy")
;; (find-sicmtext        12  "mathematical pedagogy")
;; (find-sicmpage        13  "functional notation")
;; (find-sicmtext        13  "functional notation")
;; (find-sicmpage (+ 20   1) "1 Lagrangian Mechanics")
;; (find-sicmpage (+ 20   4) "1.1 Configuration Spaces")
;; (find-sicmpage (+ 20   6) "1.2 Generalized Coordinates")
;; (find-sicmpage (+ 20   8) "1.3 The Principle of Stationary Action")
;; (find-sicmpage (+ 20  14) "1.4 Computing Actions")
;; (find-sicmpage (+ 20  14)   "as a procedure")
;; (find-sicmtext (+ 20  14)   "as a procedure")
;; (find-sicmpage (+ 20  23) "1.5 The Euler-Lagrange Equations")
;; (find-sicmpage (+ 20  25) "1.5.1 Derivation of the Lagrange Equations")
;; (find-sicmpage (+ 20  25)   "correct use of the traditional notation")
;; (find-sicmtext (+ 20  25)   "correct use of the traditional notation")
;; (find-sicmpage (+ 20  33) "1.5.2 Computing Lagrange's Equations")
;; (find-sicmpage (+ 20  36) "1.6 How to Find Lagrangians")
;; (find-sicmpage (+ 20  44) "1.6.1 Coordinate Transformations")
;; (find-sicmpage (+ 20  49) "1.6.2 Systems with Rigid Constraints")
;; (find-sicmpage (+ 20  59) "1.6.3 Constraints as Coordinate Transformations")
;; (find-sicmpage (+ 20  63) "1.6.4 The Lagrangian Is Not Unique")
;; (find-sicmpage (+ 20  68) "1.7 Evolution of Dynamical State")
;; (find-sicmpage (+ 20  78) "1.8 Conserved Quantities")
;; (find-sicmpage (+ 20  79) "1.8.1 Conserved Momenta")
;; (find-sicmpage (+ 20  81) "1.8.2 Energy Conservation")
;; (find-sicmpage (+ 20  84) "1.8.3 Central Forces in Three Dimensions")
;; (find-sicmpage (+ 20  86) "1.8.4 The Restricted Three-Body Problem")
;; (find-sicmpage (+ 20  90) "1.8.5 Noether's Theorem")
;; (find-sicmpage (+ 20  94) "1.9 Abstraction of Path Functions")
;; (find-sicmpage (+ 20  99) "1.10 Constrained Motion")
;; (find-sicmpage (+ 20 101) "1.10.1 Coordinate Constraints")
;; (find-sicmpage (+ 20 108) "1.10.2 Derivative Constraints")
;; (find-sicmpage (+ 20 112) "1.10.3 Nonholonomic Systems")
;; (find-sicmpage (+ 20 115) "1.11 Summary")
;; (find-sicmpage (+ 20 116) "1.12 Projects")
;; (find-sicmpage (+ 20 119) "2 Rigid Bodies")
;; (find-sicmpage (+ 20 120) "2.1 Rotational Kinetic Energy")
;; (find-sicmpage (+ 20 122) "2.2 Kinematics of Rotation")
;; (find-sicmpage (+ 20 126) "2.3 Moments of Inertia")
;; (find-sicmpage (+ 20 130) "2.4 Inertia Tensor")
;; (find-sicmpage (+ 20 132) "2.5 Principal Moments of Inertia")
;; (find-sicmpage (+ 20 135) "2.6 Vector Angular Momentum")
;; (find-sicmpage (+ 20 137) "2.7 Euler Angles")
;; (find-sicmpage (+ 20 141) "2.8 Motion of a Free Rigid Body")
;; (find-sicmpage (+ 20 143) "2.8.1 Computing the Motion of Free Rigid Bodies")
;; (find-sicmpage (+ 20 146) "2.8.2 Qualitative Features")
;; (find-sicmpage (+ 20 151) "2.9 Euler's Equations")
;; (find-sicmpage (+ 20 157) "2.10 Axisymmetric Tops")
;; (find-sicmpage (+ 20 165) "2.11 Spin-Orbit Coupling")
;; (find-sicmpage (+ 20 165) "2.11.1 Development of the Potential Energy")
;; (find-sicmpage (+ 20 170) "2.11.2 Rotation of the Moon and Hyperion")
;; (find-sicmpage (+ 20 177) "2.11.3 Spin-Orbit Resonances")
;; (find-sicmpage (+ 20 181) "2.12 Nonsingular Coordinates and Quaternions")
;; (find-sicmpage (+ 20 188) "2.12.1 Motion in Terms of Quaternions")
;; (find-sicmpage (+ 20 191) "2.13 Summary")
;; (find-sicmpage (+ 20 193) "2.14 Projects")
;; (find-sicmpage (+ 19 195) "3 Hamiltonian Mechanics")
;; (find-sicmpage (+ 19 197) "3.1 Hamilton's Equations")
;; (find-sicmpage (+ 19 205) "3.1.1 The Legendre Transformation")
;; (find-sicmpage (+ 19 215) "3.1.2 Hamilton's Equations from the Action Principle")
;; (find-sicmpage (+ 19 217) "3.1.3 A Wiring Diagram")
;; (find-sicmpage (+ 19 218) "3.2 Poisson Brackets")
;; (find-sicmpage (+ 19 222) "3.3 One Degree of Freedom")
;; (find-sicmpage (+ 19 224) "3.4 Phase Space Reduction")
;; (find-sicmpage (+ 19 233) "3.4.1 Lagrangian Reduction")
;; (find-sicmpage (+ 19 236) "3.5 Phase Space Evolution")
;; (find-sicmpage (+ 19 238) "3.5.1 Phase-Space Description Is Not Unique")
;; (find-sicmpage (+ 19 239) "3.6 Surfaces of Section")
;; (find-sicmpage (+ 19 241) "3.6.1 Periodically Driven Systems")
;; (find-sicmpage (+ 19 246) "3.6.2 Computing Stroboscopic Surfaces of Section")
;; (find-sicmpage (+ 19 248) "3.6.3 Autonomous Systems")
;; (find-sicmpage (+ 19 261) "3.6.4 Computing Henon-Heiles Surfaces of Section")
;; (find-sicmpage (+ 19 263) "3.6.5 Non-Axisymmetric Top")
;; (find-sicmpage (+ 19 263) "3.7 Exponential Divergence")
;; (find-sicmpage (+ 19 268) "3.8 Liouville's Theorem")
;; (find-sicmpage (+ 19 277) "3.9 Standard Map")
;; (find-sicmpage (+ 19 281) "3.10 Summary")
;; (find-sicmpage (+ 19 282) "3.11 Projects")
;; (find-sicmpage (+ 18 285) "4 Phase Space Structure")
;; (find-sicmpage (+ 18 286) "4.1 Emergence of the Divided Phase Space")
;; (find-sicmpage (+ 18 290) "4.2 Linear Stability")
;; (find-sicmpage (+ 18 291) "4.2.1 Equilibria of Differential Equations")
;; (find-sicmpage (+ 18 295) "4.2.2 Fixed Points of Maps")
;; (find-sicmpage (+ 18 297) "4.2.3 Relations Among Exponents")
;; (find-sicmpage (+ 18 302) "4.3 Homoclinic Tangle")
;; (find-sicmpage (+ 18 307) "4.3.1 Computation of Stable and Unstable Manifolds")
;; (find-sicmpage (+ 18 309) "4.4 Integrable Systems")
;; (find-sicmpage (+ 18 316) "4.5 Poincare-Birkhoff Theorem")
;; (find-sicmpage (+ 18 321) "4.5.1 Computing the Poincare-Birkhoff Construction")
;; (find-sicmpage (+ 18 322) "4.6 Invariant Curves")
;; (find-sicmpage (+ 18 326) "4.6.1 Finding Invariant Curves")
;; (find-sicmpage (+ 18 329) "4.6.2 Dissolution of Invariant Curves")
;; (find-sicmpage (+ 18 330) "4.7 Summary")
;; (find-sicmpage (+ 18 333) "4.8 Projects")
;; (find-sicmpage (+ 17 335) "5 Canonical Transformations")
;; (find-sicmpage (+ 17 336) "5.1 Point Transformations")
;; (find-sicmpage (+ 17 342) "5.2 General Canonical Transformations")
;; (find-sicmpage (+ 17 347) "5.2.1 Time-Dependent Transformations")
;; (find-sicmpage (+ 17 350) "5.2.2 Abstracting the Canonical Condition")
;; (find-sicmpage (+ 17 357) "5.3 Invariants of Canonical Transformations")
;; (find-sicmpage (+ 17 364) "5.4 Generating Functions")
;; (find-sicmpage (+ 17 366) "5.4.1 F1 Generates Canonical Transformations")
;; (find-sicmpage (+ 17 368) "5.4.2 Generating Functions and Integral Invariants")
;; (find-sicmpage (+ 17 373) "5.4.3 Types of Generating Functions")
;; (find-sicmpage (+ 17 375) "5.4.4 Point Transformations")
;; (find-sicmpage (+ 17 390) "5.4.5 Total Time Derivatives")
;; (find-sicmpage (+ 17 394) "5.5 Extended Phase Space")
;; (find-sicmpage (+ 17 402) "5.5.1 Poincare-Cartan Integral Invariant")
;; (find-sicmpage (+ 17 402) "5.6 Reduced Phase Space")
;; (find-sicmpage (+ 17 408) "5.7 Summary")
;; (find-sicmpage (+ 17 408) "5.8 Projects")
;; (find-sicmpage (+ 17 411) "6 Canonical Evolution")
;; (find-sicmpage (+ 17 411) "6.1 Hamilton-Jacobi Equation")
;; (find-sicmpage (+ 17 413) "6.1.1 Harmonic Oscillator")
;; (find-sicmpage (+ 17 417) "6.1.2 Hamilton-Jacobi Solution of the Kepler Problem")
;; (find-sicmpage (+ 17 421) "6.1.3 F2 and the Lagrangian")
;; (find-sicmpage (+ 17 423) "6.1.4 The Action Generates Time Evolution")
;; (find-sicmpage (+ 17 426) "6.2 Time Evolution is Canonical")
;; (find-sicmpage (+ 17 431) "6.2.1 Another View of Time Evolution")
;; (find-sicmpage (+ 17 435) "6.2.2 Yet Another View of Time Evolution")
;; (find-sicmpage (+ 17 437) "6.3 Lie Transforms")
;; (find-sicmpage (+ 17 443) "6.4 Lie Series")
;; (find-sicmpage (+ 17 451) "6.5 Exponential Identities")
;; (find-sicmpage (+ 17 453) "6.6 Summary")
;; (find-sicmpage (+ 17 453) "6.7 Projects")
;; (find-sicmpage (+ 17 457) "7 Canonical Perturbation Theory")
;; (find-sicmpage (+ 17 458) "7.1 Perturbation Theory with Lie Series")
;; (find-sicmpage (+ 17 460) "7.2 Pendulum as a Perturbed Rotor")
;; (find-sicmpage (+ 17 468) "7.2.1 Higher Order")
;; (find-sicmpage (+ 17 471) "7.2.2 Eliminating Secular Terms")
;; (find-sicmpage (+ 17 473) "7.3 Many Degrees of Freedom")
;; (find-sicmpage (+ 17 476) "7.3.1 Driven Pendulum as a Perturbed Rotor")
;; (find-sicmpage (+ 17 478) "7.4 Nonlinear Resonance")
;; (find-sicmpage (+ 17 480) "7.4.1 Pendulum Approximation")
;; (find-sicmpage (+ 17 488) "7.4.2 Reading the Hamiltonian")
;; (find-sicmpage (+ 17 488) "7.4.3 Resonance-Overlap Criterion")
;; (find-sicmpage (+ 17 489) "7.4.4 Higher-Order Perturbation Theory")
;; (find-sicmpage (+ 17 491) "7.4.5 Stability of the Inverted Vertical Equilibrium")
;; (find-sicmpage (+ 17 494) "7.5 Summary")
;; (find-sicmpage (+ 17 496) "7.6 Projects")
;; (find-sicmpage (+ 17 497) "8 Appendix: Scheme")
;; (find-sicmpage (+ 17 509) "9 Appendix: Our Notation")
;; (find-sicmpage (+ 16 525) "References")
;; (find-sicmpage (+ 15 529) "List of Exercises")
;; (find-sicmpage (+ 14 531) "Index")
;; (find-sicmtext "")




;; «wilkinson»  (to ".wilkinson")
;; http://gigapedia.com/items/50977/the-grammar-of-graphics--second-edition
(code-xpdf      "grammarofgraphics" "~/books/__comp/wilkinson__the_grammar_of_graphics.pdf")
(code-pdftotext "grammarofgraphics" "~/books/__comp/wilkinson__the_grammar_of_graphics.pdf")
;; (find-grammarofgraphicspage       12  "Contents")
;; (find-grammarofgraphicspage (+ 2 681) "Index")
;; (find-grammarofgraphicstext "")



;; «yanofsky-mannucci»  (to ".yanofsky-mannucci")
;; (find-books "__comp/__comp.el" "yanofsky-mannucci")
(code-pdf-page "quantumccs" "~/books/__comp/yanofsky_mannucci__quantum_computing_for_computer_scientists.pdf")
(code-pdf-text "quantumccs" "~/books/__comp/yanofsky_mannucci__quantum_computing_for_computer_scientists.pdf" 1)
;; (find-quantumccspage)
;; (find-quantumccspage         9  "Contents")
;; (find-quantumccspage (+ 18 381) "Index")
;; (find-quantumccstext "")




;; «zeilberger»  (to ".zeilberger")
;; (find-books "__comp/__comp.el" "zeilberger")
;; Noam Zeilberger: "The Logical Basis of Evaluation Order and Pattern-Matching"
;; http://noamz.org/thesis.pdf
(code-pdf-page "zeilbergerthesis" "$S/http/noamz.org/thesis.pdf")
(code-pdf-text "zeilbergerthesis" "$S/http/noamz.org/thesis.pdf")
;; (find-zeilbergerthesispage)
;; (find-zeilbergerthesistext)
;; (find-zeilbergerthesispage (+ 12   1) "1 Introduction")
;; (find-zeilbergerthesispage (+ 12   7) "2 Canonical derivations")
;; (find-zeilbergerthesispage (+ 12   8) "2.1 A proof-biased logic")
;; (find-zeilbergerthesispage (+ 12   8) "2.1.1 Refutation frames, proof patterns, connectives")
;; (find-zeilbergerthesispage (+ 12   9) "2.1.2 The definition ordering")
;; (find-zeilbergerthesispage (+ 12  10) "2.1.3 Proofs and refutations")
;; (find-zeilbergerthesispage (+ 12  12) "2.1.4 Identity and composition")
;; (find-zeilbergerthesispage (+ 12  14) "2.1.5 Complex frames")
;; (find-zeilbergerthesispage (+ 12  16) "2.2 A refutation-biased logic")
;; (find-zeilbergerthesispage (+ 12  16) "2.2.1 Proof frames, refutation patterns, definition ordering")
;; (find-zeilbergerthesispage (+ 12  17) "2.2.2 Proofs and refutations, identity and composition, complex hypotheses")
;; (find-zeilbergerthesispage (+ 12  20) "2.3 Propositional polarized logic")
;; (find-zeilbergerthesispage (+ 12  20) "2.3.1 A unified view")
;; (find-zeilbergerthesispage (+ 12  22) "2.3.2 Atomic propositions")
;; (find-zeilbergerthesispage (+ 12  23) "2.3.3 The entailment relation(s)")
;; (find-zeilbergerthesispage (+ 12  26) "2.4 Linear and affine canonical derivations")
;; (find-zeilbergerthesispage (+ 12  29) "2.5 Related Work")
;; (find-zeilbergerthesispage (+ 12  33) "3 Focusing proofs and double-negation translations")
;; (find-zeilbergerthesispage (+ 12  34) "3.1 Focusing proof search for linear logic")
;; (find-zeilbergerthesispage (+ 12  34) "3.1.1 Naive proof search for linear logic")
;; (find-zeilbergerthesispage (+ 12  36) "3.1.2 Observation #1: Invertibility and the Inversion Phase")
;; (find-zeilbergerthesispage (+ 12  37) "3.1.3 Observation #2: Focalization and the Focus Phase")
;; (find-zeilbergerthesispage (+ 12  38) "3.2 Relating focusing proofs to canonical derivations")
;; (find-zeilbergerthesispage (+ 12  38) "3.2.1 Polarity, invertibility, and focalization")
;; (find-zeilbergerthesispage (+ 12  40) "3.2.2 Focusing proofs, through a microscope")
;; (find-zeilbergerthesispage (+ 12  43) "3.2.3 Focusing proofs, standing back and squinting")
;; (find-zeilbergerthesispage (+ 12  47) "3.2.4 Focusing proofs are canonical derivations")
;; (find-zeilbergerthesispage (+ 12  49) "3.2.5 Complex hypotheses and weak focalization")
;; (find-zeilbergerthesispage (+ 12  49) "3.3 Completeness of focusing proofs")
;; (find-zeilbergerthesispage (+ 12  51) "3.4 Unrestricted derivations and classical sequent calculus")
;; (find-zeilbergerthesispage (+ 12  51) "3.4.1 Polarizations of classical logic")
;; (find-zeilbergerthesispage (+ 12  52) "3.4.2 Focusing proofs for classical sequent calculus")
;; (find-zeilbergerthesispage (+ 12  55) "3.4.3 Classical focusing proofs are unrestricted canonical derivations")
;; (find-zeilbergerthesispage (+ 12  56) "3.4.4 The completeness theorem")
;; (find-zeilbergerthesispage (+ 12  57) "3.5 Relating focusing and double-negation translations")
;; (find-zeilbergerthesispage (+ 12  61) "3.6 Related Work")
;; (find-zeilbergerthesispage (+ 12  63) "4 Proofs as programs")
;; (find-zeilbergerthesispage (+ 12  64) "4.1 Type-free notations for typeful derivations")
;; (find-zeilbergerthesispage (+ 12  66) "4.2 L+ : A call-by-value language")
;; (find-zeilbergerthesispage (+ 12  66) "4.2.1 Continuation frames and value patterns")
;; (find-zeilbergerthesispage (+ 12  67) "4.2.2 Annotated frames, contexts and binding")
;; (find-zeilbergerthesispage (+ 12  68) "4.2.3 Values, continuations, substitutions, expressions")
;; (find-zeilbergerthesispage (+ 12  74) "4.2.4 Is this really syntax?")
;; (find-zeilbergerthesispage (+ 12  75) "4.2.5 Equality, operational semantics, and effects: overview")
;; (find-zeilbergerthesispage (+ 12  76) "4.2.6 Definitional equality")
;; (find-zeilbergerthesispage (+ 12  77) "4.2.7 Identity")
;; (find-zeilbergerthesispage (+ 12  78) "4.2.8 Composition")
;; (find-zeilbergerthesispage (+ 12  78) "4.2.9 Properties of composition")
;; (find-zeilbergerthesispage (+ 12  80) "4.2.10 Complex variables")
;; (find-zeilbergerthesispage (+ 12  81) "4.2.11 Type isomorphisms")
;; (find-zeilbergerthesispage (+ 12  83) "4.2.12 Environment semantics")
;; (find-zeilbergerthesispage (+ 12  85) "4.2.13 Observational equivalence")
;; (find-zeilbergerthesispage (+ 12  86) "4.2.14 Immediate failure, and the chronicle representation")
;; (find-zeilbergerthesispage (+ 12  92) "4.2.15 Ground state, and the separation theorem")
;; (find-zeilbergerthesispage (+ 12  94) "4.3 L: A language with mixed evaluation order")
;; (find-zeilbergerthesispage (+ 12  94) "4.3.1 Continuation patterns and value frames")
;; (find-zeilbergerthesispage (+ 12  95) "4.3.2 Terms")
;; (find-zeilbergerthesispage (+ 12  96) "4.3.3 Mixed polarity types")
;; (find-zeilbergerthesispage (+ 12  99) "4.3.4 Untyped, or "uni-typed"? Better: bi-typed!")
;; (find-zeilbergerthesispage (+ 12 100) "4.3.5 L equality, semantics and effects: overview")
;; (find-zeilbergerthesispage (+ 12 100) "4.3.6 Definitional equality")
;; (find-zeilbergerthesispage (+ 12 101) "4.3.7 Identity")
;; (find-zeilbergerthesispage (+ 12 101) "4.3.8 Composition")
;; (find-zeilbergerthesispage (+ 12 101) "4.3.9 Properties of composition")
;; (find-zeilbergerthesispage (+ 12 102) "4.3.10 Type isomorphisms")
;; (find-zeilbergerthesispage (+ 12 102) "4.3.11 Environment semantics")
;; (find-zeilbergerthesispage (+ 12 103) "4.3.12 Observational equivalence and the separation theorems")
;; (find-zeilbergerthesispage (+ 12 103) "4.4 Polarization and CPS translations")
;; (find-zeilbergerthesispage (+ 12 104) "4.4.1 From -calculus to L+ and back")
;; (find-zeilbergerthesispage (+ 12 107) "4.4.2 Reconstructing call-by-value and call-by-name")
;; (find-zeilbergerthesispage (+ 12 111) "4.4.3 Polarization for fun and profit")
;; (find-zeilbergerthesispage (+ 12 112) "4.5 Related Work")
;; (find-zeilbergerthesispage (+ 12 115) "5 Concrete notations for abstract derivations")
;; (find-zeilbergerthesispage (+ 12 116) "5.1 An embedding of L in Agda")
;; (find-zeilbergerthesispage (+ 12 124) "5.2 An embedding of L+ in Twelf")
;; (find-zeilbergerthesispage (+ 12 134) "5.3 Related work")
;; (find-zeilbergerthesispage (+ 12 135) "6 Refinement types and completeness of subtyping")
;; (find-zeilbergerthesispage (+ 12 135) "6.1 Introduction")
;; (find-zeilbergerthesispage (+ 12 138) "6.2 Refining L+0")
;; (find-zeilbergerthesispage (+ 12 138) "6.2.1 A refinement "restriction"?")
;; (find-zeilbergerthesispage (+ 12 139) "6.2.2 Refining types")
;; (find-zeilbergerthesispage (+ 12 142) "6.2.3 Refining terms")
;; (find-zeilbergerthesispage (+ 12 146) "6.2.4 Refining equality, identity and composition")
;; (find-zeilbergerthesispage (+ 12 146) "6.2.5 Refining complex hypotheses")
;; (find-zeilbergerthesispage (+ 12 147) "6.2.6 Subtyping: the identity coercion interpretation")
;; (find-zeilbergerthesispage (+ 12 149) "6.2.7 Subtyping: axiomatization")
;; (find-zeilbergerthesispage (+ 12 150) "6.2.8 Reconstructing the value/evaluation context restrictions")
;; (find-zeilbergerthesispage (+ 12 151) "6.2.9 The environment semantics and type safety")
;; (find-zeilbergerthesispage (+ 12 152) "6.2.10 Subtyping: the no-counterexamples interpretation")
;; (find-zeilbergerthesispage (+ 12 154) "6.2.11 Some counterexample examples (and counterexamples)")
;; (find-zeilbergerthesispage (+ 12 157) "6.2.12 The (conditional) completeness of the identity coercion interpretation")
;; (find-zeilbergerthesispage (+ 12 160) "6.3 Refining full L")
;; (find-zeilbergerthesispage (+ 12 160) "6.4 Related Work")
;; (find-zeilbergerthesispage (+ 12 163) "7 Conclusion")
;; (find-zeilbergerthesispage (+ 12 165) "Bibliography")
;; (find-zeilbergerthesispage (+ 12 177) "A Agda embedding of L+")
;; (find-zeilbergerthesispage (+ 12 185) "B Twelf embedding of L+")







;; «free-as-in-freedom»  (to ".free-as-in-freedom")
;; (find-books "__comp/__comp.el" "free-as-in-freedom")
;; Free as in Freedom (2.0): Richard Stallman and the Free Software Revolution
;; https://www.fsf.org/faif
;; https://static.fsf.org/nosvn/faif-2.0.pdf
(code-pdf-page "faif" "$S/https/static.fsf.org/nosvn/faif-2.0.pdf")
(code-pdf-text "faif" "$S/https/static.fsf.org/nosvn/faif-2.0.pdf" 16)
;; (find-faifpage)
;; (find-faifpage 5 "Contents")
;; (find-faiftext)

;; «levy-hackers»  (to ".levy-hackers")
;; (find-books "__comp/__comp.el" "levy-hackers")
(code-pdf-page "hackers" "~/books/__comp/levy__hackers_heroes_of_the_computer_revolution.pdf")
(code-pdf-text "hackers" "~/books/__comp/levy__hackers_heroes_of_the_computer_revolution.pdf" 17)
;; (find-hackerspage)
;; (find-hackerspage         6  "Contents")
;; (find-hackerspage        10  "Preface")
;; (find-hackerspage        12  "Who's Who")
;; (find-hackerspage (+ 17   1) "CAMBRIDGE: The Fifties and Sixties")
;; (find-hackerspage (+ 17   3) "Part One. TRUE HACKERS")
;; (find-hackerspage (+ 17   3) "1. The Tech Model Railroad Club")
;; (find-hackerspage (+ 17  27) "2. The Hacker Ethic")
;; (find-hackerspage (+ 17  39) "3. Spacewar")
;; (find-hackerspage (+ 17  61) "4. Greenblatt and Gosper")
;; (find-hackerspage (+ 17  83) "5. The Midnight Computer Wiring Society")
;; (find-hackerspage (+ 17 101) "6. Winners and Losers")
;; (find-hackerspage (+ 17 123) "7. Life")
;; (find-hackerspage (+ 17 149) "Part Two. HARDWARE HACKERS - NORTHERN CALIFORNIA: The Seventies")
;; (find-hackerspage (+ 17 151) "8. Revolt in 2100")
;; (find-hackerspage (+ 17 179) "9. Every Man a God")
;; (find-hackerspage (+ 17 201) "10. The Homebrew Computer Club")
;; (find-hackerspage (+ 17 227) "11. Tiny BASIC")
;; (find-hackerspage (+ 17 249) "12. Woz")
;; (find-hackerspage (+ 17 275) "13. Secrets")
;; (find-hackerspage (+ 17 287) "Part Three. GAME HACKERS - THE SIERRAS: The Eighties")
;; (find-hackerspage (+ 17 289) "14. The Wizard and the Princess")
;; (find-hackerspage (+ 17 313) "15. The Brotherhood")
;; (find-hackerspage (+ 17 325) "16. The Third Generation")
;; (find-hackerspage (+ 17 345) "17. Summer Camp")
;; (find-hackerspage (+ 17 365) "18. Frogger")
;; (find-hackerspage (+ 17 389) "19. Applefest")
;; (find-hackerspage (+ 17 413) "20. Wizard vs. Wizards")
;; (find-hackerspage (+ 17 435) "Part Four. THE LAST OF THE TRUE HACKERS - Cambridge 1983")
;; (find-hackerspage (+ 17 437) "The Last of the True Hackers")
;; (find-hackerspage (+ 17 455) "Afterword: Ten Years After")
;; (find-hackerspage (+ 17 463) "Afterword: 2010")
;; (find-hackerspage (+ 17 479) "Notes")
;; (find-hackerspage (+ 17 485) "Acknowledgments")
;; (find-hackerspage (+ 17 489) "Index")
;; (find-hackerstext "")

;; «stallman»  (to ".stallman")
;; Free Software, Free Society: Selected Essays of Richard M. Stallman
;; https://www.gnu.org/philosophy/fsfs/rms-essays.pdf
(code-pdf-page "rmsessays" "$S/https/www.gnu.org/philosophy/fsfs/rms-essays.pdf")
(code-pdf-text "rmsessays" "$S/https/www.gnu.org/philosophy/fsfs/rms-essays.pdf" 6)
;; (find-rmsessayspage)
;; (find-rmsessayspage        3  "Contents")
;; (find-rmsessayspage (+ 6   1) "Editor's Note")
;; (find-rmsessayspage (+ 6   3) "A Note on Software")
;; (find-rmsessayspage (+ 6   7) "Topic Guide")
;; (find-rmsessayspage (+ 6  11) "Introduction")
;; (find-rmsessayspage (+ 6  15) "Section One")
;; (find-rmsessayspage (+ 6  17) "1 The GNU Project")
;; (find-rmsessayspage (+ 6  33) "2 The GNU Manifesto")
;; (find-rmsessayspage (+ 6  43) "3 Free Software Definition")
;; (find-rmsessayspage (+ 6  47) "4 Why Software Should Not Have Owners")
;; (find-rmsessayspage (+ 6  53) "5 What's in a Name?")
;; (find-rmsessayspage (+ 6  57) "6 Why "Free Software" is Better than "Open Source"")
;; (find-rmsessayspage (+ 6  63) "7 Releasing Free Software if You Work at a University")
;; (find-rmsessayspage (+ 6  65) "8 Selling Free Software")
;; (find-rmsessayspage (+ 6  69) "9 Free Software Needs Free Documentation")
;; (find-rmsessayspage (+ 6  71) "10 Free Software Song")
;; (find-rmsessayspage (+ 6  73) "Section Two")
;; (find-rmsessayspage (+ 6  75) "11 The Right to Read")
;; (find-rmsessayspage (+ 6  79) "12 Misinterpreting Copyright--A Series of Errors")
;; (find-rmsessayspage (+ 6  89) "13 Science Must `Push' Copyright Aside")
;; (find-rmsessayspage (+ 6  91) "14 What is Copyleft?")
;; (find-rmsessayspage (+ 6  93) "15 Copyleft: Pragmatic Idealism")
;; (find-rmsessayspage (+ 6  97) "16 The Danger of Software Patents")
;; (find-rmsessayspage (+ 6 115) "Section Three")
;; (find-rmsessayspage (+ 6 117) "17 Can You Trust Your Computer?")
;; (find-rmsessayspage (+ 6 121) "18 Why Software Should Be Free")
;; (find-rmsessayspage (+ 6 128)   "Japanese oceanographers")
;; (find-rmsessaystext (+ 6 128)   "Japanese oceanographers")
;; (find-rmsessayspage (+ 6 135) "19 Copyright and Globalization in the Age of Computer Networks")
;; (find-rmsessayspage (+ 6 157) "20 Free Software: Freedom and Cooperation")
;; (find-rmsessayspage (+ 6 191) "21 Words to Avoid")
;; (find-rmsessayspage (+ 6 197) "Section Four")
;; (find-rmsessayspage (+ 6 199) "GNU General Public License")
;; (find-rmsessayspage (+ 6 207) "GNU Lesser General Public License")
;; (find-rmsessayspage (+ 6 217) "GNU Free Documentation License")
;; (find-rmsessaystext)




;; «kelty»  (to ".kelty")
;; (find-books "__comp/__comp.el" "kelty")
;; EMACS, grep, and UNIX: authorship, invention and translation in software
;; Christopher Kelty, Rice University - March 20, 2006
(code-pdf-page "contextkelty" "~/books/__comp/ConText-Kelty.pdf")
(code-pdf-text "contextkelty" "~/books/__comp/ConText-Kelty.pdf" 1)
;; (find-contextkeltypage)
;; (find-contextkeltypage        1  "Contents")
;; (find-contextkeltypage (+ 1 189) "Index")
;; (find-contextkeltypage (+ 1 10) "was an expression of the way Stallman expected" "others to behave")
;; (find-contextkeltytext (+ 1 10) "was an expression of the way Stallman expected" "others to behave")
;; (find-contextkeltypage (+ 1 14) "emerged from a communal sharing")
;; (find-contextkeltytext (+ 1 14) "emerged from a communal sharing")
;; (find-contextkeltypage (+ 1 25) "If TECO is a programming language")
;; (find-contextkeltytext (+ 1 25) "If TECO is a programming language")
;; (find-contextkeltypage (+ 1 28) "buying software was a less risky option")
;; (find-contextkeltytext (+ 1 28) "buying software was a less risky option")
;; (find-contextkeltypage (+ 1 32) "Part II" "Grep")
;; (find-contextkeltytext (+ 1 32) "Part II" "Grep")
;; (find-contextkeltypage (+ 1 39) "Steven C. Kleene")
;; (find-contextkeltytext (+ 1 39) "Steven C. Kleene")
;; (find-contextkeltypage (+ 1 46) "fixity of printed texts")
;; (find-contextkeltytext (+ 1 46) "fixity of printed texts")
;; (find-contextkeltypage (+ 1 46) "memorized compositions and as spoken")
;; (find-contextkeltytext (+ 1 46) "memorized compositions and as spoken")
;; (find-contextkeltypage (+ 1 48) "transformed")
;; (find-contextkeltytext (+ 1 48) "transformed")
;; (find-contextkeltytext "")




;; (find-angg ".emacs.papers" "lamportlatex")
;; (find-angg ".emacs.papers" "kopkadaly")

;; http://gigapedia.com/items/2926/digital-typography-using-latex
;; Syropoulos/Tsolomitis/Sofroniou: "Digital Typography Using LaTeX"
(code-xpdf      "syropoulos" "~/books/__comp/syropoulos__digital_typography_using_latex.pdf")
(code-pdftotext "syropoulos" "~/books/__comp/syropoulos__digital_typography_using_latex.pdf" 16)
;; (ee-page-parameters "syropoulos" 16)
;; (find-syropoulospage         7  "Contents")
;; (find-syropoulospage (+ 16 475) "Index")
;; (find-syropoulostext "\\newenvironment{fminipage}")
;; (find-syropoulostext "")



;; «agda»  (to ".agda")
;; (find-books "__comp/__comp.el" "agda")
;; (find-angg ".emacs.papers" "agda")
;; (find-es "agda" "agda-user-manual")
(code-pdf-page "agdausermanual" "~/usrc/agda/doc/user-manual.pdf")
(code-pdf-text "agdausermanual" "~/usrc/agda/doc/user-manual.pdf")
;; (find-agdausermanualpage)
;; (find-agdausermanualtext)
;; (find-agdausermanualpage        3  "CONTENTS")
;; (find-agdausermanualtext        3  "CONTENTS")
;; (find-agdausermanualpage (+ 4   3) "1 Overview")
;; (find-agdausermanualpage (+ 4   5) "2 Getting Started")
;; (find-agdausermanualpage (+ 4   5) "2.1 What is Agda?")
;; (find-agdausermanualpage (+ 4   7) "2.2 Prerequisites")
;; (find-agdausermanualpage (+ 4   7) "2.3 Installation")
;; (find-agdausermanualpage (+ 4  12) "2.4 `Hello world' in Agda")
;; (find-agdausermanualpage (+ 4  12) "2.5 Quick Guide to Editing, Type Checking and Compiling Agda Code")
;; (find-agdausermanualpage (+ 4  14) "2.6 A List of Tutorials")
;; (find-agdausermanualpage (+ 4  17) "3 Language Reference")
;; (find-agdausermanualpage (+ 4  17) "3.1 Abstract definitions")
;; (find-agdausermanualpage (+ 4  20) "3.2 Built-ins")
;; (find-agdausermanualpage (+ 4  32) "3.3 Coinduction")
;; (find-agdausermanualpage (+ 4  34) "3.4 Copatterns")
;; (find-agdausermanualpage (+ 4  37) "3.5 Core language")
;; (find-agdausermanualpage (+ 4  41) "3.6 Cubical")
;; (find-agdausermanualpage (+ 4  54) "3.7 Cumulativity")
;; (find-agdausermanualpage (+ 4  55) "3.8 Data Types")
;; (find-agdausermanualpage (+ 4  58) "3.9 Flat Modality")
;; (find-agdausermanualpage (+ 4  59) "3.10 Foreign Function Interface")
;; (find-agdausermanualpage (+ 4  64) "3.11 Function Definitions")
;; (find-agdausermanualpage (+ 4  68) "3.12 Function Types")
;; (find-agdausermanualpage (+ 4  69) "3.13 Generalization of Declared Variables")
;; (find-agdausermanualpage (+ 4  73) "3.14 Implicit Arguments")
;; (find-agdausermanualpage (+ 4  76) "3.15 Instance Arguments")
;; (find-agdausermanualpage (+ 4  82) "3.16 Irrelevance")
;; (find-agdausermanualpage (+ 4  87) "3.17 Lambda Abstraction")
;; (find-agdausermanualpage (+ 4  88) "3.18 Local Definitions: let and where")
;; (find-agdausermanualpage (+ 4  93) "3.19 Lexical Structure")
;; (find-agdausermanualpage (+ 4  96) "3.20 Literal Overloading")
;; (find-agdausermanualpage (+ 4  98) "3.21 Mixfix Operators")
;; (find-agdausermanualpage (+ 4 101) "3.22 Module System")
;; (find-agdausermanualpage (+ 4 106) "3.23 Mutual Recursion")
;; (find-agdausermanualpage (+ 4 107) "3.24 Pattern Synonyms")
;; (find-agdausermanualpage (+ 4 109) "3.25 Positivity Checking")
;; (find-agdausermanualpage (+ 4 111) "3.26 Postulates")
;; (find-agdausermanualpage (+ 4 112) "3.27 Pragmas")
;; (find-agdausermanualpage (+ 4 115) "3.28 Prop")
;; (find-agdausermanualpage (+ 4 117) "3.29 Record Types")
;; (find-agdausermanualpage (+ 4 124) "3.30 Reflection")
;; (find-agdausermanualpage (+ 4 134) "3.31 Rewriting")
;; (find-agdausermanualpage (+ 4 137) "3.32 Run-time Irrelevance")
;; (find-agdausermanualpage (+ 4 139) "3.33 Safe Agda")
;; (find-agdausermanualpage (+ 4 140) "3.34 Sized Types")
;; (find-agdausermanualpage (+ 4 143) "3.35 Sort System")
;; (find-agdausermanualpage (+ 4 148) "3.36 Syntactic Sugar")
;; (find-agdausermanualpage (+ 4 153) "3.37 Syntax Declarations")
;; (find-agdausermanualpage (+ 4 153) "3.38 Telescopes")
;; (find-agdausermanualpage (+ 4 154) "3.39 Termination Checking")
;; (find-agdausermanualpage (+ 4 156) "3.40 Universe Levels")
;; (find-agdausermanualpage (+ 4 158) "3.41 With-Abstraction")
;; (find-agdausermanualpage (+ 4 170) "3.42 Without K")
;; (find-agdausermanualpage (+ 4 173) "4 Tools")
;; (find-agdausermanualpage (+ 4 173) "4.1 Automatic Proof Search (Auto)")
;; (find-agdausermanualpage (+ 4 176) "4.2 Command-line options")
;; (find-agdausermanualpage (+ 4 186) "4.3 Compilers")
;; (find-agdausermanualpage (+ 4 189) "4.4 Emacs Mode")
;; (find-agdausermanualpage (+ 4 195) "4.5 Literate Programming")
;; (find-agdausermanualpage (+ 4 197) "4.6 Generating HTML")
;; (find-agdausermanualpage (+ 4 197) "4.7 Generating LaTeX")
;; (find-agdausermanualpage (+ 4 214) "4.8 Interface files")
;; (find-agdausermanualpage (+ 4 215) "4.9 Library Management")
;; (find-agdausermanualpage (+ 4 217) "4.10 Performance debugging")
;; (find-agdausermanualpage (+ 4 218) "4.11 Search Definitions in Scope")
;; (find-agdausermanualpage (+ 4 221) "5 Contribute")
;; (find-agdausermanualpage (+ 4 221) "5.1 Documentation")
;; (find-agdausermanualpage (+ 4 225) "6 The Agda Team and License")
;; (find-agdausermanualpage (+ 4 227) "7 Indices and tables")
;; (find-agdausermanualpage (+ 4 229) "Bibliography")
;; (find-agdausermanualpage (+ 4 231) "Index")


;; «agda-dtp»  (to ".agda-dtp")
;; Norell/Chapman: "Dependently Typed Programming in Agda" (2008)
;; http://www.cse.chalmers.se/~ulfn/papers/afp08/tutorial.pdf
(code-pdf-page "agdadtp" "$S/http/www.cse.chalmers.se/~ulfn/papers/afp08/tutorial.pdf")
(code-pdf-text "agdadtp" "$S/http/www.cse.chalmers.se/~ulfn/papers/afp08/tutorial.pdf")
;; (find-agdadtppage)
;; (find-agdadtptext)
;; (find-agdadtppage 1 "1     Introduction")
;; (find-agdadtptext 1 "1     Introduction")
;; (find-agdadtppage 1 "2     Agda Basics")
;; (find-agdadtptext 1 "2     Agda Basics")
;; (find-agdadtppage 21 "3     Programming Techniques")
;; (find-agdadtptext 21 "3     Programming Techniques")
;; (find-agdadtppage 38 "4.1     Relating Agda types to Haskell types")
;; (find-agdadtptext 38 "4.1     Relating Agda types to Haskell types")


;; «agda-verified»  (to ".agda-verified")
;; (find-books "__comp/__comp.el" "agda-verified")
;; https://dl.acm.org/doi/book/10.1145/2841316
;; https://dl.acm.org/doi/pdf/10.1145/2841316
(code-pdf-page "agdaverified" "~/books/__comp/stump__verified_functional_programming_in_agda.pdf")
(code-pdf-text "agdaverified" "~/books/__comp/stump__verified_functional_programming_in_agda.pdf" 25)
;; (find-agdaverifiedpage)
;; (find-agdaverifiedpage        10  "Contents")
;; (find-agdaverifiedtext        10  "Contents")
;; (find-agdaverifiedpage (+ 25   1) "1 Functional Programming with the Booleans")
;; (find-agdaverifiedpage (+ 25   1) "1.1 Declaring the Datatype of Booleans")
;; (find-agdaverifiedpage (+ 25   4) "1.2 First Steps Interacting with Agda")
;; (find-agdaverifiedpage (+ 25   4) "1.3 Syntax Declarations")
;; (find-agdaverifiedpage (+ 25   6) "1.4 Defining Boolean Operations by Pattern Matching: Negation")
;; (find-agdaverifiedpage (+ 25   9) "1.5 Defining Boolean Operations by Pattern Matching: And, Or")
;; (find-agdaverifiedpage (+ 25  11) "1.6 The if-then-else Operation")
;; (find-agdaverifiedpage (+ 25  14) "1.7 Conclusion")
;; (find-agdaverifiedpage (+ 25  14) "Exercises")
;; (find-agdaverifiedpage (+ 25  17) "2 Introduction to Constructive Proof")
;; (find-agdaverifiedpage (+ 25  17) "2.1 A First Theorem about the Booleans")
;; (find-agdaverifiedpage (+ 25  20) "2.2 Universal Theorems")
;; (find-agdaverifiedpage (+ 25  25) "2.3 Another Example, and More On Implicit Arguments")
;; (find-agdaverifiedpage (+ 25  28) "2.4 Theorems with Hypotheses")
;; (find-agdaverifiedpage (+ 25  35) "2.5 Going Deeper: Curry-Howard and Constructivity")
;; (find-agdaverifiedpage (+ 25  38) "2.6 Further Examples")
;; (find-agdaverifiedpage (+ 25  40) "2.7 Conclusion")
;; (find-agdaverifiedpage (+ 25  41) "Exercises")
;; (find-agdaverifiedpage (+ 25  43) "3 Natural Numbers")
;; (find-agdaverifiedpage (+ 25  44) "3.1 Peano Natural Numbers")
;; (find-agdaverifiedpage (+ 25  45) "3.2 Addition")
;; (find-agdaverifiedpage (+ 25  50)   "(x : N)  x + 0  x")
;; (find-agdaverifiedtext (+ 25  50)   "(x : N)  x + 0  x")
;; (find-agdaverifiedpage (+ 25  57) "3.3 Multiplication")
;; (find-agdaverifiedpage (+ 25  63) "3.4 Arithmetic Comparison")
;; (find-agdaverifiedpage (+ 25  69) "3.5 Even/Odd and Mutually Recursive Definitions")
;; (find-agdaverifiedpage (+ 25  70) "3.6 Conclusion")
;; (find-agdaverifiedpage (+ 25  70) "Exercises")
;; (find-agdaverifiedpage (+ 25  73) "4 Lists")
;; (find-agdaverifiedpage (+ 25  73) "4.1 The List Datatype and Type Parameters")
;; (find-agdaverifiedpage (+ 25  75) "4.2 Basic Operations on Lists")
;; (find-agdaverifiedpage (+ 25  83) "4.3 Reasoning about List Operations")
;; (find-agdaverifiedpage (+ 25  95) "4.4 Conclusion")
;; (find-agdaverifiedpage (+ 25  96) "Exercises")
;; (find-agdaverifiedpage (+ 25  99) "5 Internal Verification")
;; (find-agdaverifiedpage (+ 25 100) "5.1 Vectors")
;; (find-agdaverifiedpage (+ 25 107) "5.2 Binary Search Trees")
;; (find-agdaverifiedpage (+ 25 115) "5.3 Sigma Types")
;; (find-agdaverifiedtext (+ 25 115)   "Sigma Types\n5.3")
;; (find-agdaverifiedpage (+ 25 117)   "5.3.1 Why Sigma and Pi?")
;; (find-agdaverifiedtext (+ 25 117)   "5.3.1 Why Sigma and Pi?")
;; (find-agdaverifiedpage (+ 25 118) "5.4 Braun Trees")
;; (find-agdaverifiedpage (+ 25 127) "5.5 Discussion: Internal vs. External Verification")
;; (find-agdaverifiedpage (+ 25 129) "5.6 Conclusion")
;; (find-agdaverifiedpage (+ 25 129) "Exercises")
;; (find-agdaverifiedpage (+ 25 131) "6 Type-Level Computation")
;; (find-agdaverifiedpage (+ 25 131) "6.1 Integers")
;; (find-agdaverifiedpage (+ 25 136) "6.2 Formatted Printing")
;; (find-agdaverifiedpage (+ 25 141) "6.3 Proof by Reflection")
;; (find-agdaverifiedpage (+ 25 148) "6.4 Conclusion")
;; (find-agdaverifiedpage (+ 25 149) "Exercises")
;; (find-agdaverifiedpage (+ 25 151) "7 Generating Agda Parsers with gratr")
;; (find-agdaverifiedpage (+ 25 152) "7.1 A Primer on Grammars")
;; (find-agdaverifiedpage (+ 25 158) "7.2 Generating Parsers with gratr")
;; (find-agdaverifiedpage (+ 25 165) "7.3 Conclusion")
;; (find-agdaverifiedpage (+ 25 166) "Exercises")
;; (find-agdaverifiedpage (+ 25 169) "8 A Case Study: Huffman Encoding and Decoding")
;; (find-agdaverifiedpage (+ 25 170) "8.1 The Files")
;; (find-agdaverifiedpage (+ 25 171) "8.2 The Input Formats")
;; (find-agdaverifiedpage (+ 25 171) "8.3 Encoding Textual Input")
;; (find-agdaverifiedpage (+ 25 181) "8.4 Decoding Encoded Text")
;; (find-agdaverifiedpage (+ 25 184) "8.5 Conclusion")
;; (find-agdaverifiedpage (+ 25 185) "Exercises")
;; (find-agdaverifiedpage (+ 25 187) "9 Reasoning About Termination")
;; (find-agdaverifiedpage (+ 25 187) "9.1 Termination Proofs")
;; (find-agdaverifiedpage (+ 25 197) "9.2 Operational Semantics for SK Combinators")
;; (find-agdaverifiedpage (+ 25 213) "9.3 Conclusion")
;; (find-agdaverifiedpage (+ 25 214) "Exercises")
;; (find-agdaverifiedpage (+ 25 215) "10 Intuitionistic Logic and Kripke Semantics")
;; (find-agdaverifiedpage (+ 25 216) "10.1 Positive Propositional Intuitionistic Logic (PPIL)")
;; (find-agdaverifiedpage (+ 25 220) "10.2 Kripke Structures")
;; (find-agdaverifiedpage (+ 25 224) "10.3 Kripke Semantics for PPIL")
;; (find-agdaverifiedpage (+ 25 227) "10.4 Soundness of PPIL")
;; (find-agdaverifiedpage (+ 25 232) "10.5 Completeness")
;; (find-agdaverifiedpage (+ 25 245) "10.6 Conclusion")
;; (find-agdaverifiedpage (+ 25 246) "Exercises")
;; (find-agdaverifiedpage (+ 25 247) "Appendix A Quick Guide to Symbols")
;; (find-agdaverifiedpage (+ 25 249) "Appendix B Commonly Used Emacs Control Commands")
;; (find-agdaverifiedpage (+ 25 251) "Appendix C Some Extra Emacs Definitions")
;; (find-agdaverifiedpage (+ 25 253) "References")
;; (find-agdaverifiedpage (+ 25 257) "Index")
;; (find-agdaverifiedpage (+ 25 259) "Author's Biography")
;; (find-agdaverifiedtext "")





;; «awk»  (to ".awk")
;; (find-books "__comp/__comp.el" "awk")
(code-pdf-page "awkbook" "~/books/__comp/aho_kernighan_weinberger__the_awk_programming_language.pdf")
(code-pdf-text "awkbook" "~/books/__comp/aho_kernighan_weinberger__the_awk_programming_language.pdf" 12)
;; (find-awkbookpage         9  "Contents")
;; (find-awkbooktext         9  "Contents")
;; (find-awkbookpage (+ 12 147) "6.6    Recursive-Descent Parsing")
;; (find-awkbooktext (+ 12 147) "6.6    Recursive-Descent Parsing")
;; (find-awkbookpage (+ 12 205) "INDEX")
;; (find-awkbooktext (+ 12 205) "INDEX")
;; (find-awkbooktext "")




;; «clojure»  (to ".clojure")
;; (find-es "clojure" "simple-graphics")
(code-xpdf      "practclojure" "~/books/__comp/vanderhart_sierra__practical_clojure.pdf")
(code-pdftotext "practclojure" "~/books/__comp/vanderhart_sierra__practical_clojure.pdf")
;; (find-practclojurepage         6  "Contents at a Glance")
;; (find-practclojurepage         7  "Contents")
;; (find-practclojurepage (+ 18 199) "Index")
;; (find-practclojuretext "")
(code-xpdf      "progclojure" "~/books/__comp/halloway__programming_clojure.pdf")
(code-pdftotext "progclojure" "~/books/__comp/halloway__programming_clojure.pdf")
;; (find-progclojurepage   7 "Contents")
;; (find-progclojurepage 286 "Index")
;; (find-progclojuretext "")
(code-xpdf      "joyofclojure" "~/books/__comp/fogus_houser__the_joy_of_clojure.pdf")
(code-pdftotext "joyofclojure" "~/books/__comp/fogus_houser__the_joy_of_clojure.pdf")
;; (find-joyofclojurepage         8  "Brief Contents")
;; (find-joyofclojurepage        10  "Contents")
;; (find-joyofclojurepage (+ 33  52) "(def frame (java.awt.Frame.))")
;; (find-joyofclojuretext            "(def frame (java.awt.Frame.))")
;; (find-joyofclojurepage (+ 33 118) "lazy")
;; (find-joyofclojurepage (+ 33 319) "Index")
;; (find-joyofclojuretext "")





;; «coq»  (to ".coq")
;; (find-LATEX "catsem.bib" "bib-Coq")
;; (find-es "coq" "bertot-casteran")
;; http://books.google.com/books?id=m5w5PRj5Nj4C
;; http://gigapedia.com/items/123523/interactive-theorem-proving-and-program-development
(code-djvu       "bertotcasteran" "~/books/__comp/bertot_casteran__interactive_theorem_proving_and_program_development.djvu")
(code-djvutotext "bertotcasteran" "~/books/__comp/bertot_casteran__interactive_theorem_proving_and_program_development.djvu")
;; (find-bertotcasteranpage        17  "Contents")
;; (find-bertotcasteranpage        15  "certification of Java applets")
;; (find-bertotcasteranpage (+ 26   1) "1. A Brief Overview")
;; (find-bertotcasteranpage (+ 26 460) "Index")
;; (find-bertotcasterantext)


;; «csound»  (to ".csound")
(code-djvu       "csoundbook" "~/books/__comp/boulanger__the_csound_book.djvu")
(code-djvutotext "csoundbook" "~/books/__comp/boulanger__the_csound_book.djvu")
;; (find-csoundbookpage      4  "Contents")
;; (find-csoundbookpage (+ 6 727) "Index")
;; (find-csoundbooktext "")

;; (find-csoundbookpage (+ 34 5) "1. Introduction to Sound Design in Csound")
;; (find-csoundbookpage (+ 34 65) "2. Understanding and Using Csound's GEN Routines")
;; (find-csoundbookpage (+ 33 99) "3. What Happens When You Run Csound")
;; (find-csoundbookpage (+ 32 123) "4. Optimizing Your Csound Instruments")
;; (find-csoundbookpage (+ 31 137) "5. Using Csound's Macro Language Extensions")
;; (find-csoundbookpage (+ 29 155) "6. Designing Acoustically Viable Instruments in Csound")
;; (find-csoundbookpage (+ 29 171) "7. Designing Legato Instruments in Csound")
;; (find-csoundbookpage (+ 28 187) "8. Contiguous-Group Wavetable Synthesis of the French Horn in Csound")
;; (find-csoundbookpage (+ 27 197) "9. FM Synthesis and Morphing in Csound: from Percussion to Brass")
;; (find-csoundbookpage (+ 27 207) "10. Modeling \"Classic\" Electronic Keyboards in Csound")
;; (find-csoundbookpage (+ 25 223) "11. A Survey of Classic Synthesis Techniques in Csound")
;; (find-csoundbookpage (+ 25 261) "12. FM Synthesis in Csound")
;; (find-csoundbookpage (+ 24 281) "13. Granular Synthesis in Csound")
;; (find-csoundbookpage (+ 24 293) "14. FOF and FOG Synthesis in Csound")
;; (find-csoundbookpage (+ 24 307) "15. Processing Samples with Csound's FOF Opcode")
;; (find-csoundbookpage (+ 23 321) "16. A Look at Random Numbers, Noise, and Chaos with")
;; (find-csoundbookpage (+ 23 339) "17. Constrained Random Event Generation and Retriggering in Csound")
;; (find-csoundbookpage (+ 23 339) "18. Using Global Csound Instruments for Meta-Parameter")
;; (find-csoundbookpage (+ 23 369) "19. Mathematical Modeling with Csound: From Waveguides to Chaos")
;; (find-csoundbookpage (+ 23 389) "20. An Introduction to Signal Processing with Csound")
;; (find-csoundbookpage (+ 20 437) "21. Understanding Csound's Spectral Data Types")
;; (find-csoundbookpage (+ 18 451) "22. Using Csound to Understand Delay Lines and Their Applications")
;; (find-csoundbookpage (+ 18 467) "23. An Introduction to Reverberation Design with Csound")
;; (find-csoundbookpage (+ 17 483) "24. Implementing the Gardner Reverbs in Csound")
;; (find-csoundbookpage (+ 17 493) "25. Csound-based Auditory Localization")
;; (find-csoundbookpage (+ 15 507) "26. Convolution in Csound: Traditional and Novel Applications")
;; (find-csoundbookpage (+ 15 521) "27. Working with Csound's ADSYN, LPREAD, and LPRESON Opcodes")
;; (find-csoundbookpage (+ 14 541) "28. Csound's Phase Vocoder and Extensions")
;; (find-csoundbookpage (+ 13 563) "29. Efficient Implementation of Analog Waveshaping in Csound")
;; (find-csoundbookpage (+ 12 575) "30. Modeling a Multieffects Processor in Csound")
;; (find-csoundbookpage (+ 10 599) "31. Extending Csound")
;; (find-csoundbookpage (+ 10 613) "32. Adding New Unit Generators to Csound")
;; (find-csoundbookpage (+  8 637) "1. List of the Csound Book Chapter Instruments")
;; (find-csoundbookpage (+  8 645) "2. Recommended Reading")
;; (find-csoundbookpage (+  8 647) "3. Recommended Listening")
;; (find-csoundbookpage (+  7 653) "4. Sound Intensity and Formants")
;; (find-csoundbookpage (+  7 657) "5. Pitch Conversion")
;; (find-csoundbookpage (+  6 663) "6. Csound's Error Messages")
;; (find-csoundbookpage (+  6 701) "7. Csound Quick Reference")



;; «css»  (to ".css")
(code-xpdf      "csscookbook" "~/books/__comp/schmitt__css_cookbook_3rd_ed.pdf")
(code-pdftotext "csscookbook" "~/books/__comp/schmitt__css_cookbook_3rd_ed.pdf" 26)
;; (ee-page-parameters "csscookbook" 26)
;; (find-csscookbookpage         9  "Contents")
;; (find-csscookbookpage (+ 26   1) "1.   Using HTML Basics")
;; (find-csscookbookpage (+ 26  33) "2.   CSS Basics")
;; (find-csscookbookpage (+ 26  35) "2.1  Applying CSS Rules to a Web Page")
;; (find-csscookbookpage (+ 26  38) "2.2  Using Basic Selectors to Apply Styles")
;; (find-csscookbookpage (+ 26  47) "2.3  Applying Child Selectors")
;; (find-csscookbookpage (+ 26  49) "2.4  Applying Adjacent Selectors")
;; (find-csscookbookpage (+ 26  51) "2.5  Applying Attribute Selectors")
;; (find-csscookbookpage (+ 26  53) "2.6  Using Pseudo-Classes")
;; (find-csscookbookpage (+ 26  54) "2.7  Using Pseudo-Elements")
;; (find-csscookbookpage (+ 26  56) "2.8  Determining When to Use Class and ID Selectors")
;; (find-csscookbookpage (+ 26  61) "2.9  Understanding CSS Properties")
;; (find-csscookbookpage (+ 26  62) "2.10 Understanding the Box Model")
;; (find-csscookbookpage (+ 26  70) "2.11 Associating Styles to a Web Page")
;; (find-csscookbookpage (+ 26  73) "2.12 Understanding the Origin")
;; (find-csscookbookpage (+ 26  73) "2.13 Understanding the Sort Order Within CSS")
;; (find-csscookbookpage (+ 26  76) "2.14 Using !important to Override Certain CSS Rules")
;; (find-csscookbookpage (+ 26  77) "2.15 Clarifying Specificity")
;; (find-csscookbookpage (+ 26  79) "2.16 Setting Up Different Types of Stylesheets")
;; (find-csscookbookpage (+ 26  83) "2.17 Adding Comments Within Stylesheets")
;; (find-csscookbookpage (+ 26  84) "2.18 Organizing the Contents of a Stylesheet")
;; (find-csscookbookpage (+ 26  86) "2.19 Working with Shorthand Properties")
;; (find-csscookbookpage (+ 26  88) "2.20 Setting Up an Alternate Stylesheet")
;; (find-csscookbookpage (+ 26  89) "2.21 Using Floats")
;; (find-csscookbookpage (+ 26  92) "2.22 Using Self-Clearing Floated Elements")
;; (find-csscookbookpage (+ 26  95) "2.23 Using Absolute Positioning")
;; (find-csscookbookpage (+ 26  98) "2.24 Using Relative Positioning")
;; (find-csscookbookpage (+ 26  99) "2.25 Using Shackling Positioning")
;; (find-csscookbookpage (+ 26 101) "2.26 Stacking Elements with z-index")
;; (find-csscookbookpage (+ 26 102) "2.27 Validating CSS Rules")
;; (find-csscookbookpage (+ 26 105) "3.   Web Typography")
;; (find-csscookbookpage (+ 26 106) "3.1  Specifying Fonts")
;; (find-csscookbookpage (+ 26 109) "3.2  Using Web-Safe Fonts")
;; (find-csscookbookpage (+ 26 112) "3.3  Setting an Ampersand Flourish")
;; (find-csscookbookpage (+ 26 114) "3.4  Embedding Font Files")
;; (find-csscookbookpage (+ 26 118) "3.5  Forcing a Break on Really Long Words")
;; (find-csscookbookpage (+ 26 119) "3.6  Specifying Font Measurements and Sizes")
;; (find-csscookbookpage (+ 26 121) "3.7  Gaining More Cross-Browser Consistency with Font Sizes")
;; (find-csscookbookpage (+ 26 125) "3.8  Setting Hyphens, Em Dashes, and En Dashes")
;; (find-csscookbookpage (+ 26 126) "3.9  Centering Text")
;; (find-csscookbookpage (+ 26 126) "3.10 Setting Text to Be Justified")
;; (find-csscookbookpage (+ 26 128) "3.11 Indicating an Overflow of Text with an Ellipsis")
;; (find-csscookbookpage (+ 26 129) "3.12 Removing Space Between Headings and Paragraphs")
;; (find-csscookbookpage (+ 26 130) "3.13 Setting a Simple Initial Cap")
;; (find-csscookbookpage (+ 26 131) "3.14 Setting a Larger, Centered Initial Cap")
;; (find-csscookbookpage (+ 26 133) "3.15 Setting an Initial Cap with Decoration (Imagery)")
;; (find-csscookbookpage (+ 26 135) "3.16 Creating a Heading with Stylized Text")
;; (find-csscookbookpage (+ 26 137) "3.17 Creating a Heading with Stylized Text and Borders")
;; (find-csscookbookpage (+ 26 139) "3.18 Stylizing a Heading with Text and an Image")
;; (find-csscookbookpage (+ 26 141) "3.19 Creating a Pull Quote with HTML Text")
;; (find-csscookbookpage (+ 26 143) "3.20 Placing a Pull Quote to the Side of a Column")
;; (find-csscookbookpage (+ 26 145) "3.21 Creating a Pull Quote with Borders")
;; (find-csscookbookpage (+ 26 146) "3.22 Creating a Pull Quote with Images")
;; (find-csscookbookpage (+ 26 149) "3.23 Setting the Indent in the First Line of a Paragraph")
;; (find-csscookbookpage (+ 26 150) "3.24 Setting the Indent of Entire Paragraphs")
;; (find-csscookbookpage (+ 26 153) "3.25 Creating a Hanging Indent")
;; (find-csscookbookpage (+ 26 156) "3.26 Styling the First Line of a Paragraph")
;; (find-csscookbookpage (+ 26 158) "3.27 Styling the First Line of a Paragraph with an Image")
;; (find-csscookbookpage (+ 26 159) "3.28 Creating a Highlighted Text Effect")
;; (find-csscookbookpage (+ 26 160) "3.29 Changing the Text Selection Color")
;; (find-csscookbookpage (+ 26 161) "3.30 Changing Line Spacing")
;; (find-csscookbookpage (+ 26 163) "3.31 Adding a Graphic Treatment to HTML Text")
;; (find-csscookbookpage (+ 26 165) "3.32 Placing a Shadow Behind Text")
;; (find-csscookbookpage (+ 26 168) "3.33 Adjusting the Space Between Letters and Words")
;; (find-csscookbookpage (+ 26 171) "3.34 Applying Baseline Rhythm on Web Typography")
;; (find-csscookbookpage (+ 26 173) "3.35 Styling Superscripts and Subscripts Without Messing the Text Baseline")
;; (find-csscookbookpage (+ 26 175) "3.36 Setting Up Multiple Columns of Text")
;; (find-csscookbookpage (+ 26 179) "4.   Images")
;; (find-csscookbookpage (+ 26 179) "4.1  Transforming Color Images to Black and White in IE with CSS")
;; (find-csscookbookpage (+ 26 180) "4.2  Setting a Border Around an Image")
;; (find-csscookbookpage (+ 26 182) "4.3  Setting a Rounded Border Around an Image")
;; (find-csscookbookpage (+ 26 184) "4.4  Removing Borders Set on Images by Default in Some Browsers")
;; (find-csscookbookpage (+ 26 186) "4.5  Setting a Background Image")
;; (find-csscookbookpage (+ 26 187) "4.6  Creating a Line of Background Images")
;; (find-csscookbookpage (+ 26 188) "4.7  Positioning a Background Image")
;; (find-csscookbookpage (+ 26 191) "4.8  Using Multiple Background Images on One HTML Element")
;; (find-csscookbookpage (+ 26 194) "4.9  Setting Images on a Border")
;; (find-csscookbookpage (+ 26 197) "4.10 Creating a Stationary Background Image")
;; (find-csscookbookpage (+ 26 199) "4.11 Stretching Images As the Browser Resizes")
;; (find-csscookbookpage (+ 26 202) "4.12 Stretching an Image Across the Entire Browser Window")
;; (find-csscookbookpage (+ 26 203) "4.13 Making Images Scalable")
;; (find-csscookbookpage (+ 26 205) "4.14 Setting How a Browser Renders an Image")
;; (find-csscookbookpage (+ 26 206) "4.15 Rotating Images with CSS")
;; (find-csscookbookpage (+ 26 208) "4.16 Setting Gradients with CSS")
;; (find-csscookbookpage (+ 26 211) "4.17 Creating Transparent PNG Images for IE6 and Later")
;; (find-csscookbookpage (+ 26 212) "4.18 Using Transparent PNG Images with JavaScript")
;; (find-csscookbookpage (+ 26 215) "4.19 Overlaying HTML Text on an Image")
;; (find-csscookbookpage (+ 26 217) "4.20 Replacing HTML Text with an Image")
;; (find-csscookbookpage (+ 26 220) "4.21 Building a Panoramic Image Presentation")
;; (find-csscookbookpage (+ 26 222) "4.22 Combining Different Image Formats")
;; (find-csscookbookpage (+ 26 227) "4.23 Rounding Corners with Fixed-Width Columns")
;; (find-csscookbookpage (+ 26 230) "4.24 Rounding Corners (Sliding Doors Technique)")
;; (find-csscookbookpage (+ 26 235) "4.25 Rounding Corners (Mountaintop Technique)")
;; (find-csscookbookpage (+ 26 239) "4.26 Rounding Corners with JavaScript")
;; (find-csscookbookpage (+ 26 242) "4.27 Setting a Shadow on an Element with CSS")
;; (find-csscookbookpage (+ 26 244) "4.28 Placing a Drop Shadow Behind an Image")
;; (find-csscookbookpage (+ 26 247) "4.29 Placing a Smooth Drop Shadow Behind an Image")
;; (find-csscookbookpage (+ 26 251) "4.30 Making Word Balloons")
;; (find-csscookbookpage (+ 26 254) "4.31 Hindering People from Stealing Your Images")
;; (find-csscookbookpage (+ 26 256) "4.32 Inserting Reflections on Images Automatically")
;; (find-csscookbookpage (+ 26 258) "4.33 Using Image Sprites")
;; (find-csscookbookpage (+ 26 260) "4.34 Clipping Background Images")
;; (find-csscookbookpage (+ 26 262) "4.35 Applying Masks to Images and Borders")
;; (find-csscookbookpage (+ 26 845) "Index")
;; (find-csscookbooktext "")


;; «epigram-ppdt»  (to ".epigram-ppdt")
;; https://cs.ru.nl/~freek/courses/tt-2010/tvftl/epigram-notes.pdf
(code-pdf-page "epigramppdt" "$S/https/cs.ru.nl/~freek/courses/tt-2010/tvftl/epigram-notes.pdf")
(code-pdf-text "epigramppdt" "$S/https/cs.ru.nl/~freek/courses/tt-2010/tvftl/epigram-notes.pdf")
;; (find-epigramppdtpage)
;; (find-epigramppdttext)




;; «git»  (to ".git")
;; (find-es "git" "books")
;; (find-books "__comp/__comp.el" "git")
;; (find-angg ".emacs" "git-internals")
;; (find-es "cvs" "git")
;; (find-es "git")
;; http://peepcode.com/products/git-internals-pdf
;; (code-xpdf      "gitinternals" "~/books/__comp/chacon__git_internals.pdf")
;; (code-pdftotext "gitinternals" "~/books/__comp/chacon__git_internals.pdf" 0)

;; «git-internals» (to ".git-internals")
;; (find-books "__comp/__comp.el" "git-internals")
;; (find-es "git" "git-internals")
;; https://github.com/pluralsight/git-internals-pdf/releases/download/v2.0/peepcode-git.pdf
;; (find-fline "$S/https/github.com/pluralsight/git-internals-pdf/releases/download/v2.0/")
(code-pdf-page "gitinternals" "$S/https/github.com/pluralsight/git-internals-pdf/releases/download/v2.0/peepcode-git.pdf")
(code-pdf-text "gitinternals" "$S/https/github.com/pluralsight/git-internals-pdf/releases/download/v2.0/peepcode-git.pdf")
(code-c-d "gitinternals" "~/usrc/git-internals-pdf-2.0/")
;; (find-gitinternalsfile "")
;; (find-gitinternalspage)
;; (find-gitinternalstext)
;; (find-gitinternalspage   3 "Contents")
;; (find-gitinternalstext   3 "Contents")
;; (find-gitinternalspage  15 "The Blob")
;; (find-gitinternalstext  15 "The Blob")
;; (find-gitinternalspage  16 "blob : a906cb")
;; (find-gitinternalstext  16 "blob : a906cb")
;; (find-gitinternalstext  16 "blob : a906cb" "\f\f")
;; (find-gitinternalspage  17 "The Tree")
;; (find-gitinternalstext  17 "The Tree")
;; (find-gitinternalspage  22 "The Git Data Model")
;; (find-gitinternalstext  22 "The Git Data Model")
;; (find-gitinternalspage  23 "The Model")
;; (find-gitinternalstext  23 "The Model")
;; (find-gitinternalspage  28 "Branching and Merging")
;; (find-gitinternalstext  28 "Branching and Merging")
;; (find-gitinternalspage  30   "called master")
;; (find-gitinternalstext  30   "called master")
;; (find-gitinternalspage  32 "Remotes")
;; (find-gitinternalspage  34 "Rebasing")
;; (find-gitinternalspage  36   "master")
;; (find-gitinternalstext  36   "master")
;; (find-gitinternalspage  39   "cheap branches")
;; (find-gitinternalstext  39   "cheap branches")
;; (find-gitinternalspage  41 "The Treeish")
;; (find-gitinternalspage  42 "Ordinal spec")
;; (find-gitinternalspage  44 "The Git directory")
;; (find-gitinternalspage  48 "Working directory")
;; (find-gitinternalspage  49 "Non-SCM Uses of Git")
;; (find-gitinternalstext  49 "Non-SCM Uses of Git")
;; (find-gitinternalspage  54 "Setting Up Your Profile")
;; (find-gitinternalspage  57 "git status")
;; (find-gitinternalspage  68 "gitk")
;; (find-gitinternalspage  75 "Branching")
;; (find-gitinternalspage  77 "Simple Merging")
;; (find-gitinternalspage  80 "Rebasing")
;; (find-gitinternalspage  86 "Stashing")
;; (find-gitinternalspage  89 "Tagging")
;; (find-gitinternalspage  91 "Exporting Git")
;; (find-gitinternalspage 111 "Commands Overview")
;; (find-gitinternalstext "")

;; «git-progit» (to ".git-progit")
;; (find-books "__comp/__comp.el" "git-progit")
;; (find-angg ".emacs" "pro-git")
(code-pdf       "progit"  "~/books/__comp/chacon__pro_git.pdf")
(code-pdftotext "progit"  "~/books/__comp/chacon__pro_git.pdf" 24)
(code-pdf       "progit2" "~/books/__comp/chacon_straub__pro_git.pdf")
(code-pdftotext "progit2" "~/books/__comp/chacon_straub__pro_git.pdf" 1)
;; (find-progitpage)
;; (find-progitpage         7  "Contents at a Glance")
;; (find-progittext         7  "Contents at a Glance")
;; (find-progitpage         9  "Contents")
;; (find-progittext         9  "Contents")
;; (find-progitpage (+ 24   1) "1 Getting Started")
;; (find-progitpage (+ 24  12)   "Your Diff Tool")
;; (find-progittext (+ 24  12)   "Your Diff Tool")
;; (find-progitpage (+ 24  15) "2 Git Basics")
;; (find-progitpage (+ 24  35)   "Working with Remotes")
;; (find-progittext (+ 24  35)   "Working with Remotes")
;; (find-progitpage (+ 24  36)   "Adding Remote Repositories")
;; (find-progittext (+ 24  36)   "Adding Remote Repositories")
;; (find-progitpage (+ 24  38)   "Tagging")
;; (find-progittext (+ 24  38)   "Tagging")
;; (find-progitpage (+ 24  47) "3 Git Branching")
;; (find-progittext (+ 24  47)   "Git Branching")
;; (find-progitpage (+ 24  53)   "Basic Branching\n")
;; (find-progittext (+ 24  53)   "Basic Branching\n")
;; (find-progitpage (+ 24  69)   "Tracking Branches")
;; (find-progittext (+ 24  69)   "Tracking Branches")
;; (find-progitpage (+ 24  79) "4 Git on the Server")
;; (find-progitpage (+ 24 107) "5 Distributed Git")
;; (find-progitpage (+ 24 143) "6 Git Tools")
;; (find-progitpage (+ 24 175) "7 Customizing Git")
;; (find-progitpage (+ 24 203) "8 Git and Other Systems")
;; (find-progitpage (+ 24 223) "9 Git Internals.")
;; (find-progitpage (+ 24 259) "Index")
;; (find-progittext "")

;; «git-progit2» (to ".git-progit2")
;; (find-books "__comp/__comp.el" "git-progit2")
;; https://git-scm.com/book/en/v2
;; https://github.com/progit/progit2
;; https://github.com/progit/progit2/releases
;; https://github.com/progit/progit2/releases/download/2.1.277/progit.pdf
;; (find-fline "$S/https/github.com/progit/progit2/releases/download/2.1.109/")
(code-pdf-page "progit2" "$S/https/github.com/progit/progit2/releases/download/2.1.277/progit.pdf")
(code-pdf-text "progit2" "$S/https/github.com/progit/progit2/releases/download/2.1.277/progit.pdf" 6)
;; (find-progit2page)
;; (find-progit2text)
;; (find-progit2page 3 "Table of Contents")
;; (find-progit2text 3 "Table of Contents")
;; (find-progit2page (+ 6   1) "Licence")
;; (find-progit2page (+ 6   2) "Preface by Scott Chacon")
;; (find-progit2page (+ 6   3) "Preface by Ben Straub")
;; (find-progit2page (+ 6   4) "Dedications.")
;; (find-progit2page (+ 6   5) "Contributors.")
;; (find-progit2page (+ 6   7) "Introduction")
;; (find-progit2page (+ 6   9) "Getting Started.")
;; (find-progit2page (+ 6   9)   "About Version Control.")
;; (find-progit2page (+ 6  13)   "A Short History of Git")
;; (find-progit2page (+ 6  13)   "What is Git?")
;; (find-progit2page (+ 6  17)   "The Command Line")
;; (find-progit2page (+ 6  17)   "Installing Git")
;; (find-progit2page (+ 6  20)   "First-Time Git Setup.")
;; (find-progit2page (+ 6  23)   "Getting Help.")
;; (find-progit2page (+ 6  24)   "Summary")
;; (find-progit2page (+ 6  25) "Git Basics.")
;; (find-progit2page (+ 6  25)   "Getting a Git Repository")
;; (find-progit2page (+ 6  27)   "Recording Changes to the Repository")
;; (find-progit2page (+ 6  39)   "Viewing the Commit History")
;; (find-progit2page (+ 6  46)   "Undoing Things.")
;; (find-progit2page (+ 6  50)   "Working with Remotes")
;; (find-progit2page (+ 6  56)   "Tagging")
;; (find-progit2page (+ 6  62)   "Git Aliases")
;; (find-progit2page (+ 6  63)   "Summary")
;; (find-progit2page (+ 6  64) "Git Branching.")
;; (find-progit2page (+ 6  64)   "Branches in a Nutshell")
;; (find-progit2page (+ 6  71)   "Basic Branching and Merging")
;; (find-progit2page (+ 6  74)     "Fast-forward")
;; (find-progit2text (+ 6  74)     "Fast-forward")
;; (find-progit2page (+ 6  80)   "Branch Management")
;; (find-progit2page (+ 6  83)   "Branching Workflows")
;; (find-progit2page (+ 6  87)   "Remote Branches")
;; (find-progit2page (+ 6  96)   "Rebasing")
;; (find-progit2page (+ 6 105)   "Summary")

;; (find-progit2page (+ 6 221) "Git Tools")
;; (find-progit2page (+ 6 221)   "Revision Selection")
;; (find-progit2page (+ 6 230)   "Interactive Staging.")
;; (find-progit2page (+ 6 234)   "Stashing and Cleaning")
;; (find-progit2page (+ 6 240)   "Signing Your Work.")
;; (find-progit2page (+ 6 244)   "Searching")
;; (find-progit2page (+ 6 248)   "Rewriting History.")
;; (find-progit2page (+ 6 256)   "Reset Demystified")
;; (find-progit2page (+ 6 276)   "Advanced Merging.")
;; (find-progit2page (+ 6 295)   "Rerere")
;; (find-progit2page (+ 6 301)   "Debugging with Git")
;; (find-progit2page (+ 6 304)   "Submodules.")
;; (find-progit2page (+ 6 326)   "Bundling.")
;; (find-progit2page (+ 6 330)   "Replace")
;; (find-progit2page (+ 6 338)   "Credential Storage")
;; (find-progit2page (+ 6 343)   "Summary")
;; (find-progit2page (+ 6 344) "Customizing Git.")
;; (find-progit2page (+ 6 344)   "Git Configuration")
;; (find-progit2page (+ 6 354)   "Git Attributes.")
;; (find-progit2page (+ 6 362)   "Git Hooks")
;; (find-progit2page (+ 6 365)   "An Example Git-Enforced Policy")
;; (find-progit2page (+ 6 375) "Summary")
;; (find-progit2page (+ 6 376)   "Git and Other Systems")
;; (find-progit2page (+ 6 376)   "Git as a Client")
;; (find-progit2page (+ 6 413)   "Migrating to Git")
;; (find-progit2page (+ 6 431)   "Summary")
;; (find-progit2page (+ 6 432) "Git Internals.")
;; (find-progit2page (+ 6 432)   "Plumbing and Porcelain.")
;; (find-progit2page (+ 6 433)   "Git Objects")
;; (find-progit2page (+ 6 443)   "Git References.")
;; (find-progit2page (+ 6 447)   "Packfiles")
;; (find-progit2page (+ 6 450)   "The Refspec")
;; (find-progit2page (+ 6 453)   "Transfer Protocols")
;; (find-progit2page (+ 6 458)   "Maintenance and Data Recovery")
;; (find-progit2page (+ 6 465)   "Environment Variables")
;; (find-progit2page (+ 6 471)   "Summary")

;; (find-progit2page (+ 6 498) "Appendix C: Git Commands")
;; (find-progit2page (+ 6 498)   "Setup and Config")
;; (find-progit2page (+ 6 500)   "Getting and Creating Projects")
;; (find-progit2page (+ 6 501)   "Basic Snapshotting.")
;; (find-progit2page (+ 6 503)   "Branching and Merging")
;; (find-progit2page (+ 6 505)   "Sharing and Updating Projects")
;; (find-progit2page (+ 6 507)   "Inspection and Comparison")
;; (find-progit2page (+ 6 508)   "Debugging")
;; (find-progit2page (+ 6 509)   "Patching")
;; (find-progit2page (+ 6 509)   "Email")
;; (find-progit2page (+ 6 511)   "External Systems")
;; (find-progit2page (+ 6 511)   "Administration")
;; (find-progit2page (+ 6 512)   "Plumbing Commands")
;; (find-progit2page (+ 6 513) "Index")

;; «git-fbu» (to ".git-fbu")
;; http://ftp.newartisans.com/pub/git.from.bottom.up.pdf
;; (find-fline "$S/http/ftp.newartisans.com/pub/")
(code-pdf-page "gitfbu" "$S/http/ftp.newartisans.com/pub/git.from.bottom.up.pdf")
(code-pdf-text "gitfbu" "$S/http/ftp.newartisans.com/pub/git.from.bottom.up.pdf")
;; (find-gitfbupage)
;; (find-gitfbutext)








;; (find-progit2page)
;; (find-progit2page        3  "Contents")
;; (find-progit2page (+ 4 421) "Contents")
;; (find-progit2text "")









;; «haskell»  (to ".haskell")
;; (find-books "__comp/__comp.el" "haskell")

;; «haskell-hutton»  (to ".haskell-hutton")
;; (find-books "__comp/__comp.el" "haskell-hutton")
;; (find-es "haskell" "hutton-book")
;; http://www.cs.nott.ac.uk/~pszgmh/
;; http://www.cs.nott.ac.uk/~pszgmh/pih.html
;; http://www.cs.nott.ac.uk/~pszgmh/Code.zip
(code-pdf-page "huttonbook" "~/books/__comp/hutton__programming_in_haskell.pdf")
(code-pdf-text "huttonbook" "~/books/__comp/hutton__programming_in_haskell.pdf" 1)
;; (find-huttonbookpage)
;; (find-huttonbookpage   6 "Contents")
;; (find-huttonbooktext   6 "Contents")
;; (find-huttonbookpage  27   "Num a => [a] -> a")
;; (find-huttonbooktext  27   "Num a => [a] -> a")
;; (find-huttonbookpage  32 "2.3      Standard prelude")
;; (find-huttonbooktext  32 "2.3      Standard prelude")
;; (find-huttonbookpage  44 "3.4     Tuple types")
;; (find-huttonbooktext  44 "3.4     Tuple types")
;; (find-huttonbookpage  57 "4.2      Conditional expressions")
;; (find-huttonbooktext  57 "4.2      Conditional expressions")
;; (find-huttonbookpage  49 "3.9     Basic classes")
;; (find-huttonbooktext  49 "3.9     Basic classes")
;; (find-huttonbookpage  58 "4.3     Guarded equations")
;; (find-huttonbooktext  58 "4.3     Guarded equations")
;; (find-huttonbookpage  67 "5" "List comprehensions")
;; (find-huttonbooktext  67 "5" "List comprehensions")
;; (find-huttonbookpage  72 "5.5    The Caesar cipher")
;; (find-huttonbooktext  72 "5.5    The Caesar cipher")
;; (find-huttonbookfile             "cipher.hs")
;; (find-huttonbookpage  96 "7" "Higher-order functions")
;; (find-huttonbooktext  96 "7" "Higher-order functions")
;; (find-huttonbookpage 106 "7.6     Binary string transmitter")
;; (find-huttonbooktext 106 "7.6     Binary string transmitter")
;; (find-huttonbookfile             "transmit.hs")
;; (find-huttonbookpage 110 "7.7    Voting algorithms")
;; (find-huttonbooktext 110 "7.7    Voting algorithms")
;; (find-huttonbookfile             "voting.hs")
;; (find-huttonbookpage 116 "8" "Declaring types and classes")
;; (find-huttonbooktext 116 "8" "Declaring types and classes")
;; (find-huttonbookpage 116 "8.1     Type declarations")
;; (find-huttonbooktext 116 "8.1     Type declarations")
;; (find-huttonbookpage 117 "8.2    Data declarations")
;; (find-huttonbooktext 117 "8.2    Data declarations")
;; (find-huttonbookpage 119         "fully evaluated")
;; (find-huttonbooktext 119         "fully evaluated")
;; (find-huttonbookpage 119 "8.3    Newtype declarations")
;; (find-huttonbooktext 119 "8.3    Newtype declarations")
;; (find-huttonbookpage 120 "8.4     Recursive types")
;; (find-huttonbooktext 120 "8.4     Recursive types")
;; (find-huttonbookpage 124 "8.5     Class and instance declarations")
;; (find-huttonbooktext 124 "8.5     Class and instance declarations")
;; (find-huttonbookpage 125         "Derived instances")
;; (find-huttonbooktext 125         "Derived instances")
;; (find-huttonbookpage 126 "8.6    Tautology checker")
;; (find-huttonbooktext 126 "8.6    Tautology checker")
;; (find-huttonbookfile             "tautology.hs")
;; (find-huttonbookpage 131 "8.7     Abstract machine")
;; (find-huttonbooktext 131 "8.7     Abstract machine")
;; (find-huttonbookfile              "machine.hs")
;; (find-huttonbookpage 136 "9" "The countdown problem")
;; (find-huttonbooktext 136 "9" "The countdown problem")
;; (find-huttonbookfile              "countdown.hs")
;; (find-huttonbookfile              "countdown2.hs")
;; (find-huttonbookpage 148 "10" "Interactive programming")
;; (find-huttonbooktext 148 "10" "Interactive programming")
;; (find-huttonbookpage 148 "10.1     The problem")
;; (find-huttonbooktext 148 "10.1     The problem")
;; (find-huttonbookpage 149 "10.2     The solution")
;; (find-huttonbooktext 149 "10.2     The solution")
;; (find-huttonbookpage 150 "10.3      Basic actions")
;; (find-huttonbooktext 150 "10.3      Basic actions")
;; (find-huttonbookpage 151 "10.4      Sequencing")
;; (find-huttonbooktext 151 "10.4      Sequencing")
;; (find-huttonbookpage 151           "do notation")
;; (find-huttonbooktext 151           "do notation")
;; (find-huttonbookpage 152 "10.5      Derived primitives")
;; (find-huttonbooktext 152 "10.5      Derived primitives")
;; (find-huttonbookpage 153 "10.6     Hangman")
;; (find-huttonbooktext 153 "10.6     Hangman")
;; (find-huttonbookfile              "hangman.hs")
;; (find-huttonbookpage 155 "10.7     Nim")
;; (find-huttonbooktext 155 "10.7     Nim")
;; (find-huttonbookfile              "nim.hs")
;; (find-huttonbookpage 159 "10.8     Life")
;; (find-huttonbooktext 159 "10.8     Life")
;; (find-huttonbookfile              "life.hs")
;; (find-huttonbookpage 163 "10.9     Chapter remarks")
;; (find-huttonbooktext 163 "10.9     Chapter remarks")
;; (find-huttonbookpage 164 "10.10       Exercises")
;; (find-huttonbooktext 164 "10.10       Exercises")
;; (find-huttonbookpage 166 "11" "Unbeatable tic-tac-toe")
;; (find-huttonbooktext 148 "11" "Unbeatable tic-tac-toe")
;; (find-huttonbookpage 166 "11.1     Introduction")
;; (find-huttonbooktext 166 "11.1     Introduction")
;; (find-huttonbookpage 167 "11.2      Basic declarations")
;; (find-huttonbooktext 167 "11.2      Basic declarations")
;; (find-huttonbookpage 168 "11.3      Grid utilities")
;; (find-huttonbooktext 168 "11.3      Grid utilities")
;; (find-huttonbookpage 169 "11.4     Displaying a grid")
;; (find-huttonbooktext 169 "11.4     Displaying a grid")
;; (find-huttonbookpage 171 "11.5     Making a move")
;; (find-huttonbooktext 171 "11.5     Making a move")
;; (find-huttonbookpage 172 "11.6     Reading a number")
;; (find-huttonbooktext 172 "11.6     Reading a number")
;; (find-huttonbookpage 172 "11.7     Human vs human")
;; (find-huttonbooktext 172 "11.7     Human vs human")
;; (find-huttonbookpage 173 "11.8      Game trees")
;; (find-huttonbooktext 173 "11.8      Game trees")
;; (find-huttonbookpage 175 "11.9      Pruning the tree")
;; (find-huttonbooktext 175 "11.9      Pruning the tree")
;; (find-huttonbookpage 176 "11.10      Minimax algorithm")
;; (find-huttonbooktext 176 "11.10      Minimax algorithm")
;; (find-huttonbookpage 176 "11.10      Minimax algorithm")
;; (find-huttonbooktext 176 "11.10      Minimax algorithm")
;; (find-huttonbookpage 178 "11.11      Human vs computer")
;; (find-huttonbooktext 178 "11.11      Human vs computer")
;; (find-huttonbookfile                 "tictactoe.hs")
;; (find-huttonbookpage 180 "11.12        Chapter remarks")
;; (find-huttonbooktext 180 "11.12        Chapter remarks")
;; (find-huttonbookpage 180 "11.13        Exercises")
;; (find-huttonbooktext 180 "11.13        Exercises")
;; (find-huttonbookpage 182 "12" "Monads and more")
;; (find-huttonbooktext 182 "12" "Monads and more")
;; (find-huttonbookpage 182 "12.1     Functors")
;; (find-huttonbooktext 182 "12.1     Functors")
;; (find-huttonbookpage 187 "12.2     Applicatives")
;; (find-huttonbooktext 187 "12.2     Applicatives")
;; (find-huttonbookpage 193 "12.3      Monads")
;; (find-huttonbooktext 193 "12.3      Monads")
;; (find-huttonbookpage 196           "m1 >>= \\x1 ->")
;; (find-huttonbooktext 196           "m1 >>= \\x1 ->")
;; (find-huttonbookpage 198           "The state monad")
;; (find-huttonbooktext 198           "The state monad")
;; (find-huttonbookpage 201           "Relabelling trees")
;; (find-huttonbooktext 201           "Relabelling trees")
;; (find-huttonbookfile               "relabel.hs")
;; (find-huttonbookpage 205 "12.4      Chapter remarks")
;; (find-huttonbooktext 205 "12.4      Chapter remarks")
;; (find-huttonbookpage 205 "12.5      Exercises")
;; (find-huttonbooktext 205 "12.5      Exercises")
;; (find-huttonbookpage 208 "13" "Monadic parsing")
;; (find-huttonbooktext 208 "13" "Monadic parsing")
;; (find-huttonbookfile          "Parsing.hs")
;; (find-huttonbooktext 148 "13.1" "What is a parser?")
;; (find-huttonbooktext 148 "13.2" "Parsers as functions")
;; (find-huttonbooktext 148 "13.3" "Basic definitions")
;; (find-huttonbooktext 148 "13.4" "Sequencing parsers")
;; (find-huttonbooktext 148 "13.5" "Making choices")
;; (find-huttonbooktext 148 "13.6" "Derived primitives")
;; (find-huttonbooktext 148 "13.7" "Handling spacing")
;; (find-huttonbookpage 218 "13.8     Arithmetic expressions")
;; (find-huttonbooktext 218 "13.8     Arithmetic expressions")
;; (find-huttonbookfile               "expression.hs")
;; (find-huttonbookpage 223 "13.9      Calculator")
;; (find-huttonbooktext 223 "13.9      Calculator")
;; (find-huttonbookfile               "calculator.hs")
;; (find-huttonbooktext 148 "13.10" "Chapter remarks")
;; (find-huttonbooktext 148 "13.11" "Exercises")
;; (find-huttonbookpage 340 "Index")
;; (find-huttonbooktext "")



;; http://gigapedia.com/items/28927/haskell--the-craft-of-functional-programming--2nd-edition-
(code-djvu "haskellcraft" "~/books/__comp/thompson__haskell_the_craft_of_functional_programming.djvu")
;; (find-haskellcraftpage         4  "Contents")
;; (find-haskellcraftpage (+ 17 472) "Index")

;; http://gigapedia.com/items/216374/real-world-haskell
;; (find-unpack-chm-links "~/books/__comp/o_sullivan_stewart_goerzen__real_world_haskell.chm" "~/usrc/rwhaskell/" "rwhaskell")
(code-c-d "rwhaskell" "~/usrc/rwhaskell/")
;; (find-rwhaskellfile "")
;; (find-rwhaskellw3m "Toc.html")



;; «javascript»  (to ".javascript")
;; (to "crockford")
;; (find-es "javascript" "crockford")

;; (find-fline "~/books/__comp/")
(code-xpdf     "crockford" "~/books/__comp/crockford__javascript_the_good_parts.pdf")
(code-pdf-text "crockford" "~/books/__comp/crockford__javascript_the_good_parts.pdf" 16)
;; (find-crockfordpage)
;; (find-crockfordpage 9 "Contents")
;; (find-crockfordtext 9 "Contents")
;; (find-crockfordtext)
;; (find-crockfordpage (+ 16 65) "Regular Expressions")
;; (find-crockfordtext (+ 16 65) "Regular Expressions")



;; http://gigapedia.com/items/115692/javascript--the-good-parts
;;   http://www.youtube.com/watch?v=hQVTIJBZook
;;   http://video.yahoo.com/watch/630959/2974197
;; (find-unpack-chm-links "~/books/__comp/crockford__javascript_the_good_parts.chm" "~/usrc/crockford/" "crockford")
(code-c-d "crockford" "~/usrc/crockford/final/")
;; (find-crockfordw3m "toc.html")
;; (find-crockfordw3m "a_simple_testing_ground.html" "1.3. A Simple Testing Ground")
;; (find-crockfordw3m "exceptions.html" "4.6. Exceptions")

;; http://javascript.crockford.com/javascript.html
;; (find-unpack-chm-links "~/books/__comp/flanagan__javascript_the_definitive_guide_5th_ed.chm" "~/usrc/flanagan-jsdg5/" "flanaganjsdg5")
(code-c-d "flanaganjsdg5" "~/usrc/flanagan-jsdg5/0596101996/")
;; (find-flanaganjsdg5file "")
;; (find-flanaganjsdg5w3m "toc.html")
;; (find-flanaganjsdg5w3m "jscript5-CHP-6-SECT-16.html" "6.16. throw")
;; (find-flanaganjsdg5w3m "jscript5-CHP-6-SECT-17.html" "6.17. try/catch/finally")

;; (find-unpack-chm-links "/home/edrx/books/__comp/flanagan__javascript_pocket_reference_2nd_ed.chm" "~/usrc/flanagan-jspr2/" "flanaganjspr2")
(code-c-d "flanaganjspr2" "~/usrc/flanagan-jspr2/")
;; (find-flanaganjspr2file "")
;; (find-flanaganjspr2w3m "toc.html")
;; (find-flanaganjspr2w3m "jscriptpr2-CHP-1-SECT-2.2.html" "2.2 The Window Object")
;; (find-flanaganjspr2w3m "jscriptpr2-CHP-1-SECT-2.4.html" "2.4 The Legacy DOM")
;; (find-flanaganjspr2w3m "jscriptpr2-CHP-1-SECT-2.5.html" "2.5 The W3C DOM")




;; «latex»  (to ".latex")
;; (find-angg ".emacs.papers" "kopkadaly")
;; http://gigapedia.com/items/125839/guide-to-latex--4th-edition---tools-and-techniques-for-computer-typesetting-
(code-xpdf "kopkadaly" "~/books/__comp/kopka_daly__a_guide_to_latex_4th_ed.pdf")
;; (find-kopkadalypage         7  "Contents")
;; (find-kopkadalypage (+ 12 607) "Index")

;; https://link.springer.com/book/10.1007/978-3-319-47831-9
;; https://link.springer.com/content/pdf/10.1007%2F978-3-319-47831-9.pdf
(code-pdf-page "dattalatex" "~/books/__comp/datta__latex_in_24_hours.pdf")
(code-pdf-text "dattalatex" "~/books/__comp/datta__latex_in_24_hours.pdf")
;; (find-dattalatexpage)
;; (find-dattalatextext)

;; http://gigapedia.com/items/28942/latex--a-document-preparation-system--second-edition
(code-djvu "lamportlatex" "~/books/__comp/lamport__latex_document_preparation_system.djvu")
;; (find-lamportlatexpage         5  "Contents")
;; (find-lamportlatexpage (+ 17 237) "Index")

;; http://gigapedia.com/items/130856/lamstex--the-synthesis
(code-djvu "lamstex" "~/books/__comp/spivak__lamstex_the_synthesis.djvu")
;; (find-lamstexpage      3  "Contents")
;; (find-lamstexpage (+ 5 263) "Index")

;; http://gigapedia.com/items/104326/the-joy-of-tex--a-gourmet-guide-to-typesetting-with-the-ams-tex-macro-package
(code-djvu "joyoftex" "~/books/__comp/spivak__the_joy_of_tex.djvu")
;; (find-joyoftexpage         4  "Contents")
;; (find-joyoftexpage (+ 9 283) "Index")


;; «lilypond»  (to ".lilypond")
;; (find-books "__comp/__comp.el" "lilypond")
;; (find-es "lilypond" "lilypond-2020")
;; (find-angg ".emacs" "lilypond")
(progn
(code-c-d      "lilydoc"   "/usr/share/doc/lilypond/html/Documentation/")
(code-pdf-page "lilyessay" "/usr/share/doc/lilypond/html/Documentation/essay.pdf")
(code-pdf-text "lilyessay" "/usr/share/doc/lilypond/html/Documentation/essay.pdf")
(code-pdf-page "lilylearn" "/usr/share/doc/lilypond/html/Documentation/learning.pdf")
(code-pdf-text "lilylearn" "/usr/share/doc/lilypond/html/Documentation/learning.pdf" 5)
(code-pdf-page "lilysnipp" "/usr/share/doc/lilypond/html/Documentation/snippets.pdf")
(code-pdf-text "lilysnipp" "/usr/share/doc/lilypond/html/Documentation/snippets.pdf")
(code-pdf-page "lilynotat" "/usr/share/doc/lilypond/html/Documentation/notation.pdf")
(code-pdf-text "lilynotat" "/usr/share/doc/lilypond/html/Documentation/notation.pdf")
)
;; (find-lilydocfile "")
;; (find-lilynotatpage)
;; (find-lilynotattext)
;; (find-lilysnipppage)
;; (find-lilysnipptext)
;; (find-lilyessaypage)
;; (find-lilyessaytext)
;; (find-lilylearnpage)
;; (find-lilylearntext)
;; (find-lilylearnpage 2 "Table of Contents")
;; (find-lilylearntext 2 "Table of Contents")
;; (find-lilylearnpage (+ 5  1) "1 Tutorial")
;; (find-lilylearnpage (+ 5  1) "1.1 Compiling a file")
;; (find-lilylearnpage (+ 5  1) "1.1.1 Entering input")
;; (find-lilylearnpage (+ 5  1)  "Producing output")
;; (find-lilylearnpage (+ 5  2) "1.1.2 MacOS X.")
;; (find-lilylearnpage (+ 5  6) "1.1.3 Windows")
;; (find-lilylearnpage (+ 5 11) "1.1.4 Command-line")
;; (find-lilylearnpage (+ 5 12) "1.2 How to write input files")
;; (find-lilylearnpage (+ 5 12) "1.2.1 Simple notation")
;; (find-lilylearnpage (+ 5 12)  "Pitches")
;; (find-lilylearnpage (+ 5 14)  "Durations (rhythms)")
;; (find-lilylearnpage (+ 5 15)  "Rests")
;; (find-lilylearnpage (+ 5 15)  "Time signature")
;; (find-lilylearnpage (+ 5 15)  "Tempo marks")
;; (find-lilylearnpage (+ 5 16)  "Clef")
;; (find-lilylearnpage (+ 5 16)  "All together")
;; (find-lilylearnpage (+ 5 16) "1.2.2 Working on input files")
;; (find-lilylearnpage (+ 5 18) "1.3 Dealing with errors")
;; (find-lilylearnpage (+ 5 18) "1.3.1 General troubleshooting tips")
;; (find-lilylearnpage (+ 5 18) "1.3.2 Some common errors")
;; (find-lilylearnpage (+ 5 18) "1.4 How to read the manuals")
;; (find-lilylearnpage (+ 5 18) "1.4.1 Omitted material")
;; (find-lilylearnpage (+ 5 18) "1.4.2 Clickable examples")
;; (find-lilylearnpage (+ 5 19) "1.4.3 Overview of manuals")
;; (find-lilylearnpage (+ 5 20) "2 Common notation")
;; (find-lilylearnpage (+ 5 20) "2.1 Single staff notation")
;; (find-lilylearnpage (+ 5 20) "2.1.1 Bar lines and bar checks")
;; (find-lilylearnpage (+ 5 20)  "Bar lines")
;; (find-lilylearnpage (+ 5 20)  "Bar checks")
;; (find-lilylearnpage (+ 5 20) "2.1.2 Accidentals and key signatures")
;; (find-lilylearnpage (+ 5 20)  "Accidentals.")
;; (find-lilylearnpage (+ 5 21)  "Key signatures")
;; (find-lilylearnpage (+ 5 21)  "Warning: key signatures and pitches")
;; (find-lilylearnpage (+ 5 22) "2.1.3 Ties and slurs")
;; (find-lilylearnpage (+ 5 22)  "Ties")
;; (find-lilylearnpage (+ 5 22)  "Slurs")
;; (find-lilylearnpage (+ 5 22)  "Phrasing slurs")
;; (find-lilylearnpage (+ 5 23)  "Warnings: slurs vs. ties.")
;; (find-lilylearnpage (+ 5 23) "2.1.4 Articulation and dynamics")
;; (find-lilylearnpage (+ 5 23)  "Articulations")
;; (find-lilylearnpage (+ 5 23)  "Fingerings.")
;; (find-lilylearnpage (+ 5 24)  "Dynamics")
;; (find-lilylearnpage (+ 5 24) "2.1.5 Adding text")
;; (find-lilylearnpage (+ 5 25) "2.1.6 Automatic and manual beams")
;; (find-lilylearnpage (+ 5 25) "2.1.7 Advanced rhythmic commands")
;; (find-lilylearnpage (+ 5 25)  "Partial measure")
;; (find-lilylearnpage (+ 5 26)  "Tuplets")
;; (find-lilylearnpage (+ 5 26)  "Grace notes")
;; (find-lilylearnpage (+ 5 26) "2.2 Multiple notes at once")
;; (find-lilylearnpage (+ 5 26) "2.2.1 Music expressions explained")
;; (find-lilylearnpage (+ 5 27)  "Analogy: mathematical expressions")
;; (find-lilylearnpage (+ 5 27)  "Simultaneous music expressions: multiple staves")
;; (find-lilylearnpage (+ 5 28)  "Simultaneous music expressions: single staff")
;; (find-lilylearnpage (+ 5 28) "2.2.2 Multiple staves")
;; (find-lilylearnpage (+ 5 29) "2.2.3 Staff groups")
;; (find-lilylearnpage (+ 5 30) "2.2.4 Combining notes into chords")
;; (find-lilylearnpage (+ 5 30) "2.2.5 Single staff polyphony")
;; (find-lilylearnpage (+ 5 31) "2.3 Songs")
;; (find-lilylearnpage (+ 5 31) "2.3.1 Setting simple songs")
;; (find-lilylearnpage (+ 5 31) "2.3.2 Aligning lyrics to a melody")
;; (find-lilylearnpage (+ 5 35) "2.3.3 Lyrics to multiple staves")
;; (find-lilylearnpage (+ 5 36) "2.4 Final touches")
;; (find-lilylearnpage (+ 5 36) "2.4.1 Organizing pieces with variables")
;; (find-lilylearnpage (+ 5 37) "2.4.2 Adding titles")
;; (find-lilylearnpage (+ 5 37) "2.4.3 Absolute note names")
;; (find-lilylearnpage (+ 5 39) "2.4.4 After the tutorial")
;; (find-lilylearnpage (+ 5 40) "3 Fundamental concepts")
;; (find-lilylearnpage (+ 5 40) "3.1 How LilyPond input files work")
;; (find-lilylearnpage (+ 5 40) "3.1.1 Introduction to the LilyPond file structure")
;; (find-lilylearnpage (+ 5 42) "3.1.2 Score is a (single) compound musical expression")
;; (find-lilylearnpage (+ 5 44) "3.1.3 Nesting music expressions")
;; (find-lilylearnpage (+ 5 45) "3.1.4 On the un-nestedness of brackets and ties")
;; (find-lilylearnpage (+ 5 46) "3.2 Voices contain music")
;; (find-lilylearnpage (+ 5 47) "3.2.1 I'm hearing Voices")
;; (find-lilylearnpage (+ 5 51) "3.2.2 Explicitly instantiating voices")
;; (find-lilylearnpage (+ 5 55) "3.2.3 Voices and vocals")
;; (find-lilylearnpage (+ 5 57) "3.3 Contexts and engravers")
;; (find-lilylearnpage (+ 5 58) "3.3.1 Contexts explained")
;; (find-lilylearnpage (+ 5 59) "3.3.2 Creating contexts")
;; (find-lilylearnpage (+ 5 60) "3.3.3 Engravers explained")
;; (find-lilylearnpage (+ 5 61) "3.3.4 Modifying context properties")
;; (find-lilylearnpage (+ 5 66) "3.3.5 Adding and removing engravers")
;; (find-lilylearnpage (+ 5 69) "3.4 Extending the templates")
;; (find-lilylearnpage (+ 5 69) "3.4.1 Soprano and cello")
;; (find-lilylearnpage (+ 5 72) "3.4.2 Four-part SATB vocal score")
;; (find-lilylearnpage (+ 5 77) "3.4.3 Building a score from scratch")
;; (find-lilylearnpage (+ 5 82) "3.4.4 Saving typing with variables and functions")
;; (find-lilylearnpage (+ 5 84) "3.4.5 Scores and parts")



;; «make»  (to ".make")
;; (find-books "__comp/__comp.el" "make")
(code-pdf-page "mpwmake" "~/books/__comp/mecklenburg__managing_projects_with_gnu_make_3rd_ed.pdf")
(code-pdf-text "mpwmake" "~/books/__comp/mecklenburg__managing_projects_with_gnu_make_3rd_ed.pdf" 7)
;; (find-mpwmakepage)
;; (find-mpwmakepage        3  "Contents")
;; (find-mpwmakepage (+ 7   1) "1. Basic Concepts")
;; (find-mpwmakepage (+ 3 271) "Index")
;; (find-mpwmaketext "")


;; «ocaml»  (to ".ocaml")
;; (find-books "__comp/__comp.el" "ocaml")
;; https://ocaml.org/learn/books.html
;; https://stackoverflow.com/tags/ocaml/info
;; https://stackoverflow.com/questions/7582388/looking-for-ocaml-ide
(code-pdf-page "realworldocaml" "~/books/__comp/minsky_madhavapeddy_hickey__real_world_ocaml.pdf")
(code-pdf-text "realworldocaml" "~/books/__comp/minsky_madhavapeddy_hickey__real_world_ocaml.pdf" 1)
;; (find-realworldocamlpage)
;; (find-realworldocamlpage         7  "Contents")
;; (find-realworldocamlpage (+ 24   1) "Language concepts")
;; (find-realworldocamltext (+ 24   1) "Language concepts")
;; (find-realworldocamlpage (+ 24 471) "Index")
;; (find-realworldocamltext "")

;; Real World OCaml: Version 2, PDF edition (WIP)
;;   http://dev.realworldocaml.org/book.pdf
(code-pdf-page "realworldocaml" "$S/http/dev.realworldocaml.org/book.pdf")
(code-pdf-text "realworldocaml" "$S/http/dev.realworldocaml.org/book.pdf")
;; (find-realworldocamlpage)
;; (find-realworldocamltext)


;; «penrose»  (to ".penrose")
;; (find-books "__comp/__comp.el" "penrose")
;; http://penrose.ink/media/Penrose_SIGGRAPH2020.pdf
;; (find-es "penrose" "penrose-git")
(code-pdf-page "penrosesigg2020" "$S/http/penrose.ink/media/Penrose_SIGGRAPH2020.pdf")
(code-pdf-text "penrosesigg2020" "$S/http/penrose.ink/media/Penrose_SIGGRAPH2020.pdf")
;; (find-penrosesigg2020page)
;; (find-penrosesigg2020text)
;; (find-penrosesigg2020page 12 "into pieces or stages")
;; (find-penrosesigg2020text 12 "into pieces or stages")
;; (find-penrosesigg2020page 16 "REFERENCES")
;; (find-penrosesigg2020text 16 "REFERENCES")



;; «python»  (to ".python")
;; (find-books "__comp/__comp.el" "python")
;; (find-angg ".emacs.papers" "python")
;; (find-es "python" "books")

;; «python-downey»  (to ".python-downey")
;; (find-books "__comp/__comp.el" "python-downey")
(code-pdf-page "downeytp" "~/books/__comp/downey__think_python_2nd_ed.pdf")
(code-pdf-text "downeytp" "~/books/__comp/downey__think_python_2nd_ed.pdf" 22)
;; (find-downeytppage)
;; (find-downeytppage        1  "Contents")
;; (find-downeytptext "")
;; (find-downeytppage (+ 22 1) "1. The Way of the Program.")
;; (find-downeytppage (+ 22 1)    "What Is a Program?")
;; (find-downeytppage (+ 22 2)    "Running Python")
;; (find-downeytppage (+ 22 3)    "The First Program")
;; (find-downeytppage (+ 22 3)    "Arithmetic Operators")
;; (find-downeytppage (+ 22 4)    "Values and Types")
;; (find-downeytppage (+ 22 5)    "Formal and Natural Languages")
;; (find-downeytppage (+ 22 7)    "Debugging")
;; (find-downeytppage (+ 22 8)    "Glossary")
;; (find-downeytppage (+ 22 9)    "Exercises")
;; (find-downeytppage (+ 22 11) "2. Variables, Expressions and Statements.")
;; (find-downeytppage (+ 22 11)    "Assignment Statements")
;; (find-downeytppage (+ 22 12)    "Variable Names")
;; (find-downeytppage (+ 22 12)    "Expressions and Statements")
;; (find-downeytppage (+ 22 13)    "Script Mode")
;; (find-downeytppage (+ 22 14)    "Order of Operations")
;; (find-downeytppage (+ 22 15)    "String Operations")
;; (find-downeytppage (+ 22 15)    "Comments")
;; (find-downeytppage (+ 22 16)    "Debugging")
;; (find-downeytppage (+ 22 17)    "Glossary")
;; (find-downeytppage (+ 22 18)    "Exercises")
;; (find-downeytppage (+ 22 21) "3. Functions.")
;; (find-downeytppage (+ 22 21)    "Function Calls")
;; (find-downeytppage (+ 22 22)    "Math Functions")
;; (find-downeytppage (+ 22 23)    "Composition")
;; (find-downeytppage (+ 22 23)    "Adding New Functions")
;; (find-downeytppage (+ 22 25)    "Definitions and Uses")
;; (find-downeytppage (+ 22 25)    "Flow of Execution")
;; (find-downeytppage (+ 22 26)    "Parameters and Arguments")
;; (find-downeytppage (+ 22 27)    "Variables and Parameters Are Local")
;; (find-downeytppage (+ 22 28)    "Stack Diagrams")
;; (find-downeytppage (+ 22 29)    "Fruitful Functions and Void Functions")
;; (find-downeytppage (+ 22 30)    "Why Functions?")
;; (find-downeytppage (+ 22 30)    "Debugging")
;; (find-downeytppage (+ 22 31)    "Glossary")
;; (find-downeytppage (+ 22 32)    "Exercises")
;; (find-downeytppage (+ 22 35) "4. Case Study: Interface Design.")
;; (find-downeytppage (+ 22 35)    "The turtle Module")
;; (find-downeytppage (+ 22 37)    "Simple Repetition")
;; (find-downeytppage (+ 22 38)    "Exercises")
;; (find-downeytppage (+ 22 38)    "Encapsulation")
;; (find-downeytppage (+ 22 39)    "Generalization")
;; (find-downeytppage (+ 22 40)    "Interface Design")
;; (find-downeytppage (+ 22 41)    "Refactoring")
;; (find-downeytppage (+ 22 42)    "A Development Plan")
;; (find-downeytppage (+ 22 43)    "docstring")
;; (find-downeytppage (+ 22 43)    "Debugging")
;; (find-downeytppage (+ 22 44)    "Glossary")
;; (find-downeytppage (+ 22 44)    "Exercises")
;; (find-downeytppage (+ 22 47) "5. Conditionals and Recursion.")
;; (find-downeytppage (+ 22 47)    "Floor Division and Modulus")
;; (find-downeytppage (+ 22 48)    "Boolean Expressions")
;; (find-downeytppage (+ 22 49)    "Logical Operators")
;; (find-downeytppage (+ 22 49)    "Conditional Execution")
;; (find-downeytppage (+ 22 49)    "Alternative Execution")
;; (find-downeytppage (+ 22 50)    "Chained Conditionals")
;; (find-downeytppage (+ 22 50)    "Nested Conditionals")
;; (find-downeytppage (+ 22 51)    "Recursion")
;; (find-downeytppage (+ 22 53)    "Stack Diagrams for Recursive Functions")
;; (find-downeytppage (+ 22 53)    "Infinite Recursion")
;; (find-downeytppage (+ 22 54)    "Keyboard Input")
;; (find-downeytppage (+ 22 55)    "Debugging")
;; (find-downeytppage (+ 22 56)    "Glossary")
;; (find-downeytppage (+ 22 57)    "Exercises")
;; (find-downeytppage (+ 22 61) "6. Fruitful Functions.")
;; (find-downeytppage (+ 22 61)    "Return Values")
;; (find-downeytppage (+ 22 62)    "Incremental Development")
;; (find-downeytppage (+ 22 64)    "Composition")
;; (find-downeytppage (+ 22 65)    "Boolean Functions")
;; (find-downeytppage (+ 22 66)    "More Recursion")
;; (find-downeytppage (+ 22 68)    "Leap of Faith")
;; (find-downeytppage (+ 22 68)    "One More Example")
;; (find-downeytppage (+ 22 69)    "Checking Types")
;; (find-downeytppage (+ 22 70)    "Debugging")
;; (find-downeytppage (+ 22 71)    "Glossary")
;; (find-downeytppage (+ 22 72)    "Exercises")
;; (find-downeytppage (+ 22 75) "7. Iteration.")
;; (find-downeytppage (+ 22 75)    "Reassignment")
;; (find-downeytppage (+ 22 76)    "Updating Variables")
;; (find-downeytppage (+ 22 77)    "The while Statement")
;; (find-downeytppage (+ 22 78)    "break")
;; (find-downeytppage (+ 22 79)    "Square Roots")
;; (find-downeytppage (+ 22 81)    "Algorithms")
;; (find-downeytppage (+ 22 81)    "Debugging")
;; (find-downeytppage (+ 22 82)    "Glossary")
;; (find-downeytppage (+ 22 82)    "Exercises")
;; (find-downeytppage (+ 22 85) "8. Strings.")
;; (find-downeytppage (+ 22 85)    "A String Is a Sequence")
;; (find-downeytppage (+ 22 86)    "len")
;; (find-downeytppage (+ 22 86)    "Traversal with a for Loop")
;; (find-downeytppage (+ 22 87)    "String Slices")
;; (find-downeytppage (+ 22 88)    "Strings Are Immutable")
;; (find-downeytppage (+ 22 89)    "Searching")
;; (find-downeytppage (+ 22 89)    "Looping and Counting")
;; (find-downeytppage (+ 22 90)    "String Methods")
;; (find-downeytppage (+ 22 91)    "The in Operator")
;; (find-downeytppage (+ 22 92)    "String Comparison")
;; (find-downeytppage (+ 22 92)    "Debugging")
;; (find-downeytppage (+ 22 94)    "Glossary")
;; (find-downeytppage (+ 22 95)    "Exercises")
;; (find-downeytppage (+ 22 99) "9. Case Study: Word Play.")
;; (find-downeytppage (+ 22 99)    "Reading Word Lists")
;; (find-downeytppage (+ 22 100)    "Exercises")
;; (find-downeytppage (+ 22 101)    "Search")
;; (find-downeytppage (+ 22 103)    "Looping with Indices")
;; (find-downeytppage (+ 22 104)    "Debugging")
;; (find-downeytppage (+ 22 105)    "Glossary")
;; (find-downeytppage (+ 22 105)    "Exercises")
;; (find-downeytppage (+ 22 107) "10. Lists.")
;; (find-downeytppage (+ 22 107)    "A List Is a Sequence")
;; (find-downeytppage (+ 22 108)    "Lists Are Mutable")
;; (find-downeytppage (+ 22 109)    "Traversing a List")
;; (find-downeytppage (+ 22 110)    "List Operations")
;; (find-downeytppage (+ 22 110)    "List Slices")
;; (find-downeytppage (+ 22 111)    "List Methods")
;; (find-downeytppage (+ 22 111)    "Map, Filter and Reduce")
;; (find-downeytppage (+ 22 113)    "Deleting Elements")
;; (find-downeytppage (+ 22 113)    "Lists and Strings")
;; (find-downeytppage (+ 22 114)    "Objects and Values")
;; (find-downeytppage (+ 22 115)    "Aliasing")
;; (find-downeytppage (+ 22 116)    "List Arguments")
;; (find-downeytppage (+ 22 118)    "Debugging")
;; (find-downeytppage (+ 22 119)    "Glossary")
;; (find-downeytppage (+ 22 120)    "Exercises")
;; (find-downeytppage (+ 22 125) "11. Dictionaries.")
;; (find-downeytppage (+ 22 125)    "A Dictionary Is a Mapping")
;; (find-downeytppage (+ 22 127)    "Dictionary as a Collection of Counters")
;; (find-downeytppage (+ 22 128)    "Looping and Dictionaries")
;; (find-downeytppage (+ 22 129)    "Reverse Lookup")
;; (find-downeytppage (+ 22 130)    "Dictionaries and Lists")
;; (find-downeytppage (+ 22 131)    "Memos")
;; (find-downeytppage (+ 22 133)    "Global Variables")
;; (find-downeytppage (+ 22 134)    "Debugging")
;; (find-downeytppage (+ 22 135)    "Glossary")
;; (find-downeytppage (+ 22 137)    "Exercises")
;; (find-downeytppage (+ 22 139) "12. Tuples.")
;; (find-downeytppage (+ 22 139)    "Tuples Are Immutable")
;; (find-downeytppage (+ 22 141)    "Tuple Assignment")
;; (find-downeytppage (+ 22 141)    "Tuples as Return Values")
;; (find-downeytppage (+ 22 142)    "Variable-Length Argument Tuples")
;; (find-downeytppage (+ 22 143)    "Lists and Tuples")
;; (find-downeytppage (+ 22 144)    "Dictionaries and Tuples")
;; (find-downeytppage (+ 22 146)    "Sequences of Sequences")
;; (find-downeytppage (+ 22 147)    "Debugging")
;; (find-downeytppage (+ 22 148)    "Glossary")
;; (find-downeytppage (+ 22 148)    "Exercises")
;; (find-downeytppage (+ 22 151) "13. Case Study: Data Structure Selection.")
;; (find-downeytppage (+ 22 151)     "Word Frequency Analysis")
;; (find-downeytppage (+ 22 152)     "Random Numbers")
;; (find-downeytppage (+ 22 153)     "Word Histogram")
;; (find-downeytppage (+ 22 155)     "Most Common Words")
;; (find-downeytppage (+ 22 155)     "Optional Parameters")
;; (find-downeytppage (+ 22 156)     "Dictionary Subtraction")
;; (find-downeytppage (+ 22 157)     "Random Words")
;; (find-downeytppage (+ 22 158)     "Markov Analysis")
;; (find-downeytppage (+ 22 159)     "Data Structures")
;; (find-downeytppage (+ 22 161)     "Debugging")
;; (find-downeytppage (+ 22 162)     "Glossary")
;; (find-downeytppage (+ 22 163)     "Exercises")
;; (find-downeytppage (+ 22 165) "14. Files.")
;; (find-downeytppage (+ 22 165)     "Persistence")
;; (find-downeytppage (+ 22 166)     "Reading and Writing")
;; (find-downeytppage (+ 22 166)     "Format Operator")
;; (find-downeytppage (+ 22 167)     "Filenames and Paths")
;; (find-downeytppage (+ 22 169)     "Catching Exceptions")
;; (find-downeytppage (+ 22 169)     "Databases")
;; (find-downeytppage (+ 22 170)     "Pickling")
;; (find-downeytppage (+ 22 171)     "Pipes")
;; (find-downeytppage (+ 22 172)     "Writing Modules")
;; (find-downeytppage (+ 22 173)     "Debugging")
;; (find-downeytppage (+ 22 174)     "Glossary")
;; (find-downeytppage (+ 22 175)     "Exercises")
;; (find-downeytppage (+ 22 177) "15. Classes and Objects.")
;; (find-downeytppage (+ 22 177)     "Programmer-Defined Types")
;; (find-downeytppage (+ 22 178)     "Attributes")
;; (find-downeytppage (+ 22 179)     "Rectangles")
;; (find-downeytppage (+ 22 181)     "Instances as Return Values")
;; (find-downeytppage (+ 22 181)     "Objects Are Mutable")
;; (find-downeytppage (+ 22 182)     "Copying")
;; (find-downeytppage (+ 22 183)     "Debugging")
;; (find-downeytppage (+ 22 184)     "Glossary")
;; (find-downeytppage (+ 22 185)     "Exercises")
;; (find-downeytppage (+ 22 187) "16. Classes and Functions.")
;; (find-downeytppage (+ 22 187)     "Time")
;; (find-downeytppage (+ 22 188)     "Pure Functions")
;; (find-downeytppage (+ 22 189)     "Modifiers")
;; (find-downeytppage (+ 22 190)     "Prototyping versus Planning")
;; (find-downeytppage (+ 22 192)     "Debugging")
;; (find-downeytppage (+ 22 192)     "Glossary")
;; (find-downeytppage (+ 22 193)     "Exercises")
;; (find-downeytppage (+ 22 195) "17. Classes and Methods.")
;; (find-downeytppage (+ 22 195)     "Object-Oriented Features")
;; (find-downeytppage (+ 22 196)     "Printing Objects")
;; (find-downeytppage (+ 22 198)     "Another Example")
;; (find-downeytppage (+ 22 198)     "A More Complicated Example")
;; (find-downeytppage (+ 22 199)     "The init Method")
;; (find-downeytppage (+ 22 200)     "The __str__ Method")
;; (find-downeytppage (+ 22 200)     "Operator Overloading")
;; (find-downeytppage (+ 22 201)     "Type-Based Dispatch")
;; (find-downeytppage (+ 22 202)     "Polymorphism")
;; (find-downeytppage (+ 22 203)     "Interface and Implementation")
;; (find-downeytppage (+ 22 204)     "Debugging")
;; (find-downeytppage (+ 22 204)     "Glossary")
;; (find-downeytppage (+ 22 205)     "Exercises")
;; (find-downeytppage (+ 22 207) "18. Inheritance.")
;; (find-downeytppage (+ 22 207)     "Card Objects")
;; (find-downeytppage (+ 22 208)     "Class Attributes")
;; (find-downeytppage (+ 22 210)     "Comparing Cards")
;; (find-downeytppage (+ 22 211)     "Decks")
;; (find-downeytppage (+ 22 211)     "Printing the Deck")
;; (find-downeytppage (+ 22 212)     "Add, Remove, Shuffle and Sort")
;; (find-downeytppage (+ 22 213)     "Inheritance")
;; (find-downeytppage (+ 22 214)     "Class Diagrams")
;; (find-downeytppage (+ 22 215)     "Data Encapsulation")
;; (find-downeytppage (+ 22 217)     "Debugging")
;; (find-downeytppage (+ 22 218)     "Glossary")
;; (find-downeytppage (+ 22 219)     "Exercises")
;; (find-downeytppage (+ 22 223) "19. The Goodies.")
;; (find-downeytppage (+ 22 223)     "Conditional Expressions")
;; (find-downeytppage (+ 22 224)     "List Comprehensions")
;; (find-downeytppage (+ 22 225)     "Generator Expressions")
;; (find-downeytppage (+ 22 226)     "any and all")
;; (find-downeytppage (+ 22 226)     "Sets")
;; (find-downeytppage (+ 22 228)     "Counters")
;; (find-downeytppage (+ 22 229)     "defaultdict")
;; (find-downeytppage (+ 22 230)     "Named Tuples")
;; (find-downeytppage (+ 22 232)     "Gathering Keyword Args")
;; (find-downeytppage (+ 22 233)     "Glossary")
;; (find-downeytppage (+ 22 233)     "Exercises")
;; (find-downeytppage (+ 22 235) "20. Debugging.")
;; (find-downeytppage (+ 22 235)     "Syntax Errors")
;; (find-downeytppage (+ 22 237)     "I keep making changes and it makes no difference.")
;; (find-downeytppage (+ 22 237)     "Runtime Errors")
;; (find-downeytppage (+ 22 237)     "My program does absolutely nothing.")
;; (find-downeytppage (+ 22 238)     "My program hangs.")
;; (find-downeytppage (+ 22 239)     "When I run the program I get an exception.")
;; (find-downeytppage (+ 22 240)     "I added so many print statements I get inundated with output.")
;; (find-downeytppage (+ 22 241)     "Semantic Errors")
;; (find-downeytppage (+ 22 241)     "My program doesn't work.")
;; (find-downeytppage (+ 22 242)     "I've got a big hairy expression and it doesn't do what I expect.")
;; (find-downeytppage (+ 22 243)     "I've got a function that doesn't return what I expect.")
;; (find-downeytppage (+ 22 243)     "I'm really, really stuck and I need help.")
;; (find-downeytppage (+ 22 243)     "No, I really need help.")
;; (find-downeytppage (+ 22 245) "21. Analysis of Algorithms.")
;; (find-downeytppage (+ 22 246)     "Order of Growth")
;; (find-downeytppage (+ 22 248)     "Analysis of Basic Python Operations")
;; (find-downeytppage (+ 22 250)     "Analysis of Search Algorithms")
;; (find-downeytppage (+ 22 251)     "Hashtables")
;; (find-downeytppage (+ 22 255) "Glossary")
;; (find-downeytppage (+ 22 257) "Index.")



(code-xpdf      "corepython" "~/books/__comp/chun__core_python_programmingr_2nd_ed.pdf")
(code-pdftotext "corepython" "~/books/__comp/chun__core_python_programmingr_2nd_ed.pdf" 0)
;; (ee-page-parameters "corepython" 0)
;; (find-corepythonpage      1  "Contents")
;; (find-corepythonpage 57 "Chapter 2. Getting Started")
;; (find-corepythontext 57 "Chapter 2. Getting Started")
;; (find-corepythonpage (+ 1 1) "Index")
;; (find-corepythontext "")

(code-xpdf      "pypocketref" "~/books/__comp/lutz__python_pocket_reference_4th_ed.pdf")
(code-pdftotext "pypocketref" "~/books/__comp/lutz__python_pocket_reference_4th_ed.pdf" 12)
;; (ee-page-parameters "pypocketref" 12)
;; (find-pypocketrefpage         7  "Contents")
;; (find-pypocketrefpage (+ 12 189) "Index")
;; (find-pypocketreftext "")

(code-xpdf      "pycookbook" "~/books/__comp/martelli_ascher__python_cookbook.pdf")
(code-pdftotext "pycookbook" "~/books/__comp/martelli_ascher__python_cookbook.pdf")
;; (find-pycookbookpage      2  "Contents")
;; (find-pycookbookpage     33  "1")
;; (find-pycookbookpage (+ 1 1) "Index")
;; (find-pycookbooktext "")


;; «R» (to ".R")
;; (find-es "r")
;; (find-fline "~/books/__comp/")
(code-xpdf     "teetor" "~/books/__comp/teetor__25_recipes_for_getting_started_with_R.pdf")
(code-pdf-text "teetor" "~/books/__comp/teetor__25_recipes_for_getting_started_with_R.pdf")
;; (find-teetorpage)
;; (find-teetortext)



;; «ruby»  (to ".ruby")

;; «rubyforrails»  (to ".rubyforrails")
;; (find-books "__comp/__comp.el" "rubyforrails")
(code-pdf-page "rubyforrails" "~/books/__comp/black__ruby_for_rails.pdf")
(code-pdf-text "rubyforrails" "~/books/__comp/black__ruby_for_rails.pdf" 35)
;; (find-rubyforrailspage)
;; (find-rubyforrailspage         8  "Brief Contents")
;; (find-rubyforrailspage        10  "Contents")
;; (find-rubyforrailspage (+ 35 477) "Index")
;; (find-rubyforrailstext "")

;; (find-unpack-chm-links "~/books/__comp/fulton__the_ruby_way.chm" "/tmp/rubyway/" "rubyway")
(code-c-d "rubyway" "/tmp/rubyway/0768667208/")
;; (find-rubywayfile "")
;; (find-rubywayw3m "toc.html")
;; (find-rubywayw3m "index.html")

;; «rubynutshell»  (to ".rubynutshell")
;; (find-books "__comp/__comp.el" "rubynutshell")
(code-pdf-page "rubynutshell" "~/books/__comp/matz__ruby_in_a_nutshell.pdf")
(code-pdf-text "rubynutshell" "~/books/__comp/matz__ruby_in_a_nutshell.pdf")
;; (find-rubynutshellpage   2 "Contents")
;; (find-rubynutshellpage  10 "1. Introduction")
;; (find-rubynutshellpage  11  "1.1. Ruby's Elegance")
;; (find-rubynutshellpage  14  "1.2. Ruby in Action")
;; (find-rubynutshellpage  16 "2. Language Basics")
;; (find-rubynutshellpage  17  "2.1. Command-Line Options")
;; (find-rubynutshellpage  20  "2.2. Environment Variables")
;; (find-rubynutshellpage  22  "2.3. Lexical Conventions")
;; (find-rubynutshellpage  24  "2.4. Literals")
;; (find-rubynutshellpage  31  "2.5. Variables")
;; (find-rubynutshellpage  34  "2.6. Operators")
;; (find-rubynutshellpage  37  "2.7. Methods")
;; (find-rubynutshellpage  41  "2.8. Control Structures")
;; (find-rubynutshellpage  45  "2.9. Object-Oriented Programming")
;; (find-rubynutshellpage  49  "2.10. Security")
;; (find-rubynutshellpage  53 "3. Built-in Library Reference")
;; (find-rubynutshellpage  54  "3.1. Predefined Variables")
;; (find-rubynutshellpage  57  "3.2. Predefined Global Constants")
;; (find-rubynutshellpage  59  "3.3. Built-in Functions")
;; (find-rubynutshellpage  68  "3.4. Built-in Library")
;; (find-rubynutshellpage 136 "4. Standard Library Reference")
;; (find-rubynutshellpage 137  "4.1. Standard Library")
;; (find-rubynutshellpage 184 "5. Ruby Tools")
;; (find-rubynutshellpage 185  "5.1. Standard Tools")
;; (find-rubynutshellpage 192  "5.2. Additional Tools")
;; (find-rubynutshellpage 194  "5.3. Ruby Application Archive")
;; (find-rubynutshellpage 195 "6. Ruby Updates")
;; (find-rubynutshellpage 196  "6.1. Summary of Changes")
;; (find-rubynutshellpage 197  "6.2. Changes from 1.6.5 to 1.7.1")
;; (find-rubynutshellpage 199  "6.3. The Future of Ruby")
;; (find-rubynutshellpage 200  "6.4. Participate in Ruby")
;; (find-rubynutshelltext "")


;; «pragmaticruby»  (to ".pragmaticruby")
;; (find-books "__comp/__comp.el" "pragmaticruby")
(code-pdf-page "pragmaticruby" "~/books/__comp/thomas__programming_ruby_the_pragmatic_programmers_guide.pdf")
(code-pdf-text "pragmaticruby" "~/books/__comp/thomas__programming_ruby_the_pragmatic_programmers_guide.pdf" 28)
;; (find-pragmaticrubypage)
;; (find-pragmaticrubypage         6  "Contents")
;; (find-pragmaticrubytext         6  "Contents")
;; (find-pragmaticrubypage (+ 28 762) "Index")
;; (find-pragmaticrubypage (+ 28 797) "Template characters")
;; (find-pragmaticrubytext "")


;; «scala»  (to ".scala")
(code-xpdf      "progscala" "~/books/__comp/odersky_spoon_venners__programming_in_scala_2nd_ed.pdf")
(code-pdftotext "progscala" "~/books/__comp/odersky_spoon_venners__programming_in_scala_2nd_ed.pdf")
;; (find-progscalapage       10  "Contents")
;; (find-progscalapage       11  "Contents")
;; (find-progscalapage (+ 0 846) "Index")
;; (find-progscalatext "")


;; «shell» (to ".shell")
(code-xpdf     "classicshell" "~/books/__comp/robbins_beebe__classic_shell_scripting.pdf")
(code-pdf-text "classicshell" "~/books/__comp/robbins_beebe__classic_shell_scripting.pdf" 24)
;; (find-classicshellpage (+ 24 1))
;; (find-classicshelltext (+ 24 1))




;; «smalltalk»  (to ".smalltalk")
;; SmallTalk books:
;; http://wiki.squeak.org/squeak/64
;; http://stephane.ducasse.free.fr/FreeBooks/BlueBook/
;; http://wiki.squeak.org/squeak/65
;; http://wiki.squeak.org/squeak/66
;; http://wiki.squeak.org/squeak/576
;; http://wiki.squeak.org/squeak/1600
;; http://wiki.squeak.org/squeak/920
;; 
;; http://library.nu/search?q=smalltalk
;; http://wiki.squeak.org/squeak/1859
;; http://web.cecs.pdx.edu/~black/OOP/Tutorial/SqueakLanguageRef.html
;; http://web.cecs.pdx.edu/~black/OOP/Tutorial/Squeak%20Classes%20Ref.html

(code-xpdf      "goldbergbluebook" "~/books/__comp/goldberg_robson__smalltalk-80_the_language_and_its_implementation.pdf")
(code-pdftotext "goldbergbluebook" "~/books/__comp/goldberg_robson__smalltalk-80_the_language_and_its_implementation.pdf" 22)
;; (ee-page-parameters "goldbergbluebook" 22)
;; (find-goldbergbluebookpage        17  "Contents")
;; (find-goldbergbluebookpage (+ 22  32) "An Example" "Application")
;; (find-goldbergbluebookpage (+ 22 691) "Subject Index")
;; (find-goldbergbluebookpage (+ 22 699) "System Index")
;; (find-goldbergbluebookpage (+ 22 703) "Example Class Index")
;; (find-goldbergbluebookpage (+ 22 707) "Implementation Index")
;; (find-goldbergbluebooktext "")

;;   PART ONE
;; (find-goldbergbluebookpage (+ 22  5) "1. Objects and Messages")
;; (find-goldbergbluebookpage (+ 22  8) "Classes and Instances")
;; (find-goldbergbluebookpage (+ 22 10) "An Example Application")
;; (find-goldbergbluebookpage (+ 22 13) "System Classes")
;; (find-goldbergbluebookpage (+ 22 16) "Summary of Terminology")
;;
;; (find-goldbergbluebookpage (+ 22 17) "2. Expression Syntax")
;; (find-goldbergbluebookpage (+ 22 19) "Literals")
;; (find-goldbergbluebookpage (+ 22 21) "Variables")
;; (find-goldbergbluebookpage (+ 22 24) "Messages")
;; (find-goldbergbluebookpage (+ 22 31) "Blocks")
;; (find-goldbergbluebookpage (+ 22 37) "Summary of Terminology")
;;
;; (find-goldbergbluebookpage (+ 22 39) "3. Classes and Instances")
;; (find-goldbergbluebookpage (+ 22 41) "Protocol Descriptions")
;; (find-goldbergbluebookpage (+ 22 43) "Implementation Descriptions")
;; (find-goldbergbluebookpage (+ 22 44) "Variable Declarations")
;; (find-goldbergbluebookpage (+ 22 46) "Methods")
;; (find-goldbergbluebookpage (+ 22 52) "Primitive Methods")
;; (find-goldbergbluebookpage (+ 22 53) "Summary of Terminology")
;;
;; (find-goldbergbluebookpage (+ 22 55) "4. Subclasses")
;; (find-goldbergbluebookpage (+ 22 58) "Subclass Descriptions")
;; (find-goldbergbluebookpage (+ 22 59) "An Example Subclass")
;; (find-goldbergbluebookpage (+ 22 61) "Method Determination")
;; (find-goldbergbluebookpage (+ 22 66) "Abstract Superclasses")
;; (find-goldbergbluebookpage (+ 22 72) "Subclass Framework Messages")
;; (find-goldbergbluebookpage (+ 22 73) "Summary of Terminology")
;;
;; (find-goldbergbluebookpage (+ 22 75) "5. Metaclasses")
;; (find-goldbergbluebookpage (+ 22 77) "Initialization of Instances")
;; (find-goldbergbluebookpage (+ 22 78) "An Example Metaclass")
;; (find-goldbergbluebookpage (+ 22 81) "Metaclass Inheritance")
;; (find-goldbergbluebookpage (+ 22 84) "Initialization of Class Variables")
;; (find-goldbergbluebookpage (+ 22 88) "Summary of Method Determination")
;; (find-goldbergbluebookpage (+ 22 89) "Summary of Terminology")
;;
;;   PART TWO
;; (find-goldbergbluebookpage (+ 22 93) "6. Protocol for all Objects")
;; (find-goldbergbluebookpage (+ 22 95) "Testing the Functionality of an Object")
;; (find-goldbergbluebookpage (+ 22 96) "Comparing Objects")
;; (find-goldbergbluebookpage (+ 22 97) "Copying Objects")
;; (find-goldbergbluebookpage (+ 22 99) "Accessing the Parts of an Object")
;; (find-goldbergbluebookpage (+ 22 100) "Printing and Storing Objects")
;; (find-goldbergbluebookpage (+ 22 102) "Error Handling")
;;
;; (find-goldbergbluebookpage (+ 22 105) "7 Linear Measures")
;; (find-goldbergbluebookpage (+ 22 107) "Class Magnitude")
;; (find-goldbergbluebookpage (+ 22 108) "Class Date")
;; (find-goldbergbluebookpage (+ 22 111) "Class Time")
;; (find-goldbergbluebookpage (+ 22 114) "Class Character")
;;
;; (find-goldbergbluebookpage (+ 22 117) "8 Numerical Classes")
;; (find-goldbergbluebookpage (+ 22 120) "Protocol of the Number Classes")
;; (find-goldbergbluebookpage (+ 22 126) "Classes Float and Fraction")
;; (find-goldbergbluebookpage (+ 22 127) "Integer Classes")
;; (find-goldbergbluebookpage (+ 22 129) "Class Random: A Random Number Generator")
;;
;; (find-goldbergbluebookpage (+ 22 131) "9 Protocol for All Collection Classes")
;; (find-goldbergbluebookpage (+ 22 134) "Adding, Removing, and Testing Elements")
;; (find-goldbergbluebookpage (+ 22 136) "Enumerating Elements")
;; (find-goldbergbluebookpage (+ 22 139) "Instance Creation")
;; (find-goldbergbluebookpage (+ 22 140) "Conversion Among Collection Classes")
;;
;; (find-goldbergbluebookpage (+ 22 143) "10 Hierarchy of the Collection Classes")
;; (find-goldbergbluebookpage (+ 22 147) "Class Bag")
;; (find-goldbergbluebookpage (+ 22 148) "Class Set")
;; (find-goldbergbluebookpage (+ 22 148) "Classes Dictionary and IdentityDictionary")
;; (find-goldbergbluebookpage (+ 22 153) "Class SequenceableCollection")
;; (find-goldbergbluebookpage (+ 22 157) "Subclasses of SequenceableCollection")
;; (find-goldbergbluebookpage (+ 22 165) "Class ArrayedCollection")
;; (find-goldbergbluebookpage (+ 22 168) "Class MappedCollection")
;; (find-goldbergbluebookpage (+ 22 169) "Summary of Conversions Among Collections")
;;
;; (find-goldbergbluebookpage (+ 22 171) "11 Three Examples that Use Collections")
;; (find-goldbergbluebookpage (+ 22 172) "Random Selection and Playing Cards")
;; (find-goldbergbluebookpage (+ 22 181) "The Drunken Cockroach Problem")
;; (find-goldbergbluebookpage (+ 22 185) "Traversing Binary Trees")
;;
;; (find-goldbergbluebookpage (+ 22 193) "12 Protocol for Streams")
;; (find-goldbergbluebookpage (+ 22 195) "Class Stream")
;; (find-goldbergbluebookpage (+ 22 198) "Positionable Streams")
;; (find-goldbergbluebookpage (+ 22 204) "Streams of Generated Elements")
;; (find-goldbergbluebookpage (+ 22 205) "Streams for Collections Without External Keys")
;; (find-goldbergbluebookpage (+ 22 208) "External Streams and File Streams")
;;
;; (find-goldbergbluebookpage (+ 22 211) "13 Implementations of the Basic Collection Protocol")
;; (find-goldbergbluebookpage (+ 22 212) "Class Collection")
;; (find-goldbergbluebookpage (+ 22 219) "Subclasses of Collection")
;;
;; (find-goldbergbluebookpage (+ 22 235) "14 Kernel Support")
;; (find-goldbergbluebookpage (+ 22 237) "Class UndefinedObject")
;; (find-goldbergbluebookpage (+ 22 237) "Classes Boolean, True, and False")
;; (find-goldbergbluebookpage (+ 22 239) "Additional Protocol for Class Object")
;;
;; (find-goldbergbluebookpage (+ 22 249) "15 Multiple Independent Processes")
;; (find-goldbergbluebookpage (+ 22 251) "Processes")
;; (find-goldbergbluebookpage (+ 22 257) "Semaphores")
;; (find-goldbergbluebookpage (+ 22 265) "Class SharedQueue")
;; (find-goldbergbluebookpage (+ 22 266) "Class Delay")
;;
;; (find-goldbergbluebookpage (+ 22 267) "16 Protocol for Classes")
;; (find-goldbergbluebookpage (+ 22 272) "Class Behavior")
;; (find-goldbergbluebookpage (+ 22 284) "Class ClassDescription")
;; (find-goldbergbluebookpage (+ 22 287) "Class Metaclass")
;; (find-goldbergbluebookpage (+ 22 288) "Class Class")
;;
;; (find-goldbergbluebookpage (+ 22 291) "17 The Programming Interface")
;; (find-goldbergbluebookpage (+ 22 292) "Views")
;; (find-goldbergbluebookpage (+ 22 297) "Browsers")
;; (find-goldbergbluebookpage (+ 22 308) "Testing")
;; (find-goldbergbluebookpage (+ 22 314) "Error Reporting")
;;
;; (find-goldbergbluebookpage (+ 22 329) "18 Graphics Kernel")
;; (find-goldbergbluebookpage (+ 22 331) "Graphical Representation")
;; (find-goldbergbluebookpage (+ 22 331) "Graphical Storage")
;; (find-goldbergbluebookpage (+ 22 333) "Graphical Manipulation")
;; (find-goldbergbluebookpage (+ 22 338) "Classes Form and Bitmap")
;; (find-goldbergbluebookpage (+ 22 340) "Spatial Reference")
;; (find-goldbergbluebookpage (+ 22 349) "Class BitBIt")
;; (find-goldbergbluebookpage (+ 22 351) "Line Drawing")
;; (find-goldbergbluebookpage (+ 22 354) "Text Display")
;; (find-goldbergbluebookpage (+ 22 355) "Simulation of BitBIt")
;;
;; (find-goldbergbluebookpage (+ 22 364) "19 Pens")
;; (find-goldbergbluebookpage (+ 22 365) "Class Pen")
;; (find-goldbergbluebookpage (+ 22 370) "Geometric Designs")
;; (find-goldbergbluebookpage (+ 22 375) "Commander Pen")
;;
;; (find-goldbergbluebookpage (+ 22 381) "20 Display Objects")
;; (find-goldbergbluebookpage (+ 22 383) "Class DisplayObject")
;; (find-goldbergbluebookpage (+ 22 390) "Class DisplayMedium")
;; (find-goldbergbluebookpage (+ 22 396) "Forms")
;; (find-goldbergbluebookpage (+ 22 400) "Display Text")
;; (find-goldbergbluebookpage (+ 22 400) "Paths")
;; (find-goldbergbluebookpage (+ 22 405) "Image Manipulation with Forms")
;;
;;   PART THREE
;; (find-goldbergbluebookpage (+ 22 417) "21 Probability Distributions")
;; (find-goldbergbluebookpage (+ 22 418) "Probability Distribution Framework")
;; (find-goldbergbluebookpage (+ 22 423) "Discrete Probability Distributions")
;; (find-goldbergbluebookpage (+ 22 432) "Continuous Probability Distributions")
;;
;; (find-goldbergbluebookpage (+ 22 439) "22 Event-Driven Simulations")
;; (find-goldbergbluebookpage (+ 22 442) "A Framework for Simulation")
;; (find-goldbergbluebookpage (+ 22 452) "Implementation of the Simulation Classes")
;;
;; (find-goldbergbluebookpage (+ 22 465) "23 Statistics Gathering in Event - Driven Simulations")
;; (find-goldbergbluebookpage (+ 22 466) "Duration Statistics")
;; (find-goldbergbluebookpage (+ 22 469) "Throughput Histograms")
;; (find-goldbergbluebookpage (+ 22 474) "Tallying Events")
;; (find-goldbergbluebookpage (+ 22 476) "Event Monitoring")
;;            
;; (find-goldbergbluebookpage (+ 22 483) "24 The Use of Resources in Event - Driven Simulations")
;; (find-goldbergbluebookpage (+ 22 484) "Implementing ResourceProvider and StaticResource")
;; (find-goldbergbluebookpage (+ 22 489) "Consumable Resources")
;; (find-goldbergbluebookpage (+ 22 492) "Nonconsumable Resources")
;; (find-goldbergbluebookpage (+ 22 503) "Renewable Resources")
;;
;; (find-goldbergbluebookpage (+ 22 515) "25 Coordinated Resources for Event-Driven Simulations")
;; (find-goldbergbluebookpage (+ 22 516) "The Implementation of Class ResourceCoordinator")
;; (find-goldbergbluebookpage (+ 22 518) "Example: A Car Wash Simulation")
;; (find-goldbergbluebookpage (+ 22 521) "Example: A Ferry Service for a Special Truck")
;; (find-goldbergbluebookpage (+ 22 526) "Example: A Bank")
;; (find-goldbergbluebookpage (+ 22 533) "Example: An Information System")
;;
;;   PART FOUR
;; (find-goldbergbluebookpage (+ 22 541) "26 The Implementation")
;; (find-goldbergbluebookpage (+ 22 542) "The Compiler")
;; (find-goldbergbluebookpage (+ 22 550) "The Interpreter")
;; (find-goldbergbluebookpage (+ 22 564) "The Object Memory")
;; (find-goldbergbluebookpage (+ 22 566) "The Hardware")
;;
;; (find-goldbergbluebookpage (+ 22 567) "27 Specification of the Virtual Machine")
;; (find-goldbergbluebookpage (+ 22 568) "Form of the Specification")
;; (find-goldbergbluebookpage (+ 22 570) "Object Memory Interface")
;; (find-goldbergbluebookpage (+ 22 575) "Objects Used by the Interpreter")
;;
;; (find-goldbergbluebookpage (+ 22 593) "28 Formal Specification of the Interpreter")
;; (find-goldbergbluebookpage (+ 22 597) "Stack Bytecodes")
;; (find-goldbergbluebookpage (+ 22 601) "Jump Bytecodes")
;; (find-goldbergbluebookpage (+ 22 603) "Send Bytecodes")
;; (find-goldbergbluebookpage (+ 22 608) "Return Bytecodes")
;;            
;; (find-goldbergbluebookpage (+ 22 611) "29 Formal Specification of the Primitive Methods")
;; (find-goldbergbluebookpage (+ 22 621) "Arithmetic Primitives")
;; (find-goldbergbluebookpage (+ 22 627) "Array and Stream Primitives")
;; (find-goldbergbluebookpage (+ 22 633) "Storage Management Primitives")
;; (find-goldbergbluebookpage (+ 22 637) "Control Primitives")
;; (find-goldbergbluebookpage (+ 22 647) "Input/Output Primitives")
;; (find-goldbergbluebookpage (+ 22 652) "System Primitives")
;;
;; (find-goldbergbluebookpage (+ 22 655) "30 Formal Specification of the Object Memory")
;; (find-goldbergbluebookpage (+ 22 657) "Heap Storage")
;; (find-goldbergbluebookpage (+ 22 659) "The Object Table")
;; (find-goldbergbluebookpage (+ 22 667) "Allocation and Deallocation")
;; (find-goldbergbluebookpage (+ 22 674) "Garbage Collection")
;; (find-goldbergbluebookpage (+ 22 684) "Nonpointer Objects")
;; (find-goldbergbluebookpage (+ 22 686) "Interface to the Bytecode Interpreter")
;;
;; (find-goldbergbluebookpage (+ 22 691) "Subject Index")
;; (find-goldbergbluebookpage (+ 22 699) "System Index")
;; (find-goldbergbluebookpage (+ 22 703) "Example Class Index")
;; (find-goldbergbluebookpage (+ 22 707) "Implementation Index")


(code-xpdf      "goldbergredbook" "~/books/__comp/goldberg__smalltalk-80_the_interactive_programming_environment.pdf")
(code-pdftotext "goldbergredbook" "~/books/__comp/goldberg__smalltalk-80_the_interactive_programming_environment.pdf")
;; (find-goldbergredbookpage        7  "Contents")
;; (find-goldbergredbookpage (+ 9 503) "System Workspace Index")
;; (find-goldbergredbookpage (+ 9 510) "Menu Command Index")
;; (find-goldbergredbookpage (+ 9 512) "Subject Index")
;; (find-goldbergredbooktext "")

(code-xpdf      "insidesmalltalk1" "~/books/__comp/lalonde_pugh__inside_smalltalk_vol_1.pdf")
(code-pdftotext "insidesmalltalk1" "~/books/__comp/lalonde_pugh__inside_smalltalk_vol_1.pdf")
;; (find-insidesmalltalk1page         3  "Contents")
;; (find-insidesmalltalk1page (+ 16 506) "Class Index")
;; (find-insidesmalltalk1page (+ 16 508) "Index")
;; (find-insidesmalltalk1text "")

(code-xpdf      "insidesmalltalk2" "~/books/__comp/lalonde_pugh__inside_smalltalk_vol_2.pdf")
(code-pdftotext "insidesmalltalk2" "~/books/__comp/lalonde_pugh__inside_smalltalk_vol_2.pdf")
;; (find-insidesmalltalk2page         5  "Contents")
;; (find-insidesmalltalk2page (+ 20 545) "Class Index")
;; (find-insidesmalltalk2page (+ 20 549) "Index")
;; (find-insidesmalltalk2text "")

(code-xpdf      "smalltalkbyex" "~/books/__comp/sharp__smalltalk_by_example.pdf")
(code-pdftotext "smalltalkbyex" "~/books/__comp/sharp__smalltalk_by_example.pdf")
;; (find-smalltalkbyexpage (+ 1  9) "1. Basic Concepts")
;; (find-smalltalkbyexpage (+ 1 16) "2. Messages")
;; (find-smalltalkbyextext "")




;; «ssh»  (to ".ssh")
;; http://gigapedia.com/items/4269/ssh--the-secure-shell---the-definitive-guide--2nd-edition--2005-01
(code-xpdf      "snailbook" "~/books/__comp/barrett_silverman__ssh_the_secure_shell_2ed.pdf")
(code-pdftotext "snailbook" "~/books/__comp/barrett_silverman__ssh_the_secure_shell_2ed.pdf" 16)
;; (ee-page-parameters "snailbook" 16)
;; (find-snailbookpage         5  "Contents")
;; (find-snailbookpage (+ 16  26) "2.4. Authentication by Cryptographic Key")
;; (find-snailbooktext (+ 16  26) "2.4. Authentication by Cryptographic Key")
;; (find-snailbookpage (+ 16  32) "2.5. The SSH Agent")
;; (find-snailbooktext (+ 16  32) "2.5. The SSH Agent")
;; (find-snailbookpage (+ 16  37) "2.6. Connecting Without a Password")
;; (find-snailbooktext            "2.6. Connecting Without a Password")
;; (find-snailbookpage (+ 16  60) "3.4.2.3. Trusted-host authentication")
;; (find-snailbooktext            "3.4.2.3. Trusted-host authentication")
;; (find-snailbookpage (+ 16 521) "Index")
;; (find-snailbooktext            "Index")



;; «unixtools»  (to ".unixtools")
;; (find-books "__comp/__comp.el" "unixtools")
;; Markus Kuhn: "Unix Tools" (course at the Cambridge Computer Lab)
;; https://www.cl.cam.ac.uk/teaching/1516/UnixTools/
;; https://www.cl.cam.ac.uk/teaching/1516/UnixTools/unixtools-slides.pdf
;; https://www.cl.cam.ac.uk/teaching/1516/UnixTools/notes.pdf
(code-pdf-page "unixtoolss" "$S/https/www.cl.cam.ac.uk/teaching/1516/UnixTools/unixtools-slides.pdf")
(code-pdf-text "unixtoolss" "$S/https/www.cl.cam.ac.uk/teaching/1516/UnixTools/unixtools-slides.pdf")
(code-pdf-page "unixtoolsn" "$S/https/www.cl.cam.ac.uk/teaching/1516/UnixTools/notes.pdf")
(code-pdf-text "unixtoolsn" "$S/https/www.cl.cam.ac.uk/teaching/1516/UnixTools/notes.pdf")
;; (find-unixtoolsspage)
;; (find-unixtoolsstext)
;; (find-unixtoolsnpage)
;; (find-unixtoolsntext)



;; «unusual-effectiveness»  (to ".unusual-effectiveness")
;; (find-books "__comp/__comp.el" "unusual-effectiveness")
;; https://www.cs.cmu.edu/~rwh/papers/unreasonable/basl.pdf
;; Halpern/Harper/Immerman/Kolaitis/Vardi/Vian:
;; "On the Unusual Effectiveness of Logic in Computer Science"
(code-pdf-page "unusualeff" "$S/https/www.cs.cmu.edu/~rwh/papers/unreasonable/basl.pdf")
(code-pdf-text "unusualeff" "$S/https/www.cs.cmu.edu/~rwh/papers/unreasonable/basl.pdf")
;; (find-unusualeffpage)
;; (find-unusualefftext)
;;
;; [Wig60] E.P. Wigner. The unreasonable effectiveness of mathematics
;; in the natural sciences. Comm. on Pure and Applied Math.,
;; 13:1-14, 1960.
;;
;; [Ham80] R.W. Hamming. The unreasonable effectiveness of
;; mathematics. American Mathematical Monthly, 87:8190, 1980.





;; http://gigapedia.com/items/5208/advanced-programming-language-design
(code-xpdf      "finkel" "~/books/__comp/finkel__advanced_programming_languages_design.pdf")
(code-pdftotext "finkel" "~/books/__comp/finkel__advanced_programming_languages_design.pdf")
;; (find-finkelpage        1  "Contents")
;; (find-finkelpage (+ 7 351) "3.19 Continuations")
;; (find-finkeltext )

;; Very incomplete
(code-xpdf "sebesta" "~/books/__comp/sebesta__concepts_of_programming_languages.pdf")
;; (find-sebestapage         7  "Contents")
;; (find-sebestapage (+ -1 677) "Index")

(code-xpdf      "stevensonplf" "~/books/__comp/stevenson__programming_language_fundamentals_by_example.pdf")
(code-pdftotext "stevensonplf" "~/books/__comp/stevenson__programming_language_fundamentals_by_example.pdf")
;; (find-stevensonplfpage        6  "Contents")
;; (find-stevensonplfpage (+ 16  1) "1. A word about using this text")
;; (find-stevensonplfpage (+ 16 37) "Milestone I\n" "LEARNING A NEW" "LANGUAGE, Gforth")
;; (find-stevensonplftext           "Milestone I\n" "LEARNING A NEW" "LANGUAGE, Gforth")
;; (find-stevensonplftext "")

;; http://gigapedia.com/items/194905/design-concepts-in-programming-languages
(code-xpdf      "turbakgifford" "~/books/__comp/turbak_gifford__design_concepts_in_programming_languages.pdf")
(code-pdftotext "turbakgifford" "~/books/__comp/turbak_gifford__design_concepts_in_programming_languages.pdf")
;; (find-turbakgiffordpage          6  "Contents")
;; (find-turbakgiffordpage (+ 25 1227) "Index")
;; (find-turbakgiffordtext             "")


;; ~/books/__comp/gang_of_four__design_patterns.chm
;; (find-unpack-chm-links "~/books/__comp/gang_of_four__design_patterns.chm" "/tmp/designpats/" "designpats")
(code-c-d "designpats" "/tmp/designpats/")
;; (find-designpatsfile "")
;; (find-designpatsw3m "00.htm")



;; http://gigapedia.com/items/17653/concepts--techniques--and-models-of-computer-programming
(code-xpdf "vanroyharidi" "~/books/__comp/van_roy_haridi__concepts_techniques_and_models_of_computer_programming.pdf")
;; (find-vanroyharidipage         8  "Contents")
;; (find-vanroyharidipage (+ 31 863) "Index")

;; http://gigapedia.com/items/206006/forth-encyclopedia--the-complete-forth-programmer--039-s-manual
(code-xpdf "forthencyclopedia" "~/books/__comp/derick_baker__forth_encyclopedia.pdf")
;; (find-forthencyclopediapage         4  "Contents")
;; (find-forthencyclopediapage (+ 12 331) "Index")


;; http://gigapedia.com/items/115838/theorem-proving-in-higher-order-logics--10th-international-conference--tphols--039-97--murray-hill--nj--usa--august-19-22--1997--proceedings--lecture-notes-in-computer-science-
;; "Theorem Proving in Higher Order Logics": TPHOLs'97, LNCS 1275
(code-xpdf "tphol" "~/books/__comp/gunter_felty__theorem_proving_in_higher_order_logic.pdf")
;; (find-tpholpage        6  "Contents")
;; (find-tpholpage (+ 7   1) "Index")
;; (find-tpholpage (+ 1 199) "On Formalization of Bicategory Theory")



;; http://gigapedia.com/items/335403/theoretical-computer-science--volume-375--issues-1-3--pages-1-350--1-may-2007---festschrift-for-john-c--reynolds---s-70th-birthday
(code-xpdf "tcs375" "~/books/__comp/tcs_375__john_c_reynolds_festschrift.pdf")
;; (find-tcs375page (+ 5   3) "A fibrational framework...")
;; (find-tcs375page (+ 5  20) "Combining algebraic effects with continuations")
;; (find-tcs375page (+ 5  42) "On the relations between monadic semantics")
;; (find-tcs375page (+ 5  76) "A syntactic correspondence...")
;; (find-tcs375page (+ 5 193) "Core algebra revisited")
;; (find-tcs375page (+ 5 201) "The Girard-Reynolds isomorphism")
;; (find-tcs375page (+ 5 335) "A few exercises in theorem processing")

;; http://gigapedia.com/items/335399/theoretical-computer-science--volume-316--issues-1-3--pages-1-323--28-may-2004---recent-developments-in-domain-theory--a-collection-of-papers-in-honour-of-dana-s--scott
(code-xpdf "tcs316" "~/books/__comp/tcs_316__in_honour_of_dana_scott.pdf")
;; (find-tcs316page        1  "Contents")
;; (find-tcs316page (+ 1 105) "Lawvere" "Left and right adjoint operations on spaces and data types")
;; (find-tcs316page (+ 1 112) "Gentzen")
;; (find-tcs316page (+ 1 189) "Streicher")
;; (find-tcs316page      320  "Author index")

;; http://gigapedia.com/items/104785/edinburgh-lcf--a-mechanized-logic-of-computation--lecture-notes-in-computer-science-
(code-xpdf "gmwelcf" "~/books/__comp/gordon_milner_wadsworth__edinburgh_lcf.pdf")
;; (find-gmwelcfpage        7  "Contents")
;; (find-gmwelcfpage (+ 8 158) "Index")

;; http://gigapedia.com/items/36701/isabelle-hol--a-proof-assistant-for-higher-order-logic--lecture-notes-in-computer-science-2283-
(code-xpdf "npwisahol" "~/books/__comp/nipkow_paulson_wenzel__isabelle_hol.pdf")
;; (find-npwisaholpage        6  "Contents")
;; (find-npwisaholpage (+ 11 214) "Index")

;; http://gigapedia.com/items/258668/proof--language--and-interaction--essays-in-honour-of-robin-milner--foundations-of-computing-
(code-xpdf "plandi" "~/books/__comp/plotkin_stirling_tofte__proof_language_and_interaction.pdf")
;; (find-plandipage         6  "Contents")
;; (find-plandipage (+ 15 169) "From LCF to HOL: a short history")
;; (find-plandipage (+ 15 239) "Constructive Category Theory")
;; (find-plandipage (+ 15 721) "Contributors")

;; http://gigapedia.com/items/66716/beautiful-code--leading-programmers-explain-how-they-think--theory-in-practice--o--039-reilly--
;; (find-unpack-chm-links "~/books/__comp/oram_wilson__beautiful_code.chm" "/tmp/beautifulcode/" "beautifulcode")
(code-c-d "beautifulcode" "/tmp/beautifulcode/")
;; (find-beautifulcodefile "")
;; (find-beautifulcodew3m "000.toc.html")
;; (find-beautifulcodew3m "246.index.html")



;; http://gigapedia.com/items/111804/the-little-lisper---3rd-edition
(code-djvu "littlelisper" "~/books/__comp/friedman_felleisen__the_little_lisper.djvu")
;; (find-littlelisperpage   4 "vii" "Contents")
;; (find-littlelisperpage 108 "205" "Index")

;; http://gigapedia.com/items/137595/the-art-of-the-metaobject-protocol
(code-djvu "taotmp" "~/books/__comp/kiczales__the_art_of_the_metaobject_protocol.djvu")
;; (find-taotmppage         2  "Contents")
;; (find-taotmppage (+ -5 327) "Index")


;; http://gigapedia.com/items/360364/masterminds-of-programming--conversations-with-the-creators-of-major-programming-languages--theory-in-practice--o--039-reilly--
(code-xpdf      "masterminds" "~/books/__comp/biancuzzi_warden__masterminds_of_programming.pdf")
(code-pdftotext "masterminds" "~/books/__comp/biancuzzi_warden__masterminds_of_programming.pdf")
;; (find-mastermindspage         5  "Contents")
;; (find-mastermindspage (+ 14  43) "APL")
;; (find-mastermindspage (+ 14  59) "Forth")
;; (find-mastermindspage (+ 14 459) "Index")
;; (find-mastermindstext "")



;; ~/books/__comp/kernighan_ritchie__the_C_programming_language.tar.gz
;; ~/books/__comp/oreilly__essential_actionscript_2.0.chm
;; ~/books/__comp/oreilly__managing_projects_with_gnu_make.chm
;; ~/books/__comp/professional_software_devel.chm
;; ~/books/__comp/professional_software_devel.tar.gz
;; ~/books/__comp/salus__handbook_of_programming_languages_4.tgz
;; ~/books/__comp/gui_programming_with_Qt_4.chm

;; http://gigapedia.com/items/7127/programming-pearls
;; http://gigapedia.com/items/10108/programming-pearls--2nd-edition-
;; http://gigapedia.com/items/6460/more-programming-pearls--confessions-of-a-coder
;; http://gigapedia.com/items/265594/the-anatomy-of-programming-languages


(code-xpdf      "tate7langs" "~/books/__comp/tate__seven_languages_in_seven_weeks.pdf")
(code-pdftotext "tate7langs" "~/books/__comp/tate__seven_languages_in_seven_weeks.pdf")
;; (find-tate7langspage   7 "Contents")
;; (find-tate7langspage  25 "2. Ruby")
;; (find-tate7langspage  60 "3. Io")
;; (find-tate7langspage  95 "4. Prolog")
;; (find-tate7langspage 135 "5. Scala")
;; (find-tate7langspage 181 "6. Erlang")
;; (find-tate7langspage 323 "Index")
;; (find-tate7langstext "")




;; Programming pearls 1, chap 13: "a spelling checker" - pipeline
;; (find-sh "grep gigapedia /tmp/pen/todo-persephone")
;; (find-sh "grep gigapedia /tmp/pen/notes-horses")



(code-xpdf      "pliemilner" "~/books/__comp/plotkin_stirling_tofte__proof_language_and_interaction_essays_in_honor_of_robin_milner.pdf")
(code-pdftotext "pliemilner" "~/books/__comp/plotkin_stirling_tofte__proof_language_and_interaction_essays_in_honor_of_robin_milner.pdf")
;; (find-pliemilnerpage         6  "Contents")
;; (find-pliemilnerpage (+ 15 239) "Huet" "Saibi" "Constructive Category Theory")
;; (find-pliemilnertext "")



(code-djvu       "kernighanpike" "~/books/__comp/kernighan_pike__the_unix_programming_environment.djvu")
(code-djvutotext "kernighanpike" "~/books/__comp/kernighan_pike__the_unix_programming_environment.djvu")
;; (find-kernighanpikepage      1  "Contents")
;; (find-kernighanpikepage (+ 1 1) "Index")
;; (find-kernighanpiketext "")


(code-xpdf      "steele" "~/books/__comp/steele__common_lisp_the_language.pdf")
(code-pdftotext "steele" "~/books/__comp/steele__common_lisp_the_language.pdf")
;; (find-steelepage          2  "Contents")
;; (find-steelepage (+ 25  504) "19. Structures")
;; (find-steelepage (+ 25 1064) "Index")
;; (find-steeletext "")

(code-xpdf      "seibel" "~/books/__comp/seibel__practical_common_lisp.pdf")
(code-pdftotext "seibel" "~/books/__comp/seibel__practical_common_lisp.pdf")
;; (find-seibelpage         7  "Contents at a glance")
;; (find-seibelpage         9  "Contents")
;; (find-seibelpage (+ 26 481) "Index")
;; (find-seibeltext "")

;; <icm2009>
;; (find-books "__comp/__comp.el" "icm2009")
;; https://link.springer.com/chapter/10.1007/978-3-642-02614-0_15
(code-pdf-page "icm2009" "~/books/__comp/intelligent_computer_mathematics_2009.pdf")
(code-pdf-text "icm2009" "~/books/__comp/intelligent_computer_mathematics_2009.pdf" 1)
;; (find-icm2009page)
;; (find-icm2009page        16  "Contents")
;; (find-icm2009page (+ 18 138) "Reasoning with Generic Cases" "in the Arithmetic of Abstract Matrices")
;; (find-icm2009text (+ 18 138) "Reasoning with Generic Cases" "in the Arithmetic of Abstract Matrices")
;; (find-icm2009page (+ 18 201) "Index")
;; (find-icm2009text "")

;; <almonen-sexton-sorge>
;; (find-books "__comp/__comp.el" "almonen-sexton-sorge")
;; https://sci-hub.tw/https://link.springer.com/article/10.1007/s10472-012-9299-5
(code-pdf-page "almonensextonsorge" "~/books/__comp/almomen_sexton_sorge__abstracting_symbolic_matrices.pdf")
(code-pdf-text "almonensextonsorge" "~/books/__comp/almomen_sexton_sorge__abstracting_symbolic_matrices.pdf" 1)
;; (find-almonensextonsorgepage)
;; (find-almonensextonsorgepage        1  "Contents")
;; (find-almonensextonsorgepage (+ 1 189) "Index")
;; (find-almonensextonsorgetext "")







;;
;; Local Variables:
;; mode:   emacs-lisp
;; coding: raw-text-unix
;; End: