coq-core-8.20.1-5.fc43 in Fedora 43

↵ Return to the main page of coq-core
View build
Search for updates

Package Info (Data from x86_64 build)
🠗 Changelog
🠗 Dependencies
🠗 Provides
🠗 Files

Changelog

Date	Author	Change
2025-09-19	Python Maint <python dash maint at redhat dot com> - 8.20.1-5	- Rebuilt for Python 3.14.0rc3 bytecode
2025-08-15	Python Maint <python dash maint at redhat dot com> - 8.20.1-4	- Rebuilt for Python 3.14.0rc2 bytecode
2025-07-23	Fedora Release Engineering <releng at fedoraproject dot org> - 8.20.1-3	- Rebuilt for https://fedoraproject.org/wiki/Fedora_43_Mass_Rebuild
2025-07-12	Jerry James <loganjerry at gmail dot com> - 8.20.1-2	- Rebuild to fix OCaml dependencies
2025-01-22	Jerry James <loganjerry at gmail dot com> - 8.20.1-1	- Version 8.20.1
2025-01-16	Fedora Release Engineering <releng at fedoraproject dot org> - 8.20.0-2	- Rebuilt for https://fedoraproject.org/wiki/Fedora_42_Mass_Rebuild
2025-01-09	Jerry James <loganjerry at gmail dot com> - 8.20.0-1	- OCaml 5.3.0 rebuild for Fedora 42 - Version 8.20.0
2024-07-17	Fedora Release Engineering <releng at fedoraproject dot org> - 8.18.0-10	- Rebuilt for https://fedoraproject.org/wiki/Fedora_41_Mass_Rebuild
2024-07-16	Jerry James <loganjerry at gmail dot com> - 8.18.0-9	- Rebuild for ocaml-zarith 1.14
2024-07-11	Jerry James <loganjerry at gmail dot com> - 8.18.0-8	- Rebuild for antlr4 4.13.1

Dependencies

coq = 8.20.1-5.fc43
glibc
gmp
ocaml = aa550bdab521d60e769a9ad43a677e65
ocaml-compiler-libs = ee5ea19ab996e4503ae182f530861d78
ocaml-findlib = 779950132c996b22f5dabb442c2d2697
ocaml-findlib-devel = 779950132c996b22f5dabb442c2d2697
ocaml-runtime = aa550bdab521d60e769a9ad43a677e65
ocaml-zarith = f7619514b131a39933cc9ce06f741304
ocaml-zarith-devel = f7619514b131a39933cc9ce06f741304

Provides

coq-core
coq-core(x86-64)
ocaml(Abbreviation)
ocaml(Abstract)
ocaml(AcyclicGraph)
ocaml(Arguments_renaming)
ocaml(Assumptions)
ocaml(AsyncTaskQueue)
ocaml(Attributes)
ocaml(Auto)
ocaml(Auto_ind_decl)
ocaml(Autorewrite)
ocaml(Aux_file)
ocaml(Boot)
ocaml(Boot__Env)
ocaml(Boot__Path)
ocaml(Boot__Usage)
ocaml(Boot__Util)
ocaml(Btauto_plugin)
ocaml(Btauto_plugin__G_btauto)
ocaml(Btauto_plugin__Refl_btauto)
ocaml(Btermdn)
ocaml(CArray)
ocaml(CAst)
ocaml(CClosure)
ocaml(CDebug)
ocaml(CEphemeron)
ocaml(CErrors)
ocaml(CLexer)
ocaml(CList)
ocaml(CMap)
ocaml(CObj)
ocaml(CPrimitives)
ocaml(CSet)
ocaml(CSig)
ocaml(CString)
ocaml(CThread)
ocaml(CUnix)
ocaml(CWarnings)
ocaml(Canonical)
ocaml(Cases)
ocaml(Cbn)
ocaml(Cbv)
ocaml(Cc_plugin)
ocaml(Cc_plugin__Ccalgo)
ocaml(Cc_plugin__Ccproof)
ocaml(Cc_plugin__Cctac)
ocaml(Cc_plugin__G_congruence)
ocaml(Ccompile)
ocaml(Class_tactics)
ocaml(Classes)
ocaml(Clenv)
ocaml(Coercion)
ocaml(Coercionops)
ocaml(Colors)
ocaml(ComArguments)
ocaml(ComAssumption)
ocaml(ComCoercion)
ocaml(ComDefinition)
ocaml(ComExtraDeps)
ocaml(ComFixpoint)
ocaml(ComHints)
ocaml(ComInductive)
ocaml(ComPrimitive)
ocaml(ComProgramFixpoint)
ocaml(ComRewriteRule)
ocaml(ComSearch)
ocaml(ComTactic)
ocaml(Combinators)
ocaml(Common_compile)
ocaml(Constant_typing)
ocaml(Constr)
ocaml(Constr_matching)
ocaml(Constrexpr)
ocaml(Constrexpr_ops)
ocaml(Constrextern)
ocaml(Constrintern)
ocaml(Context)
ocaml(Contradiction)
ocaml(Control)
ocaml(Conv_oracle)
ocaml(Conversion)
ocaml(Cooking)
ocaml(CoqProject_file)
ocaml(Coq_byte_config)
ocaml(Coq_checklib)
ocaml(Coq_checklib__Analyze)
ocaml(Coq_checklib__Check)
ocaml(Coq_checklib__CheckFlags)
ocaml(Coq_checklib__CheckInductive)
ocaml(Coq_checklib__CheckTypes)
ocaml(Coq_checklib__Check_stat)
ocaml(Coq_checklib__Checker)
ocaml(Coq_checklib__Mod_checking)
ocaml(Coq_checklib__Safe_checking)
ocaml(Coq_checklib__Validate)
ocaml(Coq_checklib__Values)
ocaml(Coq_config)
ocaml(Coqargs)
ocaml(Coqc)
ocaml(Coqcargs)
ocaml(Coqinit)
ocaml(Coqlib)
ocaml(Coqloadpath)
ocaml(Coqloop)
ocaml(Coqrc)
ocaml(Coqrun)
ocaml(Coqtop)
ocaml(CoqworkmgrApi)
ocaml(Core_plugins_findlib_compat)
ocaml(DAst)
ocaml(Dag)
ocaml(DebugHook)
ocaml(Debugger_support)
ocaml(Declarations)
ocaml(Declare)
ocaml(DeclareInd)
ocaml(DeclareScheme)
ocaml(DeclareUniv)
ocaml(Declaremods)
ocaml(Declareops)
ocaml(Decls)
ocaml(Deprecation)
ocaml(Derive_plugin)
ocaml(Derive_plugin__Derive)
ocaml(Derive_plugin__G_derive)
ocaml(Detyping)
ocaml(Diff2)
ocaml(Discharge)
ocaml(Dn)
ocaml(Dumpglob)
ocaml(Dyn)
ocaml(EClause)
ocaml(EConstr)
ocaml(Eauto)
ocaml(Egramcoq)
ocaml(Egramml)
ocaml(Elim)
ocaml(Elimschemes)
ocaml(Entries)
ocaml(Envars)
ocaml(Environ)
ocaml(Eqdecide)
ocaml(Eqschemes)
ocaml(Equality)
ocaml(Esubst)
ocaml(Evaluable)
ocaml(Evar)
ocaml(Evar_kinds)
ocaml(Evar_tactics)
ocaml(Evarconv)
ocaml(Evardefine)
ocaml(Evarsolve)
ocaml(Evarutil)
ocaml(Evd)
ocaml(Exninfo)
ocaml(Extend)
ocaml(Extraction_plugin)
ocaml(Extraction_plugin__Common)
ocaml(Extraction_plugin__Extract_env)
ocaml(Extraction_plugin__Extraction)
ocaml(Extraction_plugin__G_extraction)
ocaml(Extraction_plugin__Haskell)
ocaml(Extraction_plugin__Json)
ocaml(Extraction_plugin__Miniml)
ocaml(Extraction_plugin__Mlutil)
ocaml(Extraction_plugin__Modutil)
ocaml(Extraction_plugin__Ocaml)
ocaml(Extraction_plugin__Scheme)
ocaml(Extraction_plugin__Table)
ocaml(Feedback)
ocaml(Find_subterm)
ocaml(Firstorder_plugin)
ocaml(Firstorder_plugin__Formula)
ocaml(Firstorder_plugin__G_ground)
ocaml(Firstorder_plugin__Ground)
ocaml(Firstorder_plugin__Instances)
ocaml(Firstorder_plugin__Rules)
ocaml(Firstorder_plugin__Sequent)
ocaml(Firstorder_plugin__Unify)
ocaml(Flags)
ocaml(Float64)
ocaml(Float64_common)
ocaml(Ftactic)
ocaml(Funind_plugin)
ocaml(Funind_plugin__Functional_principles_proofs)
ocaml(Funind_plugin__Functional_principles_types)
ocaml(Funind_plugin__G_indfun)
ocaml(Funind_plugin__Gen_principle)
ocaml(Funind_plugin__Glob_term_to_relation)
ocaml(Funind_plugin__Glob_termops)
ocaml(Funind_plugin__Indfun)
ocaml(Funind_plugin__Indfun_common)
ocaml(Funind_plugin__Invfun)
ocaml(Funind_plugin__Recdef)
ocaml(Future)
ocaml(G_constr)
ocaml(G_prim)
ocaml(G_proofs)
ocaml(G_redexpr)
ocaml(G_toplevel)
ocaml(G_vernac)
ocaml(Genarg)
ocaml(Generalize)
ocaml(Genintern)
ocaml(Geninterp)
ocaml(Genlambda)
ocaml(Genprint)
ocaml(Genredexpr)
ocaml(Gensubst)
ocaml(GlobEnv)
ocaml(Glob_ops)
ocaml(Glob_term)
ocaml(Global)
ocaml(Globnames)
ocaml(Goal_select)
ocaml(Goptions)
ocaml(Gramlib)
ocaml(Gramlib__Gramext)
ocaml(Gramlib__Grammar)
ocaml(Gramlib__LStream)
ocaml(Gramlib__Plexing)
ocaml(Gramlib__Stream)
ocaml(HMap)
ocaml(Hashcons)
ocaml(Hashset)
ocaml(Heads)
ocaml(Heap)
ocaml(Himsg)
ocaml(Hints)
ocaml(Hipattern)
ocaml(Hook)
ocaml(IStream)
ocaml(Impargs)
ocaml(Implicit_quantifiers)
ocaml(IndTyping)
ocaml(Ind_tables)
ocaml(Indrec)
ocaml(Indschemes)
ocaml(Indtypes)
ocaml(Induction)
ocaml(Inductive)
ocaml(Inductiveops)
ocaml(InferCumulativity)
ocaml(Instr)
ocaml(Int)
ocaml(Inv)
ocaml(Keys)
ocaml(Lib)
ocaml(Libnames)
ocaml(Libobject)
ocaml(Library)
ocaml(Library_info)
ocaml(Load)
ocaml(Loadpath)
ocaml(Loc)
ocaml(Locality)
ocaml(Locus)
ocaml(Locusops)
ocaml(Logic)
ocaml(Logic_monad)
ocaml(Ltac2_ltac1_plugin)
ocaml(Ltac2_ltac1_plugin__G_ltac2_ltac1)
ocaml(Ltac2_ltac1_plugin__Tac2core_ltac1)
ocaml(Ltac2_ltac1_plugin__Tac2quote_ltac1)
ocaml(Ltac2_ltac1_plugin__Tac2stdlib_ltac1)
ocaml(Ltac2_plugin)
ocaml(Ltac2_plugin__G_ltac2)
ocaml(Ltac2_plugin__Tac2bt)
ocaml(Ltac2_plugin__Tac2core)
ocaml(Ltac2_plugin__Tac2dyn)
ocaml(Ltac2_plugin__Tac2entries)
ocaml(Ltac2_plugin__Tac2env)
ocaml(Ltac2_plugin__Tac2expr)
ocaml(Ltac2_plugin__Tac2externals)
ocaml(Ltac2_plugin__Tac2extffi)
ocaml(Ltac2_plugin__Tac2ffi)
ocaml(Ltac2_plugin__Tac2intern)
ocaml(Ltac2_plugin__Tac2interp)
ocaml(Ltac2_plugin__Tac2match)
ocaml(Ltac2_plugin__Tac2print)
ocaml(Ltac2_plugin__Tac2qexpr)
ocaml(Ltac2_plugin__Tac2quote)
ocaml(Ltac2_plugin__Tac2stdlib)
ocaml(Ltac2_plugin__Tac2tactics)
ocaml(Ltac2_plugin__Tac2types)
ocaml(Ltac2_plugin__Tac2typing_env)
ocaml(Ltac2_plugin__Tac2val)
ocaml(Ltac_plugin)
ocaml(Ltac_plugin__ComRewrite)
ocaml(Ltac_plugin__Coretactics)
ocaml(Ltac_plugin__Extraargs)
ocaml(Ltac_plugin__Extratactics)
ocaml(Ltac_plugin__G_auto)
ocaml(Ltac_plugin__G_class)
ocaml(Ltac_plugin__G_eqdecide)
ocaml(Ltac_plugin__G_ltac)
ocaml(Ltac_plugin__G_obligations)
ocaml(Ltac_plugin__G_rewrite)
ocaml(Ltac_plugin__G_tactic)
ocaml(Ltac_plugin__Internals)
ocaml(Ltac_plugin__Leminv)
ocaml(Ltac_plugin__Pltac)
ocaml(Ltac_plugin__Pptactic)
ocaml(Ltac_plugin__Profile_ltac_tactics)
ocaml(Ltac_plugin__Tacarg)
ocaml(Ltac_plugin__Taccoerce)
ocaml(Ltac_plugin__Tacentries)
ocaml(Ltac_plugin__Tacenv)
ocaml(Ltac_plugin__Tacexpr)
ocaml(Ltac_plugin__Tacintern)
ocaml(Ltac_plugin__Tacinterp)
ocaml(Ltac_plugin__Tacsubst)
ocaml(Ltac_plugin__Tactic_debug)
ocaml(Ltac_plugin__Tactic_matching)
ocaml(Ltac_plugin__Tactic_option)
ocaml(Ltac_pretype)
ocaml(Memprof_coq)
ocaml(Memtrace_init)
ocaml(Metasyntax)
ocaml(Micromega_core_plugin)
ocaml(Micromega_core_plugin__Micromega)
ocaml(Micromega_core_plugin__Mutils)
ocaml(Micromega_core_plugin__NumCompat)
ocaml(Micromega_core_plugin__Sos)
ocaml(Micromega_core_plugin__Sos_lib)
ocaml(Micromega_core_plugin__Sos_types)
ocaml(Micromega_plugin)
ocaml(Micromega_plugin__Certificate)
ocaml(Micromega_plugin__Coq_micromega)
ocaml(Micromega_plugin__G_micromega)
ocaml(Micromega_plugin__Itv)
ocaml(Micromega_plugin__Linsolve)
ocaml(Micromega_plugin__Persistent_cache)
ocaml(Micromega_plugin__Polynomial)
ocaml(Micromega_plugin__Simplex)
ocaml(Micromega_plugin__Vect)
ocaml(Miscprint)
ocaml(Mltop)
ocaml(Mod_subst)
ocaml(Mod_typing)
ocaml(Modintern)
ocaml(Modops)
ocaml(Monad)
ocaml(Mutex_aux)
ocaml(Namegen)
ocaml(Nameops)
ocaml(Names)
ocaml(Nametab)
ocaml(Nativecode)
ocaml(Nativeconv)
ocaml(Nativelambda)
ocaml(Nativelib)
ocaml(Nativelibrary)
ocaml(Nativenorm)
ocaml(Nativevalues)
ocaml(NeList)
ocaml(NewProfile)
ocaml(Notation)
ocaml(Notation_gram)
ocaml(Notation_ops)
ocaml(Notation_term)
ocaml(Notationextern)
ocaml(Notgram_ops)
ocaml(Nsatz_plugin)
ocaml(Nsatz_plugin__G_nsatz)
ocaml(Nsatz_plugin__Ideal)
ocaml(Nsatz_plugin__Nsatz)
ocaml(Nsatz_plugin__Polynom)
ocaml(Nsatz_plugin__Utile)
ocaml(NumTok)
ocaml(Number_string_notation_plugin)
ocaml(Number_string_notation_plugin__G_number_string)
ocaml(Number_string_notation_plugin__Number_string)
ocaml(ObjFile)
ocaml(Opaqueproof)
ocaml(Opaques)
ocaml(Option)
ocaml(OrderedType)
ocaml(Parray)
ocaml(Partac)
ocaml(Partial_subst)
ocaml(Pattern)
ocaml(Patternops)
ocaml(Pcoq)
ocaml(Perf)
ocaml(PolyMap)
ocaml(Pp)
ocaml(Pp_diff)
ocaml(Ppconstr)
ocaml(Ppextend)
ocaml(Ppred)
ocaml(Pputils)
ocaml(Ppvernac)
ocaml(Predicate)
ocaml(Prettyp)
ocaml(Pretype_errors)
ocaml(Pretyping)
ocaml(Primred)
ocaml(Printer)
ocaml(Printmod)
ocaml(Profile_tactic)
ocaml(Program)
ocaml(Proof)
ocaml(ProofBlockDelimiter)
ocaml(Proof_bullet)
ocaml(Proof_diffs)
ocaml(Proof_using)
ocaml(Proofview)
ocaml(Proofview_monad)
ocaml(Pstring)
ocaml(Pvernac)
ocaml(Range)
ocaml(RecLemmas)
ocaml(Record)
ocaml(RedFlags)
ocaml(Redexpr)
ocaml(Redops)
ocaml(Reduction)
ocaml(Reductionops)
ocaml(Refine)
ocaml(Relevanceops)
ocaml(Reserve)
ocaml(RetrieveObl)
ocaml(Retroknowledge)
ocaml(Retyping)
ocaml(Rewrite)
ocaml(Ring_plugin)
ocaml(Ring_plugin__G_ring)
ocaml(Ring_plugin__Ring)
ocaml(Ring_plugin__Ring_ast)
ocaml(Rtauto_plugin)
ocaml(Rtauto_plugin__G_rtauto)
ocaml(Rtauto_plugin__Proof_search)
ocaml(Rtauto_plugin__Refl_tauto)
ocaml(Rtree)
ocaml(SList)
ocaml(Safe_typing)
ocaml(Search)
ocaml(Section)
ocaml(Segmenttree)
ocaml(Smartlocate)
ocaml(Sorts)
ocaml(Spawn)
ocaml(Spawned)
ocaml(Ssreflect_plugin)
ocaml(Ssreflect_plugin__Ssrast)
ocaml(Ssreflect_plugin__Ssrbwd)
ocaml(Ssreflect_plugin__Ssrcommon)
ocaml(Ssreflect_plugin__Ssrelim)
ocaml(Ssreflect_plugin__Ssrequality)
ocaml(Ssreflect_plugin__Ssrfwd)
ocaml(Ssreflect_plugin__Ssripats)
ocaml(Ssreflect_plugin__Ssrparser)
ocaml(Ssreflect_plugin__Ssrprinters)
ocaml(Ssreflect_plugin__Ssrtacs)
ocaml(Ssreflect_plugin__Ssrtacticals)
ocaml(Ssreflect_plugin__Ssrvernac)
ocaml(Ssreflect_plugin__Ssrview)
ocaml(Ssrmatching_plugin)
ocaml(Ssrmatching_plugin__G_ssrmatching)
ocaml(Ssrmatching_plugin__Ssrmatching)
ocaml(Stateid)
ocaml(Stdarg)
ocaml(Stm)
ocaml(Stmargs)
ocaml(Store)
ocaml(Structures)
ocaml(Subtyping)
ocaml(Summary)
ocaml(Synterp)
ocaml(System)
ocaml(TQueue)
ocaml(Tacmach)
ocaml(Tacred)
ocaml(Tacticals)
ocaml(Tactics)
ocaml(Tactypes)
ocaml(Tauto_plugin)
ocaml(Tauto_plugin__Tauto)
ocaml(Term)
ocaml(Terminal)
ocaml(Termops)
ocaml(Tok)
ocaml(Top_printers)
ocaml(Topfmt)
ocaml(TransparentState)
ocaml(Trie)
ocaml(Tuto0_plugin)
ocaml(Tuto0_plugin__G_tuto0)
ocaml(Tuto0_plugin__Tuto0_main)
ocaml(Tuto1_plugin)
ocaml(Tuto1_plugin__G_tuto1)
ocaml(Tuto1_plugin__Inspector)
ocaml(Tuto1_plugin__Simple_check)
ocaml(Tuto1_plugin__Simple_declare)
ocaml(Tuto1_plugin__Simple_print)
ocaml(Tuto2_plugin)
ocaml(Tuto2_plugin__Counter)
ocaml(Tuto2_plugin__Custom)
ocaml(Tuto2_plugin__G_tuto2)
ocaml(Tuto2_plugin__Persistent_counter)
ocaml(Tuto3_plugin)
ocaml(Tuto3_plugin__Construction_game)
ocaml(Tuto3_plugin__G_tuto3)
ocaml(Tuto3_plugin__Tuto_tactic)
ocaml(Type_errors)
ocaml(Typeclasses)
ocaml(Typeclasses_errors)
ocaml(Typeops)
ocaml(Typing)
ocaml(UGraph)
ocaml(UState)
ocaml(UVars)
ocaml(Uint63)
ocaml(Unicode)
ocaml(Unicodetable)
ocaml(Unification)
ocaml(Unionfind)
ocaml(Univ)
ocaml(UnivFlex)
ocaml(UnivGen)
ocaml(UnivMinim)
ocaml(UnivNames)
ocaml(UnivProblem)
ocaml(UnivSubst)
ocaml(UserWarn)
ocaml(Util)
ocaml(Values)
ocaml(Vars)
ocaml(Vconv)
ocaml(Vcs)
ocaml(Vernac)
ocaml(Vernac_classifier)
ocaml(Vernacentries)
ocaml(Vernacexpr)
ocaml(Vernacextend)
ocaml(Vernacinterp)
ocaml(Vernacoptions)
ocaml(Vernacprop)
ocaml(Vernacstate)
ocaml(Vernactypes)
ocaml(Vm)
ocaml(Vm_printers)
ocaml(Vmbytecodes)
ocaml(Vmbytegen)
ocaml(Vmemitcodes)
ocaml(Vmerrors)
ocaml(Vmlambda)
ocaml(Vmlibrary)
ocaml(Vmopcodes)
ocaml(Vmsymtable)
ocaml(Vmvalues)
ocaml(Vnorm)
ocaml(WorkerLoop)
ocaml(WorkerPool)
ocaml(Xml_datatype)
ocaml(Zify_plugin)
ocaml(Zify_plugin__G_zify)
ocaml(Zify_plugin__Zify)
ocamlx(Abbreviation)
ocamlx(Abstract)
ocamlx(AcyclicGraph)
ocamlx(Arguments_renaming)
ocamlx(Assumptions)
ocamlx(AsyncTaskQueue)
ocamlx(Attributes)
ocamlx(Auto)
ocamlx(Auto_ind_decl)
ocamlx(Autorewrite)
ocamlx(Aux_file)
ocamlx(Boot)
ocamlx(Boot__Env)
ocamlx(Boot__Path)
ocamlx(Boot__Usage)
ocamlx(Boot__Util)
ocamlx(Btauto_plugin)
ocamlx(Btauto_plugin__G_btauto)
ocamlx(Btauto_plugin__Refl_btauto)
ocamlx(Btermdn)
ocamlx(CArray)
ocamlx(CAst)
ocamlx(CClosure)
ocamlx(CDebug)
ocamlx(CEphemeron)
ocamlx(CErrors)
ocamlx(CLexer)
ocamlx(CList)
ocamlx(CMap)
ocamlx(CObj)
ocamlx(CPrimitives)
ocamlx(CSet)
ocamlx(CString)
ocamlx(CThread)
ocamlx(CUnix)
ocamlx(CWarnings)
ocamlx(Canonical)
ocamlx(Cases)
ocamlx(Cbn)
ocamlx(Cbv)
ocamlx(Cc_plugin)
ocamlx(Cc_plugin__Ccalgo)
ocamlx(Cc_plugin__Ccproof)
ocamlx(Cc_plugin__Cctac)
ocamlx(Cc_plugin__G_congruence)
ocamlx(Ccompile)
ocamlx(Class_tactics)
ocamlx(Classes)
ocamlx(Clenv)
ocamlx(Coercion)
ocamlx(Coercionops)
ocamlx(Colors)
ocamlx(ComArguments)
ocamlx(ComAssumption)
ocamlx(ComCoercion)
ocamlx(ComDefinition)
ocamlx(ComExtraDeps)
ocamlx(ComFixpoint)
ocamlx(ComHints)
ocamlx(ComInductive)
ocamlx(ComPrimitive)
ocamlx(ComProgramFixpoint)
ocamlx(ComRewriteRule)
ocamlx(ComSearch)
ocamlx(ComTactic)
ocamlx(Combinators)
ocamlx(Common_compile)
ocamlx(Constant_typing)
ocamlx(Constr)
ocamlx(Constr_matching)
ocamlx(Constrexpr_ops)
ocamlx(Constrextern)
ocamlx(Constrintern)
ocamlx(Context)
ocamlx(Contradiction)
ocamlx(Control)
ocamlx(Conv_oracle)
ocamlx(Conversion)
ocamlx(Cooking)
ocamlx(CoqProject_file)
ocamlx(Coq_checklib)
ocamlx(Coq_checklib__Analyze)
ocamlx(Coq_checklib__Check)
ocamlx(Coq_checklib__CheckFlags)
ocamlx(Coq_checklib__CheckInductive)
ocamlx(Coq_checklib__CheckTypes)
ocamlx(Coq_checklib__Check_stat)
ocamlx(Coq_checklib__Checker)
ocamlx(Coq_checklib__Mod_checking)
ocamlx(Coq_checklib__Safe_checking)
ocamlx(Coq_checklib__Validate)
ocamlx(Coq_checklib__Values)
ocamlx(Coq_config)
ocamlx(Coqargs)
ocamlx(Coqc)
ocamlx(Coqcargs)
ocamlx(Coqinit)
ocamlx(Coqlib)
ocamlx(Coqloadpath)
ocamlx(Coqloop)
ocamlx(Coqrc)
ocamlx(Coqrun)
ocamlx(Coqtop)
ocamlx(CoqworkmgrApi)
ocamlx(Core_plugins_findlib_compat)
ocamlx(DAst)
ocamlx(Dag)
ocamlx(DebugHook)
ocamlx(Debugger_support)
ocamlx(Declare)
ocamlx(DeclareInd)
ocamlx(DeclareScheme)
ocamlx(DeclareUniv)
ocamlx(Declaremods)
ocamlx(Declareops)
ocamlx(Decls)
ocamlx(Deprecation)
ocamlx(Derive_plugin)
ocamlx(Derive_plugin__Derive)
ocamlx(Derive_plugin__G_derive)
ocamlx(Detyping)
ocamlx(Diff2)
ocamlx(Discharge)
ocamlx(Dn)
ocamlx(Dumpglob)
ocamlx(Dyn)
ocamlx(EClause)
ocamlx(EConstr)
ocamlx(Eauto)
ocamlx(Egramcoq)
ocamlx(Egramml)
ocamlx(Elim)
ocamlx(Elimschemes)
ocamlx(Envars)
ocamlx(Environ)
ocamlx(Eqdecide)
ocamlx(Eqschemes)
ocamlx(Equality)
ocamlx(Esubst)
ocamlx(Evaluable)
ocamlx(Evar)
ocamlx(Evar_kinds)
ocamlx(Evar_tactics)
ocamlx(Evarconv)
ocamlx(Evardefine)
ocamlx(Evarsolve)
ocamlx(Evarutil)
ocamlx(Evd)
ocamlx(Exninfo)
ocamlx(Extend)
ocamlx(Extraction_plugin)
ocamlx(Extraction_plugin__Common)
ocamlx(Extraction_plugin__Extract_env)
ocamlx(Extraction_plugin__Extraction)
ocamlx(Extraction_plugin__G_extraction)
ocamlx(Extraction_plugin__Haskell)
ocamlx(Extraction_plugin__Json)
ocamlx(Extraction_plugin__Miniml)
ocamlx(Extraction_plugin__Mlutil)
ocamlx(Extraction_plugin__Modutil)
ocamlx(Extraction_plugin__Ocaml)
ocamlx(Extraction_plugin__Scheme)
ocamlx(Extraction_plugin__Table)
ocamlx(Feedback)
ocamlx(Find_subterm)
ocamlx(Firstorder_plugin)
ocamlx(Firstorder_plugin__Formula)
ocamlx(Firstorder_plugin__G_ground)
ocamlx(Firstorder_plugin__Ground)
ocamlx(Firstorder_plugin__Instances)
ocamlx(Firstorder_plugin__Rules)
ocamlx(Firstorder_plugin__Sequent)
ocamlx(Firstorder_plugin__Unify)
ocamlx(Flags)
ocamlx(Float64)
ocamlx(Float64_common)
ocamlx(Ftactic)
ocamlx(Funind_plugin)
ocamlx(Funind_plugin__Functional_principles_proofs)
ocamlx(Funind_plugin__Functional_principles_types)
ocamlx(Funind_plugin__G_indfun)
ocamlx(Funind_plugin__Gen_principle)
ocamlx(Funind_plugin__Glob_term_to_relation)
ocamlx(Funind_plugin__Glob_termops)
ocamlx(Funind_plugin__Indfun)
ocamlx(Funind_plugin__Indfun_common)
ocamlx(Funind_plugin__Invfun)
ocamlx(Funind_plugin__Recdef)
ocamlx(Future)
ocamlx(G_constr)
ocamlx(G_prim)
ocamlx(G_proofs)
ocamlx(G_redexpr)
ocamlx(G_toplevel)
ocamlx(G_vernac)
ocamlx(Genarg)
ocamlx(Generalize)
ocamlx(Genintern)
ocamlx(Geninterp)
ocamlx(Genlambda)
ocamlx(Genprint)
ocamlx(Gensubst)
ocamlx(GlobEnv)
ocamlx(Glob_ops)
ocamlx(Global)
ocamlx(Globnames)
ocamlx(Goal_select)
ocamlx(Goptions)
ocamlx(Gramlib)
ocamlx(Gramlib__Gramext)
ocamlx(Gramlib__Grammar)
ocamlx(Gramlib__LStream)
ocamlx(Gramlib__Stream)
ocamlx(HMap)
ocamlx(Hashcons)
ocamlx(Hashset)
ocamlx(Heads)
ocamlx(Heap)
ocamlx(Himsg)
ocamlx(Hints)
ocamlx(Hipattern)
ocamlx(Hook)
ocamlx(IStream)
ocamlx(Impargs)
ocamlx(Implicit_quantifiers)
ocamlx(IndTyping)
ocamlx(Ind_tables)
ocamlx(Indrec)
ocamlx(Indschemes)
ocamlx(Indtypes)
ocamlx(Induction)
ocamlx(Inductive)
ocamlx(Inductiveops)
ocamlx(InferCumulativity)
ocamlx(Instr)
ocamlx(Int)
ocamlx(Inv)
ocamlx(Keys)
ocamlx(Lib)
ocamlx(Libnames)
ocamlx(Libobject)
ocamlx(Library)
ocamlx(Library_info)
ocamlx(Load)
ocamlx(Loadpath)
ocamlx(Loc)
ocamlx(Locality)
ocamlx(Locusops)
ocamlx(Logic)
ocamlx(Logic_monad)
ocamlx(Ltac2_ltac1_plugin)
ocamlx(Ltac2_ltac1_plugin__G_ltac2_ltac1)
ocamlx(Ltac2_ltac1_plugin__Tac2core_ltac1)
ocamlx(Ltac2_ltac1_plugin__Tac2quote_ltac1)
ocamlx(Ltac2_ltac1_plugin__Tac2stdlib_ltac1)
ocamlx(Ltac2_plugin)
ocamlx(Ltac2_plugin__G_ltac2)
ocamlx(Ltac2_plugin__Tac2bt)
ocamlx(Ltac2_plugin__Tac2core)
ocamlx(Ltac2_plugin__Tac2dyn)
ocamlx(Ltac2_plugin__Tac2entries)
ocamlx(Ltac2_plugin__Tac2env)
ocamlx(Ltac2_plugin__Tac2externals)
ocamlx(Ltac2_plugin__Tac2extffi)
ocamlx(Ltac2_plugin__Tac2ffi)
ocamlx(Ltac2_plugin__Tac2intern)
ocamlx(Ltac2_plugin__Tac2interp)
ocamlx(Ltac2_plugin__Tac2match)
ocamlx(Ltac2_plugin__Tac2print)
ocamlx(Ltac2_plugin__Tac2quote)
ocamlx(Ltac2_plugin__Tac2stdlib)
ocamlx(Ltac2_plugin__Tac2tactics)
ocamlx(Ltac2_plugin__Tac2typing_env)
ocamlx(Ltac2_plugin__Tac2val)
ocamlx(Ltac_plugin)
ocamlx(Ltac_plugin__ComRewrite)
ocamlx(Ltac_plugin__Coretactics)
ocamlx(Ltac_plugin__Extraargs)
ocamlx(Ltac_plugin__Extratactics)
ocamlx(Ltac_plugin__G_auto)
ocamlx(Ltac_plugin__G_class)
ocamlx(Ltac_plugin__G_eqdecide)
ocamlx(Ltac_plugin__G_ltac)
ocamlx(Ltac_plugin__G_obligations)
ocamlx(Ltac_plugin__G_rewrite)
ocamlx(Ltac_plugin__G_tactic)
ocamlx(Ltac_plugin__Internals)
ocamlx(Ltac_plugin__Leminv)
ocamlx(Ltac_plugin__Pltac)
ocamlx(Ltac_plugin__Pptactic)
ocamlx(Ltac_plugin__Profile_ltac_tactics)
ocamlx(Ltac_plugin__Tacarg)
ocamlx(Ltac_plugin__Taccoerce)
ocamlx(Ltac_plugin__Tacentries)
ocamlx(Ltac_plugin__Tacenv)
ocamlx(Ltac_plugin__Tacintern)
ocamlx(Ltac_plugin__Tacinterp)
ocamlx(Ltac_plugin__Tacsubst)
ocamlx(Ltac_plugin__Tactic_debug)
ocamlx(Ltac_plugin__Tactic_matching)
ocamlx(Ltac_plugin__Tactic_option)
ocamlx(Memprof_coq)
ocamlx(Memtrace_init)
ocamlx(Metasyntax)
ocamlx(Micromega_core_plugin)
ocamlx(Micromega_core_plugin__Micromega)
ocamlx(Micromega_core_plugin__Mutils)
ocamlx(Micromega_core_plugin__NumCompat)
ocamlx(Micromega_core_plugin__Sos)
ocamlx(Micromega_core_plugin__Sos_lib)
ocamlx(Micromega_core_plugin__Sos_types)
ocamlx(Micromega_plugin)
ocamlx(Micromega_plugin__Certificate)
ocamlx(Micromega_plugin__Coq_micromega)
ocamlx(Micromega_plugin__G_micromega)
ocamlx(Micromega_plugin__Itv)
ocamlx(Micromega_plugin__Linsolve)
ocamlx(Micromega_plugin__Persistent_cache)
ocamlx(Micromega_plugin__Polynomial)
ocamlx(Micromega_plugin__Simplex)
ocamlx(Micromega_plugin__Vect)
ocamlx(Miscprint)
ocamlx(Mltop)
ocamlx(Mod_subst)
ocamlx(Mod_typing)
ocamlx(Modintern)
ocamlx(Modops)
ocamlx(Monad)
ocamlx(Mutex_aux)
ocamlx(Namegen)
ocamlx(Nameops)
ocamlx(Names)
ocamlx(Nametab)
ocamlx(Nativecode)
ocamlx(Nativeconv)
ocamlx(Nativelambda)
ocamlx(Nativelib)
ocamlx(Nativelibrary)
ocamlx(Nativenorm)
ocamlx(Nativevalues)
ocamlx(NeList)
ocamlx(NewProfile)
ocamlx(Notation)
ocamlx(Notation_ops)
ocamlx(Notationextern)
ocamlx(Notgram_ops)
ocamlx(Nsatz_plugin)
ocamlx(Nsatz_plugin__G_nsatz)
ocamlx(Nsatz_plugin__Ideal)
ocamlx(Nsatz_plugin__Nsatz)
ocamlx(Nsatz_plugin__Polynom)
ocamlx(Nsatz_plugin__Utile)
ocamlx(NumTok)
ocamlx(Number_string_notation_plugin)
ocamlx(Number_string_notation_plugin__G_number_string)
ocamlx(Number_string_notation_plugin__Number_string)
ocamlx(ObjFile)
ocamlx(Opaqueproof)
ocamlx(Opaques)
ocamlx(Option)
ocamlx(OrderedType)
ocamlx(Parray)
ocamlx(Partac)
ocamlx(Partial_subst)
ocamlx(Patternops)
ocamlx(Pcoq)
ocamlx(Perf)
ocamlx(PolyMap)
ocamlx(Pp)
ocamlx(Pp_diff)
ocamlx(Ppconstr)
ocamlx(Ppextend)
ocamlx(Ppred)
ocamlx(Pputils)
ocamlx(Ppvernac)
ocamlx(Predicate)
ocamlx(Prettyp)
ocamlx(Pretype_errors)
ocamlx(Pretyping)
ocamlx(Primred)
ocamlx(Printer)
ocamlx(Printmod)
ocamlx(Profile_tactic)
ocamlx(Program)
ocamlx(Proof)
ocamlx(ProofBlockDelimiter)
ocamlx(Proof_bullet)
ocamlx(Proof_diffs)
ocamlx(Proof_using)
ocamlx(Proofview)
ocamlx(Proofview_monad)
ocamlx(Pstring)
ocamlx(Pvernac)
ocamlx(Range)
ocamlx(RecLemmas)
ocamlx(Record)
ocamlx(RedFlags)
ocamlx(Redexpr)
ocamlx(Redops)
ocamlx(Reduction)
ocamlx(Reductionops)
ocamlx(Refine)
ocamlx(Relevanceops)
ocamlx(Reserve)
ocamlx(RetrieveObl)
ocamlx(Retroknowledge)
ocamlx(Retyping)
ocamlx(Rewrite)
ocamlx(Ring_plugin)
ocamlx(Ring_plugin__G_ring)
ocamlx(Ring_plugin__Ring)
ocamlx(Ring_plugin__Ring_ast)
ocamlx(Rtauto_plugin)
ocamlx(Rtauto_plugin__G_rtauto)
ocamlx(Rtauto_plugin__Proof_search)
ocamlx(Rtauto_plugin__Refl_tauto)
ocamlx(Rtree)
ocamlx(SList)
ocamlx(Safe_typing)
ocamlx(Search)
ocamlx(Section)
ocamlx(Segmenttree)
ocamlx(Smartlocate)
ocamlx(Sorts)
ocamlx(Spawn)
ocamlx(Spawned)
ocamlx(Ssreflect_plugin)
ocamlx(Ssreflect_plugin__Ssrbwd)
ocamlx(Ssreflect_plugin__Ssrcommon)
ocamlx(Ssreflect_plugin__Ssrelim)
ocamlx(Ssreflect_plugin__Ssrequality)
ocamlx(Ssreflect_plugin__Ssrfwd)
ocamlx(Ssreflect_plugin__Ssripats)
ocamlx(Ssreflect_plugin__Ssrparser)
ocamlx(Ssreflect_plugin__Ssrprinters)
ocamlx(Ssreflect_plugin__Ssrtacs)
ocamlx(Ssreflect_plugin__Ssrtacticals)
ocamlx(Ssreflect_plugin__Ssrvernac)
ocamlx(Ssreflect_plugin__Ssrview)
ocamlx(Ssrmatching_plugin)
ocamlx(Ssrmatching_plugin__G_ssrmatching)
ocamlx(Ssrmatching_plugin__Ssrmatching)
ocamlx(Stateid)
ocamlx(Stdarg)
ocamlx(Stm)
ocamlx(Stmargs)
ocamlx(Store)
ocamlx(Structures)
ocamlx(Subtyping)
ocamlx(Summary)
ocamlx(Synterp)
ocamlx(System)
ocamlx(TQueue)
ocamlx(Tacmach)
ocamlx(Tacred)
ocamlx(Tacticals)
ocamlx(Tactics)
ocamlx(Tauto_plugin)
ocamlx(Tauto_plugin__Tauto)
ocamlx(Term)
ocamlx(Terminal)
ocamlx(Termops)
ocamlx(Tok)
ocamlx(Top_printers)
ocamlx(Topfmt)
ocamlx(TransparentState)
ocamlx(Trie)
ocamlx(Tuto0_plugin)
ocamlx(Tuto0_plugin__G_tuto0)
ocamlx(Tuto0_plugin__Tuto0_main)
ocamlx(Tuto1_plugin)
ocamlx(Tuto1_plugin__G_tuto1)
ocamlx(Tuto1_plugin__Inspector)
ocamlx(Tuto1_plugin__Simple_check)
ocamlx(Tuto1_plugin__Simple_declare)
ocamlx(Tuto1_plugin__Simple_print)
ocamlx(Tuto2_plugin)
ocamlx(Tuto2_plugin__Counter)
ocamlx(Tuto2_plugin__Custom)
ocamlx(Tuto2_plugin__G_tuto2)
ocamlx(Tuto2_plugin__Persistent_counter)
ocamlx(Tuto3_plugin)
ocamlx(Tuto3_plugin__Construction_game)
ocamlx(Tuto3_plugin__G_tuto3)
ocamlx(Tuto3_plugin__Tuto_tactic)
ocamlx(Type_errors)
ocamlx(Typeclasses)
ocamlx(Typeclasses_errors)
ocamlx(Typeops)
ocamlx(Typing)
ocamlx(UGraph)
ocamlx(UState)
ocamlx(UVars)
ocamlx(Uint63)
ocamlx(Unicode)
ocamlx(Unicodetable)
ocamlx(Unification)
ocamlx(Unionfind)
ocamlx(Univ)
ocamlx(UnivFlex)
ocamlx(UnivGen)
ocamlx(UnivMinim)
ocamlx(UnivNames)
ocamlx(UnivProblem)
ocamlx(UnivSubst)
ocamlx(UserWarn)
ocamlx(Util)
ocamlx(Vars)
ocamlx(Vconv)
ocamlx(Vcs)
ocamlx(Vernac)
ocamlx(Vernac_classifier)
ocamlx(Vernacentries)
ocamlx(Vernacextend)
ocamlx(Vernacinterp)
ocamlx(Vernacoptions)
ocamlx(Vernacprop)
ocamlx(Vernacstate)
ocamlx(Vernactypes)
ocamlx(Vm)
ocamlx(Vm_printers)
ocamlx(Vmbytecodes)
ocamlx(Vmbytegen)
ocamlx(Vmemitcodes)
ocamlx(Vmerrors)
ocamlx(Vmlambda)
ocamlx(Vmlibrary)
ocamlx(Vmopcodes)
ocamlx(Vmsymtable)
ocamlx(Vmvalues)
ocamlx(Vnorm)
ocamlx(WorkerLoop)
ocamlx(WorkerPool)
ocamlx(Zify_plugin)
ocamlx(Zify_plugin__G_zify)
ocamlx(Zify_plugin__Zify)

Files

usr/
- bin/
  - coq-tex
  - coq_makefile
  - coqc
  - coqc.byte
  - coqchk
  - coqdep
  - coqdoc
  - coqnative
  - coqpp
  - coqtimelog2html
  - coqtop
  - coqtop.byte
  - coqwc
  - coqworker.opt
  - coqworkmgr
  - csdpcert
  - ocamllibdep
  - votour
- lib/
  - .build-id/
    - 02/
      - 4fce2f91e8359f3bb84ca0d6edc1cf8a34f347
      - 6e69d94bffc1222989de58bfdf328ef3a1e564
    - 04/
      - 782c53c1b2a83c57df97462e5bb69284627ac6
    - 0b/
      - fda2437ee3a7d3dcab487e79e7d3e2eb35913b
    - 0d/
      - 41f762b222818c127561a30724a3c309e37c1d
    - 10/
      - 4c79e31b659014cf47b311ef776be0a5e2166a
    - 11/
      - d7487f243ff65a448a0bae07843c6d02df6fe3
    - 12/
      - cdec8e8d97fa42a5dfab69093a4272c5eddfd1
    - 18/
      - 048ef40295460449dca3cb2ec2482383f220de
      - 127d77455447c865fcabbe0c079c3dac3c42aa
    - 24/
      - 11420bae225d7a64966fea869883693644c43b
    - 26/
      - 6c021a354614889af792d8065b6f92f74af1ba
    - 28/
      - e277118da2cfd6fa4bdbdb3563d83dc2d87381
    - 2d/
      - 79241f181e9a1d0b7a02a01e2d4590469d57b0
    - 32/
      - fb99ecefb45aeb1092460e3fefbd6de2ff6a37
    - 39/
      - 065ca23dc76b9fcf54bf17b1b464b940445101
    - 3a/
      - b45795294e134ce06f5a7805937f280a9ed4b3
    - 3e/
      - 6a63544218def950d7a38ca657f7e55640e361
    - 5d/
      - 828d87debf7a16ae5977b53e8dc8f8db37f08b
    - 70/
      - a723124438d3d31c2cd11b3d521af5d160641f
    - 75/
      - 47d863c3e26d9531546017c1bafbb3d3f59db3
    - 77/
      - 99015ce81f1f7e724c724b196c6f8bccaa0dbd
    - 79/
      - 00b91f0cf9b72d8f0f1c6f045967c2c727ae04
      - 899aa715b5538f7c2202c932d256b231e97945
    - 87/
      - a539ac53f365c84a5d9f10ec79fcac917ca5e1
    - 91/
      - 04fa9a492ceb59a915f8080281dd3a96ff4379
    - 96/
      - 2bfcdc7e8f6e6fcee0adb05e14fbd67cd1ecf0
    - 98/
      - 32f0b02d4681037880bc98854f6c6953a00fd4
    - 9d/
      - 7594552ce1e81acdf608180deaa521f29518e8
    - a0/
      - a985b52d739faa34a86a74f0da6ccde6f836b6
      - d52f7727613a932dfb0340f639dc475140336b
    - a5/
      - 05483e0a55275a7ece740ecdc0360dd5cf5004
    - a6/
      - c8c9229dbfc68451f7b55c163701cd7e8753f7
    - a8/
      - 0cc9b9b2af6059369c0fa54e4ebef80eaf36bf
      - ee0124b9b50c17b48ec8945d35be75bcef2971
    - ac/
      - 0b1142f61a7b7d22e9aa88fc579411a8e10fea
    - ae/
      - 0b909742f55ed288542c19c9349039dd6a8efc
    - af/
      - 68f4524e7f0b586b8033db273a4f2f77d84a59
    - ba/
      - 734b18d0f847571cef969fea54ea5047948fce
    - bc/
      - 2dda5cf4eb773d06f184c78023953733d12f7b
    - bf/
      - 1e4a1062366db72be697dcc0d40d6492d98634
    - c3/
      - 4b97e2f40bac7d46d656c23b028824a685be4a
      - e152525b38754095546f98a53b437d4a155964
    - c8/
      - c15c9cea078e5955b989ecba3de4c7508b888d
    - cc/
      - cda9736370702bbcdcdc0147c0e9263cd7096e
    - ce/
      - 0eb8fbf357e9fc5d4e36b7bb4742039cf3fc4a
    - cf/
      - 812fc83abc5503585ae82985a2dc4e1194dcc6
    - d0/
      - 77b5903be38b3f5c15b280eb6912f58cd5ba67
    - d6/
      - e465970a947585d35216dc85a80b9a7a0107ce
    - d8/
      - 0a30c20f09b750e1a0ff3722ce4a4c22e175d5
    - d9/
      - b883d09992ca88dc4605a4d14c9e896fc2eceb
    - dd/
      - f59d6415a8d5e515b078adbae42cd1c4a8a704
    - e3/
      - 368c9315bdf90de944d762a511bffaa0c76fcc
    - e4/
      - 90dbd9d1c88787696d0ee1bd953c95268bbf07
    - e5/
      - ccd92ffe8b9d5a3037a8fe9a8b783b2a587f8f
    - eb/
      - 52764f42be46be02863211517f09fb3fb5babc
      - a8551c894e8084e15522436032c1dd553468c4
    - ee/
      - 081383130b7a42d68a5b3e88ed9ae4acb69f0e
    - ef/
      - 3dd5dd1e4f72137f4923db86c5182e702e3d52
    - f0/
      - 325f56270971bb1ac0d3af3338c053f942dcc9
    - f1/
      - be98dd5cd714761ce2c102b5db6a4aa9fbf3e4
    - fa/
      - cfa451540be4a1cb2ea8b7e8b670256bbb9307
    - fb/
      - e422eed788ee5d6cb6711cbb871bf8a614e0a2
    - fd/
      - eadcb9507a61718151e95b69d351f3cd530dbb
    - fe/
      - 4a4528c2c9f07df20a4bae9517b27e0b4910b6
- lib64/
  - ocaml/
    - coq-core/
      - META
      - boot/
        
        boot.a
        
        boot.cma
        
        boot.cmi
        
        boot.cmt
        
        boot.cmx
        
        boot.cmxa
        
        boot.cmxs
        
        boot.ml
        
        boot__Env.cmi
        
        boot__Env.cmt
        
        boot__Env.cmti
        
        boot__Env.cmx
        
        boot__Path.cmi
        
        boot__Path.cmt
        
        boot__Path.cmti
        
        boot__Path.cmx
        
        boot__Usage.cmi
        
        boot__Usage.cmt
        
        boot__Usage.cmti
        
        boot__Usage.cmx
        
        boot__Util.cmi
        
        boot__Util.cmt
        
        boot__Util.cmti
        
        boot__Util.cmx
        
        env.mli
        
        path.mli
        
        usage.mli
        
        util.mli
      - checklib/
        
        analyze.mli
        
        check.mli
        
        checkFlags.mli
        
        checkInductive.mli
        
        checkTypes.mli
        
        check_stat.mli
        
        checker.mli
        
        coq_checklib.a
        
        coq_checklib.cma
        
        coq_checklib.cmi
        
        coq_checklib.cmt
        
        coq_checklib.cmx
        
        coq_checklib.cmxa
        
        coq_checklib.cmxs
        
        coq_checklib.ml
        
        coq_checklib__Analyze.cmi
        
        coq_checklib__Analyze.cmt
        
        coq_checklib__Analyze.cmti
        
        coq_checklib__Analyze.cmx
        
        coq_checklib__Check.cmi
        
        coq_checklib__Check.cmt
        
        coq_checklib__Check.cmti
        
        coq_checklib__Check.cmx
        
        coq_checklib__CheckFlags.cmi
        
        coq_checklib__CheckFlags.cmt
        
        coq_checklib__CheckFlags.cmti
        
        coq_checklib__CheckFlags.cmx
        
        coq_checklib__CheckInductive.cmi
        
        coq_checklib__CheckInductive.cmt
        
        coq_checklib__CheckInductive.cmti
        
        coq_checklib__CheckInductive.cmx
        
        coq_checklib__CheckTypes.cmi
        
        coq_checklib__CheckTypes.cmt
        
        coq_checklib__CheckTypes.cmti
        
        coq_checklib__CheckTypes.cmx
        
        coq_checklib__Check_stat.cmi
        
        coq_checklib__Check_stat.cmt
        
        coq_checklib__Check_stat.cmti
        
        coq_checklib__Check_stat.cmx
        
        coq_checklib__Checker.cmi
        
        coq_checklib__Checker.cmt
        
        coq_checklib__Checker.cmti
        
        coq_checklib__Checker.cmx
        
        coq_checklib__Mod_checking.cmi
        
        coq_checklib__Mod_checking.cmt
        
        coq_checklib__Mod_checking.cmti
        
        coq_checklib__Mod_checking.cmx
        
        coq_checklib__Safe_checking.cmi
        
        coq_checklib__Safe_checking.cmt
        
        coq_checklib__Safe_checking.cmti
        
        coq_checklib__Safe_checking.cmx
        
        coq_checklib__Validate.cmi
        
        coq_checklib__Validate.cmt
        
        coq_checklib__Validate.cmti
        
        coq_checklib__Validate.cmx
        
        coq_checklib__Values.cmi
        
        coq_checklib__Values.cmt
        
        coq_checklib__Values.cmti
        
        coq_checklib__Values.cmx
        
        mod_checking.mli
        
        safe_checking.mli
        
        validate.mli
        
        values.mli
      - clib/
        
        cArray.cmi
        
        cArray.cmt
        
        cArray.cmti
        
        cArray.cmx
        
        cArray.mli
        
        cEphemeron.cmi
        
        cEphemeron.cmt
        
        cEphemeron.cmti
        
        cEphemeron.cmx
        
        cEphemeron.mli
        
        cList.cmi
        
        cList.cmt
        
        cList.cmti
        
        cList.cmx
        
        cList.mli
        
        cMap.cmi
        
        cMap.cmt
        
        cMap.cmti
        
        cMap.cmx
        
        cMap.mli
        
        cObj.cmi
        
        cObj.cmt
        
        cObj.cmti
        
        cObj.cmx
        
        cObj.mli
        
        cSet.cmi
        
        cSet.cmt
        
        cSet.cmti
        
        cSet.cmx
        
        cSet.mli
        
        cSig.cmi
        
        cSig.cmti
        
        cSig.mli
        
        cString.cmi
        
        cString.cmt
        
        cString.cmti
        
        cString.cmx
        
        cString.mli
        
        cThread.cmi
        
        cThread.cmt
        
        cThread.cmti
        
        cThread.cmx
        
        cThread.mli
        
        cUnix.cmi
        
        cUnix.cmt
        
        cUnix.cmti
        
        cUnix.cmx
        
        cUnix.mli
        
        clib.a
        
        clib.cma
        
        clib.cmxa
        
        clib.cmxs
        
        diff2.cmi
        
        diff2.cmt
        
        diff2.cmti
        
        diff2.cmx
        
        diff2.mli
        
        dyn.cmi
        
        dyn.cmt
        
        dyn.cmti
        
        dyn.cmx
        
        dyn.mli
        
        exninfo.cmi
        
        exninfo.cmt
        
        exninfo.cmti
        
        exninfo.cmx
        
        exninfo.mli
        
        hMap.cmi
        
        hMap.cmt
        
        hMap.cmti
        
        hMap.cmx
        
        hMap.mli
        
        hashcons.cmi
        
        hashcons.cmt
        
        hashcons.cmti
        
        hashcons.cmx
        
        hashcons.mli
        
        hashset.cmi
        
        hashset.cmt
        
        hashset.cmti
        
        hashset.cmx
        
        hashset.mli
        
        heap.cmi
        
        heap.cmt
        
        heap.cmti
        
        heap.cmx
        
        heap.mli
        
        iStream.cmi
        
        iStream.cmt
        
        iStream.cmti
        
        iStream.cmx
        
        iStream.mli
        
        int.cmi
        
        int.cmt
        
        int.cmti
        
        int.cmx
        
        int.mli
        
        memprof_coq.cmi
        
        memprof_coq.cmt
        
        memprof_coq.cmti
        
        memprof_coq.cmx
        
        memprof_coq.mli
        
        monad.cmi
        
        monad.cmt
        
        monad.cmti
        
        monad.cmx
        
        monad.mli
        
        mutex_aux.cmi
        
        mutex_aux.cmt
        
        mutex_aux.cmti
        
        mutex_aux.cmx
        
        mutex_aux.mli
        
        neList.cmi
        
        neList.cmt
        
        neList.cmti
        
        neList.cmx
        
        neList.mli
        
        option.cmi
        
        option.cmt
        
        option.cmti
        
        option.cmx
        
        option.mli
        
        orderedType.cmi
        
        orderedType.cmt
        
        orderedType.cmti
        
        orderedType.cmx
        
        orderedType.mli
        
        polyMap.cmi
        
        polyMap.cmt
        
        polyMap.cmti
        
        polyMap.cmx
        
        polyMap.mli
        
        predicate.cmi
        
        predicate.cmt
        
        predicate.cmti
        
        predicate.cmx
        
        predicate.mli
        
        range.cmi
        
        range.cmt
        
        range.cmti
        
        range.cmx
        
        range.mli
        
        sList.cmi
        
        sList.cmt
        
        sList.cmti
        
        sList.cmx
        
        sList.mli
        
        segmenttree.cmi
        
        segmenttree.cmt
        
        segmenttree.cmti
        
        segmenttree.cmx
        
        segmenttree.mli
        
        store.cmi
        
        store.cmt
        
        store.cmti
        
        store.cmx
        
        store.mli
        
        terminal.cmi
        
        terminal.cmt
        
        terminal.cmti
        
        terminal.cmx
        
        terminal.mli
        
        trie.cmi
        
        trie.cmt
        
        trie.cmti
        
        trie.cmx
        
        trie.mli
        
        unicode.cmi
        
        unicode.cmt
        
        unicode.cmti
        
        unicode.cmx
        
        unicode.mli
        
        unicodetable.cmi
        
        unicodetable.cmt
        
        unicodetable.cmti
        
        unicodetable.cmx
        
        unicodetable.mli
        
        unionfind.cmi
        
        unionfind.cmt
        
        unionfind.cmti
        
        unionfind.cmx
        
        unionfind.mli
      - config/
        
        byte/
        
        byte_config.cma
        
        coq_byte_config.cmi
        
        coq_byte_config.cmt
        
        coq_byte_config.cmti
        
        coq_byte_config.mli
        
        config.a
        
        config.cma
        
        config.cmxa
        
        config.cmxs
        
        coq_config.cmi
        
        coq_config.cmt
        
        coq_config.cmti
        
        coq_config.cmx
        
        coq_config.mli
      - coqworkmgrapi/
        
        coqworkmgrApi.cmi
        
        coqworkmgrApi.cmt
        
        coqworkmgrApi.cmti
        
        coqworkmgrApi.cmx
        
        coqworkmgrApi.mli
        
        coqworkmgrlib.a
        
        coqworkmgrlib.cma
        
        coqworkmgrlib.cmxa
        
        coqworkmgrlib.cmxs
      - debugger_support/
        
        debugger_support.a
        
        debugger_support.cma
        
        debugger_support.cmi
        
        debugger_support.cmt
        
        debugger_support.cmti
        
        debugger_support.cmx
        
        debugger_support.cmxa
        
        debugger_support.cmxs
        
        debugger_support.mli
      - dev/
        
        dev.a
        
        dev.cma
        
        dev.cmxa
        
        dev.cmxs
        
        ml_toplevel/
        
        include
        
        include_directories
        
        include_printers
        
        include_utilities
        
        top_printers.cmi
        
        top_printers.cmt
        
        top_printers.cmti
        
        top_printers.cmx
        
        top_printers.mli
        
        vm_printers.cmi
        
        vm_printers.cmt
        
        vm_printers.cmti
        
        vm_printers.cmx
        
        vm_printers.mli
      - dune-package
      - engine/
        
        eConstr.cmi
        
        eConstr.cmt
        
        eConstr.cmti
        
        eConstr.cmx
        
        eConstr.mli
        
        engine.a
        
        engine.cma
        
        engine.cmxa
        
        engine.cmxs
        
        evar_kinds.cmi
        
        evar_kinds.cmt
        
        evar_kinds.cmti
        
        evar_kinds.cmx
        
        evar_kinds.mli
        
        evarutil.cmi
        
        evarutil.cmt
        
        evarutil.cmti
        
        evarutil.cmx
        
        evarutil.mli
        
        evd.cmi
        
        evd.cmt
        
        evd.cmti
        
        evd.cmx
        
        evd.mli
        
        ftactic.cmi
        
        ftactic.cmt
        
        ftactic.cmti
        
        ftactic.cmx
        
        ftactic.mli
        
        logic_monad.cmi
        
        logic_monad.cmt
        
        logic_monad.cmti
        
        logic_monad.cmx
        
        logic_monad.mli
        
        namegen.cmi
        
        namegen.cmt
        
        namegen.cmti
        
        namegen.cmx
        
        namegen.mli
        
        nameops.cmi
        
        nameops.cmt
        
        nameops.cmti
        
        nameops.cmx
        
        nameops.mli
        
        profile_tactic.cmi
        
        profile_tactic.cmt
        
        profile_tactic.cmti
        
        profile_tactic.cmx
        
        profile_tactic.mli
        
        proofview.cmi
        
        proofview.cmt
        
        proofview.cmti
        
        proofview.cmx
        
        proofview.mli
        
        proofview_monad.cmi
        
        proofview_monad.cmt
        
        proofview_monad.cmti
        
        proofview_monad.cmx
        
        proofview_monad.mli
        
        termops.cmi
        
        termops.cmt
        
        termops.cmti
        
        termops.cmx
        
        termops.mli
        
        uState.cmi
        
        uState.cmt
        
        uState.cmti
        
        uState.cmx
        
        uState.mli
        
        univFlex.cmi
        
        univFlex.cmt
        
        univFlex.cmti
        
        univFlex.cmx
        
        univFlex.mli
        
        univGen.cmi
        
        univGen.cmt
        
        univGen.cmti
        
        univGen.cmx
        
        univGen.mli
        
        univMinim.cmi
        
        univMinim.cmt
        
        univMinim.cmti
        
        univMinim.cmx
        
        univMinim.mli
        
        univNames.cmi
        
        univNames.cmt
        
        univNames.cmti
        
        univNames.cmx
        
        univNames.mli
        
        univProblem.cmi
        
        univProblem.cmt
        
        univProblem.cmti
        
        univProblem.cmx
        
        univProblem.mli
        
        univSubst.cmi
        
        univSubst.cmt
        
        univSubst.cmti
        
        univSubst.cmx
        
        univSubst.mli
      - gramlib/
        
        gramext.mli
        
        gramlib.a
        
        gramlib.cma
        
        gramlib.cmi
        
        gramlib.cmt
        
        gramlib.cmx
        
        gramlib.cmxa
        
        gramlib.cmxs
        
        gramlib.ml
        
        gramlib__Gramext.cmi
        
        gramlib__Gramext.cmt
        
        gramlib__Gramext.cmti
        
        gramlib__Gramext.cmx
        
        gramlib__Grammar.cmi
        
        gramlib__Grammar.cmt
        
        gramlib__Grammar.cmti
        
        gramlib__Grammar.cmx
        
        gramlib__LStream.cmi
        
        gramlib__LStream.cmt
        
        gramlib__LStream.cmti
        
        gramlib__LStream.cmx
        
        gramlib__Plexing.cmi
        
        gramlib__Plexing.cmti
        
        gramlib__Stream.cmi
        
        gramlib__Stream.cmt
        
        gramlib__Stream.cmti
        
        gramlib__Stream.cmx
        
        grammar.mli
        
        lStream.mli
        
        plexing.mli
        
        stream.mli
      - interp/
        
        abbreviation.cmi
        
        abbreviation.cmt
        
        abbreviation.cmti
        
        abbreviation.cmx
        
        abbreviation.mli
        
        constrexpr.cmi
        
        constrexpr.cmti
        
        constrexpr.mli
        
        constrexpr_ops.cmi
        
        constrexpr_ops.cmt
        
        constrexpr_ops.cmti
        
        constrexpr_ops.cmx
        
        constrexpr_ops.mli
        
        constrextern.cmi
        
        constrextern.cmt
        
        constrextern.cmti
        
        constrextern.cmx
        
        constrextern.mli
        
        constrintern.cmi
        
        constrintern.cmt
        
        constrintern.cmti
        
        constrintern.cmx
        
        constrintern.mli
        
        decls.cmi
        
        decls.cmt
        
        decls.cmti
        
        decls.cmx
        
        decls.mli
        
        dumpglob.cmi
        
        dumpglob.cmt
        
        dumpglob.cmti
        
        dumpglob.cmx
        
        dumpglob.mli
        
        genintern.cmi
        
        genintern.cmt
        
        genintern.cmti
        
        genintern.cmx
        
        genintern.mli
        
        impargs.cmi
        
        impargs.cmt
        
        impargs.cmti
        
        impargs.cmx
        
        impargs.mli
        
        implicit_quantifiers.cmi
        
        implicit_quantifiers.cmt
        
        implicit_quantifiers.cmti
        
        implicit_quantifiers.cmx
        
        implicit_quantifiers.mli
        
        interp.a
        
        interp.cma
        
        interp.cmxa
        
        interp.cmxs
        
        modintern.cmi
        
        modintern.cmt
        
        modintern.cmti
        
        modintern.cmx
        
        modintern.mli
        
        notation.cmi
        
        notation.cmt
        
        notation.cmti
        
        notation.cmx
        
        notation.mli
        
        notation_ops.cmi
        
        notation_ops.cmt
        
        notation_ops.cmti
        
        notation_ops.cmx
        
        notation_ops.mli
        
        notation_term.cmi
        
        notation_term.cmti
        
        notation_term.mli
        
        notationextern.cmi
        
        notationextern.cmt
        
        notationextern.cmti
        
        notationextern.cmx
        
        notationextern.mli
        
        numTok.cmi
        
        numTok.cmt
        
        numTok.cmti
        
        numTok.cmx
        
        numTok.mli
        
        reserve.cmi
        
        reserve.cmt
        
        reserve.cmti
        
        reserve.cmx
        
        reserve.mli
        
        smartlocate.cmi
        
        smartlocate.cmt
        
        smartlocate.cmti
        
        smartlocate.cmx
        
        smartlocate.mli
        
        stdarg.cmi
        
        stdarg.cmt
        
        stdarg.cmti
        
        stdarg.cmx
        
        stdarg.mli
      - kernel/
        
        cClosure.cmi
        
        cClosure.cmt
        
        cClosure.cmti
        
        cClosure.cmx
        
        cClosure.mli
        
        cPrimitives.cmi
        
        cPrimitives.cmt
        
        cPrimitives.cmti
        
        cPrimitives.cmx
        
        cPrimitives.mli
        
        constant_typing.cmi
        
        constant_typing.cmt
        
        constant_typing.cmti
        
        constant_typing.cmx
        
        constant_typing.mli
        
        constr.cmi
        
        constr.cmt
        
        constr.cmti
        
        constr.cmx
        
        constr.mli
        
        context.cmi
        
        context.cmt
        
        context.cmti
        
        context.cmx
        
        context.mli
        
        conv_oracle.cmi
        
        conv_oracle.cmt
        
        conv_oracle.cmti
        
        conv_oracle.cmx
        
        conv_oracle.mli
        
        conversion.cmi
        
        conversion.cmt
        
        conversion.cmti
        
        conversion.cmx
        
        conversion.mli
        
        cooking.cmi
        
        cooking.cmt
        
        cooking.cmti
        
        cooking.cmx
        
        cooking.mli
        
        declarations.cmi
        
        declarations.cmti
        
        declarations.mli
        
        declareops.cmi
        
        declareops.cmt
        
        declareops.cmti
        
        declareops.cmx
        
        declareops.mli
        
        discharge.cmi
        
        discharge.cmt
        
        discharge.cmti
        
        discharge.cmx
        
        discharge.mli
        
        entries.cmi
        
        entries.cmti
        
        entries.mli
        
        environ.cmi
        
        environ.cmt
        
        environ.cmti
        
        environ.cmx
        
        environ.mli
        
        esubst.cmi
        
        esubst.cmt
        
        esubst.cmti
        
        esubst.cmx
        
        esubst.mli
        
        evar.cmi
        
        evar.cmt
        
        evar.cmti
        
        evar.cmx
        
        evar.mli
        
        float64.cmi
        
        float64.cmt
        
        float64.cmti
        
        float64.cmx
        
        float64.mli
        
        float64_common.cmi
        
        float64_common.cmt
        
        float64_common.cmti
        
        float64_common.cmx
        
        float64_common.mli
        
        genlambda.cmi
        
        genlambda.cmt
        
        genlambda.cmti
        
        genlambda.cmx
        
        genlambda.mli
        
        indTyping.cmi
        
        indTyping.cmt
        
        indTyping.cmti
        
        indTyping.cmx
        
        indTyping.mli
        
        indtypes.cmi
        
        indtypes.cmt
        
        indtypes.cmti
        
        indtypes.cmx
        
        indtypes.mli
        
        inductive.cmi
        
        inductive.cmt
        
        inductive.cmti
        
        inductive.cmx
        
        inductive.mli
        
        inferCumulativity.cmi
        
        inferCumulativity.cmt
        
        inferCumulativity.cmti
        
        inferCumulativity.cmx
        
        inferCumulativity.mli
        
        kernel.a
        
        kernel.cma
        
        kernel.cmxa
        
        kernel.cmxs
        
        mod_subst.cmi
        
        mod_subst.cmt
        
        mod_subst.cmti
        
        mod_subst.cmx
        
        mod_subst.mli
        
        mod_typing.cmi
        
        mod_typing.cmt
        
        mod_typing.cmti
        
        mod_typing.cmx
        
        mod_typing.mli
        
        modops.cmi
        
        modops.cmt
        
        modops.cmti
        
        modops.cmx
        
        modops.mli
        
        names.cmi
        
        names.cmt
        
        names.cmti
        
        names.cmx
        
        names.mli
        
        nativecode.cmi
        
        nativecode.cmt
        
        nativecode.cmti
        
        nativecode.cmx
        
        nativecode.mli
        
        nativeconv.cmi
        
        nativeconv.cmt
        
        nativeconv.cmti
        
        nativeconv.cmx
        
        nativeconv.mli
        
        nativelambda.cmi
        
        nativelambda.cmt
        
        nativelambda.cmti
        
        nativelambda.cmx
        
        nativelambda.mli
        
        nativelib.cmi
        
        nativelib.cmt
        
        nativelib.cmti
        
        nativelib.cmx
        
        nativelib.mli
        
        nativelibrary.cmi
        
        nativelibrary.cmt
        
        nativelibrary.cmti
        
        nativelibrary.cmx
        
        nativelibrary.mli
        
        nativevalues.cmi
        
        nativevalues.cmt
        
        nativevalues.cmti
        
        nativevalues.cmx
        
        nativevalues.mli
        
        opaqueproof.cmi
        
        opaqueproof.cmt
        
        opaqueproof.cmti
        
        opaqueproof.cmx
        
        opaqueproof.mli
        
        parray.cmi
        
        parray.cmt
        
        parray.cmti
        
        parray.cmx
        
        parray.mli
        
        partial_subst.cmi
        
        partial_subst.cmt
        
        partial_subst.cmti
        
        partial_subst.cmx
        
        partial_subst.mli
        
        primred.cmi
        
        primred.cmt
        
        primred.cmti
        
        primred.cmx
        
        primred.mli
        
        pstring.cmi
        
        pstring.cmt
        
        pstring.cmti
        
        pstring.cmx
        
        pstring.mli
        
        redFlags.cmi
        
        redFlags.cmt
        
        redFlags.cmti
        
        redFlags.cmx
        
        redFlags.mli
        
        reduction.cmi
        
        reduction.cmt
        
        reduction.cmti
        
        reduction.cmx
        
        reduction.mli
        
        relevanceops.cmi
        
        relevanceops.cmt
        
        relevanceops.cmti
        
        relevanceops.cmx
        
        relevanceops.mli
        
        retroknowledge.cmi
        
        retroknowledge.cmt
        
        retroknowledge.cmti
        
        retroknowledge.cmx
        
        retroknowledge.mli
        
        safe_typing.cmi
        
        safe_typing.cmt
        
        safe_typing.cmti
        
        safe_typing.cmx
        
        safe_typing.mli
        
        section.cmi
        
        section.cmt
        
        section.cmti
        
        section.cmx
        
        section.mli
        
        sorts.cmi
        
        sorts.cmt
        
        sorts.cmti
        
        sorts.cmx
        
        sorts.mli
        
        subtyping.cmi
        
        subtyping.cmt
        
        subtyping.cmti
        
        subtyping.cmx
        
        subtyping.mli
        
        term.cmi
        
        term.cmt
        
        term.cmti
        
        term.cmx
        
        term.mli
        
        transparentState.cmi
        
        transparentState.cmt
        
        transparentState.cmti
        
        transparentState.cmx
        
        transparentState.mli
        
        type_errors.cmi
        
        type_errors.cmt
        
        type_errors.cmti
        
        type_errors.cmx
        
        type_errors.mli
        
        typeops.cmi
        
        typeops.cmt
        
        typeops.cmti
        
        typeops.cmx
        
        typeops.mli
        
        uGraph.cmi
        
        uGraph.cmt
        
        uGraph.cmti
        
        uGraph.cmx
        
        uGraph.mli
        
        uVars.cmi
        
        uVars.cmt
        
        uVars.cmti
        
        uVars.cmx
        
        uVars.mli
        
        uint63.cmi
        
        uint63.cmt
        
        uint63.cmti
        
        uint63.cmx
        
        uint63.mli
        
        univ.cmi
        
        univ.cmt
        
        univ.cmti
        
        univ.cmx
        
        univ.mli
        
        values.cmi
        
        values.cmti
        
        values.mli
        
        vars.cmi
        
        vars.cmt
        
        vars.cmti
        
        vars.cmx
        
        vars.mli
        
        vconv.cmi
        
        vconv.cmt
        
        vconv.cmti
        
        vconv.cmx
        
        vconv.mli
        
        vm.cmi
        
        vm.cmt
        
        vm.cmti
        
        vm.cmx
        
        vm.mli
        
        vmbytecodes.cmi
        
        vmbytecodes.cmt
        
        vmbytecodes.cmti
        
        vmbytecodes.cmx
        
        vmbytecodes.mli
        
        vmbytegen.cmi
        
        vmbytegen.cmt
        
        vmbytegen.cmti
        
        vmbytegen.cmx
        
        vmbytegen.mli
        
        vmemitcodes.cmi
        
        vmemitcodes.cmt
        
        vmemitcodes.cmti
        
        vmemitcodes.cmx
        
        vmemitcodes.mli
        
        vmerrors.cmi
        
        vmerrors.cmt
        
        vmerrors.cmti
        
        vmerrors.cmx
        
        vmerrors.mli
        
        vmlambda.cmi
        
        vmlambda.cmt
        
        vmlambda.cmti
        
        vmlambda.cmx
        
        vmlambda.mli
        
        vmlibrary.cmi
        
        vmlibrary.cmt
        
        vmlibrary.cmti
        
        vmlibrary.cmx
        
        vmlibrary.mli
        
        vmopcodes.cmi
        
        vmopcodes.cmt
        
        vmopcodes.cmti
        
        vmopcodes.cmx
        
        vmopcodes.mli
        
        vmsymtable.cmi
        
        vmsymtable.cmt
        
        vmsymtable.cmti
        
        vmsymtable.cmx
        
        vmsymtable.mli
        
        vmvalues.cmi
        
        vmvalues.cmt
        
        vmvalues.cmti
        
        vmvalues.cmx
        
        vmvalues.mli
      - lib/
        
        acyclicGraph.cmi
        
        acyclicGraph.cmt
        
        acyclicGraph.cmti
        
        acyclicGraph.cmx
        
        acyclicGraph.mli
        
        aux_file.cmi
        
        aux_file.cmt
        
        aux_file.cmti
        
        aux_file.cmx
        
        aux_file.mli
        
        cAst.cmi
        
        cAst.cmt
        
        cAst.cmti
        
        cAst.cmx
        
        cAst.mli
        
        cDebug.cmi
        
        cDebug.cmt
        
        cDebug.cmti
        
        cDebug.cmx
        
        cDebug.mli
        
        cErrors.cmi
        
        cErrors.cmt
        
        cErrors.cmti
        
        cErrors.cmx
        
        cErrors.mli
        
        cWarnings.cmi
        
        cWarnings.cmt
        
        cWarnings.cmti
        
        cWarnings.cmx
        
        cWarnings.mli
        
        control.cmi
        
        control.cmt
        
        control.cmti
        
        control.cmx
        
        control.mli
        
        coqProject_file.cmi
        
        coqProject_file.cmt
        
        coqProject_file.cmti
        
        coqProject_file.cmx
        
        coqProject_file.mli
        
        core_plugins_findlib_compat.cmi
        
        core_plugins_findlib_compat.cmt
        
        core_plugins_findlib_compat.cmti
        
        core_plugins_findlib_compat.cmx
        
        core_plugins_findlib_compat.mli
        
        dAst.cmi
        
        dAst.cmt
        
        dAst.cmti
        
        dAst.cmx
        
        dAst.mli
        
        deprecation.cmi
        
        deprecation.cmt
        
        deprecation.cmti
        
        deprecation.cmx
        
        deprecation.mli
        
        envars.cmi
        
        envars.cmt
        
        envars.cmti
        
        envars.cmx
        
        envars.mli
        
        feedback.cmi
        
        feedback.cmt
        
        feedback.cmti
        
        feedback.cmx
        
        feedback.mli
        
        flags.cmi
        
        flags.cmt
        
        flags.cmti
        
        flags.cmx
        
        flags.mli
        
        hook.cmi
        
        hook.cmt
        
        hook.cmti
        
        hook.cmx
        
        hook.mli
        
        instr.cmi
        
        instr.cmt
        
        instr.cmti
        
        instr.cmx
        
        instr.mli
        
        lib.a
        
        lib.cma
        
        lib.cmxa
        
        lib.cmxs
        
        loc.cmi
        
        loc.cmt
        
        loc.cmti
        
        loc.cmx
        
        loc.mli
        
        newProfile.cmi
        
        newProfile.cmt
        
        newProfile.cmti
        
        newProfile.cmx
        
        newProfile.mli
        
        objFile.cmi
        
        objFile.cmt
        
        objFile.cmti
        
        objFile.cmx
        
        objFile.mli
        
        pp.cmi
        
        pp.cmt
        
        pp.cmti
        
        pp.cmx
        
        pp.mli
        
        pp_diff.cmi
        
        pp_diff.cmt
        
        pp_diff.cmti
        
        pp_diff.cmx
        
        pp_diff.mli
        
        rtree.cmi
        
        rtree.cmt
        
        rtree.cmti
        
        rtree.cmx
        
        rtree.mli
        
        spawn.cmi
        
        spawn.cmt
        
        spawn.cmti
        
        spawn.cmx
        
        spawn.mli
        
        stateid.cmi
        
        stateid.cmt
        
        stateid.cmti
        
        stateid.cmx
        
        stateid.mli
        
        system.cmi
        
        system.cmt
        
        system.cmti
        
        system.cmx
        
        system.mli
        
        userWarn.cmi
        
        userWarn.cmt
        
        userWarn.cmti
        
        userWarn.cmx
        
        userWarn.mli
        
        util.cmi
        
        util.cmt
        
        util.cmti
        
        util.cmx
        
        util.mli
        
        xml_datatype.cmi
        
        xml_datatype.cmti
        
        xml_datatype.mli
      - library/
        
        coqlib.cmi
        
        coqlib.cmt
        
        coqlib.cmti
        
        coqlib.cmx
        
        coqlib.mli
        
        global.cmi
        
        global.cmt
        
        global.cmti
        
        global.cmx
        
        global.mli
        
        globnames.cmi
        
        globnames.cmt
        
        globnames.cmti
        
        globnames.cmx
        
        globnames.mli
        
        goptions.cmi
        
        goptions.cmt
        
        goptions.cmti
        
        goptions.cmx
        
        goptions.mli
        
        lib.cmi
        
        lib.cmt
        
        lib.cmti
        
        lib.cmx
        
        lib.mli
        
        libnames.cmi
        
        libnames.cmt
        
        libnames.cmti
        
        libnames.cmx
        
        libnames.mli
        
        libobject.cmi
        
        libobject.cmt
        
        libobject.cmti
        
        libobject.cmx
        
        libobject.mli
        
        library.a
        
        library.cma
        
        library.cmxa
        
        library.cmxs
        
        library_info.cmi
        
        library_info.cmt
        
        library_info.cmti
        
        library_info.cmx
        
        library_info.mli
        
        nametab.cmi
        
        nametab.cmt
        
        nametab.cmti
        
        nametab.cmx
        
        nametab.mli
        
        summary.cmi
        
        summary.cmt
        
        summary.cmti
        
        summary.cmx
        
        summary.mli
      - opam
      - parsing/
        
        cLexer.cmi
        
        cLexer.cmt
        
        cLexer.cmti
        
        cLexer.cmx
        
        cLexer.mli
        
        extend.cmi
        
        extend.cmt
        
        extend.cmti
        
        extend.cmx
        
        extend.mli
        
        g_constr.cmi
        
        g_constr.cmt
        
        g_constr.cmti
        
        g_constr.cmx
        
        g_constr.mli
        
        g_prim.cmi
        
        g_prim.cmt
        
        g_prim.cmti
        
        g_prim.cmx
        
        g_prim.mli
        
        notation_gram.cmi
        
        notation_gram.cmti
        
        notation_gram.mli
        
        notgram_ops.cmi
        
        notgram_ops.cmt
        
        notgram_ops.cmti
        
        notgram_ops.cmx
        
        notgram_ops.mli
        
        parsing.a
        
        parsing.cma
        
        parsing.cmxa
        
        parsing.cmxs
        
        pcoq.cmi
        
        pcoq.cmt
        
        pcoq.cmti
        
        pcoq.cmx
        
        pcoq.mli
        
        tok.cmi
        
        tok.cmt
        
        tok.cmti
        
        tok.cmx
        
        tok.mli
      - perf/
        
        coqperf.a
        
        coqperf.cma
        
        coqperf.cmxa
        
        coqperf.cmxs
        
        libcoqperf_stubs.a
        
        perf.cmi
        
        perf.cmt
        
        perf.cmti
        
        perf.cmx
        
        perf.mli
      - plugins/
        
        btauto/
        
        btauto_plugin.a
        
        btauto_plugin.cma
        
        btauto_plugin.cmi
        
        btauto_plugin.cmt
        
        btauto_plugin.cmx
        
        btauto_plugin.cmxa
        
        btauto_plugin.cmxs
        
        btauto_plugin.ml
        
        btauto_plugin__G_btauto.cmi
        
        btauto_plugin__G_btauto.cmt
        
        btauto_plugin__G_btauto.cmti
        
        btauto_plugin__G_btauto.cmx
        
        btauto_plugin__Refl_btauto.cmi
        
        btauto_plugin__Refl_btauto.cmt
        
        btauto_plugin__Refl_btauto.cmti
        
        btauto_plugin__Refl_btauto.cmx
        
        g_btauto.mli
        
        refl_btauto.mli
        
        cc/
        
        cc_plugin.a
        
        cc_plugin.cma
        
        cc_plugin.cmi
        
        cc_plugin.cmt
        
        cc_plugin.cmx
        
        cc_plugin.cmxa
        
        cc_plugin.cmxs
        
        cc_plugin.ml
        
        cc_plugin__Ccalgo.cmi
        
        cc_plugin__Ccalgo.cmt
        
        cc_plugin__Ccalgo.cmti
        
        cc_plugin__Ccalgo.cmx
        
        cc_plugin__Ccproof.cmi
        
        cc_plugin__Ccproof.cmt
        
        cc_plugin__Ccproof.cmti
        
        cc_plugin__Ccproof.cmx
        
        cc_plugin__Cctac.cmi
        
        cc_plugin__Cctac.cmt
        
        cc_plugin__Cctac.cmti
        
        cc_plugin__Cctac.cmx
        
        cc_plugin__G_congruence.cmi
        
        cc_plugin__G_congruence.cmt
        
        cc_plugin__G_congruence.cmti
        
        cc_plugin__G_congruence.cmx
        
        ccalgo.mli
        
        ccproof.mli
        
        cctac.mli
        
        g_congruence.mli
        
        derive/
        
        derive.mli
        
        derive_plugin.a
        
        derive_plugin.cma
        
        derive_plugin.cmi
        
        derive_plugin.cmt
        
        derive_plugin.cmx
        
        derive_plugin.cmxa
        
        derive_plugin.cmxs
        
        derive_plugin.ml
        
        derive_plugin__Derive.cmi
        
        derive_plugin__Derive.cmt
        
        derive_plugin__Derive.cmti
        
        derive_plugin__Derive.cmx
        
        derive_plugin__G_derive.cmi
        
        derive_plugin__G_derive.cmt
        
        derive_plugin__G_derive.cmti
        
        derive_plugin__G_derive.cmx
        
        g_derive.mli
        
        extraction/
        
        common.mli
        
        extract_env.mli
        
        extraction.mli
        
        extraction_plugin.a
        
        extraction_plugin.cma
        
        extraction_plugin.cmi
        
        extraction_plugin.cmt
        
        extraction_plugin.cmx
        
        extraction_plugin.cmxa
        
        extraction_plugin.cmxs
        
        extraction_plugin.ml
        
        extraction_plugin__Common.cmi
        
        extraction_plugin__Common.cmt
        
        extraction_plugin__Common.cmti
        
        extraction_plugin__Common.cmx
        
        extraction_plugin__Extract_env.cmi
        
        extraction_plugin__Extract_env.cmt
        
        extraction_plugin__Extract_env.cmti
        
        extraction_plugin__Extract_env.cmx
        
        extraction_plugin__Extraction.cmi
        
        extraction_plugin__Extraction.cmt
        
        extraction_plugin__Extraction.cmti
        
        extraction_plugin__Extraction.cmx
        
        extraction_plugin__G_extraction.cmi
        
        extraction_plugin__G_extraction.cmt
        
        extraction_plugin__G_extraction.cmti
        
        extraction_plugin__G_extraction.cmx
        
        extraction_plugin__Haskell.cmi
        
        extraction_plugin__Haskell.cmt
        
        extraction_plugin__Haskell.cmti
        
        extraction_plugin__Haskell.cmx
        
        extraction_plugin__Json.cmi
        
        extraction_plugin__Json.cmt
        
        extraction_plugin__Json.cmti
        
        extraction_plugin__Json.cmx
        
        extraction_plugin__Miniml.cmi
        
        extraction_plugin__Miniml.cmt
        
        extraction_plugin__Miniml.cmti
        
        extraction_plugin__Miniml.cmx
        
        extraction_plugin__Mlutil.cmi
        
        extraction_plugin__Mlutil.cmt
        
        extraction_plugin__Mlutil.cmti
        
        extraction_plugin__Mlutil.cmx
        
        extraction_plugin__Modutil.cmi
        
        extraction_plugin__Modutil.cmt
        
        extraction_plugin__Modutil.cmti
        
        extraction_plugin__Modutil.cmx
        
        extraction_plugin__Ocaml.cmi
        
        extraction_plugin__Ocaml.cmt
        
        extraction_plugin__Ocaml.cmti
        
        extraction_plugin__Ocaml.cmx
        
        extraction_plugin__Scheme.cmi
        
        extraction_plugin__Scheme.cmt
        
        extraction_plugin__Scheme.cmti
        
        extraction_plugin__Scheme.cmx
        
        extraction_plugin__Table.cmi
        
        extraction_plugin__Table.cmt
        
        extraction_plugin__Table.cmti
        
        extraction_plugin__Table.cmx
        
        g_extraction.mli
        
        haskell.mli
        
        json.mli
        
        miniml.mli
        
        mlutil.mli
        
        modutil.mli
        
        ocaml.mli
        
        scheme.mli
        
        table.mli
        
        firstorder/
        
        firstorder_plugin.a
        
        firstorder_plugin.cma
        
        firstorder_plugin.cmi
        
        firstorder_plugin.cmt
        
        firstorder_plugin.cmx
        
        firstorder_plugin.cmxa
        
        firstorder_plugin.cmxs
        
        firstorder_plugin.ml
        
        firstorder_plugin__Formula.cmi
        
        firstorder_plugin__Formula.cmt
        
        firstorder_plugin__Formula.cmti
        
        firstorder_plugin__Formula.cmx
        
        firstorder_plugin__G_ground.cmi
        
        firstorder_plugin__G_ground.cmt
        
        firstorder_plugin__G_ground.cmti
        
        firstorder_plugin__G_ground.cmx
        
        firstorder_plugin__Ground.cmi
        
        firstorder_plugin__Ground.cmt
        
        firstorder_plugin__Ground.cmti
        
        firstorder_plugin__Ground.cmx
        
        firstorder_plugin__Instances.cmi
        
        firstorder_plugin__Instances.cmt
        
        firstorder_plugin__Instances.cmti
        
        firstorder_plugin__Instances.cmx
        
        firstorder_plugin__Rules.cmi
        
        firstorder_plugin__Rules.cmt
        
        firstorder_plugin__Rules.cmti
        
        firstorder_plugin__Rules.cmx
        
        firstorder_plugin__Sequent.cmi
        
        firstorder_plugin__Sequent.cmt
        
        firstorder_plugin__Sequent.cmti
        
        firstorder_plugin__Sequent.cmx
        
        firstorder_plugin__Unify.cmi
        
        firstorder_plugin__Unify.cmt
        
        firstorder_plugin__Unify.cmti
        
        firstorder_plugin__Unify.cmx
        
        formula.mli
        
        g_ground.mli
        
        ground.mli
        
        instances.mli
        
        rules.mli
        
        sequent.mli
        
        unify.mli
        
        funind/
        
        functional_principles_proofs.mli
        
        functional_principles_types.mli
        
        funind_plugin.a
        
        funind_plugin.cma
        
        funind_plugin.cmi
        
        funind_plugin.cmt
        
        funind_plugin.cmx
        
        funind_plugin.cmxa
        
        funind_plugin.cmxs
        
        funind_plugin.ml
        
        funind_plugin__Functional_principles_proofs.cmi
        
        funind_plugin__Functional_principles_proofs.cmt
        
        funind_plugin__Functional_principles_proofs.cmti
        
        funind_plugin__Functional_principles_proofs.cmx
        
        funind_plugin__Functional_principles_types.cmi
        
        funind_plugin__Functional_principles_types.cmt
        
        funind_plugin__Functional_principles_types.cmti
        
        funind_plugin__Functional_principles_types.cmx
        
        funind_plugin__G_indfun.cmi
        
        funind_plugin__G_indfun.cmt
        
        funind_plugin__G_indfun.cmti
        
        funind_plugin__G_indfun.cmx
        
        funind_plugin__Gen_principle.cmi
        
        funind_plugin__Gen_principle.cmt
        
        funind_plugin__Gen_principle.cmti
        
        funind_plugin__Gen_principle.cmx
        
        funind_plugin__Glob_term_to_relation.cmi
        
        funind_plugin__Glob_term_to_relation.cmt
        
        funind_plugin__Glob_term_to_relation.cmti
        
        funind_plugin__Glob_term_to_relation.cmx
        
        funind_plugin__Glob_termops.cmi
        
        funind_plugin__Glob_termops.cmt
        
        funind_plugin__Glob_termops.cmti
        
        funind_plugin__Glob_termops.cmx
        
        funind_plugin__Indfun.cmi
        
        funind_plugin__Indfun.cmt
        
        funind_plugin__Indfun.cmti
        
        funind_plugin__Indfun.cmx
        
        funind_plugin__Indfun_common.cmi
        
        funind_plugin__Indfun_common.cmt
        
        funind_plugin__Indfun_common.cmti
        
        funind_plugin__Indfun_common.cmx
        
        funind_plugin__Invfun.cmi
        
        funind_plugin__Invfun.cmt
        
        funind_plugin__Invfun.cmti
        
        funind_plugin__Invfun.cmx
        
        funind_plugin__Recdef.cmi
        
        funind_plugin__Recdef.cmt
        
        funind_plugin__Recdef.cmti
        
        funind_plugin__Recdef.cmx
        
        g_indfun.mli
        
        gen_principle.mli
        
        glob_term_to_relation.mli
        
        glob_termops.mli
        
        indfun.mli
        
        indfun_common.mli
        
        invfun.mli
        
        recdef.mli
        
        ltac/
        
        comRewrite.mli
        
        coretactics.mli
        
        extraargs.mli
        
        extratactics.mli
        
        g_auto.mli
        
        g_class.mli
        
        g_eqdecide.mli
        
        g_ltac.mli
        
        g_obligations.mli
        
        g_rewrite.mli
        
        g_tactic.mli
        
        internals.mli
        
        leminv.mli
        
        ltac_plugin.a
        
        ltac_plugin.cma
        
        ltac_plugin.cmi
        
        ltac_plugin.cmt
        
        ltac_plugin.cmx
        
        ltac_plugin.cmxa
        
        ltac_plugin.cmxs
        
        ltac_plugin.ml
        
        ltac_plugin__ComRewrite.cmi
        
        ltac_plugin__ComRewrite.cmt
        
        ltac_plugin__ComRewrite.cmti
        
        ltac_plugin__ComRewrite.cmx
        
        ltac_plugin__Coretactics.cmi
        
        ltac_plugin__Coretactics.cmt
        
        ltac_plugin__Coretactics.cmti
        
        ltac_plugin__Coretactics.cmx
        
        ltac_plugin__Extraargs.cmi
        
        ltac_plugin__Extraargs.cmt
        
        ltac_plugin__Extraargs.cmti
        
        ltac_plugin__Extraargs.cmx
        
        ltac_plugin__Extratactics.cmi
        
        ltac_plugin__Extratactics.cmt
        
        ltac_plugin__Extratactics.cmti
        
        ltac_plugin__Extratactics.cmx
        
        ltac_plugin__G_auto.cmi
        
        ltac_plugin__G_auto.cmt
        
        ltac_plugin__G_auto.cmti
        
        ltac_plugin__G_auto.cmx
        
        ltac_plugin__G_class.cmi
        
        ltac_plugin__G_class.cmt
        
        ltac_plugin__G_class.cmti
        
        ltac_plugin__G_class.cmx
        
        ltac_plugin__G_eqdecide.cmi
        
        ltac_plugin__G_eqdecide.cmt
        
        ltac_plugin__G_eqdecide.cmti
        
        ltac_plugin__G_eqdecide.cmx
        
        ltac_plugin__G_ltac.cmi
        
        ltac_plugin__G_ltac.cmt
        
        ltac_plugin__G_ltac.cmti
        
        ltac_plugin__G_ltac.cmx
        
        ltac_plugin__G_obligations.cmi
        
        ltac_plugin__G_obligations.cmt
        
        ltac_plugin__G_obligations.cmti
        
        ltac_plugin__G_obligations.cmx
        
        ltac_plugin__G_rewrite.cmi
        
        ltac_plugin__G_rewrite.cmt
        
        ltac_plugin__G_rewrite.cmti
        
        ltac_plugin__G_rewrite.cmx
        
        ltac_plugin__G_tactic.cmi
        
        ltac_plugin__G_tactic.cmt
        
        ltac_plugin__G_tactic.cmti
        
        ltac_plugin__G_tactic.cmx
        
        ltac_plugin__Internals.cmi
        
        ltac_plugin__Internals.cmt
        
        ltac_plugin__Internals.cmti
        
        ltac_plugin__Internals.cmx
        
        ltac_plugin__Leminv.cmi
        
        ltac_plugin__Leminv.cmt
        
        ltac_plugin__Leminv.cmti
        
        ltac_plugin__Leminv.cmx
        
        ltac_plugin__Pltac.cmi
        
        ltac_plugin__Pltac.cmt
        
        ltac_plugin__Pltac.cmti
        
        ltac_plugin__Pltac.cmx
        
        ltac_plugin__Pptactic.cmi
        
        ltac_plugin__Pptactic.cmt
        
        ltac_plugin__Pptactic.cmti
        
        ltac_plugin__Pptactic.cmx
        
        ltac_plugin__Profile_ltac_tactics.cmi
        
        ltac_plugin__Profile_ltac_tactics.cmt
        
        ltac_plugin__Profile_ltac_tactics.cmti
        
        ltac_plugin__Profile_ltac_tactics.cmx
        
        ltac_plugin__Tacarg.cmi
        
        ltac_plugin__Tacarg.cmt
        
        ltac_plugin__Tacarg.cmti
        
        ltac_plugin__Tacarg.cmx
        
        ltac_plugin__Taccoerce.cmi
        
        ltac_plugin__Taccoerce.cmt
        
        ltac_plugin__Taccoerce.cmti
        
        ltac_plugin__Taccoerce.cmx
        
        ltac_plugin__Tacentries.cmi
        
        ltac_plugin__Tacentries.cmt
        
        ltac_plugin__Tacentries.cmti
        
        ltac_plugin__Tacentries.cmx
        
        ltac_plugin__Tacenv.cmi
        
        ltac_plugin__Tacenv.cmt
        
        ltac_plugin__Tacenv.cmti
        
        ltac_plugin__Tacenv.cmx
        
        ltac_plugin__Tacexpr.cmi
        
        ltac_plugin__Tacexpr.cmti
        
        ltac_plugin__Tacintern.cmi
        
        ltac_plugin__Tacintern.cmt
        
        ltac_plugin__Tacintern.cmti
        
        ltac_plugin__Tacintern.cmx
        
        ltac_plugin__Tacinterp.cmi
        
        ltac_plugin__Tacinterp.cmt
        
        ltac_plugin__Tacinterp.cmti
        
        ltac_plugin__Tacinterp.cmx
        
        ltac_plugin__Tacsubst.cmi
        
        ltac_plugin__Tacsubst.cmt
        
        ltac_plugin__Tacsubst.cmti
        
        ltac_plugin__Tacsubst.cmx
        
        ltac_plugin__Tactic_debug.cmi
        
        ltac_plugin__Tactic_debug.cmt
        
        ltac_plugin__Tactic_debug.cmti
        
        ltac_plugin__Tactic_debug.cmx
        
        ltac_plugin__Tactic_matching.cmi
        
        ltac_plugin__Tactic_matching.cmt
        
        ltac_plugin__Tactic_matching.cmti
        
        ltac_plugin__Tactic_matching.cmx
        
        ltac_plugin__Tactic_option.cmi
        
        ltac_plugin__Tactic_option.cmt
        
        ltac_plugin__Tactic_option.cmti
        
        ltac_plugin__Tactic_option.cmx
        
        pltac.mli
        
        pptactic.mli
        
        profile_ltac_tactics.mli
        
        tacarg.mli
        
        taccoerce.mli
        
        tacentries.mli
        
        tacenv.mli
        
        tacexpr.mli
        
        tacintern.mli
        
        tacinterp.mli
        
        tacsubst.mli
        
        tactic_debug.mli
        
        tactic_matching.mli
        
        tactic_option.mli
        
        ltac2/
        
        g_ltac2.mli
        
        ltac2_plugin.a
        
        ltac2_plugin.cma
        
        ltac2_plugin.cmi
        
        ltac2_plugin.cmt
        
        ltac2_plugin.cmx
        
        ltac2_plugin.cmxa
        
        ltac2_plugin.cmxs
        
        ltac2_plugin.ml
        
        ltac2_plugin__G_ltac2.cmi
        
        ltac2_plugin__G_ltac2.cmt
        
        ltac2_plugin__G_ltac2.cmti
        
        ltac2_plugin__G_ltac2.cmx
        
        ltac2_plugin__Tac2bt.cmi
        
        ltac2_plugin__Tac2bt.cmt
        
        ltac2_plugin__Tac2bt.cmti
        
        ltac2_plugin__Tac2bt.cmx
        
        ltac2_plugin__Tac2core.cmi
        
        ltac2_plugin__Tac2core.cmt
        
        ltac2_plugin__Tac2core.cmti
        
        ltac2_plugin__Tac2core.cmx
        
        ltac2_plugin__Tac2dyn.cmi
        
        ltac2_plugin__Tac2dyn.cmt
        
        ltac2_plugin__Tac2dyn.cmti
        
        ltac2_plugin__Tac2dyn.cmx
        
        ltac2_plugin__Tac2entries.cmi
        
        ltac2_plugin__Tac2entries.cmt
        
        ltac2_plugin__Tac2entries.cmti
        
        ltac2_plugin__Tac2entries.cmx
        
        ltac2_plugin__Tac2env.cmi
        
        ltac2_plugin__Tac2env.cmt
        
        ltac2_plugin__Tac2env.cmti
        
        ltac2_plugin__Tac2env.cmx
        
        ltac2_plugin__Tac2expr.cmi
        
        ltac2_plugin__Tac2expr.cmti
        
        ltac2_plugin__Tac2externals.cmi
        
        ltac2_plugin__Tac2externals.cmt
        
        ltac2_plugin__Tac2externals.cmti
        
        ltac2_plugin__Tac2externals.cmx
        
        ltac2_plugin__Tac2extffi.cmi
        
        ltac2_plugin__Tac2extffi.cmt
        
        ltac2_plugin__Tac2extffi.cmti
        
        ltac2_plugin__Tac2extffi.cmx
        
        ltac2_plugin__Tac2ffi.cmi
        
        ltac2_plugin__Tac2ffi.cmt
        
        ltac2_plugin__Tac2ffi.cmti
        
        ltac2_plugin__Tac2ffi.cmx
        
        ltac2_plugin__Tac2intern.cmi
        
        ltac2_plugin__Tac2intern.cmt
        
        ltac2_plugin__Tac2intern.cmti
        
        ltac2_plugin__Tac2intern.cmx
        
        ltac2_plugin__Tac2interp.cmi
        
        ltac2_plugin__Tac2interp.cmt
        
        ltac2_plugin__Tac2interp.cmti
        
        ltac2_plugin__Tac2interp.cmx
        
        ltac2_plugin__Tac2match.cmi
        
        ltac2_plugin__Tac2match.cmt
        
        ltac2_plugin__Tac2match.cmti
        
        ltac2_plugin__Tac2match.cmx
        
        ltac2_plugin__Tac2print.cmi
        
        ltac2_plugin__Tac2print.cmt
        
        ltac2_plugin__Tac2print.cmti
        
        ltac2_plugin__Tac2print.cmx
        
        ltac2_plugin__Tac2qexpr.cmi
        
        ltac2_plugin__Tac2qexpr.cmti
        
        ltac2_plugin__Tac2quote.cmi
        
        ltac2_plugin__Tac2quote.cmt
        
        ltac2_plugin__Tac2quote.cmti
        
        ltac2_plugin__Tac2quote.cmx
        
        ltac2_plugin__Tac2stdlib.cmi
        
        ltac2_plugin__Tac2stdlib.cmt
        
        ltac2_plugin__Tac2stdlib.cmti
        
        ltac2_plugin__Tac2stdlib.cmx
        
        ltac2_plugin__Tac2tactics.cmi
        
        ltac2_plugin__Tac2tactics.cmt
        
        ltac2_plugin__Tac2tactics.cmti
        
        ltac2_plugin__Tac2tactics.cmx
        
        ltac2_plugin__Tac2types.cmi
        
        ltac2_plugin__Tac2types.cmti
        
        ltac2_plugin__Tac2typing_env.cmi
        
        ltac2_plugin__Tac2typing_env.cmt
        
        ltac2_plugin__Tac2typing_env.cmti
        
        ltac2_plugin__Tac2typing_env.cmx
        
        ltac2_plugin__Tac2val.cmi
        
        ltac2_plugin__Tac2val.cmt
        
        ltac2_plugin__Tac2val.cmti
        
        ltac2_plugin__Tac2val.cmx
        
        tac2bt.mli
        
        tac2core.mli
        
        tac2dyn.mli
        
        tac2entries.mli
        
        tac2env.mli
        
        tac2expr.mli
        
        tac2externals.mli
        
        tac2extffi.mli
        
        tac2ffi.mli
        
        tac2intern.mli
        
        tac2interp.mli
        
        tac2match.mli
        
        tac2print.mli
        
        tac2qexpr.mli
        
        tac2quote.mli
        
        tac2stdlib.mli
        
        tac2tactics.mli
        
        tac2types.mli
        
        tac2typing_env.mli
        
        tac2val.mli
        
        ltac2_ltac1/
        
        g_ltac2_ltac1.mli
        
        ltac2_ltac1_plugin.a
        
        ltac2_ltac1_plugin.cma
        
        ltac2_ltac1_plugin.cmi
        
        ltac2_ltac1_plugin.cmt
        
        ltac2_ltac1_plugin.cmx
        
        ltac2_ltac1_plugin.cmxa
        
        ltac2_ltac1_plugin.cmxs
        
        ltac2_ltac1_plugin.ml
        
        ltac2_ltac1_plugin__G_ltac2_ltac1.cmi
        
        ltac2_ltac1_plugin__G_ltac2_ltac1.cmt
        
        ltac2_ltac1_plugin__G_ltac2_ltac1.cmti
        
        ltac2_ltac1_plugin__G_ltac2_ltac1.cmx
        
        ltac2_ltac1_plugin__Tac2core_ltac1.cmi
        
        ltac2_ltac1_plugin__Tac2core_ltac1.cmt
        
        ltac2_ltac1_plugin__Tac2core_ltac1.cmti
        
        ltac2_ltac1_plugin__Tac2core_ltac1.cmx
        
        ltac2_ltac1_plugin__Tac2quote_ltac1.cmi
        
        ltac2_ltac1_plugin__Tac2quote_ltac1.cmt
        
        ltac2_ltac1_plugin__Tac2quote_ltac1.cmti
        
        ltac2_ltac1_plugin__Tac2quote_ltac1.cmx
        
        ltac2_ltac1_plugin__Tac2stdlib_ltac1.cmi
        
        ltac2_ltac1_plugin__Tac2stdlib_ltac1.cmt
        
        ltac2_ltac1_plugin__Tac2stdlib_ltac1.cmti
        
        ltac2_ltac1_plugin__Tac2stdlib_ltac1.cmx
        
        tac2core_ltac1.mli
        
        tac2quote_ltac1.mli
        
        tac2stdlib_ltac1.mli
        
        micromega/
        
        certificate.mli
        
        coq_micromega.mli
        
        g_micromega.mli
        
        itv.mli
        
        linsolve.mli
        
        micromega_plugin.a
        
        micromega_plugin.cma
        
        micromega_plugin.cmi
        
        micromega_plugin.cmt
        
        micromega_plugin.cmx
        
        micromega_plugin.cmxa
        
        micromega_plugin.cmxs
        
        micromega_plugin.ml
        
        micromega_plugin__Certificate.cmi
        
        micromega_plugin__Certificate.cmt
        
        micromega_plugin__Certificate.cmti
        
        micromega_plugin__Certificate.cmx
        
        micromega_plugin__Coq_micromega.cmi
        
        micromega_plugin__Coq_micromega.cmt
        
        micromega_plugin__Coq_micromega.cmti
        
        micromega_plugin__Coq_micromega.cmx
        
        micromega_plugin__G_micromega.cmi
        
        micromega_plugin__G_micromega.cmt
        
        micromega_plugin__G_micromega.cmti
        
        micromega_plugin__G_micromega.cmx
        
        micromega_plugin__Itv.cmi
        
        micromega_plugin__Itv.cmt
        
        micromega_plugin__Itv.cmti
        
        micromega_plugin__Itv.cmx
        
        micromega_plugin__Linsolve.cmi
        
        micromega_plugin__Linsolve.cmt
        
        micromega_plugin__Linsolve.cmti
        
        micromega_plugin__Linsolve.cmx
        
        micromega_plugin__Persistent_cache.cmi
        
        micromega_plugin__Persistent_cache.cmt
        
        micromega_plugin__Persistent_cache.cmti
        
        micromega_plugin__Persistent_cache.cmx
        
        micromega_plugin__Polynomial.cmi
        
        micromega_plugin__Polynomial.cmt
        
        micromega_plugin__Polynomial.cmti
        
        micromega_plugin__Polynomial.cmx
        
        micromega_plugin__Simplex.cmi
        
        micromega_plugin__Simplex.cmt
        
        micromega_plugin__Simplex.cmti
        
        micromega_plugin__Simplex.cmx
        
        micromega_plugin__Vect.cmi
        
        micromega_plugin__Vect.cmt
        
        micromega_plugin__Vect.cmti
        
        micromega_plugin__Vect.cmx
        
        persistent_cache.mli
        
        polynomial.mli
        
        simplex.mli
        
        vect.mli
        
        micromega_core/
        
        micromega.mli
        
        micromega_core_plugin.a
        
        micromega_core_plugin.cma
        
        micromega_core_plugin.cmi
        
        micromega_core_plugin.cmt
        
        micromega_core_plugin.cmx
        
        micromega_core_plugin.cmxa
        
        micromega_core_plugin.cmxs
        
        micromega_core_plugin.ml
        
        micromega_core_plugin__Micromega.cmi
        
        micromega_core_plugin__Micromega.cmt
        
        micromega_core_plugin__Micromega.cmti
        
        micromega_core_plugin__Micromega.cmx
        
        micromega_core_plugin__Mutils.cmi
        
        micromega_core_plugin__Mutils.cmt
        
        micromega_core_plugin__Mutils.cmti
        
        micromega_core_plugin__Mutils.cmx
        
        micromega_core_plugin__NumCompat.cmi
        
        micromega_core_plugin__NumCompat.cmt
        
        micromega_core_plugin__NumCompat.cmti
        
        micromega_core_plugin__NumCompat.cmx
        
        micromega_core_plugin__Sos.cmi
        
        micromega_core_plugin__Sos.cmt
        
        micromega_core_plugin__Sos.cmti
        
        micromega_core_plugin__Sos.cmx
        
        micromega_core_plugin__Sos_lib.cmi
        
        micromega_core_plugin__Sos_lib.cmt
        
        micromega_core_plugin__Sos_lib.cmti
        
        micromega_core_plugin__Sos_lib.cmx
        
        micromega_core_plugin__Sos_types.cmi
        
        micromega_core_plugin__Sos_types.cmt
        
        micromega_core_plugin__Sos_types.cmti
        
        micromega_core_plugin__Sos_types.cmx
        
        mutils.mli
        
        numCompat.mli
        
        sos.mli
        
        sos_lib.mli
        
        sos_types.mli
        
        nsatz/
        
        g_nsatz.mli
        
        ideal.mli
        
        nsatz.mli
        
        nsatz_plugin.a
        
        nsatz_plugin.cma
        
        nsatz_plugin.cmi
        
        nsatz_plugin.cmt
        
        nsatz_plugin.cmx
        
        nsatz_plugin.cmxa
        
        nsatz_plugin.cmxs
        
        nsatz_plugin.ml
        
        nsatz_plugin__G_nsatz.cmi
        
        nsatz_plugin__G_nsatz.cmt
        
        nsatz_plugin__G_nsatz.cmti
        
        nsatz_plugin__G_nsatz.cmx
        
        nsatz_plugin__Ideal.cmi
        
        nsatz_plugin__Ideal.cmt
        
        nsatz_plugin__Ideal.cmti
        
        nsatz_plugin__Ideal.cmx
        
        nsatz_plugin__Nsatz.cmi
        
        nsatz_plugin__Nsatz.cmt
        
        nsatz_plugin__Nsatz.cmti
        
        nsatz_plugin__Nsatz.cmx
        
        nsatz_plugin__Polynom.cmi
        
        nsatz_plugin__Polynom.cmt
        
        nsatz_plugin__Polynom.cmti
        
        nsatz_plugin__Polynom.cmx
        
        nsatz_plugin__Utile.cmi
        
        nsatz_plugin__Utile.cmt
        
        nsatz_plugin__Utile.cmti
        
        nsatz_plugin__Utile.cmx
        
        polynom.mli
        
        utile.mli
        
        number_string_notation/
        
        g_number_string.mli
        
        number_string.mli
        
        number_string_notation_plugin.a
        
        number_string_notation_plugin.cma
        
        number_string_notation_plugin.cmi
        
        number_string_notation_plugin.cmt
        
        number_string_notation_plugin.cmx
        
        number_string_notation_plugin.cmxa
        
        number_string_notation_plugin.cmxs
        
        number_string_notation_plugin.ml
        
        number_string_notation_plugin__G_number_string.cmi
        
        number_string_notation_plugin__G_number_string.cmt
        
        number_string_notation_plugin__G_number_string.cmti
        
        number_string_notation_plugin__G_number_string.cmx
        
        number_string_notation_plugin__Number_string.cmi
        
        number_string_notation_plugin__Number_string.cmt
        
        number_string_notation_plugin__Number_string.cmti
        
        number_string_notation_plugin__Number_string.cmx
        
        ring/
        
        g_ring.mli
        
        ring.mli
        
        ring_ast.mli
        
        ring_plugin.a
        
        ring_plugin.cma
        
        ring_plugin.cmi
        
        ring_plugin.cmt
        
        ring_plugin.cmx
        
        ring_plugin.cmxa
        
        ring_plugin.cmxs
        
        ring_plugin.ml
        
        ring_plugin__G_ring.cmi
        
        ring_plugin__G_ring.cmt
        
        ring_plugin__G_ring.cmti
        
        ring_plugin__G_ring.cmx
        
        ring_plugin__Ring.cmi
        
        ring_plugin__Ring.cmt
        
        ring_plugin__Ring.cmti
        
        ring_plugin__Ring.cmx
        
        ring_plugin__Ring_ast.cmi
        
        ring_plugin__Ring_ast.cmt
        
        ring_plugin__Ring_ast.cmti
        
        ring_plugin__Ring_ast.cmx
        
        rtauto/
        
        g_rtauto.mli
        
        proof_search.mli
        
        refl_tauto.mli
        
        rtauto_plugin.a
        
        rtauto_plugin.cma
        
        rtauto_plugin.cmi
        
        rtauto_plugin.cmt
        
        rtauto_plugin.cmx
        
        rtauto_plugin.cmxa
        
        rtauto_plugin.cmxs
        
        rtauto_plugin.ml
        
        rtauto_plugin__G_rtauto.cmi
        
        rtauto_plugin__G_rtauto.cmt
        
        rtauto_plugin__G_rtauto.cmti
        
        rtauto_plugin__G_rtauto.cmx
        
        rtauto_plugin__Proof_search.cmi
        
        rtauto_plugin__Proof_search.cmt
        
        rtauto_plugin__Proof_search.cmti
        
        rtauto_plugin__Proof_search.cmx
        
        rtauto_plugin__Refl_tauto.cmi
        
        rtauto_plugin__Refl_tauto.cmt
        
        rtauto_plugin__Refl_tauto.cmti
        
        rtauto_plugin__Refl_tauto.cmx
        
        ssreflect/
        
        ssrast.mli
        
        ssrbwd.mli
        
        ssrcommon.mli
        
        ssreflect_plugin.a
        
        ssreflect_plugin.cma
        
        ssreflect_plugin.cmi
        
        ssreflect_plugin.cmt
        
        ssreflect_plugin.cmx
        
        ssreflect_plugin.cmxa
        
        ssreflect_plugin.cmxs
        
        ssreflect_plugin.ml
        
        ssreflect_plugin__Ssrast.cmi
        
        ssreflect_plugin__Ssrast.cmti
        
        ssreflect_plugin__Ssrbwd.cmi
        
        ssreflect_plugin__Ssrbwd.cmt
        
        ssreflect_plugin__Ssrbwd.cmti
        
        ssreflect_plugin__Ssrbwd.cmx
        
        ssreflect_plugin__Ssrcommon.cmi
        
        ssreflect_plugin__Ssrcommon.cmt
        
        ssreflect_plugin__Ssrcommon.cmti
        
        ssreflect_plugin__Ssrcommon.cmx
        
        ssreflect_plugin__Ssrelim.cmi
        
        ssreflect_plugin__Ssrelim.cmt
        
        ssreflect_plugin__Ssrelim.cmti
        
        ssreflect_plugin__Ssrelim.cmx
        
        ssreflect_plugin__Ssrequality.cmi
        
        ssreflect_plugin__Ssrequality.cmt
        
        ssreflect_plugin__Ssrequality.cmti
        
        ssreflect_plugin__Ssrequality.cmx
        
        ssreflect_plugin__Ssrfwd.cmi
        
        ssreflect_plugin__Ssrfwd.cmt
        
        ssreflect_plugin__Ssrfwd.cmti
        
        ssreflect_plugin__Ssrfwd.cmx
        
        ssreflect_plugin__Ssripats.cmi
        
        ssreflect_plugin__Ssripats.cmt
        
        ssreflect_plugin__Ssripats.cmti
        
        ssreflect_plugin__Ssripats.cmx
        
        ssreflect_plugin__Ssrparser.cmi
        
        ssreflect_plugin__Ssrparser.cmt
        
        ssreflect_plugin__Ssrparser.cmti
        
        ssreflect_plugin__Ssrparser.cmx
        
        ssreflect_plugin__Ssrprinters.cmi
        
        ssreflect_plugin__Ssrprinters.cmt
        
        ssreflect_plugin__Ssrprinters.cmti
        
        ssreflect_plugin__Ssrprinters.cmx
        
        ssreflect_plugin__Ssrtacs.cmi
        
        ssreflect_plugin__Ssrtacs.cmt
        
        ssreflect_plugin__Ssrtacs.cmti
        
        ssreflect_plugin__Ssrtacs.cmx
        
        ssreflect_plugin__Ssrtacticals.cmi
        
        ssreflect_plugin__Ssrtacticals.cmt
        
        ssreflect_plugin__Ssrtacticals.cmti
        
        ssreflect_plugin__Ssrtacticals.cmx
        
        ssreflect_plugin__Ssrvernac.cmi
        
        ssreflect_plugin__Ssrvernac.cmt
        
        ssreflect_plugin__Ssrvernac.cmti
        
        ssreflect_plugin__Ssrvernac.cmx
        
        ssreflect_plugin__Ssrview.cmi
        
        ssreflect_plugin__Ssrview.cmt
        
        ssreflect_plugin__Ssrview.cmti
        
        ssreflect_plugin__Ssrview.cmx
        
        ssrelim.mli
        
        ssrequality.mli
        
        ssrfwd.mli
        
        ssripats.mli
        
        ssrparser.mli
        
        ssrprinters.mli
        
        ssrtacs.mli
        
        ssrtacticals.mli
        
        ssrvernac.mli
        
        ssrview.mli
        
        ssrmatching/
        
        g_ssrmatching.mli
        
        ssrmatching.mli
        
        ssrmatching_plugin.a
        
        ssrmatching_plugin.cma
        
        ssrmatching_plugin.cmi
        
        ssrmatching_plugin.cmt
        
        ssrmatching_plugin.cmx
        
        ssrmatching_plugin.cmxa
        
        ssrmatching_plugin.cmxs
        
        ssrmatching_plugin.ml
        
        ssrmatching_plugin__G_ssrmatching.cmi
        
        ssrmatching_plugin__G_ssrmatching.cmt
        
        ssrmatching_plugin__G_ssrmatching.cmti
        
        ssrmatching_plugin__G_ssrmatching.cmx
        
        ssrmatching_plugin__Ssrmatching.cmi
        
        ssrmatching_plugin__Ssrmatching.cmt
        
        ssrmatching_plugin__Ssrmatching.cmti
        
        ssrmatching_plugin__Ssrmatching.cmx
        
        tauto/
        
        tauto.mli
        
        tauto_plugin.a
        
        tauto_plugin.cma
        
        tauto_plugin.cmi
        
        tauto_plugin.cmt
        
        tauto_plugin.cmx
        
        tauto_plugin.cmxa
        
        tauto_plugin.cmxs
        
        tauto_plugin.ml
        
        tauto_plugin__Tauto.cmi
        
        tauto_plugin__Tauto.cmt
        
        tauto_plugin__Tauto.cmti
        
        tauto_plugin__Tauto.cmx
        
        tutorial/
        
        p0/
        
        g_tuto0.ml
        
        tuto0_main.mli
        
        tuto0_plugin.a
        
        tuto0_plugin.cma
        
        tuto0_plugin.cmi
        
        tuto0_plugin.cmt
        
        tuto0_plugin.cmx
        
        tuto0_plugin.cmxa
        
        tuto0_plugin.cmxs
        
        tuto0_plugin.ml
        
        tuto0_plugin__G_tuto0.cmi
        
        tuto0_plugin__G_tuto0.cmt
        
        tuto0_plugin__G_tuto0.cmx
        
        tuto0_plugin__Tuto0_main.cmi
        
        tuto0_plugin__Tuto0_main.cmt
        
        tuto0_plugin__Tuto0_main.cmti
        
        tuto0_plugin__Tuto0_main.cmx
        
        p1/
        
        g_tuto1.ml
        
        inspector.mli
        
        simple_check.mli
        
        simple_declare.mli
        
        simple_print.mli
        
        tuto1_plugin.a
        
        tuto1_plugin.cma
        
        tuto1_plugin.cmi
        
        tuto1_plugin.cmt
        
        tuto1_plugin.cmx
        
        tuto1_plugin.cmxa
        
        tuto1_plugin.cmxs
        
        tuto1_plugin.ml
        
        tuto1_plugin__G_tuto1.cmi
        
        tuto1_plugin__G_tuto1.cmt
        
        tuto1_plugin__G_tuto1.cmx
        
        tuto1_plugin__Inspector.cmi
        
        tuto1_plugin__Inspector.cmt
        
        tuto1_plugin__Inspector.cmti
        
        tuto1_plugin__Inspector.cmx
        
        tuto1_plugin__Simple_check.cmi
        
        tuto1_plugin__Simple_check.cmt
        
        tuto1_plugin__Simple_check.cmti
        
        tuto1_plugin__Simple_check.cmx
        
        tuto1_plugin__Simple_declare.cmi
        
        tuto1_plugin__Simple_declare.cmt
        
        tuto1_plugin__Simple_declare.cmti
        
        tuto1_plugin__Simple_declare.cmx
        
        tuto1_plugin__Simple_print.cmi
        
        tuto1_plugin__Simple_print.cmt
        
        tuto1_plugin__Simple_print.cmti
        
        tuto1_plugin__Simple_print.cmx
        
        p2/
        
        counter.mli
        
        custom.mli
        
        g_tuto2.ml
        
        persistent_counter.mli
        
        tuto2_plugin.a
        
        tuto2_plugin.cma
        
        tuto2_plugin.cmi
        
        tuto2_plugin.cmt
        
        tuto2_plugin.cmx
        
        tuto2_plugin.cmxa
        
        tuto2_plugin.cmxs
        
        tuto2_plugin.ml
        
        tuto2_plugin__Counter.cmi
        
        tuto2_plugin__Counter.cmt
        
        tuto2_plugin__Counter.cmti
        
        tuto2_plugin__Counter.cmx
        
        tuto2_plugin__Custom.cmi
        
        tuto2_plugin__Custom.cmt
        
        tuto2_plugin__Custom.cmti
        
        tuto2_plugin__Custom.cmx
        
        tuto2_plugin__G_tuto2.cmi
        
        tuto2_plugin__G_tuto2.cmt
        
        tuto2_plugin__G_tuto2.cmx
        
        tuto2_plugin__Persistent_counter.cmi
        
        tuto2_plugin__Persistent_counter.cmt
        
        tuto2_plugin__Persistent_counter.cmti
        
        tuto2_plugin__Persistent_counter.cmx
        
        p3/
        
        construction_game.mli
        
        g_tuto3.ml
        
        tuto3_plugin.a
        
        tuto3_plugin.cma
        
        tuto3_plugin.cmi
        
        tuto3_plugin.cmt
        
        tuto3_plugin.cmx
        
        tuto3_plugin.cmxa
        
        tuto3_plugin.cmxs
        
        tuto3_plugin.ml
        
        tuto3_plugin__Construction_game.cmi
        
        tuto3_plugin__Construction_game.cmt
        
        tuto3_plugin__Construction_game.cmti
        
        tuto3_plugin__Construction_game.cmx
        
        tuto3_plugin__G_tuto3.cmi
        
        tuto3_plugin__G_tuto3.cmt
        
        tuto3_plugin__G_tuto3.cmx
        
        tuto3_plugin__Tuto_tactic.cmi
        
        tuto3_plugin__Tuto_tactic.cmt
        
        tuto3_plugin__Tuto_tactic.cmti
        
        tuto3_plugin__Tuto_tactic.cmx
        
        tuto_tactic.mli
        
        zify/
        
        g_zify.mli
        
        zify.mli
        
        zify_plugin.a
        
        zify_plugin.cma
        
        zify_plugin.cmi
        
        zify_plugin.cmt
        
        zify_plugin.cmx
        
        zify_plugin.cmxa
        
        zify_plugin.cmxs
        
        zify_plugin.ml
        
        zify_plugin__G_zify.cmi
        
        zify_plugin__G_zify.cmt
        
        zify_plugin__G_zify.cmti
        
        zify_plugin__G_zify.cmx
        
        zify_plugin__Zify.cmi
        
        zify_plugin__Zify.cmt
        
        zify_plugin__Zify.cmti
        
        zify_plugin__Zify.cmx
      - pretyping/
        
        arguments_renaming.cmi
        
        arguments_renaming.cmt
        
        arguments_renaming.cmti
        
        arguments_renaming.cmx
        
        arguments_renaming.mli
        
        cases.cmi
        
        cases.cmt
        
        cases.cmti
        
        cases.cmx
        
        cases.mli
        
        cbv.cmi
        
        cbv.cmt
        
        cbv.cmti
        
        cbv.cmx
        
        cbv.mli
        
        coercion.cmi
        
        coercion.cmt
        
        coercion.cmti
        
        coercion.cmx
        
        coercion.mli
        
        coercionops.cmi
        
        coercionops.cmt
        
        coercionops.cmti
        
        coercionops.cmx
        
        coercionops.mli
        
        combinators.cmi
        
        combinators.cmt
        
        combinators.cmti
        
        combinators.cmx
        
        combinators.mli
        
        constr_matching.cmi
        
        constr_matching.cmt
        
        constr_matching.cmti
        
        constr_matching.cmx
        
        constr_matching.mli
        
        detyping.cmi
        
        detyping.cmt
        
        detyping.cmti
        
        detyping.cmx
        
        detyping.mli
        
        evaluable.cmi
        
        evaluable.cmt
        
        evaluable.cmti
        
        evaluable.cmx
        
        evaluable.mli
        
        evarconv.cmi
        
        evarconv.cmt
        
        evarconv.cmti
        
        evarconv.cmx
        
        evarconv.mli
        
        evardefine.cmi
        
        evardefine.cmt
        
        evardefine.cmti
        
        evardefine.cmx
        
        evardefine.mli
        
        evarsolve.cmi
        
        evarsolve.cmt
        
        evarsolve.cmti
        
        evarsolve.cmx
        
        evarsolve.mli
        
        find_subterm.cmi
        
        find_subterm.cmt
        
        find_subterm.cmti
        
        find_subterm.cmx
        
        find_subterm.mli
        
        genarg.cmi
        
        genarg.cmt
        
        genarg.cmti
        
        genarg.cmx
        
        genarg.mli
        
        geninterp.cmi
        
        geninterp.cmt
        
        geninterp.cmti
        
        geninterp.cmx
        
        geninterp.mli
        
        gensubst.cmi
        
        gensubst.cmt
        
        gensubst.cmti
        
        gensubst.cmx
        
        gensubst.mli
        
        globEnv.cmi
        
        globEnv.cmt
        
        globEnv.cmti
        
        globEnv.cmx
        
        globEnv.mli
        
        glob_ops.cmi
        
        glob_ops.cmt
        
        glob_ops.cmti
        
        glob_ops.cmx
        
        glob_ops.mli
        
        glob_term.cmi
        
        glob_term.cmti
        
        glob_term.mli
        
        heads.cmi
        
        heads.cmt
        
        heads.cmti
        
        heads.cmx
        
        heads.mli
        
        indrec.cmi
        
        indrec.cmt
        
        indrec.cmti
        
        indrec.cmx
        
        indrec.mli
        
        inductiveops.cmi
        
        inductiveops.cmt
        
        inductiveops.cmti
        
        inductiveops.cmx
        
        inductiveops.mli
        
        keys.cmi
        
        keys.cmt
        
        keys.cmti
        
        keys.cmx
        
        keys.mli
        
        locus.cmi
        
        locus.cmti
        
        locus.mli
        
        locusops.cmi
        
        locusops.cmt
        
        locusops.cmti
        
        locusops.cmx
        
        locusops.mli
        
        ltac_pretype.cmi
        
        ltac_pretype.cmti
        
        ltac_pretype.mli
        
        nativenorm.cmi
        
        nativenorm.cmt
        
        nativenorm.cmti
        
        nativenorm.cmx
        
        nativenorm.mli
        
        pattern.cmi
        
        pattern.cmti
        
        pattern.mli
        
        patternops.cmi
        
        patternops.cmt
        
        patternops.cmti
        
        patternops.cmx
        
        patternops.mli
        
        pretype_errors.cmi
        
        pretype_errors.cmt
        
        pretype_errors.cmti
        
        pretype_errors.cmx
        
        pretype_errors.mli
        
        pretyping.a
        
        pretyping.cma
        
        pretyping.cmi
        
        pretyping.cmt
        
        pretyping.cmti
        
        pretyping.cmx
        
        pretyping.cmxa
        
        pretyping.cmxs
        
        pretyping.mli
        
        program.cmi
        
        program.cmt
        
        program.cmti
        
        program.cmx
        
        program.mli
        
        reductionops.cmi
        
        reductionops.cmt
        
        reductionops.cmti
        
        reductionops.cmx
        
        reductionops.mli
        
        retyping.cmi
        
        retyping.cmt
        
        retyping.cmti
        
        retyping.cmx
        
        retyping.mli
        
        structures.cmi
        
        structures.cmt
        
        structures.cmti
        
        structures.cmx
        
        structures.mli
        
        tacred.cmi
        
        tacred.cmt
        
        tacred.cmti
        
        tacred.cmx
        
        tacred.mli
        
        typeclasses.cmi
        
        typeclasses.cmt
        
        typeclasses.cmti
        
        typeclasses.cmx
        
        typeclasses.mli
        
        typeclasses_errors.cmi
        
        typeclasses_errors.cmt
        
        typeclasses_errors.cmti
        
        typeclasses_errors.cmx
        
        typeclasses_errors.mli
        
        typing.cmi
        
        typing.cmt
        
        typing.cmti
        
        typing.cmx
        
        typing.mli
        
        unification.cmi
        
        unification.cmt
        
        unification.cmti
        
        unification.cmx
        
        unification.mli
        
        vnorm.cmi
        
        vnorm.cmt
        
        vnorm.cmti
        
        vnorm.cmx
        
        vnorm.mli
      - printing/
        
        genprint.cmi
        
        genprint.cmt
        
        genprint.cmti
        
        genprint.cmx
        
        genprint.mli
        
        ppconstr.cmi
        
        ppconstr.cmt
        
        ppconstr.cmti
        
        ppconstr.cmx
        
        ppconstr.mli
        
        ppextend.cmi
        
        ppextend.cmt
        
        ppextend.cmti
        
        ppextend.cmx
        
        ppextend.mli
        
        pputils.cmi
        
        pputils.cmt
        
        pputils.cmti
        
        pputils.cmx
        
        pputils.mli
        
        printer.cmi
        
        printer.cmt
        
        printer.cmti
        
        printer.cmx
        
        printer.mli
        
        printing.a
        
        printing.cma
        
        printing.cmxa
        
        printing.cmxs
        
        proof_diffs.cmi
        
        proof_diffs.cmt
        
        proof_diffs.cmti
        
        proof_diffs.cmx
        
        proof_diffs.mli
      - proofs/
        
        clenv.cmi
        
        clenv.cmt
        
        clenv.cmti
        
        clenv.cmx
        
        clenv.mli
        
        goal_select.cmi
        
        goal_select.cmt
        
        goal_select.cmti
        
        goal_select.cmx
        
        goal_select.mli
        
        logic.cmi
        
        logic.cmt
        
        logic.cmti
        
        logic.cmx
        
        logic.mli
        
        miscprint.cmi
        
        miscprint.cmt
        
        miscprint.cmti
        
        miscprint.cmx
        
        miscprint.mli
        
        proof.cmi
        
        proof.cmt
        
        proof.cmti
        
        proof.cmx
        
        proof.mli
        
        proof_bullet.cmi
        
        proof_bullet.cmt
        
        proof_bullet.cmti
        
        proof_bullet.cmx
        
        proof_bullet.mli
        
        proofs.a
        
        proofs.cma
        
        proofs.cmxa
        
        proofs.cmxs
        
        refine.cmi
        
        refine.cmt
        
        refine.cmti
        
        refine.cmx
        
        refine.mli
        
        tacmach.cmi
        
        tacmach.cmt
        
        tacmach.cmti
        
        tacmach.cmx
        
        tacmach.mli
        
        tactypes.cmi
        
        tactypes.cmti
        
        tactypes.mli
      - revision
      - stm/
        
        asyncTaskQueue.cmi
        
        asyncTaskQueue.cmt
        
        asyncTaskQueue.cmti
        
        asyncTaskQueue.cmx
        
        asyncTaskQueue.mli
        
        dag.cmi
        
        dag.cmt
        
        dag.cmti
        
        dag.cmx
        
        dag.mli
        
        partac.cmi
        
        partac.cmt
        
        partac.cmti
        
        partac.cmx
        
        partac.mli
        
        proofBlockDelimiter.cmi
        
        proofBlockDelimiter.cmt
        
        proofBlockDelimiter.cmti
        
        proofBlockDelimiter.cmx
        
        proofBlockDelimiter.mli
        
        spawned.cmi
        
        spawned.cmt
        
        spawned.cmti
        
        spawned.cmx
        
        spawned.mli
        
        stm.a
        
        stm.cma
        
        stm.cmi
        
        stm.cmt
        
        stm.cmti
        
        stm.cmx
        
        stm.cmxa
        
        stm.cmxs
        
        stm.mli
        
        stmargs.cmi
        
        stmargs.cmt
        
        stmargs.cmti
        
        stmargs.cmx
        
        stmargs.mli
        
        tQueue.cmi
        
        tQueue.cmt
        
        tQueue.cmti
        
        tQueue.cmx
        
        tQueue.mli
        
        vcs.cmi
        
        vcs.cmt
        
        vcs.cmti
        
        vcs.cmx
        
        vcs.mli
        
        workerPool.cmi
        
        workerPool.cmt
        
        workerPool.cmti
        
        workerPool.cmx
        
        workerPool.mli
      - sysinit/
        
        coqargs.cmi
        
        coqargs.cmt
        
        coqargs.cmti
        
        coqargs.cmx
        
        coqargs.mli
        
        coqinit.cmi
        
        coqinit.cmt
        
        coqinit.cmti
        
        coqinit.cmx
        
        coqinit.mli
        
        coqloadpath.cmi
        
        coqloadpath.cmt
        
        coqloadpath.cmti
        
        coqloadpath.cmx
        
        coqloadpath.mli
        
        sysinit.a
        
        sysinit.cma
        
        sysinit.cmxa
        
        sysinit.cmxs
      - tactics/
        
        abstract.cmi
        
        abstract.cmt
        
        abstract.cmti
        
        abstract.cmx
        
        abstract.mli
        
        auto.cmi
        
        auto.cmt
        
        auto.cmti
        
        auto.cmx
        
        auto.mli
        
        autorewrite.cmi
        
        autorewrite.cmt
        
        autorewrite.cmti
        
        autorewrite.cmx
        
        autorewrite.mli
        
        btermdn.cmi
        
        btermdn.cmt
        
        btermdn.cmti
        
        btermdn.cmx
        
        btermdn.mli
        
        cbn.cmi
        
        cbn.cmt
        
        cbn.cmti
        
        cbn.cmx
        
        cbn.mli
        
        class_tactics.cmi
        
        class_tactics.cmt
        
        class_tactics.cmti
        
        class_tactics.cmx
        
        class_tactics.mli
        
        contradiction.cmi
        
        contradiction.cmt
        
        contradiction.cmti
        
        contradiction.cmx
        
        contradiction.mli
        
        declareScheme.cmi
        
        declareScheme.cmt
        
        declareScheme.cmti
        
        declareScheme.cmx
        
        declareScheme.mli
        
        dn.cmi
        
        dn.cmt
        
        dn.cmti
        
        dn.cmx
        
        dn.mli
        
        eClause.cmi
        
        eClause.cmt
        
        eClause.cmti
        
        eClause.cmx
        
        eClause.mli
        
        eauto.cmi
        
        eauto.cmt
        
        eauto.cmti
        
        eauto.cmx
        
        eauto.mli
        
        elim.cmi
        
        elim.cmt
        
        elim.cmti
        
        elim.cmx
        
        elim.mli
        
        elimschemes.cmi
        
        elimschemes.cmt
        
        elimschemes.cmti
        
        elimschemes.cmx
        
        elimschemes.mli
        
        eqdecide.cmi
        
        eqdecide.cmt
        
        eqdecide.cmti
        
        eqdecide.cmx
        
        eqdecide.mli
        
        eqschemes.cmi
        
        eqschemes.cmt
        
        eqschemes.cmti
        
        eqschemes.cmx
        
        eqschemes.mli
        
        equality.cmi
        
        equality.cmt
        
        equality.cmti
        
        equality.cmx
        
        equality.mli
        
        evar_tactics.cmi
        
        evar_tactics.cmt
        
        evar_tactics.cmti
        
        evar_tactics.cmx
        
        evar_tactics.mli
        
        generalize.cmi
        
        generalize.cmt
        
        generalize.cmti
        
        generalize.cmx
        
        generalize.mli
        
        genredexpr.cmi
        
        genredexpr.cmti
        
        genredexpr.mli
        
        hints.cmi
        
        hints.cmt
        
        hints.cmti
        
        hints.cmx
        
        hints.mli
        
        hipattern.cmi
        
        hipattern.cmt
        
        hipattern.cmti
        
        hipattern.cmx
        
        hipattern.mli
        
        ind_tables.cmi
        
        ind_tables.cmt
        
        ind_tables.cmti
        
        ind_tables.cmx
        
        ind_tables.mli
        
        induction.cmi
        
        induction.cmt
        
        induction.cmti
        
        induction.cmx
        
        induction.mli
        
        inv.cmi
        
        inv.cmt
        
        inv.cmti
        
        inv.cmx
        
        inv.mli
        
        ppred.cmi
        
        ppred.cmt
        
        ppred.cmti
        
        ppred.cmx
        
        ppred.mli
        
        redexpr.cmi
        
        redexpr.cmt
        
        redexpr.cmti
        
        redexpr.cmx
        
        redexpr.mli
        
        redops.cmi
        
        redops.cmt
        
        redops.cmti
        
        redops.cmx
        
        redops.mli
        
        rewrite.cmi
        
        rewrite.cmt
        
        rewrite.cmti
        
        rewrite.cmx
        
        rewrite.mli
        
        tacticals.cmi
        
        tacticals.cmt
        
        tacticals.cmti
        
        tacticals.cmx
        
        tacticals.mli
        
        tactics.a
        
        tactics.cma
        
        tactics.cmi
        
        tactics.cmt
        
        tactics.cmti
        
        tactics.cmx
        
        tactics.cmxa
        
        tactics.cmxs
        
        tactics.mli
      - tools/
        
        CoqMakefile.in
        
        TimeFileMaker.py
        
        __pycache__/
        
        TimeFileMaker.cpython-314.opt-1.pyc
        
        TimeFileMaker.cpython-314.pyc
        
        make-both-single-timing-files.cpython-314.opt-1.pyc
        
        make-both-single-timing-files.cpython-314.pyc
        
        make-both-time-files.cpython-314.opt-1.pyc
        
        make-both-time-files.cpython-314.pyc
        
        make-one-time-file.cpython-314.opt-1.pyc
        
        make-one-time-file.cpython-314.pyc
        
        coqdoc/
        
        coqdoc.css
        
        coqdoc.sty
        
        make-both-single-timing-files.py
        
        make-both-time-files.py
        
        make-one-time-file.py
      - toplevel/
        
        ccompile.cmi
        
        ccompile.cmt
        
        ccompile.cmti
        
        ccompile.cmx
        
        ccompile.mli
        
        colors.cmi
        
        colors.cmt
        
        colors.cmti
        
        colors.cmx
        
        colors.mli
        
        common_compile.cmi
        
        common_compile.cmt
        
        common_compile.cmti
        
        common_compile.cmx
        
        common_compile.mli
        
        coqc.cmi
        
        coqc.cmt
        
        coqc.cmti
        
        coqc.cmx
        
        coqc.mli
        
        coqcargs.cmi
        
        coqcargs.cmt
        
        coqcargs.cmti
        
        coqcargs.cmx
        
        coqcargs.mli
        
        coqloop.cmi
        
        coqloop.cmt
        
        coqloop.cmti
        
        coqloop.cmx
        
        coqloop.mli
        
        coqrc.cmi
        
        coqrc.cmt
        
        coqrc.cmti
        
        coqrc.cmx
        
        coqrc.mli
        
        coqtop.cmi
        
        coqtop.cmt
        
        coqtop.cmti
        
        coqtop.cmx
        
        coqtop.mli
        
        g_toplevel.cmi
        
        g_toplevel.cmt
        
        g_toplevel.cmti
        
        g_toplevel.cmx
        
        g_toplevel.mli
        
        load.cmi
        
        load.cmt
        
        load.cmti
        
        load.cmx
        
        load.mli
        
        memtrace_init.cmi
        
        memtrace_init.cmt
        
        memtrace_init.cmti
        
        memtrace_init.cmx
        
        memtrace_init.mli
        
        toplevel.a
        
        toplevel.cma
        
        toplevel.cmxa
        
        toplevel.cmxs
        
        vernac.cmi
        
        vernac.cmt
        
        vernac.cmti
        
        vernac.cmx
        
        vernac.mli
        
        workerLoop.cmi
        
        workerLoop.cmt
        
        workerLoop.cmti
        
        workerLoop.cmx
        
        workerLoop.mli
      - vernac/
        
        assumptions.cmi
        
        assumptions.cmt
        
        assumptions.cmti
        
        assumptions.cmx
        
        assumptions.mli
        
        attributes.cmi
        
        attributes.cmt
        
        attributes.cmti
        
        attributes.cmx
        
        attributes.mli
        
        auto_ind_decl.cmi
        
        auto_ind_decl.cmt
        
        auto_ind_decl.cmti
        
        auto_ind_decl.cmx
        
        auto_ind_decl.mli
        
        canonical.cmi
        
        canonical.cmt
        
        canonical.cmti
        
        canonical.cmx
        
        canonical.mli
        
        classes.cmi
        
        classes.cmt
        
        classes.cmti
        
        classes.cmx
        
        classes.mli
        
        comArguments.cmi
        
        comArguments.cmt
        
        comArguments.cmti
        
        comArguments.cmx
        
        comArguments.mli
        
        comAssumption.cmi
        
        comAssumption.cmt
        
        comAssumption.cmti
        
        comAssumption.cmx
        
        comAssumption.mli
        
        comCoercion.cmi
        
        comCoercion.cmt
        
        comCoercion.cmti
        
        comCoercion.cmx
        
        comCoercion.mli
        
        comDefinition.cmi
        
        comDefinition.cmt
        
        comDefinition.cmti
        
        comDefinition.cmx
        
        comDefinition.mli
        
        comExtraDeps.cmi
        
        comExtraDeps.cmt
        
        comExtraDeps.cmti
        
        comExtraDeps.cmx
        
        comExtraDeps.mli
        
        comFixpoint.cmi
        
        comFixpoint.cmt
        
        comFixpoint.cmti
        
        comFixpoint.cmx
        
        comFixpoint.mli
        
        comHints.cmi
        
        comHints.cmt
        
        comHints.cmti
        
        comHints.cmx
        
        comHints.mli
        
        comInductive.cmi
        
        comInductive.cmt
        
        comInductive.cmti
        
        comInductive.cmx
        
        comInductive.mli
        
        comPrimitive.cmi
        
        comPrimitive.cmt
        
        comPrimitive.cmti
        
        comPrimitive.cmx
        
        comPrimitive.mli
        
        comProgramFixpoint.cmi
        
        comProgramFixpoint.cmt
        
        comProgramFixpoint.cmti
        
        comProgramFixpoint.cmx
        
        comProgramFixpoint.mli
        
        comRewriteRule.cmi
        
        comRewriteRule.cmt
        
        comRewriteRule.cmti
        
        comRewriteRule.cmx
        
        comRewriteRule.mli
        
        comSearch.cmi
        
        comSearch.cmt
        
        comSearch.cmti
        
        comSearch.cmx
        
        comSearch.mli
        
        comTactic.cmi
        
        comTactic.cmt
        
        comTactic.cmti
        
        comTactic.cmx
        
        comTactic.mli
        
        debugHook.cmi
        
        debugHook.cmt
        
        debugHook.cmti
        
        debugHook.cmx
        
        debugHook.mli
        
        declare.cmi
        
        declare.cmt
        
        declare.cmti
        
        declare.cmx
        
        declare.mli
        
        declareInd.cmi
        
        declareInd.cmt
        
        declareInd.cmti
        
        declareInd.cmx
        
        declareInd.mli
        
        declareUniv.cmi
        
        declareUniv.cmt
        
        declareUniv.cmti
        
        declareUniv.cmx
        
        declareUniv.mli
        
        declaremods.cmi
        
        declaremods.cmt
        
        declaremods.cmti
        
        declaremods.cmx
        
        declaremods.mli
        
        egramcoq.cmi
        
        egramcoq.cmt
        
        egramcoq.cmti
        
        egramcoq.cmx
        
        egramcoq.mli
        
        egramml.cmi
        
        egramml.cmt
        
        egramml.cmti
        
        egramml.cmx
        
        egramml.mli
        
        future.cmi
        
        future.cmt
        
        future.cmti
        
        future.cmx
        
        future.mli
        
        g_proofs.cmi
        
        g_proofs.cmt
        
        g_proofs.cmti
        
        g_proofs.cmx
        
        g_proofs.mli
        
        g_redexpr.cmi
        
        g_redexpr.cmt
        
        g_redexpr.cmti
        
        g_redexpr.cmx
        
        g_redexpr.mli
        
        g_vernac.cmi
        
        g_vernac.cmt
        
        g_vernac.cmti
        
        g_vernac.cmx
        
        g_vernac.mli
        
        himsg.cmi
        
        himsg.cmt
        
        himsg.cmti
        
        himsg.cmx
        
        himsg.mli
        
        indschemes.cmi
        
        indschemes.cmt
        
        indschemes.cmti
        
        indschemes.cmx
        
        indschemes.mli
        
        library.cmi
        
        library.cmt
        
        library.cmti
        
        library.cmx
        
        library.mli
        
        loadpath.cmi
        
        loadpath.cmt
        
        loadpath.cmti
        
        loadpath.cmx
        
        loadpath.mli
        
        locality.cmi
        
        locality.cmt
        
        locality.cmti
        
        locality.cmx
        
        locality.mli
        
        metasyntax.cmi
        
        metasyntax.cmt
        
        metasyntax.cmti
        
        metasyntax.cmx
        
        metasyntax.mli
        
        mltop.cmi
        
        mltop.cmt
        
        mltop.cmti
        
        mltop.cmx
        
        mltop.mli
        
        opaques.cmi
        
        opaques.cmt
        
        opaques.cmti
        
        opaques.cmx
        
        opaques.mli
        
        ppvernac.cmi
        
        ppvernac.cmt
        
        ppvernac.cmti
        
        ppvernac.cmx
        
        ppvernac.mli
        
        prettyp.cmi
        
        prettyp.cmt
        
        prettyp.cmti
        
        prettyp.cmx
        
        prettyp.mli
        
        printmod.cmi
        
        printmod.cmt
        
        printmod.cmti
        
        printmod.cmx
        
        printmod.mli
        
        proof_using.cmi
        
        proof_using.cmt
        
        proof_using.cmti
        
        proof_using.cmx
        
        proof_using.mli
        
        pvernac.cmi
        
        pvernac.cmt
        
        pvernac.cmti
        
        pvernac.cmx
        
        pvernac.mli
        
        recLemmas.cmi
        
        recLemmas.cmt
        
        recLemmas.cmti
        
        recLemmas.cmx
        
        recLemmas.mli
        
        record.cmi
        
        record.cmt
        
        record.cmti
        
        record.cmx
        
        record.mli
        
        retrieveObl.cmi
        
        retrieveObl.cmt
        
        retrieveObl.cmti
        
        retrieveObl.cmx
        
        retrieveObl.mli
        
        search.cmi
        
        search.cmt
        
        search.cmti
        
        search.cmx
        
        search.mli
        
        synterp.cmi
        
        synterp.cmt
        
        synterp.cmti
        
        synterp.cmx
        
        synterp.mli
        
        topfmt.cmi
        
        topfmt.cmt
        
        topfmt.cmti
        
        topfmt.cmx
        
        topfmt.mli
        
        vernac.a
        
        vernac.cma
        
        vernac.cmxa
        
        vernac.cmxs
        
        vernac_classifier.cmi
        
        vernac_classifier.cmt
        
        vernac_classifier.cmti
        
        vernac_classifier.cmx
        
        vernac_classifier.mli
        
        vernacentries.cmi
        
        vernacentries.cmt
        
        vernacentries.cmti
        
        vernacentries.cmx
        
        vernacentries.mli
        
        vernacexpr.cmi
        
        vernacexpr.cmti
        
        vernacexpr.mli
        
        vernacextend.cmi
        
        vernacextend.cmt
        
        vernacextend.cmti
        
        vernacextend.cmx
        
        vernacextend.mli
        
        vernacinterp.cmi
        
        vernacinterp.cmt
        
        vernacinterp.cmti
        
        vernacinterp.cmx
        
        vernacinterp.mli
        
        vernacoptions.cmi
        
        vernacoptions.cmt
        
        vernacoptions.cmti
        
        vernacoptions.cmx
        
        vernacoptions.mli
        
        vernacprop.cmi
        
        vernacprop.cmt
        
        vernacprop.cmti
        
        vernacprop.cmx
        
        vernacprop.mli
        
        vernacstate.cmi
        
        vernacstate.cmt
        
        vernacstate.cmti
        
        vernacstate.cmx
        
        vernacstate.mli
        
        vernactypes.cmi
        
        vernactypes.cmt
        
        vernactypes.cmti
        
        vernactypes.cmx
        
        vernactypes.mli
      - vm/
        
        coqrun.a
        
        coqrun.cma
        
        coqrun.cmi
        
        coqrun.cmt
        
        coqrun.cmx
        
        coqrun.cmxa
        
        coqrun.cmxs
        
        coqrun.ml
        
        libcoqrun_stubs.a
    - stublibs/
      - dllcoqperf_stubs.so
      - dllcoqrun_stubs.so
- share/
  - doc/
    - coq-core/
      - README.md
  - licenses/
    - coq-core/
      - LICENSE
  - man/
    - man1/
      - coq-tex.1.gz
      - coq_makefile.1.gz
      - coqc.1.gz
      - coqchk.1.gz
      - coqdep.1.gz
      - coqdoc.1.gz
      - coqnative.1.gz
      - coqtop.1.gz
      - coqtop.byte.1.gz
      - coqwc.1.gz
  - texlive/
    - texmf-dist/
      - tex/
        
        latex/
        
        misc/
        
        coqdoc.sty

Sources on Pagure