.emacs.d.git - Gitblit

			@@ -12,9 +12,4274 @@
			:lastmodtime '(23537 22014 0 0)
			:unmatched-syntax nil)
			(semanticdb-table "semanticdb-table"
			:major-mode emacs-lisp-mode
			:tags
			'( ("declare-function" code nil nil [839 909])
			("when" code nil nil [910 1034])
			("helm-config" customgroup (:user-visible-flag t) nil [1038 1116])
			("helm-command-prefix-key" variable (:default-value "C-x c") nil [1118 1604])
			("helm-minibuffer-history-key" variable (:default-value "C-r") nil [1606 2661])
			("helm-command-map" variable (:default-value (let ((map (make-sparse-keymap))) (define-key map (kbd "a") (quote helm-apropos)) (define-key map (kbd "e") (quote helm-etags-select)) (define-key map (kbd "l") (quote helm-locate)) (define-key map (kbd "s") (quote helm-surfraw)) (define-key map (kbd "r") (quote helm-regexp)) (define-key map (kbd "m") (quote helm-man-woman)) (define-key map (kbd "t") (quote helm-top)) (define-key map (kbd "/") (quote helm-find)) (define-key map (kbd "i") (quote helm-semantic-or-imenu)) (define-key map (kbd "I") (quote helm-imenu-in-all-buffers)) (define-key map (kbd "<tab>") (quote helm-lisp-completion-at-point)) (define-key map (kbd "p") (quote helm-list-emacs-process)) (define-key map (kbd "C-x r b") (quote helm-filtered-bookmarks)) (define-key map (kbd "M-y") (quote helm-show-kill-ring)) (define-key map (kbd "C-c <SPC>") (quote helm-all-mark-rings)) (define-key map (kbd "C-x C-f") (quote helm-find-files)) (define-key map (kbd "f") (quote helm-multi-files)) (define-key map (kbd "C-:") (quote helm-eval-expression-with-eldoc)) (define-key map (kbd "C-,") (quote helm-calcul-expression)) (define-key map (kbd "M-x") (quote helm-M-x)) (define-key map (kbd "M-s o") (quote helm-occur)) (define-key map (kbd "M-g a") (quote helm-do-grep-ag)) (define-key map (kbd "c") (quote helm-colors)) (define-key map (kbd "F") (quote helm-select-xfont)) (define-key map (kbd "8") (quote helm-ucs)) (define-key map (kbd "C-c f") (quote helm-recentf)) (define-key map (kbd "C-c g") (quote helm-google-suggest)) (define-key map (kbd "h i") (quote helm-info-at-point)) (define-key map (kbd "h r") (quote helm-info-emacs)) (define-key map (kbd "h g") (quote helm-info-gnus)) (define-key map (kbd "h h") (quote helm-documentation)) (define-key map (kbd "C-x C-b") (quote helm-buffers-list)) (define-key map (kbd "C-x r i") (quote helm-register)) (define-key map (kbd "C-c C-x") (quote helm-run-external-command)) (define-key map (kbd "b") (quote helm-resume)) (define-key map (kbd "M-g i") (quote helm-gid)) (define-key map (kbd "@") (quote helm-list-elisp-packages)) map)) nil [2689 4877])
			("helm-command-prefix" variable nil nil [4998 5026])
			("define-prefix-command" code nil nil [5027 5071])
			("fset" code nil nil [5072 5116])
			("setq" code nil nil [5117 5161])
			("helm-easymenu" include nil nil [5175 5199])
			("helm-configuration" function (:user-visible-flag t) nil [5218 5312])
			("cl-dolist" code nil nil [5329 6550])
			("load" code nil nil [6659 6688])
			("helm-config" package nil nil [6690 6712]))
			:file "helm-config.el"
			:pointmax 6855
			:fsize 6854
			:lastmodtime '(23537 22013 0 0)))
			:lastmodtime '(23537 22013 0 0)
			:unmatched-syntax nil)
			(semanticdb-table "semanticdb-table"
			:major-mode emacs-lisp-mode
			:tags
			'( ("cl-lib" include nil nil [819 836])
			("bookmark" include nil nil [837 856])
			("helm" include nil nil [857 872])
			("helm-lib" include nil nil [873 892])
			("helm-help" include nil nil [893 913])
			("helm-types" include nil nil [914 935])
			("helm-utils" include nil nil [936 957])
			("helm-info" include nil nil [958 978])
			("helm-adaptive" include nil nil [979 1003])
			("helm-net" include nil nil [1004 1023])
			("declare-function" code nil nil [1025 1082])
			("declare-function" code nil nil [1083 1168])
			("helm-bookmark" customgroup (:user-visible-flag t) nil [1171 1259])
			("helm-bookmark-show-location" variable nil nil [1261 1387])
			("helm-bookmark-default-filtered-sources" variable (:default-value (append (quote (helm-source-bookmark-org helm-source-bookmark-files&dirs helm-source-bookmark-helm-find-files helm-source-bookmark-info helm-source-bookmark-gnus helm-source-bookmark-man helm-source-bookmark-images helm-source-bookmark-w3m)) (list (quote helm-source-bookmark-uncategorized) (quote helm-source-bookmark-set)))) nil [1389 1971])
			("helm-bookmark-info" variable
			(:default-value (quote ((t (:foreground "green"))))
			:type "face")
			nil [1975 2119])
			("helm-bookmark-w3m" variable
			(:default-value (quote ((t (:foreground "yellow"))))
			:type "face")
			nil [2121 2265])
			("helm-bookmark-gnus" variable
			(:default-value (quote ((t (:foreground "magenta"))))
			:type "face")
			nil [2267 2388])
			("helm-bookmark-man" variable
			(:default-value (quote ((t (:foreground "Orange4"))))
			:type "face")
			nil [2390 2515])
			("helm-bookmark-file" variable
			(:default-value (quote ((t (:foreground "Deepskyblue2"))))
			:type "face")
			nil [2517 2643])
			("helm-bookmark-file-not-found" variable
			(:default-value (quote ((t (:foreground "Slategray4"))))
			:type "face")
			nil [2645 2779])
			("helm-bookmark-directory" variable
			(:default-value (quote ((t (:inherit helm-ff-directory))))
			:type "face")
			nil [2781 2912])
			("helm-bookmark-addressbook" variable
			(:default-value (quote ((t (:foreground "tomato"))))
			:type "face")
			nil [2914 3048])
			("helm-bookmark-map" variable (:default-value (let ((map (make-sparse-keymap))) (set-keymap-parent map helm-map) (define-key map (kbd "C-c o") (quote helm-bookmark-run-jump-other-window)) (define-key map (kbd "C-c C-o") (quote helm-bookmark-run-jump-other-frame)) (define-key map (kbd "C-d") (quote helm-bookmark-run-delete)) (define-key map (kbd "C-]") (quote helm-bookmark-toggle-filename)) (define-key map (kbd "M-e") (quote helm-bookmark-run-edit)) map)) nil [3052 3546])
			("helm-source-basic-bookmarks" type
			(:interfaces ("helm-type-bookmark")
			:superclasses "helm-source-in-buffer"
			:members
			( ("init" variable (:default-value "(lambda nil (bookmark-maybe-load-default-file) (helm-init-candidates-in-buffer (quote global) (bookmark-all-names)))") nil nil)
			("filtered-candidate-transformer" variable (:default-value "(quote helm-bookmark-transformer)") nil nil))
			:type "class")
			nil [3548 3928])
			("helm-source-bookmarks" variable (:default-value (helm-make-source "Bookmarks" (quote helm-source-basic-bookmarks))) nil [3930 4059])
			("helm-bookmark-transformer" function (:arguments ("candidates" "_source")) nil [4061 4666])
			("helm-bookmark-toggle-filename-1" function (:arguments ("_candidate")) nil [4668 5363])
			("helm-bookmark-toggle-filename" function (:user-visible-flag t) nil [5365 5641])
			("put" code nil nil [5642 5691])
			("helm-bookmark-jump" function (:arguments ("candidate")) nil [5693 5867])
			("helm-bookmark-jump-other-frame" function (:arguments ("candidate")) nil [5869 6100])
			("helm-bookmark-jump-other-window" function (:arguments ("candidate")) nil [6102 6265])
			("helm-source-bookmark-set" variable (:default-value (helm-build-dummy-source "Set Bookmark" :filtered-candidate-transformer (lambda (_candidates _source) (list (or (and (not (string= helm-pattern "")) helm-pattern) "Enter a bookmark name to record"))) :action (quote (("Set bookmark" lambda (candidate) (if (string= helm-pattern "") (message "No bookmark name given for record") (bookmark-set candidate))))))) nil [6289 6880])
			("helm-bookmark--non-file-filename" variable
			(:constant-flag t
			:default-value " - no file -")
			nil [6902 7024])
			("helm-bookmark-gnus-bookmark-p" function (:arguments ("bookmark")) nil [7026 7372])
			("helm-bookmark-w3m-bookmark-p" function (:arguments ("bookmark")) nil [7374 7716])
			("helm-bookmark-woman-bookmark-p" function (:arguments ("bookmark")) nil [7718 8061])
			("helm-bookmark-man-bookmark-p" function (:arguments ("bookmark")) nil [8063 8396])
			("helm-bookmark-woman-man-bookmark-p" function (:arguments ("bookmark")) nil [8398 8655])
			("helm-bookmark-info-bookmark-p" function (:arguments ("bookmark")) nil [8657 8866])
			("helm-bookmark-image-bookmark-p" function (:arguments ("bookmark")) nil [8868 9087])
			("helm-bookmark-file-p" function (:arguments ("bookmark")) nil [9089 9514])
			("helm-bookmark-org-file-p" function (:arguments ("bookmark")) nil [9516 9711])
			("helm-bookmark-helm-find-files-p" function (:arguments ("bookmark")) nil [9713 9945])
			("helm-bookmark-addressbook-p" function (:arguments ("bookmark")) nil [9947 10305])
			("helm-bookmark-uncategorized-bookmark-p" function (:arguments ("bookmark")) nil [10307 11003])
			("helm-bookmark-filter-setup-alist" function (:arguments ("fn")) nil [11005 11281])
			("w3m-async-exec" variable nil nil [11309 11332])
			("helm-bookmark-jump-w3m" function (:arguments ("bookmark")) nil [11333 12463])
			("defalias" code nil nil [12694 12756])
			("defalias" code nil nil [12872 12922])
			("defalias" code nil nil [12923 12969])
			("defalias" code nil nil [12970 13021])
			("defalias" code nil nil [13022 13078])
			("defalias" code nil nil [13079 13138])
			("defalias" code nil nil [13139 13193])
			("defalias" code nil nil [13194 13247])
			("defalias" code nil nil [13248 13297])
			("helm-source-filtered-bookmarks" type
			(:interfaces ("helm-type-bookmark")
			:superclasses "helm-source-in-buffer"
			:members
			( ("filtered-candidate-transformer" variable (:default-value "(quote (helm-adaptive-sort helm-highlight-bookmark))") nil nil))
			:type "class")
			nil [13338 13535])
			("helm-bookmark-w3m-setup-alist" function nil nil [13559 13717])
			("helm-source-bookmark-w3m" variable (:default-value (helm-make-source "Bookmark W3m" (quote helm-source-filtered-bookmarks) :init (lambda nil (bookmark-maybe-load-default-file) (helm-init-candidates-in-buffer (quote global) (helm-bookmark-w3m-setup-alist))))) nil [13719 13990])
			("helm-bookmark-images-setup-alist" function nil nil [14006 14172])
			("helm-source-bookmark-images" variable (:default-value (helm-make-source "Bookmark Images" (quote helm-source-filtered-bookmarks) :init (lambda nil (bookmark-maybe-load-default-file) (helm-init-candidates-in-buffer (quote global) (helm-bookmark-images-setup-alist))))) nil [14174 14454])
			("helm-bookmark-man-setup-alist" function nil nil [14473 14637])
			("helm-source-bookmark-man" variable (:default-value (helm-make-source "Bookmark Woman&Man" (quote helm-source-filtered-bookmarks) :init (lambda nil (bookmark-maybe-load-default-file) (helm-init-candidates-in-buffer (quote global) (helm-bookmark-man-setup-alist))))) nil [14639 14916])
			("helm-bookmark-org-setup-alist" function nil nil [14935 15094])
			("helm-source-bookmark-org" variable (:default-value (helm-make-source " Bookmarked Org files" (quote helm-source-filtered-bookmarks) :init (lambda nil (bookmark-maybe-load-default-file) (helm-init-candidates-in-buffer (quote global) (helm-bookmark-org-setup-alist))))) nil [15096 15376])
			("helm-bookmark-gnus-setup-alist" function nil nil [15390 15551])
			("helm-source-bookmark-gnus" variable (:default-value (helm-make-source "Bookmark Gnus" (quote helm-source-filtered-bookmarks) :init (lambda nil (bookmark-maybe-load-default-file) (helm-init-candidates-in-buffer (quote global) (helm-bookmark-gnus-setup-alist))))) nil [15553 15827])
			("helm-bookmark-info-setup-alist" function nil nil [15841 16002])
			("helm-source-bookmark-info" variable (:default-value (helm-make-source "Bookmark Info" (quote helm-source-filtered-bookmarks) :init (lambda nil (bookmark-maybe-load-default-file) (helm-init-candidates-in-buffer (quote global) (helm-bookmark-info-setup-alist))))) nil [16004 16278])
			("helm-bookmark-local-files-setup-alist" function nil nil [16309 16476])
			("helm-source-bookmark-files&dirs" variable (:default-value (helm-make-source "Bookmark Files&Directories" (quote helm-source-filtered-bookmarks) :init (lambda nil (bookmark-maybe-load-default-file) (helm-init-candidates-in-buffer (quote global) (helm-bookmark-local-files-setup-alist))))) nil [16478 16778])
			("helm-bookmark-helm-find-files-setup-alist" function nil nil [16813 17000])
			("helm-bookmark-browse-project" function (:arguments ("candidate")) nil [17002 17197])
			("helm-bookmark-run-browse-project" function (:user-visible-flag t) nil [17199 17399])
			("put" code nil nil [17400 17452])
			("helm-bookmark-find-files-map" variable (:default-value (let ((map (make-sparse-keymap))) (set-keymap-parent map helm-bookmark-map) (define-key map (kbd "C-x C-d") (quote helm-bookmark-run-browse-project)) map)) nil [17454 17653])
			("helm-bookmark-override-inheritor" type
			(:superclasses "helm-source"
			:type "class")
			nil [17655 17715])
			("helm--setup-source" function
			(:parent "helm-bookmark-override-inheritor"
			:arguments ("source"))
			nil [17717 18321])
			("helm-bookmark-find-files-class" type
			(:interfaces ("helm-bookmark-override-inheritor")
			:superclasses "helm-source-filtered-bookmarks"
			:type "class")
			nil [18323 18477])
			("helm-source-bookmark-helm-find-files" variable (:default-value (helm-make-source "Bookmark helm-find-files sessions" (quote helm-bookmark-find-files-class) :init (lambda nil (bookmark-maybe-load-default-file) (helm-init-candidates-in-buffer (quote global) (helm-bookmark-helm-find-files-setup-alist))) :persistent-action (lambda (_candidate) (ignore)) :persistent-help "Do nothing")) nil [18479 18895])
			("helm-bookmark-uncategorized-setup-alist" function nil nil [18928 19116])
			("helm-source-bookmark-uncategorized" variable (:default-value (helm-make-source "Bookmark uncategorized" (quote helm-source-filtered-bookmarks) :init (lambda nil (bookmark-maybe-load-default-file) (helm-init-candidates-in-buffer (quote global) (helm-bookmark-uncategorized-setup-alist))))) nil [19118 19419])
			("helm-highlight-bookmark" function (:arguments ("bookmarks" "_source")) nil [19442 24878])
			("helm-bookmark-edit-bookmark" function (:arguments ("bookmark-name")) nil [24920 25414])
			("helm-bookmark-edit-bookmark-1" function (:arguments ("bookmark-name" "handler")) nil [25416 26785])
			("helm-bookmark-maybe-save-bookmark" function nil nil [26787 27024])
			("helm-bookmark-rename" function
			(:user-visible-flag t
			:arguments ("old" "new" "batch"))
			nil [27026 28292])
			("helm-bookmark-run-edit" function (:user-visible-flag t) nil [28294 28482])
			("put" code nil nil [28483 28525])
			("helm-bookmark-run-jump-other-frame" function (:user-visible-flag t) nil [28529 28727])
			("put" code nil nil [28728 28782])
			("helm-bookmark-run-jump-other-window" function (:user-visible-flag t) nil [28784 28972])
			("put" code nil nil [28973 29028])
			("helm-bookmark-run-delete" function (:user-visible-flag t) nil [29030 29249])
			("put" code nil nil [29250 29294])
			("helm-bookmark-get-bookmark-from-name" function (:arguments ("bmk")) nil [29296 29553])
			("helm-delete-marked-bookmarks" function (:arguments ("_ignore")) nil [29555 29785])
			("helm-bookmarks" function (:user-visible-flag t) nil [29803 30057])
			("helm-filtered-bookmarks" function (:user-visible-flag t) nil [30074 30549])
			("helm-bookmark" package nil nil [30551 30575]))
			:file "helm-bookmark.el"
			:pointmax 30720
			:fsize 30719
			:lastmodtime '(23537 22013 0 0)
			:unmatched-syntax nil)
			(semanticdb-table "semanticdb-table"
			:major-mode emacs-lisp-mode
			:tags
			'( ("helm" include nil nil [805 820])
			("helm-org-headings--nofilename" variable nil nil [822 860])
			("declare-function" code nil nil [861 928])
			("helm-help" customgroup (:user-visible-flag t) nil [932 1001])
			("helm-helper" variable
			(:default-value (quote ((t :inherit helm-header)))
			:type "face")
			nil [1003 1119])
			("helm-help--string-list" variable (:default-value (quote (helm-help-message helm-buffer-help-message helm-ff-help-message helm-read-file-name-help-message helm-generic-file-help-message helm-grep-help-message helm-pdfgrep-help-message helm-etags-help-message helm-ucs-help-message helm-bookmark-help-message helm-esh-help-message helm-buffers-ido-virtual-help-message helm-moccur-help-message helm-top-help-message helm-el-package-help-message helm-M-x-help-message helm-imenu-help-message helm-colors-help-message helm-semantic-help-message helm-kmacro-help-message))) nil [1122 2292])
			("helm-documentation-buffer-name" variable (:default-value "helm documentation") nil [2294 2356])
			("helm-documentation" function (:user-visible-flag t) nil [2374 3191])
			("helm-buffer-help-message" variable (:default-value "* Helm Buffer

			** Tips

			*** Completion

			**** Major-mode

			You can enter a partial major-mode name (e.g. lisp, sh) to narrow down buffers.
			To specify the major-mode, prefix it with \"\" e.g. \"lisp\".

			If you want to match all buffers but the ones with a specific major-mode
			(negation), prefix the major-mode with \"!\" e.g. \"*!lisp\".

			If you want to specify more than one major-mode, separate them with \",\",
			e.g. \"*!lisp,!sh,!fun\" lists all buffers but the ones in lisp-mode, sh-mode
			and fundamental-mode.

			Then enter a space followed by a pattern to narrow down to buffers matching this
			pattern.

			**** Search inside buffers

			If you enter a space and a pattern prefixed by \"@\", Helm searches for text
			matching this pattern inside the buffer (i.e. not in the name of the buffer).

			If you enter a pattern prefixed with an escaped \"@\", Helm searches for a
			buffer matching \"@pattern\" but does not search inside.

			**** Search by directory name

			If you prefix the pattern with \"/\", Helm matches over the directory names
			of the buffers.

			This feature can be used to narrow down the search to one directory while
			subsequent strings entered after a space match over the buffer name only.

			Note that negation is not supported for matching on buffer filename.

			Starting from Helm v1.6.8, you can specify more than one directory.

			**** Fuzzy matching

			`helm-buffers-fuzzy-matching' turns on fuzzy matching on buffer names, but not
			on directory names or major modes. A pattern starting with \"^\" disables fuzzy
			matching and matches by exact regexp.

			**** Examples

			With the following pattern

			\"*lisp ^helm @moc\"

			Helm narrows down the list by selecting only the buffers that are in lisp mode,
			start with \"helm\" and which content matches \"moc\".

			Without the \"@\"

			\"*lisp ^helm moc\"

			Helm looks for lisp mode buffers starting with \"helm\" and containing \"moc\"
			in their name.

			With this other pattern

			\"*!lisp !helm\"

			Helm narrows down to buffers that are not in \"lisp\" mode and that do not match
			\"helm\".

			With this last pattern

			/helm/ w3

			Helm narrows down to buffers that are in any \"helm\" subdirectory and
			matching \"w3\".

			*** Creating buffers

			When creating a new buffer, use `\\[universal-argument]' to choose a mode from a
			list. This list is customizable, see `helm-buffers-favorite-modes'.

			*** Killing buffers

			You can kill buffers either one by one or all the marked buffers at once.

			One kill-buffer command leaves Helm while the other is persistent. Run the
			persistent kill-buffer command either with the regular
			`helm-execute-persistent-action' called with a prefix argument (`\\[universal-argument] \\<helm-map>\\[helm-execute-persistent-action]')
			or with its specific command `helm-buffer-run-kill-persistent'. See the
			bindings below.

			*** Switching to buffers

			To switch to a buffer, press RET, to switch to a buffer in another window, select this buffer
			and press \\<helm-buffer-map>\\[helm-buffer-switch-other-window], when called with a prefix arg
			the buffer will be displayed vertically in other window.
			If you mark more than one buffer, the marked buffers will be displayed in different windows.

			*** Meaning of colors and prefixes for buffers

			Remote buffers are prefixed with '@'.
			Red => Buffer's file was modified on disk by an external process.
			Indianred2 => Buffer exists but its file has been deleted.
			Orange => Buffer is modified and not saved to disk.
			Italic => A non-file buffer.
			Yellow => Tramp archive buffer.

			** Commands
			\\<helm-buffer-map>
			\\[helm-buffer-run-zgrep] Grep Buffer(s) works as zgrep too (`\\[universal-argument]' to grep all buffers but non-file buffers).
			\\[helm-buffers-run-multi-occur] Multi-Occur buffer or marked buffers (`\\[universal-argument]' to toggle force-searching current-buffer).
			\\[helm-buffer-switch-other-window] Switch to other window.
			\\[helm-buffer-switch-other-frame] Switch to other frame.
			\\[helm-buffers-run-browse-project] Browse project from buffer.
			\\[helm-buffer-run-query-replace-regexp] Query-replace-regexp in marked buffers.
			\\[helm-buffer-run-query-replace] Query-replace in marked buffers.
			\\[helm-buffer-run-ediff] Ediff current buffer with candidate. With two marked buffers, ediff those buffers.
			\\[helm-buffer-run-ediff-merge] Ediff-merge current buffer with candidate. With two marked buffers, ediff-merge those buffers.
			\\[helm-buffer-diff-persistent] Toggle Diff-buffer with saved file without leaving Helm.
			\\[helm-buffer-revert-persistent] Revert buffer without leaving Helm.
			\\[helm-buffer-save-persistent] Save buffer without leaving Helm.
			\\[helm-buffer-run-kill-buffers] Delete marked buffers and leave Helm.
			\\[helm-buffer-run-kill-persistent] Delete buffer without leaving Helm.
			\\[helm-buffer-run-rename-buffer] Rename buffer.
			\\[helm-toggle-all-marks] Toggle all marks.
			\\[helm-mark-all] Mark all.
			\\[helm-toggle-buffers-details] Toggle details.
			\\[helm-buffers-toggle-show-hidden-buffers] Show hidden buffers.
			\\[helm-buffers-mark-similar-buffers] Mark all buffers of the same type (color) as current buffer.") nil [3254 8427])
			("helm-ff-help-message" variable (:default-value "* Helm Find Files

			** Tips

			*** Navigation summary

			For a better experience you can enable auto completion by setting
			`helm-ff-auto-update-initial-value' to non-nil in your init file. It is not
			enabled by default to not confuse new users.

			**** Use `\\<helm-find-files-map>\\[helm-execute-persistent-action]' (persistent action) on a directory to go down one level

			On a symlinked directory a prefix argument expands to its true name.

			**** Use `\\<helm-find-files-map>\\[helm-find-files-up-one-level]' on a directory to go up one level

			**** Use `\\<helm-find-files-map>\\[helm-find-files-down-last-level]' to walk back the resulting tree of all the `\\<helm-map>\\[helm-execute-persistent-action]' you did

			The tree is reinitialized each time you browse a new tree with
			`\\<helm-map>\\[helm-execute-persistent-action]' or by entering some pattern in the prompt.

			**** `RET' behavior

			It behaves differently depending on `helm-selection' (current candidate in helm-buffer):

			- candidate basename is \".\" => Open it in dired.
			- candidate is a directory => Expand it.
			- candidate is a file => Open it.

			If you have marked candidates and you press RET on a directory,
			helm will navigate to this directory, if you want to exit with
			RET with default action with these marked candidates, press RET
			on a second time while you are on the root of this directory
			e.g. \"/home/you/dir/.\" or press RET on any file which is not a
			directory. You can also exit with default action at any moment
			with `f1'.

			Note that when copying, renaming, etc. from `helm-find-files' the
			destination file is selected with `helm-read-file-name'.

			To avoid confusion when using `read-file-name' or `read-directory-name', `RET'
			follows its standard Emacs behaviour, i.e. it exits the minibuffer as soon as
			you press `RET'. If you want the same behavior as in `helm-find-files', bind
			`helm-ff-RET' to the `helm-read-file-map':

			(define-key helm-read-file-map (kbd \"RET\") 'helm-ff-RET)

			*** Find file at point

			Helm uses `ffap' partially or completely to find file at point depending on the
			value of `helm-ff-guess-ffap-filenames': if non-nil, support is complete
			(annoying), if nil, support is partial.

			**** Find file at line number

			When text at point is in the form of

			~/elisp/helm/helm.el:1234

			Helm finds this file at the indicated line number, here 1234.

			**** Find URL at point

			When a URL is found at point, Helm expands to that URL only.
			Pressing `RET' opens that URL using `browse-url-browser-function'.

			**** Find e-mail address at point

			When an e-mail address is found at point, Helm expands to this e-mail address
			prefixed with \"mailto:\". Pressing `RET' opens a message buffer with that
			e-mail address.

			*** Quick pattern expansion

			**** Enter `~/' at end of pattern to quickly reach home directory

			**** Enter `/' at end of pattern to quickly reach the file system root

			**** Enter `./' at end of pattern to quickly reach `default-directory'

			(As per its value at the beginning of the session.)

			If you already are in the `default-directory' this will move the cursor to the top.

			**** Enter `../' at end of pattern will reach upper directory, moving cursor to the top

			This is different from using `\\<helm-find-files-map>\\[helm-find-files-up-one-level]' in that it moves
			the cursor to the top instead of remaining on the previous subdir name.

			**** Enter `..name/' at end of pattern to start a recursive search

			It searches directories matching \"name\" under the current directory, see the
			\"Recursive completion on subdirectories\" section below for more details.

			**** Any environment variable (e.g. `$HOME') at end of pattern gets expanded

			**** Any valid filename yanked after pattern gets expanded

			**** Special case: URL at point

			The quick expansions do not take effect after end a URL, you must kill the
			pattern first (`\\[helm-delete-minibuffer-contents]').

			*** Helm-find-files supports fuzzy matching

			It starts from the third character of the pattern.

			For instance \"fob\" or \"fbr\" will complete \"foobar\" but \"fb\" needs a
			third character in order to complete it.

			*** Use `\\[universal-argument] \\[helm-execute-persistent-action]' or `\\[helm-follow-action-forward]' to display an image

			*** `\\[helm-execute-persistent-action]' on a filename expands to that filename in the Helm buffer

			Second hit displays the buffer filename.
			Third hit kills the buffer filename.
			Note: `\\[universal-argument] \\[helm-execute-persistent-action]' displays the buffer directly.

			*** Browse images directories with `helm-follow-mode' and navigate up/down

			You can also use `helm-follow-action-forward' and `helm-follow-action-backward' with
			`\\[helm-follow-action-forward]' and `\\[helm-follow-action-backward]' respectively.

			*** Toggle auto-completion with `\\[helm-ff-run-toggle-auto-update]'

			It is useful when trying to create a new file or directory and you don't want
			Helm to complete what you are writing.

			Note: On a terminal, the default binding `C-<backspace>' may not work.
			In this case use `C-c <backspace>'.

			*** You can create a new directory and a new file at the same time

			Simply write the path in the prompt and press `RET', e.g.
			\"~/new/newnew/newnewnew/my_newfile.txt\".

			*** To create a new directory, append a \"/\" to the new name and press `RET'

			*** To create a new file, enter a filename not ending with \"/\"

			Note that when you enter a new name, this one is prefixed with
			[?] if you are in a writable directory. If you are in a directory
			where you have no write permission the new file name is not
			prefixed and is colored in red. There is not such distinction
			when using tramp, new filename just appear on top of buffer.

			*** Recursive search from Helm-find-files

			**** You can use Helm-browse-project (see binding below)

			- With no prefix argument:
			If the current directory is under version control with either git or hg and
			helm-ls-git and/or helm-ls-hg are installed, it lists all the files under
			version control. Otherwise it falls back to Helm-find-files. See
			https://github.com/emacs-helm/helm-ls-git and
			https://github.com/emacs-helm/helm-ls-hg.

			- With one prefix argument:
			List all the files under this directory and other subdirectories
			(recursion) and this list of files will be cached.

			- With two prefix arguments:
			Same but the cache is refreshed.

			**** You can start a recursive search with \"locate\" or \"find\"

			See \"Note\" in the [[Recusive completion on subdirectories][section on subdirectories]].

			Using \"locate\", you can enable the local database with a prefix argument. If the
			local database doesn't already exists, you will be prompted for its creation.
			If it exists and you want to refresh it, give it two prefix args.

			When using locate the helm-buffer remains empty until you type something.
			Regardless Helm uses the basename of the pattern entered in the helm-find-files
			session by default. Hitting `\\[next-history-element]' should just kick in the
			locate search with this pattern. If you want Helm to automatically do this, add
			`helm-source-locate' to `helm-sources-using-default-as-input'.

			**** Recursive completion on subdirectories

			Starting from the directory you are currently browsing, it is possible to have
			completion of all directories underneath. Say you are at \"/home/you/foo/\" and
			you want to go to \"/home/you/foo/bar/baz/somewhere/else\", simply type
			\"/home/you/foo/..else\" and hit `\\[helm-execute-persistent-action]' or enter
			the final \"/\". Helm will then list all possible directories under \"foo\"
			matching \"else\".

			Entering two spaces before \"else\" instead of two dots also works.

			Note: Completion on subdirectories uses \"locate\" as backend, you can configure
			the command with `helm-locate-recursive-dirs-command'. Because this completion
			uses an index, the directory tree displayed may be out-of-date and not reflect
			the latest change until you update the index (using \"updatedb\" for \"locate\").

			If for some reason you cannot use an index, the \"find\" command from
			\"findutils\" can be used instead. It will be slower though. You need to pass
			the basedir as first argument of \"find\" and the subdir as the value for
			'-(i)regex' or '-(i)name' with the two format specs that are mandatory in
			`helm-locate-recursive-dirs-command'.

			Examples:
			- \"find %s -type d -name '%s'\"
			- \"find %s -type d -regex .%s.$\"

			*** Insert filename at point or complete filename at point

			On insertion (not on completion, i.e. there is nothing at point):

			- `\\[helm-ff-run-complete-fn-at-point]': insert absolute file name.
			- `\\[universal-argument] \\[helm-ff-run-complete-fn-at-point]': insert abbreviated file name.
			- `\\[universal-argument] \\[universal-argument] \\[helm-ff-run-complete-fn-at-point]': insert relative file name.

			On completion:

			- Target starts with \"~/\": insert abbreviate file name.
			- target starts with \"/\" or \"[a-z]:/\": insert full path.
			- Otherwise: insert relative file name.

			*** Use the wildcard to select multiple files

			Use of wilcard is supported to run an action over a set of files.

			Example: You can copy all the files with \".el\" extension by using \"*.el\" and
			then run copy action.

			Similarly, \"**.el\" (note the two stars) will recursively select all \".el\"
			files under the current directory.

			Note that when recursively copying files, you may have files with same name
			dispatched across different subdirectories, so when copying them in the same
			directory they will get overwritten. To avoid this Helm has a special action
			called \"backup files\" that has the same behavior as the command line \"cp -f
			--backup=numbered\": it allows you to copy many files with the same name from
			different subdirectories into one directory. Files with same name are renamed
			as follows: \"foo.txt.~1~\". Like with the --force option of cp, it is possible
			to backup files in current directory.

			This command is available only when `dired-async-mode' is active.

			When using an action that involves an external backend (e.g. grep), using \"**\"
			is not recommended (even thought it works fine) because it will be slower to
			select all the files. You are better off leaving the backend to do it, it will
			be faster. However, if you know you have not many files it is reasonable to use
			this, also using not recursive wilcard (e.g. \"*.el\") is perfectly fine for
			this.

			The \"**\" feature is active by default in the option `helm-file-globstar'. It
			is different from the Bash \"shopt globstar\" feature in that to list files with
			a named extension recursively you would write \"**.el\" whereas in Bash it would
			be \"*/.el\". Directory selection with \"**/\" like Bash \"shopt globstar\"
			option is not supported yet.

			*** Query replace regexp on filenames

			Replace different parts of a file basename with something else.

			When calling this action you will be prompted twice as with
			`query-replace', first for the matching expression of the text to
			replace and second for the replacement text. Several facilities,
			however, are provided to make the two prompts more powerfull.

			**** Syntax of the first prompt

			In addition to simple regexps, these shortcuts are available:

			- Basename without extension => \"%.\"
			- Only extension => \".%\"
			- Substring => \"%:<from>:<to>\"
			- Whole basename => \"%\"

			**** Syntax of the second prompt

			In addition to a simple string to use as replacement, here is what you can use:

			- A placeholder refering to what you have selected in the first prompt: \"\\@\".

			After this placeholder you can use a search-and-replace syntax à-la sed:

			\"\\@/<regexp>/<replacement>/

			You can select a substring from the string represented by the placeholder:

			\"\\@:<from>:<to>\"

			- A special character representing a number which is incremented: \"\\#\".

			- Shortcuts for `upcase', `downcase' and `capitalize'
			are available as`%u', `%d' and `%c' respectively.

			**** Examples

			***** Recursively rename all files with \".JPG\" extension to \".jpg\"

			Use the `helm-file-globstar' feature described in [[Using wildcard to select multiple files][recursive globbing]]
			by entering \"**.JPG\" at the end of the Helm-find-files pattern, then hit
			\\<helm-map>\\[helm-ff-query-replace-on-filenames]: First \"JPG\", then \"jpg\"
			and hit `RET'.

			Alternatively you can enter \".%\" at the first prompt, then \"jpg\" and hit
			`RET'. Note that when using this instead of using \"JPG\" at the first prompt,
			all extensions will be renamed to \"jpg\" even if the extension of one of the
			files is, say, \"png\". If you want to keep the original extension you can use
			\"%d\" at the second prompt (downcase).

			***** Batch-rename files from number 001 to 00x

			Use \"\\#\" inside the second prompt.

			Example 1: To rename the files

			foo.jpg
			bar.jpg
			baz.jpg

			to

			foo-001.jpg
			foo-002.jpg
			foo-003.jpg

			use \"%.\" as matching regexp and \"foo-\\#\" as replacement string.

			Example 2: To rename the files

			foo.jpg
			bar.jpg
			baz.jpg

			to

			foo-001.jpg
			bar-002.jpg
			baz-003.jpg

			use as matching regexp \"%.\" and as replacement string \"\\@-\\#\".

			***** Replace a substring

			Use \"%:<from>:<to>\".

			Example: To rename files

			foo.jpg
			bar.jpg
			baz.jpg

			to

			fOo.jpg
			bAr.jpg
			bAz.jpg

			use as matching regexp \"%:1:2\" and as replacement string \"%u\" (upcase).

			Note that you cannot use \"%.\" and \".%\" along with substring replacement.

			***** Modify the string from the placeholder (\\@)

			- By substring, i.e. only using the substring of the placeholder: \"\\@:<from>:<to>\".
			The length of placeholder is used for <to> when unspecified.

			Example 1: \"\\@:0:2\" replaces from the beginning to the second char of the placeholder.

			Example 2: \\@:2: replaces from the second char of the placeholder to the end.

			- By search-and-replace: \"\\@/<regexp>/<replacement>/\".

			Incremental replacement is also handled in <replacement>.

			Example 3: \"\\@/foo/bar/\" replaces \"foo\" by \"bar\" in the placeholder.

			Example 4: \"\\@/foo/-\\#/\" replaces \"foo\" in the placeholder by 001, 002, etc.

			***** Clash in replacements (avoid overwriting files)

			When performing any of these replacement operations you may end up with same
			names as replacement. In such cases Helm numbers the file that would otherwise
			overwritten. For instance, should you remove the \"-m<n>\" part from the files
			\"emacs-m1.txt\", \"emacs-m2.txt\" and \"emacs-m3.txt\" you would end up with
			three files named \"emacs.txt\", the second renaming overwriting first file, and
			the third renaming overwriting second file and so on. Instead Helm will
			automatically rename the second and third files as \"emacs(1).txt\" and
			\"emacs(2).txt\" respectively.

			***** Query-replace on filenames vs. serial-rename action

			Unlike the [[Serial renaming][serial rename]] actions, the files renamed with
			the query-replace action stay in their initial directory and are not moved to
			the current directory. As such, using \"\\#\" to serial-rename files only makes
			sense for files inside the same directory. It even keeps renaming files
			with an incremental number in the next directories.

			*** Serial-rename

			You can use the serial-rename actions to rename, copy or symlink marked files to
			a specific directory or in the current directory with all the files numbered
			incrementally.

			- Serial-rename by renaming:
			Rename all marked files with incremental numbering to a specific directory.

			- Serial-rename by copying:
			Copy all marked files with incremental numbering to a specific directory.

			- Serial-rename by symlinking:
			Symlink all marked files with incremental numbering to a specific directory.

			*** Edit marked files in a dired buffer

			You can open a dired buffer containing only marked files with `\\<helm-find-files-map>\\[helm-ff-run-marked-files-in-dired]'.
			With a prefix argument you can open this same dired buffer in wdired mode for
			editing. Note that wildcards are supported as well, so you can use e.g.
			\".txt\" to select all \".txt\" files in the current directory or \"*.txt\" to
			select all files recursively from the current directory.
			See [[Use the wildcard to select multiple files]] section above.

			*** Defining default target directory for copying, renaming, etc

			You can customize `helm-dwim-target' to behave differently depending on the
			windows open in the current frame. Default is to provide completion on all
			directories associated to each window.

			*** Copying and renaming asynchronously

			If you have the async library installed (if you got Helm from MELPA you do), you
			can use it for copying/renaming files by enabling `dired-async-mode'.

			Note that even when async is enabled, running a copy/rename action with a prefix
			argument will execute action synchronously. Moreover it will follow the first
			file of the marked files in its destination directory.

			When `dired-async-mode' is enabled, an additional action named \"Backup files\"
			will be available. (Such command is not natively available in Emacs).
			See [[Use the wildcard to select multiple files]] for details.

			*** Bookmark the `helm-find-files' session

			You can bookmark the `helm-find-files' session with `\\[helm-ff-bookmark-set]'.
			You can later retrieve these bookmarks by calling `helm-filtered-bookmarks'
			or, from the current `helm-find-files' session, by hitting `\\[helm-find-files-toggle-to-bookmark]'.

			*** Grep files from `helm-find-files'

			You can grep individual files from `helm-find-files' by using
			`\\<helm-find-files-map>\\[helm-ff-run-grep]'. This same command can also
			recursively grep files from the current directory when called with a prefix
			argument. In this case you will be prompted for the file extensions to use
			(grep backend) or the types of files to use (ack-grep backend). See the
			`helm-grep-default-command' documentation to set this up. For compressed files
			or archives, use zgrep with `\\<helm-find-files-map>\\[helm-ff-run-zgrep]'.

			Otherwise you can use recursive commands like `\\<helm-find-files-map>\\[helm-ff-run-grep-ag]' or `\\<helm-find-files-map>\\[helm-ff-run-git-grep]'
			that are much faster than using `\\<helm-find-files-map>\\[helm-ff-run-grep]' with a prefix argument.
			See `helm-grep-ag-command' and `helm-grep-git-grep-command' to set this up.

			You can also use \"id-utils\"' GID with `\\<helm-find-files-map>\\[helm-ff-run-gid]'
			by creating an ID index file with the \"mkid\" shell command.

			All those grep commands use the symbol at point as the default pattern.
			Note that default is different from input (nothing is added to the prompt until
			you hit `\\[next-history-element]').

			**** Grepping on remote files

			On remote files grep is not well supported by TRAMP unless you suspend updates before
			entering the pattern and re-enable it once your pattern is ready.
			To toggle suspend-update, use `\\<helm-map>\\[helm-toggle-suspend-update]'.

			*** Setting up aliases in Eshell allows you to set up powerful customized commands

			Adding Eshell aliases to your `eshell-aliases-file' or using the
			`alias' command from Eshell allows you to create personalized
			commands not available in `helm-find-files' actions and use them
			from `\\<helm-find-files-map>\\[helm-ff-run-eshell-command-on-file]'.

			Example: You want a command to uncompress some \"*.tar.gz\" files from `helm-find-files':

			1) Create an Eshell alias named, say, \"untargz\" with the command
			\"alias untargz tar zxvf $*\".

			2) Now from `helm-find-files' select the \"*.tar.gz\" file (you can also
			mark files if needed) and hit `\\<helm-find-files-map>\\[helm-ff-run-eshell-command-on-file]'.

			Note: When using marked files with this, the meaning of the prefix argument is
			quite subtle. Say you have \"foo\", \"bar\" and \"baz\" marked; when you run
			the alias command `example' on these files with no prefix argument it will run
			`example' sequentially on each file:

			$ example foo
			$ example bar
			$ example baz

			With a prefix argument however it will apply `example' on all files at once:

			$ example foo bar baz

			Of course the alias command should support this.

			*** Using TRAMP with `helm-find-files' to read remote directories

			`helm-find-files' works fine with TRAMP despite some limitations.

			- Grepping files is not very well supported when used incrementally.
			See [[Grepping on remote files]].

			- Locate does not work on remote directories.

			**** A TRAMP syntax crash course

			Please refer to TRAMP's documentation for more details.

			- Connect to host 192.168.0.4 as user \"foo\":

			/scp:192.168.0.4@foo:

			- Connect to host 192.168.0.4 as user \"foo\" on port 2222:

			/scp:192.168.0.4@foo#2222:

			- Connect to host 192.168.0.4 as root using multihops syntax:

			/ssh:192.168.0.4@foo\|sudo:192.168.0.4:

			Note: You can also use `tramp-default-proxies-alist' when connecting often to
			the same hosts.

			As a rule of thumb, prefer the scp method unless using multihops (which only
			works with the ssh method), especially when copying large files.

			You need to hit `C-j' once on top of a directory on the first connection
			to complete the pattern in the minibuffer.

			**** Display color for directories, symlinks etc... with tramp

			Starting at helm version 2.9.7 it is somewhat possible to
			colorize fnames by listing files without loosing performances with
			external commands (ls and awk) if your system is compatible.
			For this you can use `helm-list-dir-external' as value
			for `helm-list-directory-function'.

			See `helm-list-directory-function' documentation for more infos.

			**** Completing host

			As soon as you enter the first \":\" after method e.g =/scp:= you will
			have some completion about previously used hosts or from your =~/.ssh/config=
			file, hitting `\\[helm-execute-persistent-action]' or `right' on a candidate will insert this host in minibuffer
			without addind the ending \":\", second hit insert the last \":\".
			As soon the last \":\" is entered TRAMP will kick in and you should see the list
			of candidates soon after.

			When connection fails, be sure to delete your TRAMP connection with M-x
			`helm-delete-tramp-connection' before retrying.

			**** Editing local files as root

			Use the sudo method:

			\"/sudo:host:\" or simply \"/sudo::\".

			*** Attach files to a mail buffer (message-mode)

			If you are in a `message-mode' or `mail-mode' buffer, that action will appear
			in action menu, otherwise it is available at any time with \\<helm-find-files-map>\\[helm-ff-run-mail-attach-files].
			It behaves as follows:

			- If you are in a (mail or message) buffer, files are attached there.

			- If you are not in a mail buffer but one or more mail buffers exist, you are
			prompted to attach files to one of these mail buffers.

			- If you are not in a mail buffer and no mail buffer exists,
			a new mail buffer is created with the attached files in it.

			*** Open files in separate windows

			When [[Marked candidates][marking]] multiple files or using [[Use the wildcard to select multiple files][wildcard]], helm allow opening all
			this files in separate windows using an horizontal layout or a
			vertical layout if you used a prefix arg, when no more windows can be
			displayed in frame, next files are opened in background without being
			displayed. When using \\<helm-find-files-map>\\[helm-ff-run-switch-other-window] the current
			buffer is kept and files are displayed next to it with same behavior as above.
			When using two prefix args, files are opened in background without beeing displayed.

			*** Expand archives as directories in a avfs directory

			If you have mounted your filesystem with mountavfs,
			you can expand archives in the \"~/.avfs\" directory with \\<helm-map>\\[helm-execute-persistent-action].

			*** Tramp archive support (emacs-27+ only)

			If your emacs have library tramp-archive.el, you can browse the
			content of archives with emacs and BTW helm-find-files. However this beeing
			experimental and not very fast, helm doesn't provide an automatic
			expansion and detection of archives, you will have to add the final /
			manually and may have to force update (\\<helm-map>\\[helm-refresh])
			or remove and add again the final / until tramp finish decompressing archive.

			*** Touch files

			In the completion buffer, you can choose the default which is the current-time, it is
			the first candidate or the timestamp of one of the selected files.
			If you need to use something else, use \\<helm-map>\\[next-history-element] and edit
			the date in minibuffer.
			It is also a way to quickly create a new file without opening a buffer, saving it
			and killing it.
			To touch more than one new file, separate you filenames with a comma (\",\").
			If one wants to create (touch) a new file with comma inside the name use a prefix arg,
			this will prevent splitting the name and create multiple files.

			*** Delete files

			You can delete files without quitting helm with
			`\\<helm-find-files-map>\\[helm-ff-persistent-delete]' or delete files and quit helm with `\\[helm-ff-run-delete-file]'.

			In the second method you can choose to
			make this command asynchronous by customizing
			`helm-ff-delete-files-function'.

			_WARNING_: When deleting files asynchronously you will NOT be
			WARNED if directories are not empty, that's mean non empty directories will
			be deleted in background without asking.

			A good compromise is to trash your files
			when using asynchronous method (see [[Trashing files][Trashing files]]).

			When choosing synchronous delete, you can allow recursive
			deletion of directories with `helm-ff-allow-recursive-deletes'.
			Note that when trashing (synchronous) you are not asked for recursive deletion.

			Note that `helm-ff-allow-recursive-deletes' have no effect when
			deleting asynchronously.

			First method (persistent delete) is always synchronous.

			Note that when a prefix arg is given, trashing behavior is inversed.
			See [[Trashing files][Trashing files]].

			**** Trashing files

			If you want to trash your files instead of deleting them you can
			set `delete-by-moving-to-trash' to non nil, like this your files
			will be moved to trash instead of beeing deleted.

			You can reverse at any time the behavior of `delete-by-moving-to-trash' by using
			a prefix arg with any of the delete files command.

			On GNULinux distribution, when navigating to a Trash directory you
			can restore any file in ..Trash/files directory with the 'Restore
			from trash' action you will find in action menu (needs the
			trash-cli package installed).
			You can as well delete files from Trash directories with the 'delete files from trash'
			action.

			Tip: Navigate to your Trash/files directories with `helm-find-files' and set a bookmark
			there with \\<helm-find-files-map>\\[helm-ff-bookmark-set] for fast access to Trash.

			_WARNING:_

			If you have an ENV var XDG_DATA_HOME in your .profile or .bash_profile
			and this var is set to something like $HOME/.local/share (like preconized)
			`move-file-to-trash' may try to create $HOME/.local/share/Trash (literally)
			and its subdirs in the directory where you are actually trying to trash files.
			because `move-file-to-trash' is interpreting XDG_DATA_HOME literally instead
			of evaling its value (with `substitute-in-file-name').

			***** Trashing remote files with tramp

			Trashing remote files (or local files with sudo method) is disabled by default
			because tramp is requiring the 'trash' command to be installed, if you want to
			trash your remote files, customize `helm-trash-remote-files'.
			The package on most GNU/Linux based distributions is trash-cli, it is available [[https://github.com/andreafrancia/trash-cli][here]].

			NOTE:
			When deleting your files with sudo method, your trashed files will not be listed
			with trash-list until you log in as root.

			** Commands
			\\<helm-find-files-map>
			\\[helm-ff-run-locate] Run `locate' (`\\[universal-argument]' to specify locate database, `M-n' to insert basename of candidate).
			\\[helm-ff-run-browse-project] Browse project (`\\[universal-argument]' to recurse, `\\[universal-argument] \\[universal-argument]' to recurse and refresh database).
			\\[helm-ff-run-find-sh-command] Run `find' shell command from this directory.
			\\[helm-ff-run-grep] Run Grep (`\\[universal-argument]' to recurse).
			\\[helm-ff-run-pdfgrep] Run Pdfgrep on marked files.
			\\[helm-ff-run-zgrep] Run zgrep (`\\[universal-argument]' to recurse).
			\\[helm-ff-run-grep-ag] Run AG grep on current directory.
			\\[helm-ff-run-git-grep] Run git-grep on current directory.
			\\[helm-ff-run-gid] Run gid (id-utils).
			\\[helm-ff-run-etags] Run Etags (`\\[universal-argument]' to use thing-at-point, `\\[universal-argument] \\[universal-argument]' to reload cache).
			\\[helm-ff-run-rename-file] Rename Files (`\\[universal-argument]' to follow).
			\\[helm-ff-run-query-replace-fnames-on-marked] Query replace on marked files.
			\\[helm-ff-run-copy-file] Copy Files (`\\[universal-argument]' to follow).
			\\[helm-ff-run-byte-compile-file] Byte Compile Files (`\\[universal-argument]' to load).
			\\[helm-ff-run-load-file] Load Files.
			\\[helm-ff-run-symlink-file] Symlink Files.
			\\[helm-ff-run-hardlink-file] Hardlink files.
			\\[helm-ff-run-relsymlink-file] Relative symlink Files.
			\\[helm-ff-run-delete-file] Delete Files.
			\\[helm-ff-run-touch-files] Touch files.
			\\[helm-ff-run-kill-buffer-persistent] Kill buffer candidate without leaving Helm.
			\\[helm-ff-persistent-delete] Delete file without leaving Helm.
			\\[helm-ff-run-switch-to-eshell] Switch to Eshell.
			\\[helm-ff-run-eshell-command-on-file] Eshell command on file (`\\[universal-argument]' to apply on marked files, otherwise treat them sequentially).
			\\[helm-ff-run-ediff-file] Ediff file.
			\\[helm-ff-run-ediff-merge-file] Ediff merge file.
			\\[helm-ff-run-complete-fn-at-point] Complete file name at point.
			\\[helm-ff-run-switch-other-window] Switch to other window.
			\\[helm-ff-run-switch-other-frame] Switch to other frame.
			\\[helm-ff-run-open-file-externally] Open file with external program (`\\[universal-argument]' to choose).
			\\[helm-ff-run-preview-file-externally] Preview file with external program.
			\\[helm-ff-run-open-file-with-default-tool] Open file externally with default tool.
			\\[helm-ff-rotate-left-persistent] Rotate image left.
			\\[helm-ff-rotate-right-persistent] Rotate image right.
			\\[helm-find-files-up-one-level] Go to parent directory.
			\\[helm-find-files-history] Switch to the visited-directory history.
			\\[helm-ff-file-name-history] Switch to file name history.
			\\[helm-ff-properties-persistent] Show file properties in a tooltip.
			\\[helm-mark-all] Mark all visible candidates.
			\\[helm-ff-run-toggle-auto-update] Toggle auto-expansion of directories.
			\\[helm-unmark-all] Unmark all candidates, visible and invisible ones.
			\\[helm-ff-run-gnus-attach-files] Gnus' attach files to message buffer.
			\\[helm-ff-run-print-file] Print file, (`\\[universal-argument]' to refresh printer list).
			\\[helm-enlarge-window] Enlarge Helm window.
			\\[helm-narrow-window] Narrow Helm window.
			\\[helm-ff-run-toggle-basename] Toggle basename/fullpath.
			\\[helm-ff-run-find-file-as-root] Find file as root.
			\\[helm-ff-run-find-alternate-file] Find alternate file.
			\\[helm-ff-run-insert-org-link] Insert org link.
			\\[helm-ff-bookmark-set] Set bookmark to current directory.
			\\[helm-find-files-toggle-to-bookmark] Jump to bookmark list.") nil [8475 39627])
			("helm-read-file-name-help-message" function nil nil [39670 43283])
			("helm-generic-file-help-message" variable (:default-value "* Helm Generic files

			** Tips

			*** Locate

			You can append to the search pattern any of the locate command line options,
			e.g. -b, -e, -n <number>, etc. See the locate(1) man page for more details.

			Some other sources (at the moment \"recentf\" and \"file in current directory\")
			support the -b flag for compatibility with locate when they are used with it.

			When you enable fuzzy matching on locate with `helm-locate-fuzzy-match', the
			search will be performed on basename only for efficiency (so don't add \"-b\" at
			prompt). As soon as you separate the patterns with spaces, fuzzy matching will
			be disabled and search will be done on the full filename. Note that in
			multi-match, fuzzy is completely disabled, which means that each pattern is a
			match regexp (i.e. \"helm\" will match \"helm\" but \"hlm\" will not match
			\"helm\").

			*** Browse project

			When the current directory is not under version control, don't forget to refresh
			the cache when files have been added/removed in the directory.

			*** Find command

			Recursively search files using the \"find\" shell command.

			Candidates are all filenames that match all given globbing patterns. This
			respects the options `helm-case-fold-search' and
			`helm-findutils-search-full-path'.

			You can pass arbitrary \"find\" options directly after a \"*\" separator.
			For example, this would find all files matching \"book\" that are larger
			than 1 megabyte:

			book * -size +1M

			** Commands
			\\<helm-generic-files-map>
			\\[helm-ff-run-toggle-basename] Toggle basename.
			\\[helm-ff-run-grep] Run grep (`\\[universal-argument]' to recurse).
			\\[helm-ff-run-zgrep] Run zgrep.
			\\[helm-ff-run-gid] Run GID (id-utils).
			\\[helm-ff-run-pdfgrep] Run PDFgrep on marked files.
			\\[helm-ff-run-copy-file] Copy file(s)
			\\[helm-ff-run-rename-file] Rename file(s).
			\\[helm-ff-run-symlink-file] Symlink file(s).
			\\[helm-ff-run-hardlink-file] Hardlink file(s).
			\\[helm-ff-run-delete-file] Delete file(s).
			\\[helm-ff-run-byte-compile-file] Byte compile Elisp file(s) (`\\[universal-argument]' to load).
			\\[helm-ff-run-load-file] Load Elisp file(s).
			\\[helm-ff-run-ediff-file] Ediff file.
			\\[helm-ff-run-ediff-merge-file] Ediff-merge file.
			\\[helm-ff-run-switch-other-window] Switch to other window.
			\\[helm-ff-properties-persistent] Show file properties.
			\\[helm-ff-run-etags] Run etags (`\\[universal-argument]' to use tap, `\\[universal-argument] \\[universal-argument]' to reload the database).
			\\[helm-yank-text-at-point] Yank text at point.
			\\[helm-ff-run-open-file-externally] Open file with external program (`\\[universal-argument]' to choose).
			\\[helm-ff-run-open-file-with-default-tool] Open file externally with default tool.
			\\[helm-ff-run-insert-org-link] Insert org link.") nil [43331 46147])
			("helm-grep-help-message" variable (:default-value "* Helm Grep

			** Tips

			*** Use a prefix argument to grep recursively

			With Helm supporting git-grep and AG however, you are better off using one of
			them for recursive searches.

			*** You can use wild cards when selecting files (e.g. \"*.el\")

			*** You can grep in many different directories by marking files or using wild cards

			*** You can save the result in a `helm-grep-mode' buffer

			See [[Commands][commands]] below.

			Once in that buffer you can use \"emacs-wgrep\" (external package not bundled with Helm)
			to edit your changes.

			*** Helm-grep supports multi-matching

			(Starting from version 1.9.4.)

			Simply add a space between each pattern as for most Helm commands.

			*** See full path of selected candidate

			Add (helm-popup-tip-mode 1) in your init file or enable it interactively with
			M-x helm-popup-tip-mode.

			*** Open file in other window

			The command \\<helm-grep-map>\\[helm-grep-run-other-window-action] allow you to open file
			in other window horizontally or vertically if a prefix arg is supplied.

			*** Performance over TRAMP

			Grepping works but it is badly supported as TRAMP doesn't support multiple
			processes running in a short delay (less than 5s) among other things.

			Helm uses a special hook to suspend the process automatically while you are
			typing. Even if Helm handles this automatically by delaying each process by 5s,
			you are adviced to this manually by hitting `\\<helm-map>\\[helm-toggle-suspend-update]' (suspend process) before
			typing, and hit again `\\<helm-map>\\[helm-toggle-suspend-update]' when the regexp is ready to send to the remote
			process. For simple regexps, there should be no need for this.

			Another solution is to not use TRAMP at all and mount your remote file system via
			SSHFS.

			* Helm GID

			** Tips

			Helm-GID reads the database created with the `mkid' command from id-utils.
			The name of the database file can be customized with `helm-gid-db-file-name', it
			is usually \"ID\".

			Helm-GID use the symbol at point as default-input. This command is also
			accessible from `helm-find-files' which allow you to navigate to another
			directory to consult its database.

			Note: Helm-GID supports multi-matches but only the last pattern entered will be
			highlighted since there is no ~--color~-like option in GID itself.

			* Helm AG

			** Tips

			Helm-AG is different from grep or ack-grep in that it works on a directory and
			not on a list of files.

			You can ignore files and directories with a \".agignore\" file, local to a
			directory or global when placed in the home directory. (See the AG man page for
			more details.) That file follows the same syntax as `helm-grep-ignored-files'
			and `helm-grep-ignored-directories'.

			As always you can access Helm AG from `helm-find-files'.

			Starting with version 0.30, AG accepts one or more TYPE arguments on its command
			line. Helm provides completion on these TYPE arguments when available with your
			AG version. Use a prefix argument when starting a Helm-AG session to enable this
			completion.

			Note: You can mark several types to match in the AG query. The first AG
			versions providing this feature allowed only one type, so in this case only the
			last mark will be used.

			* Helm git-grep

			Helm-git-grep searches the current directory, i.e the default directory or the
			directory in Helm-find-files. If this current directory is a subdirectory of a
			project and you want to also match parent directories (i.e the whole project),
			use a prefix argument.

			** Commands
			\\<helm-grep-map>
			\\[helm-goto-next-file] Next File.
			\\[helm-goto-precedent-file] Previous File.
			\\[helm-yank-text-at-point] Yank text at point in minibuffer.
			\\[helm-grep-run-other-window-action] Jump to other window.
			\\[helm-grep-run-other-frame-action] Jump to other frame.
			\\[helm-grep-run-default-action] Run default action (same as `RET').
			\\[helm-grep-run-save-buffer] Save to a `helm-grep-mode' enabled buffer.") nil [46169 50078])
			("helm-pdfgrep-help-message" variable (:default-value "* Helm PDFgrep Map

			** Commands
			\\<helm-pdfgrep-map>
			\\[helm-goto-next-file] Next file.
			\\[helm-goto-precedent-file] Previous file.
			\\[helm-yank-text-at-point] Yank text at point in minibuffer.") nil [50104 50345])
			("helm-etags-help-message" variable (:default-value "* Helm Etags Map

			** Commands
			\\<helm-etags-map>
			\\[helm-goto-next-file] Next file.
			\\[helm-goto-precedent-file] Previous file.
			\\[helm-yank-text-at-point] Yank text at point in minibuffer.") nil [50368 50603])
			("helm-ucs-help-message" variable (:default-value "* Helm UCS

			** Tips

			Use commands below to insert unicode characters in current buffer without
			leaving Helm.

			** Commands
			\\<helm-ucs-map>
			\\[helm-ucs-persistent-insert] Insert character.
			\\[helm-ucs-persistent-forward] Forward character.
			\\[helm-ucs-persistent-backward] Backward character.
			\\[helm-ucs-persistent-delete] Delete character backward.
			\\[helm-ucs-persistent-insert-space] Insert space.") nil [50624 51074])
			("helm-bookmark-help-message" variable (:default-value "* Helm bookmark name

			** Commands
			\\<helm-bookmark-map>
			\\[helm-bookmark-run-jump-other-window] Jump other window.
			\\[helm-bookmark-run-delete] Delete bookmark.
			\\[helm-bookmark-run-edit] Edit bookmark.
			\\[helm-bookmark-toggle-filename] Toggle bookmark location visibility.") nil [51100 51425])
			("helm-esh-help-message" variable (:default-value "* Helm Eshell on file

			** Tips

			*** Pass extra arguments after filename

			Normally the command or alias will be called with file as argument. For instance

			<command> candidate_file

			But you can also pass an argument or more after \"candidate_file\" like this:

			<command> %s [extra_args]

			\"candidate_file\" will be added at \"%s\" and the command will look at this:

			<command> candidate_file [extra_args]

			*** Specify marked files as arguments

			Example:

			<command> file1 file2...

			Call `helm-find-files-eshell-command-on-file' with one prefix argument. Otherwise
			you can pass one prefix argument from the command selection buffer.

			Note: This does not work on remote files.

			With two prefix-args the output is printed to the `current-buffer'.

			With no prefix argument or a prefix argument value of '(16) (`\\[universal-argument] \\[universal-argument]')
			the command is called once for each file like this:

			<command> file1
			<command> file2
			...

			** Commands
			\\<helm-esh-on-file-map>") nil [51465 52509])
			("helm-buffers-ido-virtual-help-message" variable (:default-value "* Helm Ido virtual buffers

			** Commands
			\\<helm-buffers-ido-virtual-map>
			\\[helm-ff-run-switch-other-window] Switch to other window.
			\\[helm-ff-run-switch-other-frame] Switch to other frame.
			\\[helm-ff-run-grep] Grep file.
			\\[helm-ff-run-zgrep] Zgrep file.
			\\[helm-ff-run-delete-file] Delete file.
			\\[helm-ff-run-open-file-externally] Open file externally.") nil [52545 52970])
			("helm-moccur-help-message" variable (:default-value "* Helm Moccur

			** Tips

			*** Matching

			Multiple regexp matching is allowed, simply enter a space to separate the regexps.

			Matching empty lines is supported with the regexp \"^$\", you then get the
			results displayed as the buffer-name and the line number only. You can
			save and edit these results, i.e. add text to the empty line.

			*** Automatically match symbol at point

			Helm can automatically match the symbol at point while keeping the minibuffer
			empty, ready to be written to. This behaviour is disabled by default. To
			enable this you need to add `helm-source-occur' and `helm-source-moccur' to
			`helm-sources-using-default-as-input'.

			*** Jump to the corresponding line in the searched buffer

			You can do this with `\\<helm-map>\\[helm-execute-persistent-action]' (persistent-action), to do it repeatedly
			you can use `\\<helm-map>\\[helm-follow-action-forward]' and `\\<helm-map>\\[helm-follow-action-backward]' or enable `helm-follow-mode' with `\\<helm-map>\\[helm-follow-mode]'.

			*** Switch to buffer in other window

			The command \\<helm-moccur-map>\\[helm-moccur-run-goto-line-ow] allow you to switch to buffer
			in other window horizontally or vertically if a prefix arg is supplied.

			*** Save the results

			Similarly to Helm-grep, you can save the results with `\\<helm-map>\\[helm-moccur-run-save-buffer]'.
			Once in the saved buffer, you can edit it, see [[Edit a saved buffer][below]].

			Of course if you don't save the results, you can resume the Helm session with
			`helm-resume'.

			*** Refresh the resumed session

			When the buffer(s) where you ran helm-(m)occur get(s) modified, the Helm buffer
			will flash red as a warning. You can refresh the buffer by running `\\<helm-map>\\[helm-refresh]'.
			This can be done automatically by customizing `helm-moccur-auto-update-on-resume'.

			*** Refresh a saved buffer

			Type `g' to update the buffer.

			*** Edit a saved buffer

			First, install wgrep (https://github.com/mhayashi1120/Emacs-wgrep) and then:

			1) `C-c C-p' (`wgrep-change-to-wgrep-mode') to edit the buffer(s).
			2) `C-x C-s' to save your changes.

			Tip: Use the excellent iedit (https://github.com/victorhge/iedit) to modify all
			occurences at once in the buffer.

			*** Search in region

			When searching in current-buffer with `helm-occur', if a region
			is found helm will search in this region only. If you marked
			this region with `mark-defun' the symbol that was at point before
			marking defun will be used when `helm-source-occur' is member of
			`helm-sources-using-default-as-input'.

			** Commands
			\\<helm-moccur-map>
			\\[helm-goto-next-file] Next buffer.
			\\[helm-goto-precedent-file] Previous buffer.
			\\[helm-yank-text-at-point] Yank text at point in minibuffer.
			\\[helm-moccur-run-goto-line-ow] Go to line in other window.
			\\[helm-moccur-run-goto-line-of] Go to line in new frame.") nil [52994 55831])
			("helm-top-help-message" variable (:default-value "* Helm Top

			** Commands
			\\<helm-top-map>
			\\[helm-top-run-sort-by-com] Sort by commands.
			\\[helm-top-run-sort-by-cpu] Sort by CPU usage.
			\\[helm-top-run-sort-by-user] Sort alphabetically by user.
			\\[helm-top-run-sort-by-mem] Sort by memory.") nil [55852 56138])
			("helm-el-package-help-message" variable (:default-value "* Helm Elisp package

			** Tips

			*** Compile all your packages asynchronously

			If you use async (if you have installed Helm from MELPA you do), only \"helm\",
			\"helm-core\", and \"magit\" are compiled asynchronously. If you want all your
			packages compiled asynchronously, add this to your init file:

			(setq async-bytecomp-allowed-packages '(all))

			*** Upgrade Elisp packages

			On initialization (when Emacs is fetching packages on remote), if Helm finds
			packages to upgrade, it will start in the upgradable packages view showing the packages
			available for upgrade.

			On subsequent runs, you will have to refresh the list with `C-c \\[universal-argument]'. If Helm
			finds upgrades you can switch to upgrade view (see below) to see what packages
			are available for upgrade or simply hit `C-c U' to upgrade them all.

			To see upgradable packages hit `M-U'.

			Then you can install all upgradable packages with the \"upgrade all\" action
			(`C-c \\[universal-argument]'), or upgrade only specific packages by marking them and running the
			\"upgrade\" action (visible only when there are upgradable packages). Of course
			you can upgrade a single package by just running the \"upgrade\" action without
			marking it (`C-c u' or `RET') .

			Warning: You are strongly advised to restart Emacs after upgrading packages.

			*** Meaning of flags prefixing packages

			(Emacs ≥25)

			- The flag \"S\" that prefixes package names means that the packages belong to `package-selected-packages'.

			- The flag \"U\" that prefix package names mean that this package is no more needed.

			** Commands
			\\<helm-el-package-map>
			\\[helm-el-package-show-all] Show all packages.
			\\[helm-el-package-show-installed] Show installed packages only.
			\\[helm-el-package-show-uninstalled] Show non-installed packages only.
			\\[helm-el-package-show-upgrade] Show upgradable packages only.
			\\[helm-el-package-show-built-in] Show built-in packages only.
			\\[helm-el-run-package-install] Install package(s).
			\\[helm-el-run-package-reinstall] Reinstall package(s).
			\\[helm-el-run-package-uninstall] Uninstall package(s).
			\\[helm-el-run-package-upgrade] Upgrade package(s).
			\\[helm-el-run-package-upgrade-all] Upgrade all packages.
			\\[helm-el-run-visit-homepage] Visit package homepage.") nil [56169 58481])
			("helm-M-x-help-message" variable (:default-value "* Helm M-x

			** Tips

			*** You can get help on any command with persistent action (\\[helm-execute-persistent-action])

			*** Prefix arguments

			You must pass prefix arguments after starting `helm-M-x'. A mode-line
			counter will display the number of given prefix arguments.

			If you pass prefix arguments before running `helm-M-x', it will be displayed in the prompt.
			The first `\\[universal-argument]' after `helm-M-x' clears those prefix arguments.") nil [58502 58985])
			("helm-imenu-help-message" variable (:default-value "* Helm Imenu

			** Commands
			\\<helm-imenu-map>
			\\[helm-imenu-next-section] Go to next section.
			\\[helm-imenu-previous-section] Go to previous section.") nil [59008 59199])
			("helm-colors-help-message" variable (:default-value "* Helm colors

			** Commands
			\\<helm-color-map>
			\\[helm-color-run-insert-name] Insert the entry name.
			\\[helm-color-run-kill-name] Kill the entry name.
			\\[helm-color-run-insert-rgb] Insert entry in RGB format.
			\\[helm-color-run-kill-rgb] Kill entry in RGB format.") nil [59223 59534])
			("helm-semantic-help-message" variable (:default-value "* Helm Semantic

			** Commands
			\\<helm-semantic-map>") nil [59560 59650])
			("helm-kmacro-help-message" variable (:default-value "* Helm kmacro

			** Tips

			- Start recording a kmacro with `f3'.
			- End the kmacro recording with `f4'.
			- Run `helm-execute-kmacro' to list all your kmacros.

			Use persistent action to run your kmacro as many time as needed.
			You can browse the kmacros with `helm-next-line' and `helm-previous-line'.

			Note: You can't record keys running Helm commands except `helm-M-x', under the
			condition that you don't choose a command using Helm completion.

			** Commands
			\\<helm-kmacro-map>") nil [59674 60184])
			("helm-kill-ring-help-message" variable (:default-value "* Helm kill ring

			** Tips

			Every Helm session lets you save a candidate to the kill-ring / clipboard /
			primary-selection with `\\<helm-map>\\[helm-kill-selection-and-quit]'.

			To save space, Helm-kill-ring truncates the candidates longer than
			`helm-kill-ring-max-offset'.
			`\\<helm-kill-ring-map>\\[helm-kill-ring-kill-selection]' then saves the whole
			text and not the truncated value. The view of truncated candidates can be
			toggled; see the command list below.

			As opposed to `yank', numeric prefix arguments are ignored with
			`helm-show-kill-ring': there is no need for them since selection happens within
			Helm. Moreover Helm has [[Shortcuts for executing Default Action on the nth
			candidate][Shortcuts for executing Default Action on the nth candidate]].

			It is recommended to globally bind `M-y' to `helm-show-kill-ring'. Once in the
			Helm-kill-ring session you can navigate to next/previous line with `M-y' and
			`M-u' for convenience. Of course `\\[helm-next-line]' and `\\[helm-previous-line]' are still available.

			It is possible to delete candidates from the kill ring.

			You can concatenate marked candidates and yank them in the current
			buffer, thus creating a new entry in the kill ring. Candidates are
			concatenated with `helm-kill-ring-separator' as default but you can
			change interactively the separator while yanking by using two prefix
			args. When you have something else than \"\\n\" as default value for
			`helm-kill-ring-separator' and you want to use \"\\n\" from prompt, use
			`C-q C-j' to enter a newline in prompt.

			To not push a new entry in the kill ring, use `\\<helm-map>\\[helm-copy-to-buffer]' instead of RET
			(note that you can't change separator with this).

			When inserting candidates with the default action (`RET'), `point' is placed at
			the end of the candidate and `mark' at the beginning. You can revert this behavior
			by using a prefix argument, i.e. `C-u RET', like the regular `yank' command does.

			** Commands
			\\<helm-kill-ring-map>
			\\[helm-next-line] Next line.
			\\[helm-previous-line] Previous line.
			\\[helm-kill-ring-delete] Delete entry.
			\\[helm-kill-ring-toggle-truncated] Toggle truncated view of candidate.
			\\[helm-kill-ring-kill-selection] Kill non-truncated of selection.") nil [60206 62475])
			("helm-org-headings-help-message" variable (:default-value "* Helm Org headings

			** Tips

			*** Refiling

			You can refile one or more headings at a time.

			To refile one heading, move the point to the entry you want to refile and run
			\\[helm-org-in-buffer-headings]. Then select the heading you want to refile to
			and press \\<helm-org-headings-map>\\[helm-org-run-refile-heading-to] or select the refile action from the actions menu.

			To refile multiple headings, run \\[helm-org-in-buffer-headings] and mark the
			headings you want to refile. Then select the heading you want to refile to
			(without marking it) and press \\<helm-org-headings-map>\\[helm-org-run-refile-heading-to] or select the refile action from the
			actions menu.

			*** Tags completion

			Tags completion use `completing-read-multiple', perhaps have a
			look at its docstring.

			**** Single tag

			From an org heading hit C-c C-c which provide a
			\"Tags\" prompt, then hit TAB and RET if you want to enter an
			existing tag or write a new tag in prompt. At this point you end
			up with an entry in your prompt, if you enter RET, the entry is
			added as tag in your org header.

			**** Multiple tags

			If you want to add more tag to your org header, add a separator[1] after
			your tag and write a new tag or hit TAB to find another existing
			tag, and so on until you have all the tags you want
			e.g \"foo,bar,baz\" then press RET to finally add the tags to your
			org header.
			Note: [1] A separator can be a comma, a colon i.e. [,:] or a space.

			** Commands
			\\<helm-org-headings-map>
			\\[helm-org-run-open-heading-in-indirect-buffer] Open heading in indirect buffer.
			\\[helm-org-run-refile-heading-to] Refile current or marked headings to selection.
			\\[helm-org-run-insert-link-to-heading-at-marker] Insert link at point to selection.") nil [62500 64270])
			("helm-comp-read-help-message" function nil nil [64295 65214])
			("helm-comp-read-mode-line" variable (:default-value "\\<helm-comp-read-map>C/\\[helm-cr-empty-string]:Empty \\<helm-map>\\[helm-help]:Help \\[helm-select-action]:Act \\[helm-maybe-exit-minibuffer]/f1/f2/f-n:NthAct \\[helm-toggle-suspend-update]:Tog.suspend") nil [65261 65516])
			("helm-read-file-name-mode-line-string" variable (:default-value "\\<helm-read-file-map>\\[helm-help]:Help C/\\[helm-cr-empty-string]:Empty \\<helm-map>\\[helm-select-action]:Act \\[helm-maybe-exit-minibuffer]/f1/f2/f-n:NthAct \\[helm-toggle-suspend-update]:Tog.suspend") nil [65533 65863])
			("helm-top-mode-line" variable (:default-value "\\<helm-top-map>\\[helm-help]:Help \\<helm-map>\\[helm-select-action]:Act \\[helm-maybe-exit-minibuffer]/f1/f2/f-n:NthAct \\[helm-toggle-suspend-update]:Tog.suspend") nil [65880 66088])
			("helm-help" package nil nil [66091 66111]))
			:file "helm-help.el"
			:pointmax 66252
			:fsize 66254
			:lastmodtime '(23537 22013 0 0)
			:unmatched-syntax nil)
			(semanticdb-table "semanticdb-table"
			:major-mode emacs-lisp-mode
			:tags
			'( ("cl-lib" include nil nil [919 936])
			("eieio" include nil nil [937 953])
			("helm-type-file" type
			(:superclasses "helm-source"
			:type "class")
			nil [967 1047])
			("helm-source-get-action-from-type" function
			(:parent "helm-type-file"
			:arguments ("object"))
			nil [1049 1149])
			("helm-actions-from-type-file" function nil nil [1151 1318])
			("helm-generic-files-map" variable (:default-value (let ((map (make-sparse-keymap))) (set-keymap-parent map helm-map) (define-key map (kbd "C-]") (quote helm-ff-run-toggle-basename)) (define-key map (kbd "C-s") (quote helm-ff-run-grep)) (define-key map (kbd "M-g s") (quote helm-ff-run-grep)) (define-key map (kbd "M-g z") (quote helm-ff-run-zgrep)) (define-key map (kbd "M-g p") (quote helm-ff-run-pdfgrep)) (define-key map (kbd "C-c g") (quote helm-ff-run-gid)) (define-key map (kbd "M-R") (quote helm-ff-run-rename-file)) (define-key map (kbd "M-C") (quote helm-ff-run-copy-file)) (define-key map (kbd "M-B") (quote helm-ff-run-byte-compile-file)) (define-key map (kbd "M-L") (quote helm-ff-run-load-file)) (define-key map (kbd "M-S") (quote helm-ff-run-symlink-file)) (define-key map (kbd "M-H") (quote helm-ff-run-hardlink-file)) (define-key map (kbd "M-D") (quote helm-ff-run-delete-file)) (define-key map (kbd "C-=") (quote helm-ff-run-ediff-file)) (define-key map (kbd "C-c =") (quote helm-ff-run-ediff-merge-file)) (define-key map (kbd "C-c o") (quote helm-ff-run-switch-other-window)) (define-key map (kbd "C-c r") (quote helm-ff-run-find-file-as-root)) (define-key map (kbd "C-c C-o") (quote helm-ff-run-switch-other-frame)) (define-key map (kbd "M-i") (quote helm-ff-properties-persistent)) (define-key map (kbd "C-c C-x") (quote helm-ff-run-open-file-externally)) (define-key map (kbd "C-c X") (quote helm-ff-run-open-file-with-default-tool)) (define-key map (kbd "M-.") (quote helm-ff-run-etags)) (define-key map (kbd "C-c @") (quote helm-ff-run-insert-org-link)) (define-key map (kbd "C-x C-q") (quote helm-ff-run-marked-files-in-dired)) (define-key map (kbd "C-c C-a") (quote helm-ff-run-mail-attach-files)) map)) nil [1320 3060])
			("helm-type-file-actions" variable (:default-value (helm-make-actions "Find file" (quote helm-find-many-files) "Find file as root" (quote helm-find-file-as-root) "Find file other window" (quote helm-find-files-other-window) "Find file other frame" (quote find-file-other-frame) "Open dired in file's directory" (quote helm-open-dired) "Attach file(s) to mail buffer `C-c C-a'" (quote helm-ff-mail-attach-files) "Marked files in dired" (quote helm-marked-files-in-dired) "Grep File(s) `C-u recurse'" (quote helm-find-files-grep) "Zgrep File(s) `C-u Recurse'" (quote helm-ff-zgrep) "Pdfgrep File(s)" (quote helm-ff-pdfgrep) "Insert as org link" (quote helm-files-insert-as-org-link) "Checksum File" (quote helm-ff-checksum) "Ediff File" (quote helm-find-files-ediff-files) "Ediff Merge File" (quote helm-find-files-ediff-merge-files) "Etags `M-., C-u reload tag file'" (quote helm-ff-etags-select) "View file" (quote view-file) "Insert file" (quote insert-file) "Add marked files to file-cache" (quote helm-ff-cache-add-file) "Delete file(s)" (quote helm-ff-delete-files) "Copy file(s) `M-C, C-u to follow'" (quote helm-find-files-copy) "Rename file(s) `M-R, C-u to follow'" (quote helm-find-files-rename) "Symlink files(s) `M-S, C-u to follow'" (quote helm-find-files-symlink) "Relsymlink file(s) `C-u to follow'" (quote helm-find-files-relsymlink) "Hardlink file(s) `M-H, C-u to follow'" (quote helm-find-files-hardlink) "Open file externally (C-u to choose)" (quote helm-open-file-externally) "Open file with default tool" (quote helm-open-file-with-default-tool) "Find file in hex dump" (quote hexl-find-file))) nil [3062 5104])
			("helm--setup-source" function
			(:parent "helm-type-file"
			:arguments ("_source"))
			nil [5106 5172])
			("helm--setup-source" function
			(:parent "helm-type-file"
			:arguments ("source"))
			nil [5174 6006])
			("helm-type-bookmark" type
			(:superclasses "helm-source"
			:type "class")
			nil [6023 6107])
			("helm-type-bookmark-actions" variable (:default-value (helm-make-actions "Jump to bookmark" (quote helm-bookmark-jump) "Jump to BM other window" (quote helm-bookmark-jump-other-window) "Jump to BM other frame" (quote helm-bookmark-jump-other-frame) "Bookmark edit annotation" (quote bookmark-edit-annotation) "Bookmark show annotation" (quote bookmark-show-annotation) "Delete bookmark(s)" (quote helm-delete-marked-bookmarks) "Edit Bookmark" (quote helm-bookmark-edit-bookmark) "Rename bookmark" (quote helm-bookmark-rename) "Relocate bookmark" (quote bookmark-relocate))) nil [6109 6770])
			("helm-source-get-action-from-type" function
			(:parent "helm-type-bookmark"
			:arguments ("object"))
			nil [6772 6876])
			("helm--setup-source" function
			(:parent "helm-type-bookmark"
			:arguments ("_source"))
			nil [6878 6948])
			("helm--setup-source" function
			(:parent "helm-type-bookmark"
			:arguments ("source"))
			nil [6950 7426])
			("helm-type-buffer" type
			(:superclasses "helm-source"
			:type "class")
			nil [7441 7520])
			("helm-type-buffer-actions" variable (:default-value (helm-make-actions "Switch to buffer(s)" (quote helm-buffer-switch-buffers) "Switch to buffer(s) other window `C-c o'" (quote helm-buffer-switch-buffers-other-window) "Switch to buffer other frame `C-c C-o'" (quote switch-to-buffer-other-frame) "Browse project from buffer" (quote helm-buffers-browse-project) "Query replace regexp `C-M-%'" (quote helm-buffer-query-replace-regexp) "Query replace `M-%'" (quote helm-buffer-query-replace) "View buffer" (quote view-buffer) "Display buffer" (quote display-buffer) "Rename buffer" (quote helm-buffers-rename-buffer) "Grep buffers `M-g s' (C-u grep all buffers)" (quote helm-zgrep-buffers) "Multi occur buffer(s) `C-s'" (quote helm-multi-occur-as-action) "Revert buffer(s) `M-U'" (quote helm-revert-marked-buffers) "Insert buffer" (quote insert-buffer) "Kill buffer(s) `M-D'" (quote helm-kill-marked-buffers) "Diff with file `C-='" (quote diff-buffer-with-file) "Ediff Marked buffers `C-c ='" (quote helm-ediff-marked-buffers) "Ediff Merge marked buffers `M-='" (lambda (candidate) (helm-ediff-marked-buffers candidate t)))) nil [7522 8708])
			("helm-source-get-action-from-type" function
			(:parent "helm-type-buffer"
			:arguments ("object"))
			nil [8710 8812])
			("helm--setup-source" function
			(:parent "helm-type-buffer"
			:arguments ("_source"))
			nil [8814 8882])
			("helm--setup-source" function
			(:parent "helm-type-buffer"
			:arguments ("source"))
			nil [8884 9379])
			("helm-type-function" type
			(:superclasses "helm-source"
			:type "class")
			nil [9395 9483])
			("helm-type-function-actions" variable (:default-value (helm-make-actions "Describe command" (quote describe-function) "Add command to kill ring" (quote helm-kill-new) "Go to command's definition" (quote find-function) "Debug on entry" (quote debug-on-entry) "Cancel debug on entry" (quote cancel-debug-on-entry) "Trace function" (quote trace-function) "Trace function (background)" (quote trace-function-background) "Untrace function" (quote untrace-function))) nil [9485 10018])
			("helm-source-get-action-from-type" function
			(:parent "helm-type-function"
			:arguments ("object"))
			nil [10020 10124])
			("helm-actions-from-type-function" function nil nil [10126 10301])
			("helm--setup-source" function
			(:parent "helm-type-function"
			:arguments ("_source"))
			nil [10303 10373])
			("helm--setup-source" function
			(:parent "helm-type-function"
			:arguments ("source"))
			nil [10375 10755])
			("helm-type-command" type
			(:superclasses "helm-source"
			:type "class")
			nil [10771 10857])
			("helm-actions-from-type-command" function nil nil [10859 11032])
			("helm-type-command-actions" variable (:default-value (append (helm-make-actions "Call interactively" (quote helm-call-interactively)) (helm-actions-from-type-function))) nil [11034 11319])
			("helm--setup-source" function
			(:parent "helm-type-command"
			:arguments ("_source"))
			nil [11321 11390])
			("helm--setup-source" function
			(:parent "helm-type-command"
			:arguments ("source"))
			nil [11392 11693])
			("helm-type-timers" type
			(:superclasses "helm-source"
			:type "class")
			nil [11705 11789])
			("helm-type-timers-actions" variable (:default-value (quote (("Cancel Timer" lambda (_timer) (let ((mkd (helm-marked-candidates))) (cl-loop for timer in mkd do (cancel-timer timer)))) ("Describe Function" lambda (tm) (describe-function (timer--function tm))) ("Find Function" lambda (tm) (helm-aif (timer--function tm) (if (byte-code-function-p it) (message "Can't find anonymous function `%s'" it) (find-function it))))))) nil [11791 12559])
			("helm--setup-source" function
			(:parent "helm-type-timers"
			:arguments ("_source"))
			nil [12561 12629])
			("helm--setup-source" function
			(:parent "helm-type-timers"
			:arguments ("source"))
			nil [12631 12995])
			("helm-build-type-file" function nil nil [13011 13077])
			("helm-build-type-function" function nil nil [13079 13153])
			("helm-build-type-command" function nil nil [13155 13227])
			("helm-types" package nil nil [13229 13250]))
			:file "helm-types.el"
			:pointmax 13392
			:fsize 13391
			:lastmodtime '(23537 22013 0 0)
			:unmatched-syntax nil)
			(semanticdb-table "semanticdb-table"
			:major-mode emacs-lisp-mode
			:tags
			'( ("cl-lib" include nil nil [813 830])
			("helm" include nil nil [831 846])
			("helm-help" include nil nil [847 867])
			("dired" include nil nil [887 903])
			("declare-function" code nil nil [906 986])
			("declare-function" code nil nil [987 1027])
			("winner-boring-buffers" variable nil nil [1028 1058])
			("helm-show-completion-overlay" variable nil nil [1059 1096])
			("helm-utils" customgroup (:user-visible-flag t) nil [1100 1173])
			("helm-su-or-sudo" variable (:default-value "sudo") nil [1175 1287])
			("helm-default-kbsize" variable (:default-value 1024.0) nil [1289 1480])
			("define-obsolete-variable-alias" code nil nil [1482 1620])
			("helm-highlight-matches-around-point-max-lines" variable (:default-value 15) nil [1622 1790])
			("helm-buffers-to-resize-on-pa" variable nil nil [1792 1981])
			("helm-resize-on-pa-text-height" variable (:default-value 12) nil [1983 2133])
			("helm-sources-using-help-echo-popup" variable (:default-value (quote ("Moccur" "Imenu in all buffers" "Ack-Grep" "AG" "RG" "Gid" "Git-Grep"))) nil [2135 2423])
			("helm-html-decode-entities-function" variable (:default-value (function helm-html-decode-entities-string)) nil [2425 2878])
			("helm-goto-line-before-hook" variable (:default-value (quote (helm-save-current-pos-to-mark-ring))) nil [2882 3469])
			("helm-save-pos-before-jump-register" variable (:default-value 95) nil [3471 3595])
			("helm-html-entities-alist" variable
			(:constant-flag t
			:default-value (quote ((""" . 34) (">" . 62) ("<" . 60) ("&" . 38) ("€" . 8364) ("&Yuml;" . 89) ("¡" . 161) ("¢" . 162) ("£" . 163) ("¤" . 164) ("&yen" . 165) ("¦" . 166) ("§" . 167) ("¨" . 32) ("©" . 169) ("ª" . 97) ("«" . 171) ("¬" . 172) ("&masr;" . 174) ("°" . 176) ("±" . 177) ("²" . 50) ("³" . 51) ("´" . 39) ("µ" . 956) ("¶" . 182) ("·" . 183) ("¸" . 32) ("¹" . 49) ("º" . 111) ("»" . 187) ("¼" . 49) ("½" . 49) ("¾" . 51) ("¿" . 191) ("À" . 192) ("Á" . 193) ("Â" . 194) ("Ã" . 195) ("Ä" . 196) ("Å" . 197) ("&Aelig" . 198) ("Ç" . 199) ("È" . 200) ("É" . 201) ("Ê" . 202) ("Ë" . 203) ("Ì" . 204) ("Í" . 205) ("Î" . 206) ("Ï" . 207) ("ð" . 208) ("Ñ" . 209) ("Ò" . 210) ("Ó" . 211) ("Ô" . 212) ("Õ" . 213) ("Ö" . 214) ("×" . 215) ("Ø" . 216) ("Ù" . 217) ("Ú" . 218) ("Û" . 219) ("Ü" . 220) ("Ý" . 221) ("þ" . 222) ("ß" . 223) ("à" . 224) ("á" . 225) ("â" . 226) ("ã" . 227) ("ä" . 228) ("å" . 229) ("æ" . 230) ("ç" . 231) ("è" . 232) ("é" . 233) ("ê" . 234) ("ë" . 235) ("ì" . 236) ("í" . 237) ("î" . 238) ("ï" . 239) ("ð" . 240) ("ñ" . 241) ("ò" . 242) ("ó" . 243) ("ô" . 244) ("õ" . 245) ("ö" . 246) ("÷" . 247) ("ø" . 248) ("ù" . 249) ("ú" . 250) ("û" . 251) ("ü" . 252) ("ý" . 253) ("þ" . 254) ("ÿ" . 255) ("®" . 174) ("" . 173))))
			nil [3597 6615])
			("helm-find-many-files-after-hook" variable nil nil [6617 6713])
			("helm-selection-line" variable
			(:default-value (quote ((t (:inherit highlight :distant-foreground "black"))))
			:type "face")
			nil [6730 6910])
			("helm-match-item" variable
			(:default-value (quote ((t (:inherit isearch))))
			:type "face")
			nil [6912 7048])
			("helm-window-prefer-horizontal-split" variable nil nil [7078 7784])
			("helm-window-show-buffers-function" variable (:default-value (function helm-window-default-split-fn)) nil [7786 8332])
			("helm-window-show-buffers" function (:arguments ("buffers" "other-window")) nil [8334 9051])
			("helm-window-default-split-fn" function (:arguments ("candidates" "other-window-fn")) nil [9053 9825])
			("helm-window-alternate-split-fn" function (:arguments ("candidates" "other-window-fn")) nil [9827 10772])
			("helm-window-mosaic-fn" function (:arguments ("candidates" "other-window-fn")) nil [10774 14599])
			("helm-window-other-window" function (:arguments ("buffer-or-name" "balance")) nil [14601 15506])
			("cl-defun" code nil nil [15508 15862])
			("helm-goto-char" function (:arguments ("loc")) nil [15864 16403])
			("helm-goto-line" function (:arguments ("lineno" "noanim")) nil [16405 16869])
			("helm-save-pos-to-register-before-jump" function nil nil [16871 17174])
			("helm-save-current-pos-to-mark-ring" function nil nil [17176 17462])
			("helm-show-all-in-this-source-only" function
			(:user-visible-flag t
			:arguments ("arg"))
			nil [17464 17951])
			("put" code nil nil [17952 18005])
			("helm-display-all-sources" function (:user-visible-flag t) nil [18007 18184])
			("put" code nil nil [18185 18229])
			("helm-displaying-source-names" function nil nil [18231 18633])
			("helm-handle-winner-boring-buffers" function nil nil [18635 18951])
			("add-hook" code nil nil [18952 19017])
			("helm-quit-and-find-file" function (:user-visible-flag t) nil [19019 22417])
			("put" code nil nil [22418 22461])
			("helm-generic-sort-fn" function (:arguments ("s1" "s2")) nil [22463 24174])
			("cl-defun" code nil nil [24176 24866])
			("cl-defun" code nil nil [24868 29642])
			("helm-split-mode-file-attributes" function (:arguments ("str" "string")) nil [29644 30350])
			("helm-format-columns-of-files" function (:arguments ("files")) nil [30352 30588])
			("with-helm-display-marked-candidates" function (:arguments ("buffer-or-name" "candidates" "body")) nil [30590 31565])
			("helm-match-line-overlay" variable nil nil [31615 31651])
			("helm--match-item-overlays" variable nil nil [31652 31690])
			("helm-highlight-current-line" function (:arguments ("start" "end" "buf" "face")) nil [31692 34550])
			("helm--translate-pcre-to-elisp" function (:arguments ("regexp")) nil [34552 35352])
			("helm-match-line-cleanup" function nil nil [35354 35593])
			("helm-match-line-cleanup-maybe" function nil nil [35595 35696])
			("helm-match-line-update" function nil nil [35698 35843])
			("helm-persistent-autoresize-hook" function nil nil [35845 36119])
			("helm-match-line-cleanup-pulse" function nil nil [36121 36214])
			("add-hook" code nil nil [36216 36281])
			("add-hook" code nil nil [36282 36360])
			("add-hook" code nil nil [36361 36415])
			("add-hook" code nil nil [36416 36481])
			("add-hook" code nil nil [36482 36551])
			("helm--show-help-echo-timer" variable nil nil [36616 36655])
			("helm-cancel-help-echo-timer" function nil nil [36657 36819])
			("helm-maybe-show-help-echo" function nil nil [36821 37741])
			("define-minor-mode" code nil nil [37758 38222])
			("helm-open-file-with-default-tool" function (:arguments ("file")) nil [38224 38824])
			("helm-open-dired" function (:arguments ("file")) nil [38826 39064])
			("helm-require-or-error" function (:arguments ("feature" "function")) nil [39066 39199])
			("helm-find-file-as-root" function (:arguments ("candidate")) nil [39201 39854])
			("helm-find-many-files" function (:arguments ("_ignore")) nil [39856 40149])
			("helm-read-repeat-string" function (:arguments ("prompt" "count")) nil [40151 40575])
			("helm-html-bookmarks-to-alist" function (:arguments ("file" "url-regexp" "bmk-regexp")) nil [40577 41339])
			("helm-html-entity-to-string" function (:arguments ("entity")) nil [41341 41677])
			("helm-html-decode-entities-string" function (:arguments ("str")) nil [41679 42032])
			("helm-utils" package nil nil [42034 42055]))
			:file "helm-utils.el"
			:pointmax 42197
			:fsize 42282
			:lastmodtime '(23537 22013 0 0)
			:unmatched-syntax '((close-paren 903 . 904) (symbol 869 . 886) (open-paren 868 . 869)))
			(semanticdb-table "semanticdb-table"
			:major-mode emacs-lisp-mode
			:tags
			'( ("cl-lib" include nil nil [810 827])
			("helm" include nil nil [828 843])
			("helm-lib" include nil nil [844 863])
			("helm-utils" include nil nil [864 885])
			("info" include nil nil [886 901])
			("declare-function" code nil nil [903 962])
			("declare-function" code nil nil [963 1020])
			("declare-function" code nil nil [1021 1108])
			("Info-history" variable nil nil [1109 1130])
			("Info-directory-list" variable nil nil [1131 1159])
			("helm-info" customgroup (:user-visible-flag t) nil [1177 1270])
			("helm-info-default-sources" variable (:default-value (quote (helm-source-info-elisp helm-source-info-cl helm-source-info-eieio helm-source-info-pages))) nil [1272 1569])
			("cl-defun" code nil nil [1633 3154])
			("helm-info-goto" function (:arguments ("node-line")) nil [3156 3260])
			("helm-info-display-to-real" function (:arguments ("line")) nil [3262 3624])
			("helm-info-source" type
			(:superclasses "helm-source-in-buffer"
			:members
			( ("info-file" variable (:default-value "nil") nil nil)
			("init" variable (:default-value "(function helm-info-init)") nil nil)
			("display-to-real" variable (:default-value "(function helm-info-display-to-real)") nil nil)
			("get-line" variable (:default-value "(function buffer-substring)") nil nil)
			("action" variable (:default-value "(quote ((\"Goto node\" . helm-info-goto)))") nil nil))
			:type "class")
			nil [3626 3966])
			("helm-build-info-source" function (:arguments ("fname" "args")) nil [3968 4121])
			("helm-build-info-index-command" function (:arguments ("name" "doc" "source" "buffer")) nil [4123 4548])
			("helm-define-info-index-sources" function (:arguments ("var-value" "commands")) nil [4550 5213])
			("helm-info-index-set" function (:arguments ("var" "value")) nil [5215 5315])
			("helm-info-searched" variable (:default-value (make-ring 32)) nil [5472 5558])
			("helm-get-info-files" function nil nil [5560 6207])
			("helm-default-info-index-list" variable (:default-value (helm-get-info-files)) nil [6209 6404])
			("helm-info-search-index" function (:arguments ("candidate")) nil [6406 6746])
			("helm-def-source--info-files" function nil nil [6748 7140])
			("helm-info" function
			(:user-visible-flag t
			:arguments ("refresh"))
			nil [7157 8119])
			("helm-info--pages-cache" variable nil nil [8320 8399])
			("helm-source-info-pages" variable (:default-value (helm-build-sync-source "Info Pages" :init (function helm-info-pages-init) :candidates (lambda nil helm-info--pages-cache) :action (quote (("Show with Info" lambda (node-str) (info (replace-regexp-in-string "^[^:]+: " "" node-str))))) :requires-pattern 2)) nil [8401 8781])
			("helm-info-pages-init" function nil nil [8783 9295])
			("helm-info-at-point" function (:user-visible-flag t) nil [9312 9775])
			("helm-info" package nil nil [9778 9798]))
			:file "helm-info.el"
			:pointmax 9939
			:fsize 9938
			:lastmodtime '(23537 22013 0 0)
			:unmatched-syntax nil)
			(semanticdb-table "semanticdb-table"
			:major-mode emacs-lisp-mode
			:tags
			'( ("cl-lib" include nil nil [893 910])
			("helm" include nil nil [911 926])
			("helm-adapt" customgroup (:user-visible-flag t) nil [930 1017])
			("helm-adaptive-history-file" variable (:default-value "~/.emacs.d/helm-adaptive-history") nil [1019 1342])
			("helm-adaptive-history-length" variable (:default-value 50) nil [1344 1478])
			("helm-adaptive-sort-by-frequent-recent-usage" variable (:default-value t) nil [1480 2015])
			("helm-adaptive-done" variable nil nil [2030 2137])
			("helm-adaptive-history" variable nil nil [2139 2301])
			("helm-adaptive-freq-coefficient" variable
			(:constant-flag t
			:default-value 5)
			nil [2303 2346])
			("helm-adaptive-recent-coefficient" variable
			(:constant-flag t
			:default-value 2)
			nil [2347 2392])
			("helm-adaptive-done-reset" function nil nil [2394 2461])
			("define-minor-mode" code nil nil [2478 3567])
			("helm-adapt-use-adaptive-p" function (:arguments ("source-name")) nil [3569 4108])
			("helm-adaptive-store-selection" function nil nil [4110 7514])
			("helm-adaptive-maybe-load-history" function nil nil [7516 7838])
			("helm-adaptive-save-history" function
			(:user-visible-flag t
			:arguments ("arg"))
			nil [7840 8437])
			("helm-adaptive-sort" function (:arguments ("candidates" "source")) nil [8439 12109])
			("helm-reset-adaptive-history" function (:user-visible-flag t) nil [12126 12456])
			("helm-adaptive-compare" function (:arguments ("x" "y")) nil [12458 12689])
			("helm-adaptive" package nil nil [12692 12716]))
			:file "helm-adaptive.el"
			:pointmax 12861
			:fsize 12860
			:lastmodtime '(23537 22013 0 0)
			:unmatched-syntax nil)
			(semanticdb-table "semanticdb-table"
			:major-mode emacs-lisp-mode
			:tags
			'( ("cl-lib" include nil nil [813 830])
			("helm" include nil nil [831 846])
			("helm-help" include nil nil [847 867])
			("url" include nil nil [868 882])
			("xml" include nil nil [883 897])
			("browse-url" include nil nil [898 919])
			("helm-net" customgroup (:user-visible-flag t) nil [923 1014])
			("helm-google-suggest-default-browser-function" variable nil nil [1016 1274])
			("helm-home-url" variable (:default-value "https://www.google.com") nil [1276 1397])
			("helm-surfraw-default-browser-function" variable nil nil [1399 1600])
			("helm-google-suggest-url" variable (:default-value "https://encrypted.google.com/complete/search?output=toolbar&q=%s") nil [1602 1837])
			("helm-google-suggest-search-url" variable (:default-value "https://encrypted.google.com/search?ie=utf-8&oe=utf-8&q=%s") nil [1839 2062])
			("defvaralias" code nil nil [2064 2131])
			("make-obsolete-variable" code nil nil [2132 2218])
			("helm-net-prefer-curl" variable nil nil [2220 2399])
			("helm-surfraw-duckduckgo-url" variable (:default-value "https://duckduckgo.com/lite/?q=%s&kp=1") nil [2401 2705])
			("helm-wikipedia-suggest-url" variable (:default-value "https://en.wikipedia.org/w/api.php?action=opensearch&search=%s") nil [2707 2946])
			("helm-search-suggest-action-wikipedia-url" variable (:default-value "https://en.wikipedia.org/wiki/Special:Search?search=%s") nil [2948 3172])
			("helm-wikipedia-summary-url" variable (:default-value "https://en.wikipedia.org/w/api.php?action=parse&format=json&prop=text&section=0&page=%s") nil [3174 3441])
			("helm-search-suggest-action-youtube-url" variable (:default-value "https://www.youtube.com/results?aq=f&search_query=%s") nil [3443 3661])
			("helm-search-suggest-action-imdb-url" variable (:default-value "http://www.imdb.com/find?s=all&q=%s") nil [3663 3858])
			("helm-search-suggest-action-google-maps-url" variable (:default-value "https://maps.google.com/maps?f=q&source=s_q&q=%s") nil [3860 4082])
			("helm-search-suggest-action-google-news-url" variable (:default-value "https://www.google.com/search?safe=off&prmd=nvlifd&source=lnms&tbs=nws:1&q=%s") nil [4084 4335])
			("helm-google-suggest-actions" variable (:default-value (quote (("Google Search" . helm-google-suggest-action) ("Wikipedia" lambda (candidate) (helm-search-suggest-perform-additional-action helm-search-suggest-action-wikipedia-url candidate)) ("Youtube" lambda (candidate) (helm-search-suggest-perform-additional-action helm-search-suggest-action-youtube-url candidate)) ("IMDb" lambda (candidate) (helm-search-suggest-perform-additional-action helm-search-suggest-action-imdb-url candidate)) ("Google Maps" lambda (candidate) (helm-search-suggest-perform-additional-action helm-search-suggest-action-google-maps-url candidate)) ("Google News" lambda (candidate) (helm-search-suggest-perform-additional-action helm-search-suggest-action-google-news-url candidate))))) nil [4337 5560])
			("helm-browse-url-firefox-new-window" variable (:default-value "-new-tab") nil [5562 5858])
			("helm-search-suggest-perform-additional-action" function (:arguments ("url" "query")) nil [5927 6099])
			("helm-net--url-retrieve-sync" function (:arguments ("request" "parser")) nil [6101 6369])
			("helm-google-suggest-parser" function nil nil [6402 6714])
			("helm-google-suggest-fetch" function (:arguments ("input")) nil [6716 6986])
			("helm-google-suggest-set-candidates" function (:arguments ("request-prefix")) nil [6988 7702])
			("helm-ggs-set-number-result" function (:arguments ("num")) nil [7704 8204])
			("helm-google-suggest-action" function (:arguments ("candidate")) nil [8206 8532])
			("helm-google-suggest-default-function" variable (:default-value (quote helm-google-suggest-set-candidates)) nil [8534 8669])
			("helm-source-google-suggest" variable (:default-value (helm-build-sync-source "Google Suggest" :candidates (lambda nil (funcall helm-google-suggest-default-function)) :action (quote helm-google-suggest-actions) :volatile t :keymap helm-map :requires-pattern 3)) nil [8671 8945])
			("helm-google-suggest-emacs-lisp" function nil nil [8947 9096])
			("declare-function" code nil nil [9130 9186])
			("helm-wikipedia-suggest-fetch" function nil nil [9187 9495])
			("helm-wikipedia--parse-buffer" function nil nil [9497 10046])
			("helm-wikipedia--summary-cache" variable (:default-value (make-hash-table :test (quote equal))) nil [10048 10117])
			("helm-wikipedia-show-summary" function
			(:user-visible-flag t
			:arguments ("input"))
			nil [10118 10520])
			("helm-wikipedia-persistent-action" function (:arguments ("candidate")) nil [10522 11111])
			("helm-wikipedia--get-summary" function (:arguments ("input")) nil [11113 11864])
			("helm-wikipedia--fetch-summary" function (:arguments ("input")) nil [11866 12099])
			("helm-wikipedia--parse-summary" function nil nil [12101 13517])
			("helm-wikipedia-map" variable (:default-value (let ((map (copy-keymap helm-map))) (define-key map (kbd "<C-return>") (quote helm-wikipedia-show-summary-action)) map)) nil [13520 13711])
			("helm-source-wikipedia-suggest" variable (:default-value (helm-build-sync-source "Wikipedia Suggest" :candidates (function helm-wikipedia-suggest-fetch) :action (quote (("Wikipedia" lambda (candidate) (helm-search-suggest-perform-additional-action helm-search-suggest-action-wikipedia-url candidate)) ("Show summary in new buffer (C-RET)" . helm-wikipedia-show-summary))) :persistent-action (function helm-wikipedia-persistent-action) :persistent-help "show summary" :volatile t :keymap helm-wikipedia-map :requires-pattern 3)) nil [13713 14339])
			("helm-wikipedia-show-summary-action" function (:user-visible-flag t) nil [14341 14573])
			("helm-browse-url-chromium-program" variable (:default-value "chromium-browser") nil [14766 14826])
			("helm-browse-url-uzbl-program" variable (:default-value "uzbl-browser") nil [14827 14879])
			("helm-browse-url-conkeror-program" variable (:default-value "conkeror") nil [14880 14932])
			("helm-browse-url-opera-program" variable (:default-value "opera") nil [14933 14979])
			("helm-browse-url-default-browser-alist" variable
			(:user-visible-flag t
			:default-value (\` (((\, (or (and (boundp (quote w3m-command)) w3m-command) "/usr/bin/w3m")) . w3m-browse-url) ((\, browse-url-firefox-program) . browse-url-firefox) ((\, helm-browse-url-chromium-program) . helm-browse-url-chromium) ((\, helm-browse-url-conkeror-program) . helm-browse-url-conkeror) ((\, helm-browse-url-opera-program) . helm-browse-url-opera) ((\, helm-browse-url-uzbl-program) . helm-browse-url-uzbl) ((\, browse-url-kde-program) . browse-url-kde) ((\, browse-url-gnome-moz-program) . browse-url-gnome-moz) ((\, browse-url-mozilla-program) . browse-url-mozilla) ((\, browse-url-galeon-program) . browse-url-galeon) ((\, browse-url-netscape-program) . browse-url-netscape) ((\, browse-url-mosaic-program) . browse-url-mosaic) ((\, browse-url-xterm-program) . browse-url-text-xterm) ("emacs" . eww-browse-url))))
			nil [14980 15920])
			("cl-defun" code nil nil [15922 16354])
			("helm-browse-url-firefox" function
			(:user-visible-flag t
			:arguments ("url" "_ignore"))
			nil [16371 17043])
			("helm-browse-url-opera" function
			(:user-visible-flag t
			:arguments ("url" "_ignore"))
			nil [17060 17666])
			("helm-browse-url-chromium" function
			(:user-visible-flag t
			:arguments ("url" "_ignore"))
			nil [17683 17872])
			("helm-browse-url-uzbl" function
			(:user-visible-flag t
			:arguments ("url" "_ignore"))
			nil [17889 18063])
			("helm-browse-url-conkeror" function
			(:user-visible-flag t
			:arguments ("url" "_ignore"))
			nil [18080 18261])
			("helm-browse-url-default-browser" function (:arguments ("url" "args")) nil [18263 18669])
			("helm-browse-url" function (:arguments ("url" "args")) nil [18671 18856])
			("helm-surfraw-engines-history" variable nil nil [18961 19002])
			("helm-surfraw-input-history" variable nil nil [19003 19042])
			("helm-surfraw--elvi-cache" variable nil nil [19043 19080])
			("helm-build-elvi-list" function nil nil [19082 19405])
			("helm-surfraw" function
			(:user-visible-flag t
			:arguments ("pattern" "engine"))
			nil [19422 21062])
			("helm-google-suggest" function (:user-visible-flag t) nil [21079 21255])
			("helm-wikipedia-suggest" function (:user-visible-flag t) nil [21272 21475])
			("helm-net" package nil nil [21478 21497]))
			:file "helm-net.el"
			:pointmax 21637
			:fsize 21636
			:lastmodtime '(23537 22013 0 0)
			:unmatched-syntax nil)
			(semanticdb-table "semanticdb-table"
			:major-mode emacs-lisp-mode
			:tags
			'( ("cl-lib" include nil nil [817 834])
			("helm" include nil nil [835 850])
			("helm-lib" include nil nil [851 870])
			("helm-files" include nil nil [871 892])
			("crm-separator" variable nil nil [894 916])
			("helm-mode" customgroup (:user-visible-flag t) nil [920 987])
			("helm-completing-read-handlers-alist" variable (:default-value (quote ((describe-function . helm-completing-read-symbols) (describe-variable . helm-completing-read-symbols) (describe-symbol . helm-completing-read-symbols) (debug-on-entry . helm-completing-read-symbols) (find-function . helm-completing-read-symbols) (disassemble . helm-completing-read-symbols) (trace-function . helm-completing-read-symbols) (trace-function-foreground . helm-completing-read-symbols) (trace-function-background . helm-completing-read-symbols) (find-tag . helm-completing-read-default-find-tag) (org-capture . helm-org-completing-read-tags) (org-set-tags . helm-org-completing-read-tags) (ffap-alternate-file) (tmm-menubar) (find-file) (find-file-at-point . helm-completing-read-sync-default-handler) (ffap . helm-completing-read-sync-default-handler) (execute-extended-command) (dired-do-rename . helm-read-file-name-handler-1) (dired-do-copy . helm-read-file-name-handler-1) (dired-do-symlink . helm-read-file-name-handler-1) (dired-do-relsymlink . helm-read-file-name-handler-1) (dired-do-hardlink . helm-read-file-name-handler-1) (basic-save-buffer . helm-read-file-name-handler-1) (write-file . helm-read-file-name-handler-1) (write-region . helm-read-file-name-handler-1)))) nil [989 5389])
			("helm-comp-read-case-fold-search" variable (:default-value helm-case-fold-search) nil [5391 5610])
			("helm-mode-handle-completion-in-region" variable (:default-value t) nil [5612 5855])
			("helm-mode-reverse-history" variable (:default-value t) nil [5857 6014])
			("helm-mode-no-completion-in-region-in-modes" variable nil nil [6016 6181])
			("helm-completion-in-region-fuzzy-match" variable nil nil [6183 6411])
			("helm-completion-in-region-default-sort-fn" variable (:default-value (quote helm-completion-in-region-sort-fn)) nil [6413 6865])
			("helm-mode-fuzzy-match" variable nil nil [6867 7255])
			("helm-mode-minibuffer-setup-hook-black-list" variable (:default-value (quote (minibuffer-completion-help))) nil [7257 7596])
			("helm-completing-read-dynamic-complete" variable nil nil [7598 8243])
			("helm-comp-read-map" variable (:default-value (let ((map (make-sparse-keymap))) (set-keymap-parent map helm-map) (define-key map (kbd "<C-return>") (quote helm-cr-empty-string)) (define-key map (kbd "M-RET") (quote helm-cr-empty-string)) map)) nil [8247 8513])
			("helm-cr-empty-string" function (:user-visible-flag t) nil [8541 8720])
			("put" code nil nil [8721 8761])
			("helm-mode--keyboard-quit" function nil nil [8763 8943])
			("cl-defun" code nil nil [8945 13915])
			("helm-cr--pattern-in-candidates-p" function (:arguments ("candidates")) nil [13917 14192])
			("helm-cr-default-transformer" function (:arguments ("candidates" "source")) nil [14194 15932])
			("helm-comp-read--move-to-first-real-candidate" function nil nil [15934 16125])
			("helm-cr-default" function (:arguments ("default" "cands")) nil [16127 16687])
			("cl-defun" code nil nil [16704 28812])
			("helm-completion-mode-string" variable (:default-value " Helm") nil [29212 29256])
			("helm-completion-mode-quit-message" variable (:default-value "Helm completion disabled") nil [29258 29329])
			("helm-completion-mode-start-message" variable (:default-value "Helm completion enabled") nil [29331 29402])
			("helm-completing-read-symbols" function (:arguments ("prompt" "_collection" "test" "_require-match" "init" "hist" "default" "_inherit-input-method" "name" "buffer")) nil [29435 30602])
			("helm-completing-read-default-1" function (:arguments ("prompt" "collection" "test" "require-match" "init" "hist" "default" "_inherit-input-method" "name" "buffer" "cands-in-buffer" "exec-when-only-one")) nil [30639 32543])
			("helm-completing-read-default-find-tag" function (:arguments ("prompt" "collection" "test" "require-match" "init" "hist" "default" "inherit-input-method" "name" "buffer")) nil [32545 33304])
			("helm-completing-read-sync-default-handler" function (:arguments ("prompt" "collection" "test" "require-match" "init" "hist" "default" "inherit-input-method" "name" "buffer")) nil [33306 33704])
			("helm-completing-read-default-handler" function (:arguments ("prompt" "collection" "test" "require-match" "init" "hist" "default" "inherit-input-method" "name" "buffer")) nil [33706 34183])
			("helm--generic-read-buffer" function (:arguments ("prompt" "default" "require-match" "predicate")) nil [34185 34498])
			("cl-defun" code nil nil [34500 39911])
			("cl-defun" code nil nil [39962 47480])
			("helm-mode--default-filename" function (:arguments ("fname" "dir" "initial")) nil [47482 48023])
			("cl-defun" code nil nil [48025 52842])
			("helm-read-file-name-handler-1" function (:arguments ("prompt" "dir" "default-filename" "mustmatch" "initial" "predicate" "name" "buffer")) nil [52897 53946])
			("helm-mode--advice-lisp--local-variables" function (:arguments ("old--fn" "args")) nil [53978 54089])
			("helm-completion-in-region-sort-fn" function (:arguments ("candidates" "_source")) nil [54091 54247])
			("helm--completion-in-region" function (:arguments ("start" "end" "collection" "predicate")) nil [54249 61483])
			("helm-mode--in-file-completion-p" function nil nil [61485 61625])
			("when" code nil nil [61627 61756])
			("define-minor-mode" code nil nil [61773 65142])
			("helm-mode" package nil nil [65144 65164]))
			:file "helm-mode.el"
			:pointmax 65305
			:fsize 65304
			:lastmodtime '(23537 22013 0 0)
			:unmatched-syntax nil)
			(semanticdb-table "semanticdb-table"
			:major-mode emacs-lisp-mode
			:tags
			'( ("cl-lib" include nil nil [815 832])
			("helm" include nil nil [833 848])
			("helm-types" include nil nil [849 870])
			("helm-utils" include nil nil [871 892])
			("helm-grep" include nil nil [893 913])
			("helm-help" include nil nil [914 934])
			("helm-locate" include nil nil [935 957])
			("helm-tags" include nil nil [958 978])
			("helm-buffers" include nil nil [979 1002])
			("image-dired" include nil nil [1128 1150])
			("tramp" include nil nil [1109 1125])
			("dired-x" include nil nil [1088 1106])
			("dired-aux" include nil nil [1065 1085])
			("ffap" include nil nil [1047 1062])
			("thingatpt" include nil nil [1024 1044])
			("declare-function" code nil nil [1153 1214])
			("declare-function" code nil nil [1215 1318])
			("declare-function" code nil nil [1319 1393])
			("declare-function" code nil nil [1394 1486])
			("declare-function" code nil nil [1487 1563])
			("declare-function" code nil nil [1564 1618])
			("declare-function" code nil nil [1619 1708])
			("declare-function" code nil nil [1709 1756])
			("declare-function" code nil nil [1757 1797])
			("declare-function" code nil nil [1798 1843])
			("declare-function" code nil nil [1844 1885])
			("declare-function" code nil nil [1886 1938])
			("declare-function" code nil nil [1939 1992])
			("declare-function" code nil nil [1993 2044])
			("declare-function" code nil nil [2045 2110])
			("declare-function" code nil nil [2111 2157])
			("declare-function" code nil nil [2158 2200])
			("declare-function" code nil nil [2201 2269])
			("declare-function" code nil nil [2270 2330])
			("recentf-list" variable nil nil [2332 2353])
			("helm-mm-matching-method" variable nil nil [2354 2386])
			("dired-async-mode" variable nil nil [2387 2412])
			("org-directory" variable nil nil [2413 2435])
			("helm-files" customgroup (:user-visible-flag t) nil [2438 2525])
			("helm-tramp-verbose" variable nil nil [2527 2758])
			("helm-ff-auto-update-initial-value" variable nil nil [2760 3162])
			("helm-ff-lynx-style-map" variable (:default-value t) nil [3164 3403])
			("helm-ff-history-max-length" variable (:default-value 100) nil [3405 3544])
			("helm-ff-fuzzy-matching" variable (:default-value t) nil [3546 3746])
			("helm-ff-exif-data-program" variable (:default-value "exiftran") nil [3748 3889])
			("helm-ff-exif-data-program-args" variable (:default-value "-d") nil [3891 4027])
			("helm-ff-newfile-prompt-p" variable (:default-value t) nil [4029 4188])
			("helm-ff-avfs-directory" variable (:default-value "~/.avfs") nil [4190 4489])
			("helm-ff-file-compressed-list" variable (:default-value (quote ("gz" "bz2" "zip" "7z"))) nil [4491 4660])
			("helm-ff-printer-list" variable nil nil [4662 5063])
			("helm-ff-transformer-show-only-basename" variable (:default-value t) nil [5065 5331])
			("helm-ff-signal-error-on-dot-files" variable (:default-value t) nil [5333 5593])
			("helm-ff-search-library-in-sexp" variable nil nil [5595 5745])
			("helm-tooltip-hide-delay" variable (:default-value 25) nil [5747 5880])
			("helm-ff-file-name-history-use-recentf" variable nil nil [5882 6049])
			("helm-ff-skip-boring-files" variable nil nil [6051 6387])
			("helm-ff-candidate-number-limit" variable (:default-value 5000) nil [6389 6868])
			("helm-ff-up-one-level-preselect" variable (:default-value t) nil [6870 7348])
			("helm-files-save-history-extra-sources" variable (:default-value (quote ("Find" "Locate" "Recentf" "Files from Current Directory" "File Cache"))) nil [7350 7595])
			("helm-find-files-before-init-hook" variable nil nil [7597 7742])
			("helm-find-files-after-init-hook" variable nil nil [7744 7887])
			("helm-find-files-bookmark-prefix" variable (:default-value "Helm-find-files: ") nil [7889 8045])
			("helm-ff-guess-ffap-filenames" variable nil nil [8047 8281])
			("helm-ff-guess-ffap-urls" variable (:default-value t) nil [8283 8584])
			("helm-ff-no-preselect" variable nil nil [8586 8733])
			("helm-find-files-ignore-thing-at-point" variable nil nil [8735 9045])
			("helm-substitute-in-filename-stay-on-remote" variable nil nil [9047 9222])
			("helm-ff-goto-first-real-dired-exceptions" variable (:default-value (quote (dired-goto-file))) nil [9224 9418])
			("helm-mounted-network-directories" variable nil nil [9420 9754])
			("helm-browse-project-default-find-files-fn" variable (:default-value (function helm-browse-project-walk-directory)) nil [9756 10006])
			("helm-ff-kill-or-find-buffer-fname-fn" variable (:default-value (function helm-ff-kill-or-find-buffer-fname)) nil [10008 10889])
			("helm-modes-using-escaped-strings" variable (:default-value (quote (eshell-mode shell-mode term-mode))) nil [10891 11077])
			("helm-ff-allow-recursive-deletes" variable nil nil [11079 11563])
			("helm-ff-delete-files-function" variable (:default-value (function helm-delete-marked-files)) nil [11565 12318])
			("helm-trash-remote-files" variable nil nil [12320 12866])
			("helm-list-directory-function" variable (:default-value (cl-case system-type (gnu/linux (function helm-list-dir-external)) (berkeley-unix (function helm-list-dir-external)) (windows-nt (function helm-list-dir-lisp)) (t (function helm-list-dir-lisp)))) nil [12868 13610])
			("helm-files-faces" customgroup (:user-visible-flag t) nil [13629 13764])
			("helm-ff-prefix" variable
			(:default-value (quote ((t (:background "yellow" :foreground "black"))))
			:type "face")
			nil [13766 13939])
			("helm-ff-executable" variable
			(:default-value (quote ((t (:foreground "green"))))
			:type "face")
			nil [13941 14086])
			("helm-ff-suid" variable
			(:default-value (quote ((t (:background "red" :foreground "white"))))
			:type "face")
			nil [14088 14239])
			("helm-ff-directory" variable
			(:default-value (quote ((t (:foreground "DarkRed" :background "LightGray"))))
			:type "face")
			nil [14241 14406])
			("helm-ff-dotted-directory" variable
			(:default-value (quote ((t (:foreground "black" :background "DimGray"))))
			:type "face")
			nil [14408 14583])
			("helm-ff-dotted-symlink-directory" variable
			(:default-value (quote ((t (:foreground "DarkOrange" :background "DimGray"))))
			:type "face")
			nil [14585 14783])
			("helm-ff-symlink" variable
			(:default-value (quote ((t :inherit font-lock-comment-face)))
			:type "face")
			nil [14785 14929])
			("helm-ff-invalid-symlink" variable
			(:default-value (quote ((t (:foreground "black" :background "red"))))
			:type "face")
			nil [14931 15099])
			("helm-ff-denied" variable
			(:default-value (quote ((t (:foreground "red" :background "black"))))
			:type "face")
			nil [15101 15264])
			("helm-ff-file" variable
			(:default-value (quote ((t (:inherit font-lock-builtin-face))))
			:type "face")
			nil [15266 15411])
			("helm-ff-truename" variable
			(:default-value (quote ((t (:inherit font-lock-string-face))))
			:type "face")
			nil [15413 15568])
			("helm-ff-dirs" variable
			(:default-value (quote ((t (:inherit font-lock-function-name-face))))
			:type "face")
			nil [15570 15750])
			("helm-ff-socket" variable
			(:default-value (quote ((t (:foreground "DeepPink"))))
			:type "face")
			nil [15752 15892])
			("helm-ff-pipe" variable
			(:default-value (quote ((t (:foreground "yellow" :background "black"))))
			:type "face")
			nil [15894 16076])
			("helm-history-deleted" variable
			(:default-value (quote ((t (:inherit helm-ff-invalid-symlink))))
			:type "face")
			nil [16078 16237])
			("helm-history-remote" variable
			(:default-value (quote ((t (:foreground "Indianred1"))))
			:type "face")
			nil [16239 16388])
			("helm-delete-async-message" variable
			(:default-value (quote ((t (:foreground "yellow"))))
			:type "face")
			nil [16390 16523])
			("helm-find-files-map" variable (:default-value (let ((map (make-sparse-keymap))) (set-keymap-parent map helm-map) (define-key map (kbd "RET") (quote helm-ff-RET)) (define-key map (kbd "C-]") (quote helm-ff-run-toggle-basename)) (define-key map (kbd "C-x C-f") (quote helm-ff-run-locate)) (define-key map (kbd "C-x C-d") (quote helm-ff-run-browse-project)) (define-key map (kbd "C-x r m") (quote helm-ff-bookmark-set)) (define-key map (kbd "C-x r b") (quote helm-find-files-toggle-to-bookmark)) (define-key map (kbd "C-x C-q") (quote helm-ff-run-marked-files-in-dired)) (define-key map (kbd "C-s") (quote helm-ff-run-grep)) (define-key map (kbd "M-g s") (quote helm-ff-run-grep)) (define-key map (kbd "M-g p") (quote helm-ff-run-pdfgrep)) (define-key map (kbd "M-g z") (quote helm-ff-run-zgrep)) (define-key map (kbd "M-g a") (quote helm-ff-run-grep-ag)) (define-key map (kbd "M-g g") (quote helm-ff-run-git-grep)) (define-key map (kbd "M-g i") (quote helm-ff-run-gid)) (define-key map (kbd "M-.") (quote helm-ff-run-etags)) (define-key map (kbd "M-R") (quote helm-ff-run-rename-file)) (define-key map (kbd "M-C") (quote helm-ff-run-copy-file)) (define-key map (kbd "M-B") (quote helm-ff-run-byte-compile-file)) (define-key map (kbd "M-L") (quote helm-ff-run-load-file)) (define-key map (kbd "M-S") (quote helm-ff-run-symlink-file)) (define-key map (kbd "M-Y") (quote helm-ff-run-relsymlink-file)) (define-key map (kbd "M-H") (quote helm-ff-run-hardlink-file)) (define-key map (kbd "M-D") (quote helm-ff-run-delete-file)) (define-key map (kbd "M-K") (quote helm-ff-run-kill-buffer-persistent)) (define-key map (kbd "M-T") (quote helm-ff-run-touch-files)) (define-key map (kbd "C-c d") (quote helm-ff-persistent-delete)) (define-key map (kbd "M-e") (quote helm-ff-run-switch-to-eshell)) (define-key map (kbd "C-c i") (quote helm-ff-run-complete-fn-at-point)) (define-key map (kbd "C-c o") (quote helm-ff-run-switch-other-window)) (define-key map (kbd "C-c C-o") (quote helm-ff-run-switch-other-frame)) (define-key map (kbd "C-c C-x") (quote helm-ff-run-open-file-externally)) (define-key map (kbd "C-c C-v") (quote helm-ff-run-preview-file-externally)) (define-key map (kbd "C-c X") (quote helm-ff-run-open-file-with-default-tool)) (define-key map (kbd "M-!") (quote helm-ff-run-eshell-command-on-file)) (define-key map (kbd "M-@") (quote helm-ff-run-query-replace-fnames-on-marked)) (define-key map (kbd "M-%") (quote helm-ff-run-query-replace)) (define-key map (kbd "C-M-%") (quote helm-ff-run-query-replace-regexp)) (define-key map (kbd "C-c =") (quote helm-ff-run-ediff-file)) (define-key map (kbd "M-=") (quote helm-ff-run-ediff-merge-file)) (define-key map (kbd "M-p") (quote helm-find-files-history)) (define-key map (kbd "C-c h") (quote helm-ff-file-name-history)) (define-key map (kbd "M-i") (quote helm-ff-properties-persistent)) (define-key map (kbd "C-}") (quote helm-narrow-window)) (define-key map (kbd "C-{") (quote helm-enlarge-window)) (define-key map (kbd "C-<backspace>") (quote helm-ff-run-toggle-auto-update)) (define-key map (kbd "C-c <DEL>") (quote helm-ff-run-toggle-auto-update)) (define-key map (kbd "C-c C-a") (quote helm-ff-run-mail-attach-files)) (define-key map (kbd "C-c p") (quote helm-ff-run-print-file)) (define-key map (kbd "C-c /") (quote helm-ff-run-find-sh-command)) (define-key map (kbd "M-l") (quote helm-ff-rotate-left-persistent)) (define-key map (kbd "M-r") (quote helm-ff-rotate-right-persistent)) (define-key map (kbd "C-l") (quote helm-find-files-up-one-level)) (define-key map (kbd "C-r") (quote helm-find-files-down-last-level)) (define-key map (kbd "C-c r") (quote helm-ff-run-find-file-as-root)) (define-key map (kbd "C-x C-v") (quote helm-ff-run-find-alternate-file)) (define-key map (kbd "C-c @") (quote helm-ff-run-insert-org-link)) (helm-define-key-with-subkeys map (kbd "DEL") 127 (quote helm-ff-delete-char-backward) (quote ((C-backspace . helm-ff-run-toggle-auto-update) ([C-c DEL] . helm-ff-run-toggle-auto-update))) nil (quote helm-ff-delete-char-backward--exit-fn)) (when helm-ff-lynx-style-map (define-key map (kbd "<left>") (quote helm-find-files-up-one-level)) (define-key map (kbd "<right>") (quote helm-execute-persistent-action))) (delq nil map))) nil [16585 21285])
			("helm-read-file-map" variable (:default-value (let ((map (make-sparse-keymap))) (set-keymap-parent map helm-map) (define-key map (kbd "<C-return>") (quote helm-cr-empty-string)) (define-key map (kbd "M-RET") (quote helm-cr-empty-string)) (define-key map (kbd "C-]") (quote helm-ff-run-toggle-basename)) (define-key map (kbd "C-.") (quote helm-find-files-up-one-level)) (define-key map (kbd "C-l") (quote helm-find-files-up-one-level)) (define-key map (kbd "C-r") (quote helm-find-files-down-last-level)) (define-key map (kbd "C-c h") (quote helm-ff-file-name-history)) (define-key map (kbd "C-<backspace>") (quote helm-ff-run-toggle-auto-update)) (define-key map (kbd "C-c <DEL>") (quote helm-ff-run-toggle-auto-update)) (helm-define-key-with-subkeys map (kbd "DEL") 127 (quote helm-ff-delete-char-backward) (quote ((C-backspace . helm-ff-run-toggle-auto-update) ([C-c DEL] . helm-ff-run-toggle-auto-update))) nil (quote helm-ff-delete-char-backward--exit-fn)) (when helm-ff-lynx-style-map (define-key map (kbd "<left>") (quote helm-find-files-up-one-level)) (define-key map (kbd "<right>") (quote helm-execute-persistent-action)) (define-key map (kbd "<M-left>") (quote helm-previous-source)) (define-key map (kbd "<M-right>") (quote helm-next-source))) (delq nil map))) nil [21287 22724])
			("helm-find-files-doc-header" variable
			(:user-visible-flag t
			:default-value " (\\<helm-find-files-map>\\[helm-find-files-up-one-level]: Go up one level)")
			nil [22741 22936])
			("helm-ff-auto-update-flag" variable nil nil [22937 23114])
			("helm-ff-last-expanded" variable nil nil [23115 23192])
			("helm-ff-default-directory" variable nil nil [23193 23231])
			("helm-ff-history" variable nil nil [23232 23260])
			("helm-ff-cand-to-mark" variable nil nil [23261 23294])
			("helm-ff-url-regexp" variable (:default-value "\\`\$news\\(post\$?:\\\|nntp:\\\|mailto:\\\|file:\\\|\$ftp\\\|https?\\\|telnet\\\|gopher\\\|www\\\|wais\$:/?/?\\).*") nil [23295 23499])
			("helm-tramp-file-name-regexp" variable (:default-value "\\`/\$[^/:\|]+\$:") nil [23710 23767])
			("helm-marked-buffer-name" variable (:default-value "helm marked") nil [23768 23816])
			("helm-ff--auto-update-state" variable nil nil [23817 23856])
			("helm-ff--deleting-char-backward" variable nil nil [23857 23901])
			("helm-multi-files--toggle-locate" variable nil nil [23902 23946])
			("helm-ff--move-to-first-real-candidate" variable (:default-value t) nil [23947 23995])
			("helm-find-files--toggle-bookmark" variable nil nil [23996 24041])
			("helm-ff--tramp-methods" variable nil nil [24042 24077])
			("helm-ff--directory-files-hash" variable (:default-value (make-hash-table :test (quote equal))) nil [24078 24147])
			("helm-ff-history-buffer-name" variable (:default-value "helm-find-files history") nil [24148 24212])
			("helm-find-files-actions" variable (:default-value (helm-make-actions "Find File" (quote helm-find-file-or-marked) "Find file in Dired" (quote helm-point-file-in-dired) "View file" (quote view-file) "Query replace fnames on marked `M-@'" (quote helm-ff-query-replace-fnames-on-marked) "Marked files in dired `C-x C-q, C-u wdired'" (quote helm-marked-files-in-dired) "Query replace contents on marked `M-%'" (quote helm-ff-query-replace) "Query replace regexp contents on marked `C-M-%'" (quote helm-ff-query-replace-regexp) "Attach file(s) to mail buffer `C-c C-a'" (quote helm-ff-mail-attach-files) "Serial rename files" (quote helm-ff-serial-rename) "Serial rename by symlinking files" (quote helm-ff-serial-rename-by-symlink) "Serial rename by copying files" (quote helm-ff-serial-rename-by-copying) "Open file with default tool" (quote helm-open-file-with-default-tool) "Find file in hex dump" (quote hexl-find-file) "Browse project `C-x C-d'" (quote helm-ff-browse-project) "Complete at point `C-c i'" (quote helm-insert-file-name-completion-at-point) "Insert as org link `C-c @'" (quote helm-files-insert-as-org-link) "Find shell command `C-c /'" (quote helm-ff-find-sh-command) "Add marked files to file-cache" (quote helm-ff-cache-add-file) "Open file externally `C-c C-x, C-u to choose'" (quote helm-open-file-externally) "Grep File(s) `C-s, C-u Recurse'" (quote helm-find-files-grep) "Grep current directory with AG `M-g a, C-u select type'" (quote helm-find-files-ag) "Git grep `M-g g, C-u from root'" (quote helm-ff-git-grep) "Zgrep File(s) `M-g z, C-u Recurse'" (quote helm-ff-zgrep) "Gid `M-g i'" (quote helm-ff-gid) "Switch to Eshell `M-e'" (quote helm-ff-switch-to-eshell) "Etags `M-., C-u reload tag file'" (quote helm-ff-etags-select) "Eshell command on file(s) `M-!, C-u take all marked as arguments.'" (quote helm-find-files-eshell-command-on-file) "Find file as root `C-c r'" (quote helm-find-file-as-root) "Find alternate file `C-x C-v'" (quote find-alternate-file) "Ediff File `C-c ='" (quote helm-find-files-ediff-files) "Ediff Merge File `M-='" (quote helm-find-files-ediff-merge-files) (lambda nil (format "Delete File(s)%s `M-D' (C-u reverse trash)" (if (eq helm-ff-delete-files-function (quote helm-delete-marked-files-async)) " async" ""))) (quote helm-ff-delete-files) "Touch File(s) `M-T'" (quote helm-ff-touch-files) "Copy file(s) `M-C, C-u to follow'" (quote helm-find-files-copy) "Rename file(s) `M-R, C-u to follow'" (quote helm-find-files-rename) "Backup files" (quote helm-find-files-backup) "Symlink files(s) `M-S, C-u to follow'" (quote helm-find-files-symlink) "Relsymlink file(s) `M-Y, C-u to follow'" (quote helm-find-files-relsymlink) "Hardlink file(s) `M-H, C-u to follow'" (quote helm-find-files-hardlink) "Find file other window `C-c o'" (quote helm-find-files-other-window) "Find file other frame `C-c C-o'" (quote find-file-other-frame) "Print File `C-c p, C-u to refresh'" (quote helm-ff-print) "Locate `C-x C-f, C-u to specify locate db'" (quote helm-ff-locate))) nil [24241 27255])
			("helm-source-find-files" variable nil nil [27257 27369])
			("helm-source-ffiles" type
			(:superclasses "helm-source-sync"
			:members
			( ("header-name" variable (:default-value "(lambda (name) (concat name (substitute-command-keys helm-find-files-doc-header)))") nil nil)
			("init" variable (:default-value "(lambda nil (setq helm-ff-auto-update-flag helm-ff-auto-update-initial-value) (setq helm-ff--auto-update-state helm-ff-auto-update-flag) (helm-set-local-variable (quote bookmark-make-record-function) (function helm-ff-make-bookmark-record)) (require (quote helm-external)))") nil nil)
			("candidates" variable (:default-value "(quote helm-find-files-get-candidates)") nil nil)
			("filtered-candidate-transformer" variable (:default-value "(quote (helm-ff-sort-candidates (lambda (candidates _source) (cl-loop for f in candidates for ff = (helm-ff-filter-candidate-one-by-one f) when ff collect ff))))") nil nil)
			("persistent-action-if" variable (:default-value "(quote helm-find-files-persistent-action-if)") nil nil)
			("persistent-help" variable (:default-value "Hit1 Expand Candidate, Hit2 or (C-u) Find file") nil nil)
			("help-message" variable (:default-value "(quote helm-ff-help-message)") nil nil)
			("mode-line" variable (:default-value "(list \"File(s)\" helm-mode-line-string)") nil nil)
			("volatile" variable (:default-value "t") nil nil)
			("cleanup" variable (:default-value "(quote helm-find-files-cleanup)") nil nil)
			("migemo" variable (:default-value "t") nil nil)
			("nohighlight" variable (:default-value "t") nil nil)
			("keymap" variable (:default-value "helm-find-files-map") nil nil)
			("candidate-number-limit" variable (:default-value "(quote helm-ff-candidate-number-limit)") nil nil)
			("action-transformer" variable (:default-value "(quote helm-find-files-action-transformer)") nil nil)
			("action" variable (:default-value "(quote helm-find-files-actions)") nil nil)
			("before-init-hook" variable (:default-value "(quote helm-find-files-before-init-hook)") nil nil)
			("after-init-hook" variable (:default-value "(quote helm-find-files-after-init-hook)") nil nil)
			("group" variable (:default-value "(quote helm-files)") nil nil))
			:type "class")
			nil [27371 29145])
			("helm-ff-make-bookmark-record" function nil nil [29172 29421])
			("helm-ff-bookmark-jump" function (:arguments ("bookmark")) nil [29423 30050])
			("helm-ff-bookmark-set" function (:user-visible-flag t) nil [30052 30381])
			("put" code nil nil [30382 30422])
			("helm-dwim-target" variable nil nil [30424 31097])
			("helm-dwim-target-directory" function nil nil [31099 32445])
			("helm-ff--count-and-collect-dups" function (:arguments ("files")) nil [32447 33184])
			("helm-find-files-do-action" function (:arguments ("action")) nil [33186 35578])
			("helm-find-files-copy" function (:arguments ("_candidate")) nil [35580 35696])
			("helm-find-files-backup" function (:arguments ("_candidate")) nil [35698 36026])
			("helm-find-files-rename" function (:arguments ("_candidate")) nil [36028 36150])
			("helm-find-files-symlink" function (:arguments ("_candidate")) nil [36152 36277])
			("helm-find-files-relsymlink" function (:arguments ("_candidate")) nil [36279 36413])
			("helm-find-files-hardlink" function (:arguments ("_candidate")) nil [36415 36543])
			("helm-find-files-other-window" function (:arguments ("_candidate")) nil [36545 36870])
			("helm-find-files-byte-compile" function (:arguments ("_candidate")) nil [36872 37157])
			("helm-find-files-load-files" function (:arguments ("_candidate")) nil [37159 37373])
			("helm-find-files-ediff-files-1" function (:arguments ("candidate" "merge")) nil [37375 38365])
			("helm-find-files-ediff-files" function (:arguments ("candidate")) nil [38367 38458])
			("helm-find-files-ediff-merge-files" function (:arguments ("candidate")) nil [38460 38564])
			("helm-find-files-grep" function (:arguments ("_candidate")) nil [38566 38767])
			("helm-ff-git-grep" function (:arguments ("_candidate")) nil [38769 38936])
			("helm-find-files-ag" function (:arguments ("_candidate")) nil [38938 39060])
			("helm-ff-zgrep" function (:arguments ("_candidate")) nil [39062 39240])
			("helm-ff-pdfgrep" function (:arguments ("_candidate")) nil [39242 39845])
			("helm-ff-etags-select" function (:arguments ("candidate")) nil [39847 40335])
			("eshell-command-aliases-list" variable nil nil [40337 40377])
			("helm-eshell-command-on-file-input-history" variable nil nil [40378 40432])
			("helm-find-files-eshell-command-on-file-1" function (:arguments ("map")) nil [40433 45677])
			("helm-find-files-eshell-command-on-file" function (:arguments ("_candidate")) nil [45679 45929])
			("helm-ff-switch-to-eshell" function (:arguments ("_candidate")) nil [45931 47062])
			("helm-ff--eshell-interactive-buffer-p" function (:arguments ("buffer")) nil [47064 47326])
			("helm-ff-touch-files" function (:arguments ("_candidate")) nil [47328 49317])
			("helm-ff-run-touch-files" function (:user-visible-flag t) nil [49319 49510])
			("put" code nil nil [49511 49554])
			("helm-ff-serial-rename-action" function (:arguments ("method")) nil [49556 51385])
			("helm-ff-member-directory-p" function (:arguments ("file" "directory")) nil [51387 51653])
			("cl-defun" code nil nil [51655 54178])
			("helm-ff-serial-rename" function (:arguments ("_candidate")) nil [54180 54449])
			("helm-ff-serial-rename-by-symlink" function (:arguments ("_candidate")) nil [54451 54732])
			("helm-ff-serial-rename-by-copying" function (:arguments ("_candidate")) nil [54734 55009])
			("helm-ff-query-replace-fnames-history-from" variable nil nil [55011 55065])
			("helm-ff-query-replace-fnames-history-to" variable nil nil [55066 55118])
			("helm-ff-query-replace-on-filenames" function (:arguments ("candidates")) nil [55119 63086])
			("helm-ff--prepare-str-with-regexp" function (:arguments ("str" "rep1" "rep2")) nil [63088 64229])
			("helm-ff-query-replace-fnames-on-marked" function (:arguments ("_candidate")) nil [64246 64414])
			("helm-ff-run-query-replace-fnames-on-marked" function nil nil [64458 64624])
			("put" code nil nil [64625 64687])
			("helm-ff-query-replace" function (:arguments ("_candidate")) nil [64689 64920])
			("helm-ff-query-replace-regexp" function (:arguments ("_candidate")) nil [64922 65164])
			("helm-ff-run-query-replace" function nil nil [65166 65298])
			("put" code nil nil [65299 65344])
			("helm-ff-run-query-replace-regexp" function nil nil [65346 65492])
			("put" code nil nil [65493 65545])
			("helm-ff-toggle-auto-update" function (:arguments ("_candidate")) nil [65547 66003])
			("helm-ff-run-toggle-auto-update" function nil nil [66005 66224])
			("put" code nil nil [66225 66275])
			("helm-ff-delete-char-backward" function (:user-visible-flag t) nil [66277 66640])
			("put" code nil nil [66641 66689])
			("helm-ff-delete-char-backward--exit-fn" function nil nil [66691 66845])
			("helm-ff-RET-1" function (:arguments ("must-match")) nil [66847 67410])
			("helm-ff-RET" function (:user-visible-flag t) nil [67412 67706])
			("helm-ff-RET-must-match" function (:user-visible-flag t) nil [67708 67831])
			("helm-ff-run-grep" function (:user-visible-flag t) nil [67833 68006])
			("put" code nil nil [68007 68043])
			("helm-ff-run-git-grep" function (:user-visible-flag t) nil [68045 68222])
			("put" code nil nil [68223 68263])
			("helm-ff-run-grep-ag" function nil nil [68265 68388])
			("put" code nil nil [68389 68428])
			("helm-ff-run-pdfgrep" function (:user-visible-flag t) nil [68430 68604])
			("put" code nil nil [68605 68644])
			("helm-ff-run-zgrep" function (:user-visible-flag t) nil [68646 68813])
			("put" code nil nil [68814 68851])
			("helm-ff-run-copy-file" function (:user-visible-flag t) nil [68853 69036])
			("put" code nil nil [69037 69078])
			("helm-ff-run-rename-file" function (:user-visible-flag t) nil [69080 69269])
			("put" code nil nil [69270 69313])
			("helm-ff-run-byte-compile-file" function (:user-visible-flag t) nil [69315 69522])
			("put" code nil nil [69523 69572])
			("helm-ff-run-load-file" function (:user-visible-flag t) nil [69574 69763])
			("put" code nil nil [69764 69805])
			("helm-ff-run-eshell-command-on-file" function (:user-visible-flag t) nil [69807 70039])
			("put" code nil nil [70040 70094])
			("helm-ff-run-ediff-file" function (:user-visible-flag t) nil [70096 70288])
			("put" code nil nil [70289 70331])
			("helm-ff-run-ediff-merge-file" function (:user-visible-flag t) nil [70333 70548])
			("put" code nil nil [70549 70597])
			("helm-ff-run-symlink-file" function (:user-visible-flag t) nil [70599 70791])
			("put" code nil nil [70792 70836])
			("helm-ff-run-relsymlink-file" function (:user-visible-flag t) nil [70838 71036])
			("put" code nil nil [71037 71084])
			("helm-ff-run-hardlink-file" function (:user-visible-flag t) nil [71086 71281])
			("put" code nil nil [71282 71327])
			("helm-ff-delete-files" function (:arguments ("candidate")) nil [71329 71454])
			("helm-ff-run-delete-file" function (:user-visible-flag t) nil [71456 71644])
			("put" code nil nil [71645 71688])
			("helm-ff-run-complete-fn-at-point" function (:user-visible-flag t) nil [71690 71919])
			("put" code nil nil [71920 71972])
			("helm-ff-run-switch-to-eshell" function (:user-visible-flag t) nil [71974 72175])
			("put" code nil nil [72176 72224])
			("helm-ff-run-switch-other-window" function (:user-visible-flag t) nil [72226 72497])
			("put" code nil nil [72498 72549])
			("helm-ff-run-switch-other-frame" function (:user-visible-flag t) nil [72551 72756])
			("put" code nil nil [72757 72807])
			("helm-ff-run-open-file-externally" function (:user-visible-flag t) nil [72809 73027])
			("put" code nil nil [73028 73080])
			("helm-ff-run-open-file-with-default-tool" function (:user-visible-flag t) nil [73082 73314])
			("put" code nil nil [73315 73374])
			("helm-ff-locate" function (:arguments ("candidate")) nil [73376 74218])
			("helm-ff-run-locate" function (:user-visible-flag t) nil [74220 74391])
			("put" code nil nil [74392 74430])
			("helm-files-insert-as-org-link" function (:arguments ("candidate")) nil [74432 74550])
			("helm-ff-run-insert-org-link" function nil nil [74552 74694])
			("put" code nil nil [74695 74742])
			("helm-ff-run-find-file-as-root" function nil nil [74744 74881])
			("put" code nil nil [74882 74931])
			("helm-ff-run-find-alternate-file" function nil nil [74933 75069])
			("put" code nil nil [75070 75121])
			("helm-ff-run-mail-attach-files" function (:user-visible-flag t) nil [75123 75335])
			("put" code nil nil [75336 75385])
			("helm-ff-run-etags" function (:user-visible-flag t) nil [75387 75570])
			("put" code nil nil [75571 75608])
			("lpr-printer-switch" variable nil nil [75610 75637])
			("helm-ff-print" function (:arguments ("_candidate")) nil [75638 77671])
			("helm-ff-run-print-file" function (:user-visible-flag t) nil [77673 77851])
			("put" code nil nil [77852 77894])
			("helm-ff-checksum" function (:arguments ("file")) nil [77896 78594])
			("helm-ff-toggle-basename" function (:arguments ("_candidate")) nil [78596 78989])
			("helm-ff-run-toggle-basename" function nil nil [78991 79138])
			("put" code nil nil [79139 79186])
			("helm-reduce-file-name" function (:arguments ("fname" "level")) nil [79188 79603])
			("helm-find-files--level-tree" variable nil nil [79605 79645])
			("helm-find-files--level-tree-iterator" variable nil nil [79646 79695])
			("helm-find-files-up-one-level" function
			(:user-visible-flag t
			:arguments ("arg"))
			nil [79696 81727])
			("put" code nil nil [81728 81776])
			("helm-find-files-down-last-level" function (:user-visible-flag t) nil [81778 82398])
			("put" code nil nil [82399 82450])
			("helm-find-files--reset-level-tree" function nil nil [82452 82586])
			("add-hook" code nil nil [82588 82652])
			("add-hook" code nil nil [82653 82721])
			("add-hook" code nil nil [82722 82802])
			("helm-ff-retrieve-last-expanded" function nil nil [82804 83466])
			("helm-ff-move-to-first-real-candidate" function nil nil [83468 84560])
			("helm-ff-update-when-only-one-matched" function nil nil [84633 89571])
			("helm-ff-auto-expand-to-home-or-root" function nil nil [89573 91645])
			("helm-ff--expand-file-name-no-dot" function (:arguments ("name" "directory")) nil [91647 92089])
			("helm-ff--expand-substitued-pattern" function (:arguments ("pattern")) nil [92091 92729])
			("helm-substitute-in-filename" function (:arguments ("fname")) nil [92731 94119])
			("helm-point-file-in-dired" function (:arguments ("file")) nil [94121 94445])
			("helm-marked-files-in-dired" function (:arguments ("_candidate")) nil [94447 95239])
			("helm-ff-run-marked-files-in-dired" function (:user-visible-flag t) nil [95241 95442])
			("put" code nil nil [95443 95496])
			("helm-ff--create-tramp-name" function (:arguments ("fname")) nil [95498 96251])
			("helm-ff--tramp-cons-or-vector" function (:arguments ("vector-or-cons")) nil [96253 96438])
			("helm-ff--get-tramp-methods" function nil nil [96440 96621])
			("helm-ff--previous-mh-tramp-method" function (:arguments ("str")) nil [96623 97096])
			("helm-ff--get-host-from-tramp-invalid-fname" function (:arguments ("fname")) nil [97098 98207])
			("cl-defun" code nil nil [98209 99558])
			("helm-ff-before-action-hook-fn" function nil nil [99560 100047])
			("add-hook" code nil nil [100048 100114])
			("cl-defun" code nil nil [100116 100333])
			("helm-ff--tramp-postfixed-p" function (:arguments ("str")) nil [100335 100803])
			("helm-ff-set-pattern" function (:arguments ("pattern")) nil [100805 103716])
			("helm-find-files-get-candidates" function (:arguments ("require-match")) nil [103718 109231])
			("helm-list-directory" function (:arguments ("directory")) nil [109233 109552])
			("helm-list-dir-lisp" function (:arguments ("directory")) nil [109554 110625])
			("helm-list-dir-external" function (:arguments ("dir")) nil [110627 112682])
			("helm-ff-directory-files" function (:arguments ("directory")) nil [112684 114004])
			("helm-ff-handle-backslash" function (:arguments ("fname")) nil [114006 114237])
			("helm-ff-fuzzy-matching-p" function nil nil [114239 114367])
			("helm-ff--transform-pattern-for-completion" function (:arguments ("pattern")) nil [114369 116952])
			("helm-dir-is-dot" function (:arguments ("dir")) nil [116954 117037])
			("helm-ff-save-history" function nil nil [117039 117515])
			("add-hook" code nil nil [117516 117567])
			("helm-files-save-file-name-history" function (:arguments ("force")) nil [117569 118484])
			("add-hook" code nil nil [118485 118557])
			("helm-ff-valid-symlink-p" function (:arguments ("file")) nil [118559 118830])
			("helm-get-default-mode-for-file" function (:arguments ("filename")) nil [118832 119096])
			("helm-ff-properties" function (:arguments ("candidate")) nil [119098 121535])
			("helm-ff-properties-persistent" function (:user-visible-flag t) nil [121537 121788])
			("put" code nil nil [121789 121838])
			("helm-ff-persistent-delete" function (:user-visible-flag t) nil [121840 122083])
			("put" code nil nil [122084 122129])
			("helm-ff-dot-file-p" function (:arguments ("file")) nil [122131 122242])
			("helm-ff-kill-buffer-fname" function (:arguments ("candidate")) nil [122244 122656])
			("helm-ff-kill-or-find-buffer-fname" function (:arguments ("candidate")) nil [122658 123815])
			("helm-ff-run-kill-buffer-persistent" function (:user-visible-flag t) nil [123817 124079])
			("put" code nil nil [124080 124134])
			("helm-ff-persistent-open-file-externally" function (:arguments ("file")) nil [124166 124485])
			("helm-ff-run-preview-file-externally" function nil nil [124487 124728])
			("put" code nil nil [124729 124784])
			("helm-ff-prefix-filename" function (:arguments ("fname" "file-or-symlinkp" "new-file")) nil [124786 125673])
			("helm-ff-score-candidate-for-pattern" function (:arguments ("str" "pattern")) nil [125675 125827])
			("helm-ff-sort-candidates-1" function (:arguments ("candidates" "input")) nil [125829 127469])
			("helm-ff-sort-candidates" function (:arguments ("candidates" "_source")) nil [127471 127687])
			("helm-ff-boring-file-p" function (:arguments ("file")) nil [127689 127913])
			("helm-ff-filter-candidate-one-by-one" function (:arguments ("file")) nil [127915 133647])
			("helm-find-files-action-transformer" function (:arguments ("actions" "candidate")) nil [133649 135942])
			("helm-ff-trash-action" function (:arguments ("fn" "names" "args")) nil [135944 137559])
			("helm-ff-trash-rm" function (:arguments ("_candidate")) nil [137561 137916])
			("helm-restore-file-from-trash" function (:arguments ("_candidate")) nil [137918 138649])
			("helm-ff-trash-rm-1" function (:arguments ("file")) nil [138651 139163])
			("helm-restore-file-from-trash-1" function (:arguments ("file" "trashed-files")) nil [139165 139871])
			("helm-ff--get-dest-file-from-trash" function (:arguments ("trashed-files" "file")) nil [139873 140264])
			("helm-ff-goto-linum" function (:arguments ("candidate")) nil [140266 140857])
			("helm-ff-mail-attach-files" function (:arguments ("_candidate")) nil [140859 142021])
			("image-dired-display-image-buffer" variable nil nil [142023 142064])
			("helm-ff-rotate-current-image-1" function (:arguments ("file" "num-arg")) nil [142065 142927])
			("helm-ff-rotate-image-left" function (:arguments ("candidate")) nil [142929 143098])
			("helm-ff-rotate-image-right" function (:arguments ("candidate")) nil [143100 143267])
			("helm-ff-rotate-left-persistent" function (:user-visible-flag t) nil [143269 143506])
			("put" code nil nil [143507 143557])
			("helm-ff-rotate-right-persistent" function (:user-visible-flag t) nil [143559 143799])
			("put" code nil nil [143800 143851])
			("helm-ff-exif-data" function (:arguments ("candidate")) nil [143853 144386])
			("cl-defun" code nil nil [144388 152030])
			("helm-find-files-recursive-dirs" function (:arguments ("directory" "input")) nil [152067 153825])
			("helm-ff-recursive-dirs" function (:arguments ("_candidate")) nil [153827 154105])
			("helm-ff-file-compressed-p" function (:arguments ("candidate")) nil [154107 154285])
			("helm-ff--fname-at-point" function nil nil [154287 154682])
			("helm-insert-file-name-completion-at-point" function (:arguments ("_candidate")) nil [154684 156552])
			("helm-ff--insert-fname" function (:arguments ("candidate" "beg" "end" "full-path" "guess")) nil [156554 157379])
			("cl-defun" code nil nil [157381 158695])
			("put" code nil nil [158696 158739])
			("helm-find-files-1" function (:arguments ("fname" "preselect")) nil [158741 160819])
			("helm-ff--update-resume-after-hook" function (:arguments ("sources" "nohook")) nil [160821 161522])
			("helm-ff-clean-initial-input" function nil nil [161524 161754])
			("helm-ff-setup-update-hook" function nil nil [161756 162075])
			("helm-find-files-cleanup" function nil nil [162077 162368])
			("helm-find-files-toggle-to-bookmark" function (:user-visible-flag t) nil [162370 163022])
			("put" code nil nil [163023 163077])
			("helm-find-files-initial-input" function (:arguments ("input")) nil [163079 163434])
			("helm-ffap-guesser" function nil nil [163436 165451])
			("helm-find-files-input" function (:arguments ("file-at-pt" "thing-at-pt")) nil [165453 167071])
			("helm-ff-find-url-at-point" function nil nil [167073 167755])
			("helm-find-library-at-point" function nil nil [167757 168825])
			("helm-ff--valid-default-directory" function nil nil [168904 169152])
			("cl-defun" code nil nil [169154 172864])
			("helm-get-dest-fnames-from-list" function (:arguments ("flist" "dest-cand" "rename-dir-flag")) nil [172866 173681])
			("helm-ff-maybe-mark-candidates" function nil nil [173683 174430])
			("helm-file-buffers" function (:arguments ("filename")) nil [174463 174763])
			("helm-ff--delete-by-moving-to-trash" function (:arguments ("file")) nil [174765 175336])
			("helm-ff-quick-delete" function (:arguments ("_candidate")) nil [175338 177011])
			("helm-delete-file" function (:arguments ("file" "error-if-dot-file-p" "synchro" "trash")) nil [177013 179981])
			("helm-delete-marked-files" function (:arguments ("_ignore")) nil [179983 181284])
			("helm-ff-delete-log-file" variable (:default-value (expand-file-name "helm-delete-file.log" user-emacs-directory)) nil [181315 181488])
			("helm-ff--trash-flag" variable nil nil [181490 181522])
			("define-minor-mode" code nil nil [181524 182298])
			("helm-delete-async-mode-line-message" function (:arguments ("text" "face" "args")) nil [182300 182777])
			("helm-delete-marked-files-async" function (:arguments ("_ignore")) nil [182779 186372])
			("helm-find-file-or-marked" function (:arguments ("candidate")) nil [186374 188231])
			("helm-ff--mkdir" function (:arguments ("dir" "helm-ff")) nil [188233 189117])
			("helm-transform-file-load-el" function (:arguments ("actions" "candidate")) nil [189119 189415])
			("helm-transform-file-browse-url" function (:arguments ("actions" "candidate")) nil [189417 189860])
			("helm-file-on-mounted-network-p" function (:arguments ("file")) nil [189862 190196])
			("file-cache-alist" variable nil nil [190240 190265])
			("helm-ff-cache-add-file" function (:arguments ("_candidate")) nil [190267 190427])
			("helm-ff-file-cache-remove-file-1" function (:arguments ("file")) nil [190429 190821])
			("helm-ff-file-cache-remove-file" function (:arguments ("_file")) nil [190823 191008])
			("helm-source-file-name-history" variable (:default-value (helm-build-sync-source "File Name History" :candidates (quote file-name-history) :persistent-action (function ignore) :filtered-candidate-transformer (function helm-file-name-history-transformer) :action (quote helm-type-file-actions))) nil [191040 191301])
			("helm-source--ff-file-name-history" variable nil nil [191303 191486])
			("helm-file-name-history-transformer" function (:arguments ("candidates" "_source")) nil [191488 191976])
			("helm-ff-file-name-history" function (:user-visible-flag t) nil [191978 193573])
			("put" code nil nil [193574 193619])
			("helm--browse-project-cache" variable (:default-value (make-hash-table :test (quote equal))) nil [193798 193864])
			("helm-buffers-in-project-p" variable nil nil [193865 193899])
			("helm-browse-project-get-buffers" function (:arguments ("root-directory")) nil [193901 194483])
			("helm-browse-project-build-buffers-source" function (:arguments ("directory")) nil [194485 194830])
			("helm-browse-project-walk-directory" function (:arguments ("directory")) nil [194832 195041])
			("helm-browse-project-ag-find-files" function (:arguments ("directory")) nil [195043 195414])
			("helm-browse-project-find-files" function (:arguments ("directory" "refresh")) nil [195416 197049])
			("helm-browse-project-history" variable nil nil [197051 197091])
			("helm-projects-history" function nil nil [197108 197472])
			("helm-browse-project" function
			(:user-visible-flag t
			:arguments ("arg"))
			nil [197489 199474])
			("helm-browse-project-get--root-dir" function (:arguments ("directory")) nil [199476 199893])
			("helm-ff-browse-project" function (:arguments ("_candidate")) nil [199895 200116])
			("helm-ff-run-browse-project" function nil nil [200118 200252])
			("put" code nil nil [200253 200299])
			("helm-ff-gid" function (:arguments ("_candidate")) nil [200301 200408])
			("helm-ff-run-gid" function nil nil [200410 200522])
			("put" code nil nil [200523 200558])
			("helm-ff-find-sh-command" function (:arguments ("_candidate")) nil [200603 200756])
			("helm-ff-run-find-sh-command" function (:user-visible-flag t) nil [200758 200961])
			("put" code nil nil [200962 201009])
			("helm-find-files" function
			(:user-visible-flag t
			:arguments ("arg"))
			nil [201028 204019])
			("helm-delete-tramp-connection" function (:user-visible-flag t) nil [204036 205779])
			("helm-files" package nil nil [205782 205803]))
			:file "helm-files.el"
			:pointmax 205945
			:fsize 205944
			:lastmodtime '(23537 22013 0 0)
			:unmatched-syntax '((close-paren 1150 . 1151) (symbol 1004 . 1021) (open-paren 1003 . 1004)))
			(semanticdb-table "semanticdb-table"
			:major-mode emacs-lisp-mode
			:tags
			'( ("cl-lib" include nil nil [804 821])
			("format-spec" include nil nil [822 844])
			("helm" include nil nil [845 860])
			("helm-help" include nil nil [861 881])
			("helm-regexp" include nil nil [882 904])
			("wgrep-helm" include nil nil [945 972])
			("declare-function" code nil nil [974 1024])
			("declare-function" code nil nil [1025 1060])
			("declare-function" code nil nil [1061 1116])
			("declare-function" code nil nil [1117 1189])
			("declare-function" code nil nil [1190 1249])
			("declare-function" code nil nil [1250 1302])
			("helm--ansi-color-regexp" variable nil nil [1303 1335])
			("helm-grep" customgroup (:user-visible-flag t) nil [1339 1432])
			("helm-grep-default-command" variable (:default-value "grep --color=always -a -d skip %e -n%cH -e %p %f") nil [1434 4079])
			("helm-grep-default-recurse-command" variable (:default-value "grep --color=always -a -d recurse %e -n%cH -e %p %f") nil [4081 4358])
			("helm-default-zgrep-command" variable (:default-value "zgrep --color=always -a -n%cH -e %p %f") nil [4360 4723])
			("helm-pdfgrep-default-command" variable (:default-value "pdfgrep --color always -niH %s %s") nil [4725 5012])
			("helm-pdfgrep-default-recurse-command" variable (:default-value "pdfgrep --color always -rniH %s %s") nil [5014 5318])
			("helm-grep-use-ioccur-style-keys" variable (:default-value t) nil [5320 5445])
			("helm-pdfgrep-default-read-command" variable nil nil [5447 5817])
			("helm-grep-max-length-history" variable (:default-value 100) nil [5819 5959])
			("helm-zgrep-file-extension-regexp" variable (:default-value ".*\$\\.gz\\\|\\.bz\\\|\\.xz\\\|\\.lzma\$$") nil [5961 6136])
			("helm-grep-preferred-ext" variable nil nil [6138 6268])
			("helm-grep-save-buffer-name-no-confirm" variable nil nil [6270 6412])
			("helm-grep-ignored-files" variable (:default-value (cons ".#" (delq nil (mapcar (lambda (s) (unless (string-match-p "/\\'" s) (concat "" s))) completion-ignored-extensions)))) nil [6414 6780])
			("helm-grep-ignored-directories" variable (:default-value helm-walk-ignore-directories) nil [6782 6978])
			("helm-grep-truncate-lines" variable (:default-value t) nil [6980 7118])
			("helm-grep-file-path-style" variable (:default-value (quote basename)) nil [7120 7588])
			("helm-grep-actions" variable (:default-value (helm-make-actions "Find File" (quote helm-grep-action) "Find file other frame" (quote helm-grep-other-frame) "Save results in grep buffer" (quote helm-grep-save-results) "Find file other window (C-u vertically)" (quote helm-grep-other-window))) nil [7590 7952])
			("helm-grep-pipe-cmd-switches" variable nil nil [7954 8516])
			("helm-grep-ag-pipe-cmd-switches" variable nil nil [8518 8841])
			("helm-grep-faces" customgroup (:user-visible-flag t) nil [8861 8993])
			("helm-grep-match" variable
			(:default-value (quote ((((background light)) :foreground "#b00000") (((background dark)) :foreground "gold1")))
			:type "face")
			nil [8995 9235])
			("helm-grep-file" variable
			(:default-value (quote ((t (:foreground "BlueViolet" :underline t))))
			:type "face")
			nil [9237 9399])
			("helm-grep-lineno" variable
			(:default-value (quote ((t (:foreground "Darkorange1"))))
			:type "face")
			nil [9401 9538])
			("helm-grep-finish" variable
			(:default-value (quote ((t (:foreground "Green"))))
			:type "face")
			nil [9540 9673])
			("helm-grep-cmd-line" variable
			(:default-value (quote ((t (:inherit font-lock-type-face))))
			:type "face")
			nil [9675 9833])
			("helm-grep-map" variable (:default-value (let ((map (make-sparse-keymap))) (set-keymap-parent map helm-map) (define-key map (kbd "M-<down>") (quote helm-goto-next-file)) (define-key map (kbd "M-<up>") (quote helm-goto-precedent-file)) (define-key map (kbd "C-c o") (quote helm-grep-run-other-window-action)) (define-key map (kbd "C-c C-o") (quote helm-grep-run-other-frame-action)) (define-key map (kbd "C-x C-s") (quote helm-grep-run-save-buffer)) (define-key map (kbd "DEL") (quote helm-delete-backward-no-update)) (when helm-grep-use-ioccur-style-keys (define-key map (kbd "<right>") (quote helm-execute-persistent-action)) (define-key map (kbd "<left>") (quote helm-grep-run-default-action))) (delq nil map))) nil [9855 10590])
			("helm-pdfgrep-map" variable (:default-value (let ((map (make-sparse-keymap))) (set-keymap-parent map helm-map) (define-key map (kbd "M-<down>") (quote helm-goto-next-file)) (define-key map (kbd "M-<up>") (quote helm-goto-precedent-file)) (define-key map (kbd "DEL") (quote helm-delete-backward-no-update)) map)) nil [10592 10920])
			("helm-grep-mode-map" variable (:default-value (let ((map (make-sparse-keymap))) (define-key map (kbd "RET") (quote helm-grep-mode-jump)) (define-key map (kbd "C-o") (quote helm-grep-mode-jump-other-window)) (define-key map (kbd "<C-down>") (quote helm-grep-mode-jump-other-window-forward)) (define-key map (kbd "<C-up>") (quote helm-grep-mode-jump-other-window-backward)) (define-key map (kbd "<M-down>") (quote helm-gm-next-file)) (define-key map (kbd "<M-up>") (quote helm-gm-precedent-file)) (define-key map (kbd "M-n") (quote helm-grep-mode-jump-other-window-forward)) (define-key map (kbd "M-p") (quote helm-grep-mode-jump-other-window-backward)) (define-key map (kbd "M-N") (quote helm-gm-next-file)) (define-key map (kbd "M-P") (quote helm-gm-precedent-file)) map)) nil [10922 11685])
			("helm-rzgrep-cache" variable (:default-value (make-hash-table :test (quote equal))) nil [11714 11771])
			("helm-grep-default-function" variable (:default-value (quote helm-grep-init)) nil [11772 11823])
			("helm-zgrep-recurse-flag" variable nil nil [11824 11860])
			("helm-grep-history" variable nil nil [11861 11891])
			("helm-grep-ag-history" variable nil nil [11892 11925])
			("helm-grep-last-targets" variable nil nil [11926 11961])
			("helm-grep-include-files" variable nil nil [11962 11998])
			("helm-grep-in-recurse" variable nil nil [11999 12032])
			("helm-grep-use-zgrep" variable nil nil [12033 12065])
			("helm-grep-default-directory-fn" variable nil nil [12066 12250])
			("helm-pdfgrep-targets" variable nil nil [12251 12284])
			("helm-grep-last-cmd-line" variable nil nil [12285 12321])
			("helm-grep-split-line-regexp" variable (:default-value "^\$[[:lower:][:upper:]]?:?.?\$:\$[0-9]+\$:\$.\$") nil [12322 12416])
			("helm-grep-prepare-candidates" function (:arguments ("candidates" "in-directory")) nil [12435 16260])
			("helm-grep-command" function (:arguments ("recursive" "grep")) nil [16262 16615])
			("cl-defun" code nil nil [16617 17243])
			("helm-grep--pipe-command-for-grep-command" function (:arguments ("smartcase" "pipe-switches" "grep-cmd")) nil [17245 17760])
			("helm-grep--prepare-cmd-line" function (:arguments ("only-files" "include" "zgrep")) nil [17762 20861])
			("helm-grep-init" function (:arguments ("cmd-line")) nil [20863 25263])
			("helm-grep-collect-candidates" function nil nil [25265 25595])
			("helm-grep-action" function (:arguments ("candidate" "where")) nil [25617 28496])
			("helm-grep-persistent-action" function (:arguments ("candidate")) nil [28498 28703])
			("helm-grep-other-window" function (:arguments ("candidate")) nil [28705 28843])
			("helm-grep-other-frame" function (:arguments ("candidate")) nil [28845 28980])
			("helm-goto-next-or-prec-file" function (:arguments ("n")) nil [28982 30935])
			("helm-goto-precedent-file" function (:user-visible-flag t) nil [30952 31140])
			("put" code nil nil [31141 31185])
			("helm-goto-next-file" function (:user-visible-flag t) nil [31202 31358])
			("helm-grep-run-default-action" function (:user-visible-flag t) nil [31360 31541])
			("put" code nil nil [31542 31590])
			("helm-grep-run-other-window-action" function (:user-visible-flag t) nil [31592 31794])
			("put" code nil nil [31795 31848])
			("helm-grep-run-other-frame-action" function (:user-visible-flag t) nil [31850 32049])
			("put" code nil nil [32050 32102])
			("helm-grep-run-save-buffer" function (:user-visible-flag t) nil [32104 32293])
			("put" code nil nil [32294 32339])
			("helm-grep-save-results" function (:arguments ("candidate")) nil [32368 32447])
			("helm-grep-save-results-1" function nil nil [32449 34892])
			("helm-grep-mode-mouse-jump" function (:arguments ("event")) nil [34894 35189])
			("put" code nil nil [35190 35235])
			("define-derived-mode" code nil nil [35237 35622])
			("put" code nil nil [35623 35657])
			("helm-grep-mode--revert-buffer-function" function (:arguments ("_ignore-auto" "_noconfirm")) nil [35659 36300])
			("helm-grep-mode--sentinel" function (:arguments ("process" "event")) nil [36302 37196])
			("helm-gm-next-file" function nil nil [37198 37276])
			("helm-gm-precedent-file" function nil nil [37278 37362])
			("helm-grep-mode-jump" function nil nil [37364 37517])
			("helm-grep-mode-jump-other-window-1" function (:arguments ("arg")) nil [37519 37881])
			("helm-grep-mode-jump-other-window-forward" function nil nil [37883 37991])
			("helm-grep-mode-jump-other-window-backward" function nil nil [37993 38103])
			("helm-grep-mode-jump-other-window" function nil nil [38105 38384])
			("helm-grep-hack-types" function nil nil [38413 39364])
			("helm-grep-ack-types-transformer" function (:arguments ("candidates" "_source")) nil [39366 39565])
			("helm-grep-ack-types-cache" variable nil nil [39567 39605])
			("helm-grep-read-ack-type" function nil nil [39606 40228])
			("helm-grep-guess-extensions" function (:arguments ("files")) nil [40258 41213])
			("helm-grep-get-file-extensions" function (:arguments ("files")) nil [41215 42198])
			("helm-grep-before-init-hook" variable nil nil [42226 42326])
			("helm-grep-after-init-hook" variable nil nil [42328 42426])
			("helm-grep-class" type
			(:superclasses "helm-source-async"
			:members
			( ("candidates-process" variable (:default-value "(quote helm-grep-collect-candidates)") nil nil)
			("filter-one-by-one" variable (:default-value "(quote helm-grep-filter-one-by-one)") nil nil)
			("keymap" variable (:default-value "helm-grep-map") nil nil)
			("pcre" variable
			(:documentation " Backend is using pcre regexp engine when non--nil."
			:default-value "nil")
			nil nil)
			("nohighlight" variable (:default-value "t") nil nil)
			("nomark" variable (:default-value "t") nil nil)
			("backend" variable
			(:documentation " The grep backend that will be used.
			It is actually used only as an internal flag
			and don't set the backend by itself.
			You probably don't want to modify this."
			:default-value "nil")
			nil nil)
			("candidate-number-limit" variable (:default-value "9999") nil nil)
			("help-message" variable (:default-value "(quote helm-grep-help-message)") nil nil)
			("history" variable (:default-value "(quote helm-grep-history)") nil nil)
			("action" variable (:default-value "(quote helm-grep-actions)") nil nil)
			("persistent-action" variable (:default-value "(quote helm-grep-persistent-action)") nil nil)
			("persistent-help" variable (:default-value "Jump to line (`C-u' Record in mark ring)") nil nil)
			("requires-pattern" variable (:default-value "2") nil nil)
			("before-init-hook" variable (:default-value "(quote helm-grep-before-init-hook)") nil nil)
			("after-init-hook" variable (:default-value "(quote helm-grep-after-init-hook)") nil nil)
			("group" variable (:default-value "(quote helm-grep)") nil nil))
			:type "class")
			nil [42428 43579])
			("helm-source-grep" variable nil nil [43581 43610])
			("helm--setup-source" function
			(:parent "helm-grep-class"
			:arguments ("source"))
			nil [43612 43958])
			("cl-defun" code nil nil [43960 47989])
			("helm-ff-zgrep-1" function (:arguments ("flist" "recursive")) nil [48009 48790])
			("helm-grep-split-line" function (:arguments ("line")) nil [48817 49293])
			("helm-grep--filter-candidate-1" function (:arguments ("candidate" "dir")) nil [49295 51088])
			("helm-grep-filter-one-by-one" function (:arguments ("candidate")) nil [51090 51718])
			("helm-grep-highlight-match" function (:arguments ("str" "multi-match")) nil [51720 53046])
			("helm-grep-buffers-1" function (:arguments ("candidate" "zgrep")) nil [53082 54684])
			("helm-grep-buffers" function (:arguments ("candidate")) nil [54686 54785])
			("helm-zgrep-buffers" function (:arguments ("candidate")) nil [54787 54895])
			("helm-pdfgrep-default-function" variable (:default-value (quote helm-pdfgrep-init)) nil [55031 55088])
			("helm-pdfgrep-init" function (:arguments ("only-files" "recurse")) nil [55089 57256])
			("helm-do-pdfgrep-1" function (:arguments ("only" "recurse")) nil [57258 58870])
			("helm-pdfgrep-action" function (:arguments ("candidate")) nil [58872 58947])
			("helm-pdfgrep-action-1" function (:arguments ("_split" "pageno" "fname")) nil [58949 59197])
			("helm-grep-ag-command" variable (:default-value "ag --line-numbers -S --hidden --color --nogroup %s %s %s") nil [59373 60599])
			("helm-grep--ag-command" function nil nil [60601 60721])
			("helm-grep-ag-get-types" function nil nil [60723 61519])
			("helm-grep-ag-prepare-cmd-line" function (:arguments ("pattern" "directory" "type")) nil [61521 62625])
			("helm-grep-ag-init" function (:arguments ("directory" "type")) nil [62627 65889])
			("helm-grep-ag-class" type
			(:superclasses "helm-source-async"
			:members
			( ("nohighlight" variable (:default-value "t") nil nil)
			("pcre" variable
			(:documentation " Backend is using pcre regexp engine when non--nil."
			:default-value "t")
			nil nil)
			("keymap" variable (:default-value "helm-grep-map") nil nil)
			("history" variable (:default-value "(quote helm-grep-ag-history)") nil nil)
			("help-message" variable (:default-value "(quote helm-grep-help-message)") nil nil)
			("filter-one-by-one" variable (:default-value "(quote helm-grep-filter-one-by-one)") nil nil)
			("persistent-action" variable (:default-value "(quote helm-grep-persistent-action)") nil nil)
			("persistent-help" variable (:default-value "Jump to line (`C-u' Record in mark ring)") nil nil)
			("candidate-number-limit" variable (:default-value "99999") nil nil)
			("requires-pattern" variable (:default-value "2") nil nil)
			("nomark" variable (:default-value "t") nil nil)
			("action" variable (:default-value "(quote helm-grep-actions)") nil nil)
			("group" variable (:default-value "(quote helm-grep)") nil nil))
			:type "class")
			nil [65891 66601])
			("helm-source-grep-ag" variable nil nil [66603 66635])
			("helm--setup-source" function
			(:parent "helm-grep-ag-class"
			:arguments ("source"))
			nil [66637 66907])
			("helm-grep-ag-1" function (:arguments ("directory" "type")) nil [66909 67596])
			("helm-grep-ag" function (:arguments ("directory" "with-types")) nil [67598 68158])
			("helm-source-grep-git" variable nil nil [68179 68212])
			("helm-grep-git-grep-command" variable (:default-value "git --no-pager grep -n%cH --color=always --full-name -e %p -- %f") nil [68214 68869])
			("helm-grep-git-1" function (:arguments ("directory" "all" "default" "input")) nil [68871 69853])
			("helm-do-grep-ag" function
			(:user-visible-flag t
			:arguments ("arg"))
			nil [69872 70138])
			("helm-grep-do-git-grep" function
			(:user-visible-flag t
			:arguments ("arg"))
			nil [70155 70390])
			("helm-grep" package nil nil [70393 70413]))
			:file "helm-grep.el"
			:pointmax 70554
			:fsize 70553
			:lastmodtime '(23537 22013 0 0)
			:unmatched-syntax nil)
			(semanticdb-table "semanticdb-table"
			:major-mode emacs-lisp-mode
			:tags
			'( ("cl-lib" include nil nil [952 969])
			("helm" include nil nil [970 985])
			("helm-types" include nil nil [986 1007])
			("helm-help" include nil nil [1008 1028])
			("helm-locate" customgroup (:user-visible-flag t) nil [1032 1129])
			("helm-locate-db-file-regexp" variable (:default-value "m?locate.db$") nil [1131 1297])
			("helm-ff-locate-db-filename" variable (:default-value "locate.db") nil [1299 1685])
			("helm-locate-command" variable nil nil [1687 2779])
			("helm-locate-create-db-command" variable (:default-value "updatedb -l 0 -o '%s' -U '%s'") nil [2781 2946])
			("helm-locate-case-fold-search" variable (:default-value helm-case-fold-search) nil [2948 3389])
			("helm-locate-fuzzy-match" variable nil nil [3391 3575])
			("helm-locate-fuzzy-sort-fn" variable (:default-value (function helm-locate-default-fuzzy-sort-fn)) nil [3577 3744])
			("helm-locate-project-list" variable nil nil [3746 3983])
			("helm-locate-recursive-dirs-command" variable (:default-value "locate -i -e -A --regex '^%s' '%s.*$'") nil [3985 4509])
			("helm-locate-map" variable (:default-value (let ((map (make-sparse-keymap))) (set-keymap-parent map helm-generic-files-map) (define-key map (kbd "DEL") (quote helm-delete-backward-no-update)) map)) nil [4513 4698])
			("helm-locate-finish" variable
			(:default-value (quote ((t (:foreground "Green"))))
			:type "face")
			nil [4701 4842])
			("helm-ff-find-locatedb" function (:arguments ("from-ff")) nil [4846 5373])
			("helm-locate-create-db-default-function" function (:arguments ("db-name" "directory")) nil [5375 5684])
			("helm-locate-create-db-function" variable (:default-value (function helm-locate-create-db-default-function)) nil [5686 5903])
			("helm-locate-1" function (:arguments ("localdb" "init" "from-ff" "default")) nil [5905 8205])
			("helm-locate-set-command" function nil nil [8207 8554])
			("helm-locate-initial-setup" function nil nil [8556 8648])
			("helm-file-name-history" variable nil nil [8650 8685])
			("helm-locate-with-db" function (:arguments ("db" "initial-input" "default")) nil [8686 10546])
			("helm-locate-init" function nil nil [10548 13758])
			("helm-locate-default-fuzzy-sort-fn" function (:arguments ("candidates")) nil [13760 13968])
			("helm-locate-override-inheritor" type
			(:superclasses "helm-type-file"
			:type "class")
			nil [13970 14031])
			("helm-locate-source" type
			(:interfaces ("helm-locate-override-inheritor")
			:superclasses "helm-source-async"
			:members
			( ("init" variable (:default-value "(quote helm-locate-initial-setup)") nil nil)
			("candidates-process" variable (:default-value "(quote helm-locate-init)") nil nil)
			("requires-pattern" variable (:default-value "3") nil nil)
			("history" variable (:default-value "(quote helm-file-name-history)") nil nil)
			("persistent-action" variable (:default-value "(quote helm-ff-kill-or-find-buffer-fname)") nil nil)
			("candidate-number-limit" variable (:default-value "9999") nil nil)
			("redisplay" variable (:default-value "(progn helm-locate-fuzzy-sort-fn)") nil nil)
			("group" variable (:default-value "(quote helm-locate)") nil nil))
			:type "class")
			nil [14033 14498])
			("helm--setup-source" function
			(:parent "helm-locate-override-inheritor"
			:arguments ("source"))
			nil [14541 14673])
			("helm-source-locate" variable (:default-value (helm-make-source "Locate" (quote helm-locate-source) :pattern-transformer (quote helm-locate-pattern-transformer) :match-part (lambda (candidate) (if (or (string-match-p " -b\\'" helm-pattern) (and helm-locate-fuzzy-match (not (string-match "\\s-" helm-pattern)))) (helm-basename candidate) candidate)))) nil [14675 15217])
			("helm-locate-pattern-transformer" function (:arguments ("pattern")) nil [15219 15917])
			("helm-locate-find-dbs-in-projects" function (:arguments ("update")) nil [15919 16673])
			("helm-locate-subdirs-source" type
			(:superclasses "helm-source-in-buffer"
			:members
			( ("basedir" variable (:default-value "nil") nil nil)
			("subdir" variable (:default-value "nil") nil nil)
			("data" variable (:default-value "(function helm-locate-init-subdirs)") nil nil)
			("group" variable (:default-value "(quote helm-locate)") nil nil))
			:type "class")
			nil [16712 17020])
			("helm-locate-init-subdirs" function nil nil [17022 17449])
			("helm-projects-find-files" function
			(:user-visible-flag t
			:arguments ("update"))
			nil [17466 18018])
			("helm-locate" function
			(:user-visible-flag t
			:arguments ("arg"))
			nil [18035 19020])
			("helm-locate" package nil nil [19022 19044]))
			:file "helm-locate.el"
			:pointmax 19187
			:fsize 19186
			:lastmodtime '(23537 22013 0 0)
			:unmatched-syntax nil)
			(semanticdb-table "semanticdb-table"
			:major-mode emacs-lisp-mode
			:tags
			'( ("cl-lib" include nil nil [798 815])
			("helm" include nil nil [816 831])
			("helm-help" include nil nil [832 852])
			("helm-utils" include nil nil [853 874])
			("helm-grep" include nil nil [875 895])
			("helm-tags" customgroup (:user-visible-flag t) nil [899 992])
			("helm-etags-tag-file-name" variable (:default-value "TAGS") nil [994 1099])
			("helm-etags-tag-file-search-limit" variable (:default-value 10) nil [1101 1290])
			("helm-etags-match-part-only" variable (:default-value (quote tag)) nil [1292 1722])
			("helm-etags-execute-action-at-once-if-one" variable (:default-value t) nil [1724 1891])
			("helm-tags-faces" customgroup (:user-visible-flag t) nil [1895 2033])
			("helm-etags-file" variable
			(:default-value (quote ((t (:foreground "Lightgoldenrod4" :underline t))))
			:type "face")
			nil [2035 2196])
			("helm-etags-run-switch-other-window" function (:user-visible-flag t) nil [2216 2481])
			("put" code nil nil [2482 2536])
			("helm-etags-run-switch-other-frame" function (:user-visible-flag t) nil [2538 2800])
			("put" code nil nil [2801 2854])
			("helm-etags-map" variable (:default-value (let ((map (make-sparse-keymap))) (set-keymap-parent map helm-map) (define-key map (kbd "M-<down>") (quote helm-goto-next-file)) (define-key map (kbd "M-<up>") (quote helm-goto-precedent-file)) (define-key map (kbd "C-c o") (quote helm-etags-run-switch-other-window)) (define-key map (kbd "C-c C-o") (quote helm-etags-run-switch-other-frame)) map)) nil [2856 3257])
			("helm-etags-mtime-alist" variable nil nil [3259 3352])
			("helm-etags-cache" variable (:default-value (make-hash-table :test (quote equal))) nil [3353 3471])
			("helm-etags-get-tag-file" function (:arguments ("directory")) nil [3473 3954])
			("helm-etags-all-tag-files" function nil nil [3956 4450])
			("helm-etags-find-tag-file-directory" function (:arguments ("current-dir")) nil [4452 5422])
			("helm-etags-get-header-name" function (:arguments ("_x")) nil [5424 5613])
			("helm-etags-create-buffer" function (:arguments ("file")) nil [5615 6995])
			("helm-etags-init" function nil nil [6997 8044])
			("helm-source-etags-select" variable nil nil [8046 8110])
			("helm-etags-build-source" function nil nil [8112 9543])
			("helm-etags-fuzzy-match" variable nil nil [9545 9799])
			("find-tag-marker-ring" variable nil nil [9801 9830])
			("helm-etags--file-from-tag" function (:arguments ("fname")) nil [9832 10060])
			("helm-etags-action-goto" function (:arguments ("switcher" "candidate")) nil [10062 11043])
			("helm-etags-mtime" function (:arguments ("file")) nil [11045 11162])
			("helm-etags-file-modified-p" function (:arguments ("file")) nil [11164 11463])
			("helm-etags-select" function
			(:user-visible-flag t
			:arguments ("reinit"))
			nil [11480 13285])
			("helm-tags" package nil nil [13287 13307]))
			:file "helm-tags.el"
			:pointmax 13448
			:fsize 13447
			:lastmodtime '(23537 22013 0 0)
			:unmatched-syntax nil)
			(semanticdb-table "semanticdb-table"
			:major-mode emacs-lisp-mode
			:tags
			'( ("cl-lib" include nil nil [812 829])
			("helm" include nil nil [830 845])
			("helm-types" include nil nil [846 867])
			("helm-utils" include nil nil [868 889])
			("helm-grep" include nil nil [890 910])
			("helm-regexp" include nil nil [911 933])
			("helm-help" include nil nil [934 954])
			("declare-function" code nil nil [956 1011])
			("declare-function" code nil nil [1012 1068])
			("declare-function" code nil nil [1069 1114])
			("declare-function" code nil nil [1115 1166])
			("helm-buffers" customgroup (:user-visible-flag t) nil [1170 1269])
			("helm-boring-buffer-regexp-list" variable (:default-value (quote ("\\` " "\\`\\helm" "\\`\\Echo Area" "\\`\\*Minibuf"))) nil [1271 1639])
			("helm-white-buffer-regexp-list" variable nil nil [1641 1878])
			("helm-buffers-favorite-modes" variable (:default-value (quote (lisp-interaction-mode emacs-lisp-mode text-mode org-mode))) nil [1880 2214])
			("helm-buffer-max-length" variable (:default-value 20) nil [2216 2484])
			("helm-buffer-details-flag" variable (:default-value t) nil [2486 2618])
			("helm-buffers-fuzzy-matching" variable nil nil [2620 2855])
			("helm-buffer-skip-remote-checking" variable nil nil [2857 3002])
			("helm-buffers-truncate-lines" variable (:default-value t) nil [3004 3142])
			("helm-mini-default-sources" variable (:default-value (quote (helm-source-buffers-list helm-source-recentf helm-source-buffer-not-found))) nil [3144 3554])
			("helm-buffers-end-truncated-string" variable (:default-value "...") nil [3556 3706])
			("helm-buffers-column-separator" variable (:default-value " ") nil [3708 3838])
			("helm-buffer--pretty-names" variable (:default-value (quote ((dired-mode . "Dired") (lisp-interaction-mode . "Lisp Inter")))) nil [3840 4461])
			("helm-buffers-faces" customgroup (:user-visible-flag t) nil [4480 4621])
			("helm-buffer-saved-out" variable
			(:default-value (quote ((t (:foreground "red" :background "black"))))
			:type "face")
			nil [4623 4792])
			("helm-buffer-not-saved" variable
			(:default-value (quote ((t (:foreground "Indianred2"))))
			:type "face")
			nil [4794 4950])
			("helm-buffer-modified" variable
			(:default-value (quote ((t :inherit font-lock-comment-face)))
			:type "face")
			nil [4952 5090])
			("helm-buffer-size" variable
			(:default-value (quote ((((background dark)) :foreground "RosyBrown") (((background light)) :foreground "SlateGray")))
			:type "face")
			nil [5092 5284])
			("helm-buffer-process" variable
			(:default-value (quote ((t (:foreground "Sienna3"))))
			:type "face")
			nil [5286 5423])
			("helm-buffer-directory" variable
			(:default-value (quote ((t (:foreground "DarkRed" :background "LightGray"))))
			:type "face")
			nil [5425 5598])
			("helm-buffer-file" variable
			(:default-value (quote ((t :inherit font-lock-builtin-face)))
			:type "face")
			nil [5600 5753])
			("helm-buffer-archive" variable
			(:default-value (quote ((t (:foreground "Gold"))))
			:type "face")
			nil [5755 5901])
			("helm-non-file-buffer" variable
			(:default-value (quote ((t (:inherit italic))))
			:type "face")
			nil [5903 6050])
			("helm-buffers-tick-counter" variable nil nil [6052 6440])
			("make-variable-buffer-local" code nil nil [6441 6496])
			("helm-buffer-map" variable (:default-value (let ((map (make-sparse-keymap))) (set-keymap-parent map helm-map) (define-key map (kbd "M-g s") (quote helm-buffer-run-zgrep)) (define-key map (kbd "C-s") (quote helm-buffers-run-multi-occur)) (define-key map (kbd "C-x C-d") (quote helm-buffers-run-browse-project)) (define-key map (kbd "C-c o") (quote helm-buffer-switch-other-window)) (define-key map (kbd "C-c C-o") (quote helm-buffer-switch-other-frame)) (define-key map (kbd "C-c =") (quote helm-buffer-run-ediff)) (define-key map (kbd "M-=") (quote helm-buffer-run-ediff-merge)) (define-key map (kbd "C-=") (quote helm-buffer-diff-persistent)) (define-key map (kbd "M-G") (quote helm-buffer-revert-persistent)) (define-key map (kbd "C-c d") (quote helm-buffer-run-kill-persistent)) (define-key map (kbd "M-D") (quote helm-buffer-run-kill-buffers)) (define-key map (kbd "C-x C-s") (quote helm-buffer-save-persistent)) (define-key map (kbd "C-M-%") (quote helm-buffer-run-query-replace-regexp)) (define-key map (kbd "M-%") (quote helm-buffer-run-query-replace)) (define-key map (kbd "M-R") (quote helm-buffer-run-rename-buffer)) (define-key map (kbd "M-m") (quote helm-toggle-all-marks)) (define-key map (kbd "M-a") (quote helm-mark-all)) (define-key map (kbd "C-]") (quote helm-toggle-buffers-details)) (define-key map (kbd "C-c a") (quote helm-buffers-toggle-show-hidden-buffers)) (define-key map (kbd "C-M-SPC") (quote helm-buffers-mark-similar-buffers)) map)) nil [6522 8231])
			("helm-buffers-ido-virtual-map" variable (:default-value (let ((map (make-sparse-keymap))) (set-keymap-parent map helm-map) (define-key map (kbd "C-c o") (quote helm-ff-run-switch-other-window)) (define-key map (kbd "C-c C-o") (quote helm-ff-run-switch-other-frame)) (define-key map (kbd "M-g s") (quote helm-ff-run-grep)) (define-key map (kbd "M-g z") (quote helm-ff-run-zgrep)) (define-key map (kbd "M-D") (quote helm-ff-run-delete-file)) (define-key map (kbd "C-c C-x") (quote helm-ff-run-open-file-externally)) map)) nil [8233 8735])
			("helm-buffer-max-len-mode" variable nil nil [8739 8776])
			("helm-buffers-in-project-p" variable nil nil [8777 8815])
			("helm-source-buffers-list" variable nil nil [8816 8853])
			("helm-buffers-list--init" function nil nil [8855 10442])
			("helm-source-buffers" type
			(:interfaces ("helm-type-buffer")
			:superclasses "helm-source-sync"
			:members
			( ("buffer-list" variable
			(:documentation " A function with no arguments to create buffer list."
			:default-value "(function helm-buffer-list)")
			nil nil)
			("init" variable (:default-value "(quote helm-buffers-list--init)") nil nil)
			("multimatch" variable (:default-value "nil") nil nil)
			("match" variable (:default-value "(quote helm-buffers-match-function)") nil nil)
			("persistent-action" variable (:default-value "(quote helm-buffers-list-persistent-action)") nil nil)
			("keymap" variable (:default-value "helm-buffer-map") nil nil)
			("migemo" variable (:default-value "(quote nomultimatch)") nil nil)
			("volatile" variable (:default-value "t") nil nil)
			("nohighlight" variable (:default-value "t") nil nil)
			("resume" variable (:default-value "(lambda nil (setq helm-buffers-in-project-p nil))") nil nil)
			("help-message" variable (:default-value "(quote helm-buffer-help-message)") nil nil))
			:type "class")
			nil [10444 11136])
			("helm-source-buffer-not-found" variable (:default-value (helm-build-dummy-source "Create buffer" :action (helm-make-actions "Create buffer (C-u choose mode)" (lambda (candidate) (let ((mjm (or (and helm-current-prefix-arg (intern-soft (helm-comp-read "Major-mode: " helm-buffers-favorite-modes))) (cl-loop for (r . m) in auto-mode-alist when (string-match r candidate) return m))) (buffer (get-buffer-create candidate))) (if mjm (with-current-buffer buffer (funcall mjm)) (set-buffer-major-mode buffer)) (switch-to-buffer buffer)))))) nil [11138 12014])
			("ido-temp-list" variable nil nil [12016 12038])
			("ido-ignored-list" variable nil nil [12039 12064])
			("ido-process-ignore-lists" variable nil nil [12065 12098])
			("ido-use-virtual-buffers" variable nil nil [12099 12131])
			("ido-virtual-buffers" variable nil nil [12132 12160])
			("helm-source-ido-virtual-buffers" variable (:default-value (helm-build-sync-source "Ido virtual buffers" :candidates (lambda nil (let (ido-temp-list ido-ignored-list (ido-process-ignore-lists t)) (when ido-use-virtual-buffers (ido-add-virtual-buffers-to-list) ido-virtual-buffers))) :fuzzy-match helm-buffers-fuzzy-matching :keymap helm-buffers-ido-virtual-map :help-message (quote helm-buffers-ido-virtual-help-message) :action (quote (("Find file" . helm-find-many-files) ("Find file other window" . find-file-other-window) ("Find file other frame" . find-file-other-frame) ("Find file as root" . helm-find-file-as-root) ("Grep File(s) `C-u recurse'" . helm-find-files-grep) ("Zgrep File(s) `C-u Recurse'" . helm-ff-zgrep) ("View file" . view-file) ("Delete file(s)" . helm-delete-marked-files) ("Open file externally (C-u to choose)" . helm-open-file-externally))))) nil [12162 13276])
			("ido-use-virtual-buffers" variable nil nil [13280 13312])
			("ido-ignore-buffers" variable nil nil [13313 13340])
			("helm-buffer-list" function nil nil [13341 13680])
			("helm-buffer-size" function (:arguments ("buffer")) nil [13682 13918])
			("helm-buffer--show-details" function (:arguments ("buf-name" "prefix" "help-echo" "size" "mode" "dir" "face1" "face2" "proc" "details" "type")) nil [13920 14569])
			("helm-buffer--format-mode-name" function (:arguments ("buf")) nil [14571 14886])
			("helm-buffer--details" function (:arguments ("buffer" "details")) nil [14888 18424])
			("helm-highlight-buffers" function (:arguments ("buffers" "_source")) nil [18426 20760])
			("helm-buffer--get-preselection" function (:arguments ("buffer")) nil [20762 21591])
			("helm-toggle-buffers-details" function nil nil [21593 22090])
			("put" code nil nil [22091 22138])
			("helm-buffers--pattern-sans-filters" function (:arguments ("separator")) nil [22140 22427])
			("helm-buffers-sort-transformer" function (:arguments ("candidates" "source")) nil [22429 22823])
			("helm-buffers-mark-similar-buffers-1" function nil nil [22825 23972])
			("helm-buffers-mark-similar-buffers" function (:user-visible-flag t) nil [23974 24363])
			("put" code nil nil [24364 24417])
			("helm-buffer--match-mjm" function (:arguments ("pattern" "mjm")) nil [24444 25132])
			("helm-buffer--memo-hash" variable (:default-value (make-hash-table :test (quote equal))) nil [25134 25196])
			("helm-buffer--memo-pattern" function (:arguments ("pattern")) nil [25197 25384])
			("helm-buffer--match-pattern" function (:arguments ("pattern" "candidate" "nofuzzy")) nil [25386 26014])
			("helm-buffers--match-from-mjm" function (:arguments ("candidate")) nil [26016 26568])
			("helm-buffers--match-from-pat" function (:arguments ("candidate")) nil [26570 27093])
			("helm-buffers--match-from-inside" function (:arguments ("candidate")) nil [27095 27758])
			("helm-buffers--match-from-directory" function (:arguments ("candidate")) nil [27760 28470])
			("helm-buffers-match-function" function (:arguments ("candidate")) nil [28472 28760])
			("helm-buffer-query-replace-1" function (:arguments ("regexp-flag" "buffers")) nil [28764 29630])
			("helm-buffer-query-replace-regexp" function (:arguments ("_candidate")) nil [29632 29725])
			("helm-buffer-query-replace" function (:arguments ("_candidate")) nil [29727 29805])
			("helm-buffer-toggle-diff" function (:arguments ("candidate")) nil [29807 30094])
			("helm-buffer-diff-persistent" function (:user-visible-flag t) nil [30096 30325])
			("put" code nil nil [30326 30373])
			("helm-revert-buffer" function (:arguments ("candidate")) nil [30375 30534])
			("helm-revert-marked-buffers" function (:arguments ("_ignore")) nil [30536 30634])
			("helm-buffer-revert-and-update" function (:arguments ("_candidate")) nil [30636 31003])
			("helm-buffer-revert-persistent" function (:user-visible-flag t) nil [31005 31257])
			("put" code nil nil [31258 31307])
			("helm-buffer-save-and-update" function (:arguments ("_candidate")) nil [31309 31763])
			("helm-buffer-save-persistent" function (:user-visible-flag t) nil [31765 32007])
			("put" code nil nil [32008 32055])
			("helm-buffers-rename-buffer" function (:arguments ("candidate")) nil [32057 32205])
			("helm-buffer-run-rename-buffer" function (:user-visible-flag t) nil [32207 32410])
			("put" code nil nil [32411 32460])
			("helm-buffer-run-kill-persistent" function (:user-visible-flag t) nil [32462 32709])
			("put" code nil nil [32710 32761])
			("helm-kill-marked-buffers" function (:arguments ("_ignore")) nil [32763 33102])
			("helm-buffer-run-kill-buffers" function (:user-visible-flag t) nil [33104 33302])
			("put" code nil nil [33303 33351])
			("helm-buffer-run-grep" function (:user-visible-flag t) nil [33353 33529])
			("put" code nil nil [33530 33570])
			("helm-buffer-run-zgrep" function (:user-visible-flag t) nil [33572 33750])
			("put" code nil nil [33751 33792])
			("helm-buffer-run-query-replace-regexp" function (:user-visible-flag t) nil [33794 34017])
			("put" code nil nil [34018 34074])
			("helm-buffer-run-query-replace" function (:user-visible-flag t) nil [34076 34278])
			("put" code nil nil [34279 34328])
			("helm-buffer-switch-other-window" function (:user-visible-flag t) nil [34330 34557])
			("put" code nil nil [34558 34609])
			("helm-buffer-switch-other-frame" function (:user-visible-flag t) nil [34611 34825])
			("put" code nil nil [34826 34876])
			("helm-buffer-switch-buffers" function (:arguments ("_candidate")) nil [34878 35197])
			("helm-buffer-switch-buffers-other-window" function (:arguments ("_candidate")) nil [35199 35392])
			("helm-buffer-run-ediff" function (:user-visible-flag t) nil [35394 35580])
			("put" code nil nil [35581 35622])
			("helm-buffer-run-ediff-merge" function (:user-visible-flag t) nil [35624 35822])
			("put" code nil nil [35823 35870])
			("helm-buffers-persistent-kill-1" function (:arguments ("buffer-or-name")) nil [35872 36436])
			("helm-buffers--quote-truncated-buffer" function (:arguments ("buffer")) nil [36438 37014])
			("helm-buffers-persistent-kill" function (:arguments ("_buffer")) nil [37016 37904])
			("helm-buffers-list-persistent-action" function (:arguments ("candidate")) nil [37906 38493])
			("helm-ediff-marked-buffers" function (:arguments ("_candidate" "merge")) nil [38495 39204])
			("helm-ediff-marked-buffers-merge" function (:arguments ("candidate")) nil [39206 39386])
			("helm-multi-occur-as-action" function (:arguments ("_candidate")) nil [39388 39997])
			("helm-buffers-run-multi-occur" function (:user-visible-flag t) nil [39999 40184])
			("put" code nil nil [40185 40233])
			("helm-buffers-toggle-show-hidden-buffers" function nil nil [40235 41091])
			("put" code nil nil [41092 41151])
			("helm-buffers-browse-project" function (:arguments ("buf")) nil [41153 41304])
			("helm-buffers-run-browse-project" function (:user-visible-flag t) nil [41306 41604])
			("helm-skip-boring-buffers" function (:arguments ("buffers" "_source")) nil [41640 41823])
			("helm-shadow-boring-buffers" function (:arguments ("buffers" "_source")) nil [41825 42054])
			("helm-buffers-list" function (:user-visible-flag t) nil [42073 42553])
			("helm-mini" function (:user-visible-flag t) nil [42570 43005])
			("helm-quit-and-helm-mini" function (:user-visible-flag t) nil [43007 43155])
			("helm-buffers" package nil nil [43157 43180]))
			:file "helm-buffers.el"
			:pointmax 43324
			:fsize 43323
			:lastmodtime '(23537 22014 0 0)
			:unmatched-syntax nil)
			(semanticdb-table "semanticdb-table"
			:major-mode emacs-lisp-mode
			:tags
			'( ("cl-lib" include nil nil [837 854])
			("helm" include nil nil [855 870])
			("helm-help" include nil nil [871 891])
			("helm-utils" include nil nil [892 913])
			("declare-function" code nil nil [915 974])
			("helm-regexp" customgroup (:user-visible-flag t) nil [978 1075])
			("helm-moccur-always-search-in-current" variable nil nil [1077 1236])
			("helm-moccur-use-ioccur-style-keys" variable (:default-value t) nil [1238 1394])
			("helm-moccur-auto-update-on-resume" variable nil nil [1396 2078])
			("helm-source-multi-occur-actions" variable (:default-value (quote (("Go to Line" . helm-moccur-goto-line) ("Goto line other window (C-u vertically)" . helm-moccur-goto-line-ow) ("Goto line new frame" . helm-moccur-goto-line-of) ("Save buffer" . helm-moccur-save-results)))) nil [2080 2465])
			("helm-moccur-truncate-lines" variable (:default-value t) nil [2467 2613])
			("helm-moccur-show-buffer-fontification" variable nil nil [2615 3127])
			("helm-moccur-buffer-substring-fn-for-modes" variable (:default-value (quote ((mu4e-headers-mode . buffer-substring) (package-menu-mode . buffer-substring-no-properties)))) nil [3129 3792])
			("helm-occur-show-buffer-name" variable nil nil [3794 4055])
			("helm-moccur-buffer" variable
			(:default-value (quote ((t (:foreground "DarkTurquoise" :underline t))))
			:type "face")
			nil [4058 4210])
			("helm-resume-need-update" variable
			(:default-value (quote ((t (:background "red"))))
			:type "face")
			nil [4212 4357])
			("helm-moccur-map" variable (:default-value (let ((map (make-sparse-keymap))) (set-keymap-parent map helm-map) (define-key map (kbd "M-<down>") (quote helm-goto-next-file)) (define-key map (kbd "M-<up>") (quote helm-goto-precedent-file)) (define-key map (kbd "C-c o") (quote helm-moccur-run-goto-line-ow)) (define-key map (kbd "C-c C-o") (quote helm-moccur-run-goto-line-of)) (define-key map (kbd "C-x C-s") (quote helm-moccur-run-save-buffer)) (when helm-moccur-use-ioccur-style-keys (define-key map (kbd "<right>") (quote helm-execute-persistent-action)) (define-key map (kbd "<left>") (quote helm-moccur-run-default-action))) (delq nil map))) nil [4361 5027])
			("helm-build-regexp-history" variable nil nil [5047 5085])
			("helm-occur-history" variable nil nil [5086 5117])
			("helm-query-replace-regexp" function (:arguments ("_candidate")) nil [5119 5461])
			("helm-kill-regexp-as-sexp" function (:arguments ("_candidate")) nil [5463 5614])
			("helm-kill-regexp" function (:arguments ("_candidate")) nil [5616 5733])
			("helm-query-replace-args" function (:arguments ("regexp")) nil [5735 6302])
			("helm-source-regexp" variable (:default-value (helm-build-in-buffer-source "Regexp Builder" :init (lambda nil (helm-init-candidates-in-buffer (quote global) (with-temp-buffer (insert-buffer-substring helm-current-buffer) (buffer-string)))) :get-line (function helm-regexp-get-line) :persistent-action (function helm-regexp-persistent-action) :persistent-help "Show this line" :multiline t :multimatch nil :requires-pattern 2 :group (quote helm-regexp) :mode-line "Press TAB to select action." :action (quote (("Kill Regexp as sexp" . helm-kill-regexp-as-sexp) ("Query Replace Regexp (C-u Not inside word.)" . helm-query-replace-regexp) ("Kill Regexp" . helm-kill-regexp))))) nil [6304 7084])
			("helm-regexp-get-line" function (:arguments ("s" "e")) nil [7086 7572])
			("helm-regexp-persistent-action" function (:arguments ("pt")) nil [7574 7670])
			("helm-regexp-kill-new" function (:arguments ("input")) nil [7672 7784])
			("helm-source-occur" variable nil nil [7804 7834])
			("helm-occur-init-source" function nil nil [7835 7988])
			("helm-multi-occur-buffer-list" variable nil nil [8027 8068])
			("helm-multi-occur-buffer-tick" variable nil nil [8069 8110])
			("helm-occur--invisible" variable nil nil [8111 8258])
			("helm-moccur-init" function nil nil [8260 9516])
			("helm-moccur--next-or-previous-char" function nil nil [9518 9662])
			("helm-moccur-get-line" function (:arguments ("beg" "end")) nil [9664 10925])
			("cl-defun" code nil nil [10927 12157])
			("helm-moccur-persistent-action" function (:arguments ("candidate")) nil [12159 12276])
			("helm-moccur-goto-line" function (:arguments ("candidate")) nil [12278 12434])
			("helm-moccur-goto-line-ow" function (:arguments ("candidate")) nil [12436 12635])
			("helm-moccur-goto-line-of" function (:arguments ("candidate")) nil [12637 12829])
			("helm-moccur-run-goto-line-ow" function (:user-visible-flag t) nil [12831 13034])
			("put" code nil nil [13035 13083])
			("helm-moccur-run-goto-line-of" function (:user-visible-flag t) nil [13085 13285])
			("put" code nil nil [13286 13334])
			("helm-moccur-run-default-action" function nil nil [13336 13473])
			("put" code nil nil [13474 13524])
			("helm-moccur-before-init-hook" variable nil nil [13526 13628])
			("helm-moccur-after-init-hook" variable nil nil [13630 13730])
			("helm-source-moccur" variable nil nil [13732 13763])
			("helm-source-multi-occur" type
			(:superclasses "helm-source-in-buffer"
			:members
			( ("init" variable (:default-value "(lambda nil (require (quote helm-grep)) (helm-moccur-init))") nil nil)
			("filter-one-by-one" variable (:default-value "(quote helm-moccur-filter-one-by-one)") nil nil)
			("get-line" variable (:default-value "helm-moccur-get-line") nil nil)
			("nohighlight" variable (:default-value "t") nil nil)
			("nomark" variable (:default-value "t") nil nil)
			("migemo" variable (:default-value "t") nil nil)
			("action" variable (:default-value "(quote helm-source-multi-occur-actions)") nil nil)
			("persistent-action" variable (:default-value "(quote helm-moccur-persistent-action)") nil nil)
			("persistent-help" variable (:default-value "Go to line") nil nil)
			("resume" variable (:default-value "(quote helm-moccur-resume-fn)") nil nil)
			("candidate-number-limit" variable (:default-value "9999") nil nil)
			("help-message" variable (:default-value "(quote helm-moccur-help-message)") nil nil)
			("keymap" variable (:default-value "helm-moccur-map") nil nil)
			("history" variable (:default-value "(quote helm-occur-history)") nil nil)
			("requires-pattern" variable (:default-value "2") nil nil)
			("before-init-hook" variable (:default-value "(quote helm-moccur-before-init-hook)") nil nil)
			("after-init-hook" variable (:default-value "(quote helm-moccur-after-init-hook)") nil nil)
			("group" variable (:default-value "(quote helm-regexp)") nil nil))
			:type "class")
			nil [13764 14699])
			("helm-moccur-resume-fn" function nil nil [14701 17657])
			("helm-moccur-filter-one-by-one" function (:arguments ("candidate" "outside-helm")) nil [17659 18734])
			("helm-multi-occur-1" function (:arguments ("buffers" "input")) nil [18736 19831])
			("helm-moccur-run-save-buffer" function (:user-visible-flag t) nil [19833 20025])
			("put" code nil nil [20026 20073])
			("helm-moccur-mode-map" variable (:default-value (let ((map (make-sparse-keymap))) (define-key map (kbd "RET") (quote helm-moccur-mode-goto-line)) (define-key map (kbd "C-o") (quote helm-moccur-mode-goto-line-ow)) (define-key map (kbd "<C-down>") (quote helm-moccur-mode-goto-line-ow-forward)) (define-key map (kbd "<C-up>") (quote helm-moccur-mode-goto-line-ow-backward)) (define-key map (kbd "<M-down>") (quote helm-gm-next-file)) (define-key map (kbd "<M-up>") (quote helm-gm-precedent-file)) (define-key map (kbd "M-n") (quote helm-moccur-mode-goto-line-ow-forward)) (define-key map (kbd "M-p") (quote helm-moccur-mode-goto-line-ow-backward)) (define-key map (kbd "M-N") (quote helm-gm-next-file)) (define-key map (kbd "M-P") (quote helm-gm-precedent-file)) map)) nil [20104 20861])
			("helm-moccur-mode-goto-line" function nil nil [20863 21044])
			("helm-moccur-mode-goto-line-ow" function nil nil [21046 21233])
			("helm-moccur-mode-goto-line-ow-forward-1" function (:arguments ("arg")) nil [21235 21462])
			("helm-moccur-mode-goto-line-ow-forward" function nil nil [21464 21574])
			("helm-moccur-mode-goto-line-ow-backward" function nil nil [21576 21688])
			("helm-moccur-save-results" function (:arguments ("_candidate")) nil [21690 23603])
			("helm-moccur-mode-mouse-goto-line" function (:arguments ("event")) nil [23605 23916])
			("put" code nil nil [23917 23969])
			("define-derived-mode" code nil nil [23986 24391])
			("put" code nil nil [24392 24428])
			("helm-moccur-mode--revert-buffer-function" function (:arguments ("_ignore-auto" "_noconfirm")) nil [24430 26458])
			("helm-regexp" function (:user-visible-flag t) nil [26508 27063])
			("helm-occur" function (:user-visible-flag t) nil [27080 29374])
			("helm-occur-from-isearch" function (:user-visible-flag t) nil [29391 30286])
			("helm-multi-occur-from-isearch" function
			(:user-visible-flag t
			:arguments ("_arg"))
			nil [30303 31306])
			("helm-regexp" package nil nil [31309 31331]))
			:file "helm-regexp.el"
			:pointmax 31474
			:fsize 31473
			:lastmodtime '(23537 22013 0 0)
			:unmatched-syntax nil)
			(semanticdb-table "semanticdb-table"
			:major-mode emacs-lisp-mode
			:tags
			'( ("cl-lib" include nil nil [817 834])
			("helm" include nil nil [835 850])
			("helm-lib" include nil nil [851 870])
			("helm-help" include nil nil [871 891])
			("helm-types" include nil nil [892 913])
			("helm-utils" include nil nil [914 935])
			("helm-info" include nil nil [936 956])
			("helm-eval" include nil nil [957 977])
			("helm-files" include nil nil [978 999])
			("declare-function" code nil nil [1001 1054])
			("declare-function" code nil nil [1055 1108])
			("declare-function" code nil nil [1109 1158])
			("helm-elisp" customgroup (:user-visible-flag t) nil [1187 1282])
			("helm-turn-on-show-completion" variable (:default-value t) nil [1284 1445])
			("helm-show-completion-min-window-height" variable (:default-value 7) nil [1447 1651])
			("helm-lisp-quoted-function-list" variable (:default-value (quote (funcall apply mapc cl-mapc mapcar cl-mapcar callf callf2 cl-callf cl-callf2 fset fboundp fmakunbound symbol-function))) nil [1653 1990])
			("helm-lisp-unquoted-function-list" variable (:default-value (quote (function defadvice))) nil [1992 2227])
			("helm-apropos-fuzzy-match" variable nil nil [2229 2366])
			("helm-lisp-fuzzy-completion" variable nil nil [2368 2699])
			("helm-apropos-function-list" variable (:default-value (quote (helm-def-source--emacs-commands helm-def-source--emacs-functions helm-def-source--eieio-classes helm-def-source--eieio-generic helm-def-source--emacs-variables helm-def-source--emacs-faces))) nil [2701 3260])
			("helm-apropos-defaut-info-lookup-sources" variable (:default-value (quote (helm-source-info-elisp helm-source-info-cl helm-source-info-eieio))) nil [3262 3616])
			("helm-show-completion-display-function" variable (:default-value (if (display-graphic-p) (function helm-display-buffer-in-own-frame) (function helm-show-completion-default-display-function))) nil [3618 4121])
			("helm-elisp-faces" customgroup (:user-visible-flag t) nil [4140 4275])
			("helm-lisp-show-completion" variable
			(:default-value (quote ((t (:background "DarkSlateGray"))))
			:type "face")
			nil [4277 4444])
			("helm-lisp-completion-info" variable
			(:default-value (quote ((t (:foreground "red"))))
			:type "face")
			nil [4446 4597])
			("helm-elisp-help-function" variable (:default-value (quote helm-elisp-show-help)) nil [4599 4942])
			("helm-locate-library-fuzzy-match" variable (:default-value t) nil [4944 5093])
			("helm-show-completion-overlay" variable nil nil [5189 5230])
			("helm-show-completion" function nil nil [5280 5487])
			("helm-show-completion-init-overlay" function (:arguments ("beg" "end")) nil [5489 5694])
			("helm-show-completion-default-display-function" function (:arguments ("buffer" "_args")) nil [5696 6731])
			("with-helm-show-completion" function (:arguments ("beg" "end" "body")) nil [6733 8029])
			("helm-lisp-completion--predicate-at-point" function (:arguments ("beg")) nil [8067 9771])
			("helm-thing-before-point" function (:arguments ("limits" "regexp")) nil [9773 10442])
			("helm-bounds-of-thing-before-point" function (:arguments ("regexp")) nil [10444 10645])
			("helm-insert-completion-at-point" function (:arguments ("beg" "end" "str")) nil [10647 11226])
			("helm-lisp-completion--cache" variable nil nil [11228 11268])
			("helm-lgst-len" variable nil nil [11269 11295])
			("helm-lisp-completion-at-point" function (:user-visible-flag t) nil [11311 13961])
			("helm-lisp-completion-persistent-action" function (:arguments ("candidate" "name")) nil [13963 14257])
			("helm-lisp-completion-persistent-help" function nil nil [14259 14556])
			("helm-elisp--show-help-1" function (:arguments ("candidate" "name")) nil [14558 15107])
			("helm-elisp-show-help" function (:arguments ("candidate" "name")) nil [15109 15511])
			("helm-elisp-show-doc-modeline" function (:arguments ("candidate" "name")) nil [15513 15875])
			("helm-lisp-completion-transformer" function (:arguments ("candidates" "_source")) nil [15877 16521])
			("helm-get-first-line-documentation" function (:arguments ("sym" "name")) nil [16523 17475])
			("helm-complete-file-name-at-point" function
			(:user-visible-flag t
			:arguments ("force"))
			nil [17549 18707])
			("helm-lisp-indent" function nil nil [18724 19108])
			("helm-lisp-completion-or-file-name-at-point" function (:user-visible-flag t) nil [19125 19648])
			("helm-apropos-history" variable nil nil [19670 19703])
			("helm-apropos-init" function (:arguments ("test" "default")) nil [19705 20144])
			("helm-apropos-init-faces" function (:arguments ("default")) nil [20146 20795])
			("helm-apropos-default-sort-fn" function (:arguments ("candidates" "_source")) nil [20797 20951])
			("helm-apropos-clean-history-variable" function (:arguments ("candidate")) nil [20953 21613])
			("helm-apropos-clean-ring" function (:arguments ("candidate")) nil [21615 22391])
			("helm-apropos-action-transformer" function (:arguments ("actions" "candidate")) nil [22393 23514])
			("helm-def-source--emacs-variables" function (:arguments ("default")) nil [23516 24431])
			("helm-def-source--emacs-faces" function (:arguments ("default")) nil [24433 25451])
			("helm-def-source--emacs-commands" function (:arguments ("default")) nil [25453 26205])
			("helm-def-source--emacs-functions" function (:arguments ("default")) nil [26207 27218])
			("helm-def-source--eieio-classes" function (:arguments ("default")) nil [27220 28047])
			("helm-def-source--eieio-generic" function (:arguments ("default")) nil [28049 28899])
			("helm-info-lookup-fallback-source" function (:arguments ("candidate")) nil [28901 29874])
			("helm-info-lookup-symbol-1" function (:arguments ("c")) nil [29876 30197])
			("helm-info-lookup-symbol" function (:arguments ("candidate")) nil [30199 30455])
			("helm-apropos" function
			(:user-visible-flag t
			:arguments ("default"))
			nil [30472 31048])
			("helm-source-advice" variable (:default-value (helm-build-sync-source "Function Advice" :init (lambda nil (require (quote advice))) :candidates (quote helm-advice-candidates) :action (helm-make-actions "Toggle Enable/Disable" (quote helm-advice-toggle)) :persistent-action (quote helm-advice-persistent-action) :nomark t :multiline t :persistent-help "Toggle describe function / C-u C-j: Toggle advice")) nil [31070 31456])
			("helm-advice-candidates" function nil nil [31458 32168])
			("helm-advice-persistent-action" function (:arguments ("func-class-advice")) nil [32170 32346])
			("helm-advice-toggle" function (:arguments ("func-class-advice")) nil [32348 32786])
			("helm-advice-update-current-display-string" function nil nil [32788 33110])
			("helm-manage-advice" function (:user-visible-flag t) nil [33127 33291])
			("helm-locate-library-scan-list" function nil nil [33326 33621])
			("helm-locate-library" function (:user-visible-flag t) nil [33638 34975])
			("helm-set-variable" function (:arguments ("var")) nil [34977 35408])
			("helm-absolute-time-timers-class" type
			(:interfaces ("helm-type-timers")
			:superclasses "helm-source-sync"
			:members
			( ("candidates" variable (:default-value "timer-list") nil nil)
			("allow-dups" variable (:default-value "t") nil nil)
			("candidate-transformer" variable (:default-value "(lambda (candidates) (cl-loop for timer in candidates collect (cons (helm-elisp--format-timer timer) timer)))") nil nil))
			:type "class")
			nil [35436 35756])
			("helm-source-absolute-time-timers" variable (:default-value (helm-make-source "Absolute Time Timers" (quote helm-absolute-time-timers-class))) nil [35758 35876])
			("helm-idle-time-timers-class" type
			(:interfaces ("helm-type-timers")
			:superclasses "helm-source-sync"
			:members
			( ("candidates" variable (:default-value "timer-idle-list") nil nil)
			("allow-dups" variable (:default-value "t") nil nil)
			("candidate-transformer" variable (:default-value "(lambda (candidates) (cl-loop for timer in candidates collect (cons (helm-elisp--format-timer timer) timer)))") nil nil))
			:type "class")
			nil [35878 36199])
			("helm-source-idle-time-timers" variable (:default-value (helm-make-source "Idle Time Timers" (quote helm-idle-time-timers-class))) nil [36201 36307])
			("helm-elisp--format-timer" function (:arguments ("timer")) nil [36309 36852])
			("helm-timers" function (:user-visible-flag t) nil [36869 37078])
			("helm-btf--usable-p" function nil nil [37116 37329])
			("if" code nil nil [37331 38746])
			("helm-source-complex-command-history" variable (:default-value (helm-build-sync-source "Complex Command History" :candidates (lambda nil (cl-loop for i in command-history unless (equal i (quote (helm-complex-command-history))) collect (prin1-to-string i))) :action (helm-make-actions "Eval" (lambda (candidate) (and (boundp (quote helm-sexp--last-sexp)) (setq helm-sexp--last-sexp candidate)) (let ((command (read candidate))) (unless (equal command (car command-history)) (setq command-history (cons command command-history)))) (run-with-timer 0.1 nil (function helm-sexp-eval) candidate)) "Edit and eval" (lambda (candidate) (edit-and-eval-command "Eval: " (read candidate)))) :persistent-action (function helm-sexp-eval) :multiline t)) nil [38748 39827])
			("helm-complex-command-history" function (:user-visible-flag t) nil [39844 40048])
			("helm-elisp" package nil nil [40050 40071]))
			:file "helm-elisp.el"
			:pointmax 40213
			:fsize 40212
			:lastmodtime '(23537 22013 0 0)
			:unmatched-syntax nil)
			(semanticdb-table "semanticdb-table"
			:major-mode emacs-lisp-mode
			:tags
			'( ("cl-lib" include nil nil [809 826])
			("helm" include nil nil [827 842])
			("helm-help" include nil nil [843 863])
			("eldoc" include nil nil [864 880])
			("edebug" include nil nil [881 898])
			("helm-eval" customgroup (:user-visible-flag t) nil [902 995])
			("helm-eldoc-in-minibuffer-show-fn" variable (:default-value (quote helm-show-info-in-mode-line)) nil [997 1191])
			("helm-show-info-in-mode-line-delay" variable (:default-value 12) nil [1193 1352])
			("if" code nil nil [1413 2341])
			("helm-eldoc-active-minibuffers-list" variable nil nil [2383 2430])
			("helm-eval-expression-map" variable (:default-value (let ((map (make-sparse-keymap))) (set-keymap-parent map helm-map) (define-key map (kbd "<C-return>") (quote helm-eval-new-line-and-indent)) (define-key map (kbd "<M-tab>") (quote lisp-indent-line)) (define-key map (kbd "<C-tab>") (quote helm-lisp-completion-at-point)) (define-key map (kbd "C-p") (quote previous-line)) (define-key map (kbd "C-n") (quote next-line)) (define-key map (kbd "<up>") (quote previous-line)) (define-key map (kbd "<down>") (quote next-line)) (define-key map (kbd "<right>") (quote forward-char)) (define-key map (kbd "<left>") (quote backward-char)) map)) nil [2432 3070])
			("helm-build-evaluation-result-source" function nil nil [3072 4542])
			("helm-eval-new-line-and-indent" function nil nil [4544 4631])
			("helm-eldoc-store-minibuffer" function nil nil [4633 4853])
			("helm-eldoc-show-in-eval" function nil nil [4855 5742])
			("helm-show-info-in-mode-line" function (:arguments ("str")) nil [5744 6051])
			("helm-source-calculation-result" variable (:default-value (helm-build-dummy-source "Calculation Result" :filtered-candidate-transformer (lambda (_candidates _source) (list (condition-case nil (calc-eval helm-pattern) (error "error")))) :nohighlight t :action (quote (("Copy result to kill-ring" lambda (candidate) (kill-new candidate) (message "Result \"%s\" copied to kill-ring" candidate)) ("Copy operation to kill-ring" lambda (_candidate) (kill-new helm-input) (message "Calculation copied to kill-ring")))))) nil [6082 7011])
			("helm-eval-expression" function
			(:user-visible-flag t
			:arguments ("arg"))
			nil [7028 7358])
			("eldoc-idle-delay" variable nil nil [7360 7385])
			("helm-eval-expression-with-eldoc" function (:user-visible-flag t) nil [7401 7958])
			("helm-calcul-expression" function (:user-visible-flag t) nil [7975 8167])
			("helm-eval" package nil nil [8169 8189]))
			:file "helm-eval.el"
			:pointmax 8330
			:fsize 8329
			:lastmodtime '(23537 22014 0 0)
			:unmatched-syntax nil)
			(semanticdb-table "semanticdb-table"
			:major-mode emacs-lisp-mode
			:tags
			'( ("helm-files" include nil nil [815 836])
			("helm-external" include nil nil [837 861])
			("helm-bookmark" include nil nil [862 886])
			("helm-multi-files-toggle-locate-binding" variable (:default-value "C-c p") nil [888 1058])
			("helm-for-files-preferred-list" variable (:default-value (quote (helm-source-buffers-list helm-source-recentf helm-source-bookmarks helm-source-file-cache helm-source-files-in-current-dir helm-source-locate))) nil [1060 1510])
			("helm-for-files-tramp-not-fancy" variable (:default-value t) nil [1512 1697])
			("file-cache-alist" variable nil nil [1720 1745])
			("helm-file-cache" type
			(:interfaces ("helm-type-file")
			:superclasses "helm-source-in-buffer"
			:members
			( ("init" variable (:default-value "(lambda nil (require (quote filecache)))") nil nil))
			:type "class")
			nil [1747 1866])
			("helm-file-cache-get-candidates" function nil nil [1868 2102])
			("helm-source-file-cache" variable nil nil [2104 2139])
			("helm-file-cache-fuzzy-match" variable nil nil [2141 2556])
			("cl-defun" code nil nil [2558 2933])
			("helm-transform-file-cache" function (:arguments ("actions" "_candidate")) nil [2935 3247])
			("helm-recentf--basename-flag" variable nil nil [3273 3313])
			("helm-recentf-pattern-transformer" function (:arguments ("pattern")) nil [3315 3827])
			("helm-turn-on-recentf" variable (:default-value t) nil [3829 3956])
			("helm-recentf-source" type
			(:interfaces ("helm-type-file")
			:superclasses "helm-source-sync"
			:members
			( ("init" variable (:default-value "(lambda nil (require (quote recentf)) (when helm-turn-on-recentf (recentf-mode 1)))") nil nil)
			("candidates" variable (:default-value "(lambda nil recentf-list)") nil nil)
			("pattern-transformer" variable (:default-value "(quote helm-recentf-pattern-transformer)") nil nil)
			("match-part" variable (:default-value "(lambda (candidate) (if (or helm-ff-transformer-show-only-basename helm-recentf--basename-flag) (helm-basename candidate) candidate))") nil nil)
			("migemo" variable (:default-value "t") nil nil)
			("persistent-action" variable (:default-value "(quote helm-ff-kill-or-find-buffer-fname)") nil nil))
			:type "class")
			nil [3958 4626])
			("helm--setup-source" function
			(:parent "helm-recentf-source"
			:arguments ("source"))
			nil [4628 5037])
			("helm-source-recentf" variable nil nil [5039 5189])
			("helm-recentf-fuzzy-match" variable nil nil [5191 5633])
			("helm-highlight-files" function (:arguments ("files" "_source")) nil [5668 7887])
			("helm-files-in-current-dir-source" type
			(:interfaces ("helm-type-file")
			:superclasses "helm-source-sync"
			:members
			( ("candidates" variable (:default-value "(lambda nil (with-helm-current-buffer (let ((dir (helm-current-directory))) (when (file-accessible-directory-p dir) (directory-files dir t)))))") nil nil)
			("pattern-transformer" variable (:default-value "(quote helm-recentf-pattern-transformer)") nil nil)
			("match-part" variable (:default-value "(lambda (candidate) (if (or helm-ff-transformer-show-only-basename helm-recentf--basename-flag) (helm-basename candidate) candidate))") nil nil)
			("fuzzy-match" variable (:default-value "t") nil nil)
			("migemo" variable (:default-value "t") nil nil))
			:type "class")
			nil [7889 8631])
			("helm-source-files-in-current-dir" variable (:default-value (helm-make-source "Files from Current Directory" (quote helm-files-in-current-dir-source))) nil [8633 8766])
			("helm-for-files" function (:user-visible-flag t) nil [8783 9268])
			("helm-multi-files-toggle-to-locate" function nil nil [9270 9953])
			("put" code nil nil [9954 10007])
			("helm-multi-files" function (:user-visible-flag t) nil [10024 11903])
			("helm-recentf" function (:user-visible-flag t) nil [11920 12118])
			("helm-for-files" package nil nil [12120 12145]))
			:file "helm-for-files.el"
			:pointmax 12291
			:fsize 12290
			:lastmodtime '(23537 22013 0 0)
			:unmatched-syntax nil)
			(semanticdb-table "semanticdb-table"
			:major-mode emacs-lisp-mode
			:tags
			'( ("cl-lib" include nil nil [844 861])
			("helm" include nil nil [862 877])
			("helm-help" include nil nil [878 898])
			("helm-net" include nil nil [899 918])
			("helm-external" customgroup (:user-visible-flag t) nil [922 1024])
			("helm-raise-command" variable nil nil [1026 1269])
			("helm-external-programs-associations" variable nil nil [1271 1577])
			("helm-default-external-file-browser" variable (:default-value "nautilus") nil [1579 1954])
			("helm-external-command-history" variable nil nil [1972 2014])
			("helm-external-commands-list" variable nil nil [2015 2191])
			("helm-external-commands-list-1" function (:arguments ("sort")) nil [2193 3277])
			("helm-run-or-raise" function (:arguments ("exe" "file")) nil [3279 4918])
			("helm-get-mailcap-for-file" function (:arguments ("filename")) nil [4920 5390])
			("helm-get-default-program-for-file" function (:arguments ("filename")) nil [5392 5973])
			("helm-open-file-externally" function (:arguments ("file")) nil [5975 8295])
			("helm-run-external-command" function
			(:user-visible-flag t
			:arguments ("program"))
			nil [8312 9115])
			("helm-external" package nil nil [9118 9142]))
			:file "helm-external.el"
			:pointmax 9284
			:fsize 9283
			:lastmodtime '(23537 22013 0 0)
			:unmatched-syntax nil)
			(semanticdb-table "semanticdb-table"
			:major-mode emacs-lisp-mode
			:tags
			'( ("cl-lib" include nil nil [808 825])
			("helm" include nil nil [826 841])
			("helm-lib" include nil nil [842 861])
			("imenu" include nil nil [862 878])
			("helm-utils" include nil nil [879 900])
			("helm-help" include nil nil [901 921])
			("helm-imenu" customgroup (:user-visible-flag t) nil [925 1020])
			("helm-imenu-delimiter" variable (:default-value " / ") nil [1022 1161])
			("helm-imenu-execute-action-at-once-if-one" variable (:default-value (function helm-imenu--execute-action-at-once-p)) nil [1163 1346])
			("helm-imenu-lynx-style-map" variable (:default-value t) nil [1348 1468])
			("helm-imenu-all-buffer-assoc" variable nil nil [1470 1876])
			("helm-imenu-in-all-buffers-separate-sources" variable (:default-value t) nil [1878 2433])
			("helm-imenu-type-faces" variable (:default-value (quote (("^Variables$" . font-lock-variable-name-face) ("^\$Function\\\|Functions\\\|Defuns\$$" . font-lock-function-name-face) ("^\$Types\\\|Provides\\\|Requires\\\|Classes\\\|Class\\\|Includes\\\|Imports\\\|Misc\\\|Code\$$" . font-lock-type-face)))) nil [2435 3091])
			("helm-imenu-extra-modes" variable nil nil [3093 3243])
			("helm-imenu-map" variable (:default-value (let ((map (make-sparse-keymap))) (set-keymap-parent map helm-map) (define-key map (kbd "M-<down>") (quote helm-imenu-next-section)) (define-key map (kbd "M-<up>") (quote helm-imenu-previous-section)) (when helm-imenu-lynx-style-map (define-key map (kbd "<left>") (quote helm-maybe-exit-minibuffer)) (define-key map (kbd "<right>") (quote helm-execute-persistent-action)) (define-key map (kbd "M-<left>") (quote helm-previous-source)) (define-key map (kbd "M-<right>") (quote helm-next-source))) (delq nil map))) nil [3257 3804])
			("helm-imenu-next-or-previous-section" function (:arguments ("n")) nil [3806 4436])
			("helm-imenu-next-section" function nil nil [4438 4530])
			("helm-imenu-previous-section" function nil nil [4532 4629])
			("helm-cached-imenu-alist" variable nil nil [4647 4683])
			("make-variable-buffer-local" code nil nil [4684 4737])
			("helm-cached-imenu-candidates" variable nil nil [4739 4780])
			("make-variable-buffer-local" code nil nil [4781 4839])
			("helm-cached-imenu-tick" variable nil nil [4841 4876])
			("make-variable-buffer-local" code nil nil [4877 4929])
			("helm-imenu--in-all-buffers-cache" variable nil nil [4931 4976])
			("helm-source-imenu" variable nil nil [4979 5039])
			("helm-source-imenu-all" variable nil nil [5040 5074])
			("helm-imenu-source" type
			(:superclasses "helm-source-sync"
			:members
			( ("candidates" variable (:default-value "(quote helm-imenu-candidates)") nil nil)
			("candidate-transformer" variable (:default-value "(quote helm-imenu-transformer)") nil nil)
			("persistent-action" variable (:default-value "(quote helm-imenu-persistent-action)") nil nil)
			("persistent-help" variable (:default-value "Show this entry") nil nil)
			("nomark" variable (:default-value "t") nil nil)
			("keymap" variable (:default-value "helm-imenu-map") nil nil)
			("help-message" variable (:default-value "(quote helm-imenu-help-message)") nil nil)
			("action" variable (:default-value "(quote helm-imenu-action)") nil nil)
			("group" variable (:default-value "(quote helm-imenu)") nil nil))
			:type "class")
			nil [5076 5534])
			("helm-imenu-fuzzy-match" variable nil nil [5536 5860])
			("helm-imenu--maybe-switch-to-buffer" function (:arguments ("candidate")) nil [5863 6037])
			("helm-imenu--execute-action-at-once-p" function nil nil [6039 6391])
			("helm-imenu-action" function (:arguments ("candidate")) nil [6393 6881])
			("helm-imenu-persistent-action" function (:arguments ("candidate")) nil [6883 7087])
			("helm-imenu-candidates" function (:arguments ("buffer")) nil [7089 7633])
			("helm-imenu-candidates-in-all-buffers" function (:arguments ("build-sources")) nil [7635 8997])
			("helm-imenu--candidates-1" function (:arguments ("alist")) nil [8999 10453])
			("helm-imenu--get-prop" function (:arguments ("item")) nil [10455 10917])
			("helm-imenu-transformer" function (:arguments ("candidates")) nil [10919 12133])
			("helm-imenu" function (:user-visible-flag t) nil [12151 12733])
			("helm-imenu-in-all-buffers" function (:user-visible-flag t) nil [12750 14402])
			("helm-imenu" package nil nil [14404 14425]))
			:file "helm-imenu.el"
			:pointmax 14567
			:fsize 14566
			:lastmodtime '(23537 22013 0 0)
			:unmatched-syntax nil)
			(semanticdb-table "semanticdb-table"
			:major-mode emacs-lisp-mode
			:tags
			'( ("cl-lib" include nil nil [811 828])
			("helm" include nil nil [829 844])
			("helm-help" include nil nil [845 865])
			("helm-font" customgroup (:user-visible-flag t) nil [869 959])
			("helm-ucs-recent-size" variable (:default-value 10) nil [961 1069])
			("helm-ucs-actions" variable (:default-value (quote (("Insert character" . helm-ucs-insert-char) ("Insert character name" . helm-ucs-insert-name) ("Insert character code in hex" . helm-ucs-insert-code) ("Kill marked characters" . helm-ucs-kill-char) ("Kill name" . helm-ucs-kill-name) ("Kill code" . helm-ucs-kill-code)))) nil [1071 1564])
			("helm-ucs-map" variable (:default-value (let ((map (make-sparse-keymap))) (set-keymap-parent map helm-map) (define-key map (kbd "<C-backspace>") (quote helm-ucs-persistent-delete)) (define-key map (kbd "<C-left>") (quote helm-ucs-persistent-backward)) (define-key map (kbd "<C-right>") (quote helm-ucs-persistent-forward)) (define-key map (kbd "C-c SPC") (quote helm-ucs-persistent-insert-space)) map)) nil [1566 1989])
			("helm-ucs-char" variable
			(:default-value (quote ((((class color) (background dark)) (:foreground "Gold"))))
			:type "face")
			nil [1991 2138])
			("helm-xfonts-cache" variable nil nil [2167 2197])
			("helm-previous-font" variable nil nil [2198 2229])
			("helm-source-xfonts" variable (:default-value (helm-build-sync-source "X Fonts" :init (lambda nil (unless helm-xfonts-cache (setq helm-xfonts-cache (x-list-fonts "*"))) (setq helm-previous-font (cdr (assq (quote font) (frame-parameters))))) :candidates (quote helm-xfonts-cache) :action (quote (("Copy font to kill ring" lambda (elm) (kill-new elm)) ("Set font" lambda (elm) (kill-new elm) (set-frame-font elm (quote keep-size)) (message "Font copied to kill ring")))) :cleanup (lambda nil (set-frame-font helm-previous-font (quote keep-size))) :persistent-action (lambda (new-font) (set-frame-font new-font (quote keep-size)) (kill-new new-font)) :persistent-help "Preview font and copy to kill-ring")) nil [2230 3281])
			("helm-ucs--max-len" variable nil nil [3317 3347])
			("helm-ucs--names" variable nil nil [3348 3376])
			("helm-ucs-history" variable nil nil [3377 3406])
			("helm-ucs-recent" variable nil nil [3407 3477])
			("helm-calculate-ucs-alist-max-len" function (:arguments ("names")) nil [3479 3793])
			("helm-calculate-ucs-hash-table-max-len" function (:arguments ("names")) nil [3795 4167])
			("helm-calculate-ucs-max-len" function nil nil [4169 4446])
			("helm-ucs-collect-symbols-alist" function (:arguments ("names")) nil [4448 5520])
			("helm-ucs-collect-symbols-hash-table" function (:arguments ("names")) nil [5522 6413])
			("helm-ucs-collect-symbols" function (:arguments ("ucs-struct")) nil [6415 6735])
			("helm-ucs-init" function nil nil [6737 7043])
			("helm-ucs-match" function (:arguments ("candidate" "n")) nil [7069 7344])
			("helm-ucs-save-recentest" function (:arguments ("candidate")) nil [7346 7584])
			("helm-ucs-insert" function (:arguments ("candidate" "n")) nil [7586 7770])
			("helm-ucs-insert-char" function (:arguments ("candidate")) nil [7772 7892])
			("helm-ucs-insert-code" function (:arguments ("candidate")) nil [7894 8014])
			("helm-ucs-insert-name" function (:arguments ("candidate")) nil [8016 8136])
			("helm-ucs-kill-char" function (:arguments ("_candidate")) nil [8154 8496])
			("helm-ucs-kill-code" function (:arguments ("candidate")) nil [8498 8616])
			("helm-ucs-kill-name" function (:arguments ("candidate")) nil [8618 8736])
			("helm-ucs-forward-char" function (:arguments ("_candidate")) nil [8784 8876])
			("helm-ucs-backward-char" function (:arguments ("_candidate")) nil [8878 8972])
			("helm-ucs-delete-backward" function (:arguments ("_candidate")) nil [8974 9069])
			("helm-ucs-insert-space" function (:arguments ("_candidate")) nil [9071 9159])
			("helm-ucs-persistent-forward" function nil nil [9161 9348])
			("put" code nil nil [9349 9396])
			("helm-ucs-persistent-backward" function nil nil [9398 9581])
			("put" code nil nil [9582 9630])
			("helm-ucs-persistent-delete" function nil nil [9632 9819])
			("put" code nil nil [9820 9866])
			("helm-ucs-persistent-insert-space" function nil nil [9868 10070])
			("helm-source-ucs-recent" variable (:default-value (helm-build-sync-source "Recent UCS" :action helm-ucs-actions :candidates (lambda nil helm-ucs-recent) :help-message helm-ucs-help-message :keymap helm-ucs-map :volatile t)) nil [10072 10297])
			("helm-source-ucs" variable (:default-value (helm-build-in-buffer-source "UCS names" :data (function helm-ucs-init) :get-line (function buffer-substring) :help-message (quote helm-ucs-help-message) :filtered-candidate-transformer (lambda (candidates _source) (sort candidates (function helm-generic-sort-fn))) :action helm-ucs-actions :persistent-action (lambda (candidate) (helm-ucs-insert-char candidate) (helm-force-update)) :keymap helm-ucs-map)) nil [10299 10831])
			("helm-select-xfont" function (:user-visible-flag t) nil [10849 11011])
			("helm-ucs" function
			(:user-visible-flag t
			:arguments ("arg"))
			nil [11028 11505])
			("helm-font" package nil nil [11507 11527]))
			:file "helm-font.el"
			:pointmax 11668
			:fsize 11724
			:lastmodtime '(23537 22013 0 0)
			:unmatched-syntax nil)
			(semanticdb-table "semanticdb-table"
			:major-mode emacs-lisp-mode
			:tags
			'( ("cl-lib" include nil nil [820 837])
			("helm" include nil nil [838 853])
			("helm-help" include nil nil [854 874])
			("package" include nil nil [875 893])
			("helm-el-package" customgroup (:user-visible-flag t) nil [895 965])
			("helm-el-package-initial-filter" variable (:default-value (quote all)) nil [967 1389])
			("helm-el-truncate-lines" variable (:default-value t) nil [1391 1519])
			("helm-el-package--show-only" variable (:default-value (quote all)) nil [1539 1579])
			("helm-el-package--initialized-p" variable nil nil [1580 1623])
			("helm-el-package--tabulated-list" variable nil nil [1624 1668])
			("helm-el-package--upgrades" variable nil nil [1669 1707])
			("helm-el-package--removable-packages" variable nil nil [1708 1756])
			("package-menu-async" variable nil nil [1795 1822])
			("declare-function" code nil nil [1853 1926])
			("helm-el-package--init" function nil nil [1928 4000])
			("helm-el-package-describe" function (:arguments ("candidate")) nil [4002 4251])
			("helm-el-package-visit-homepage" function (:arguments ("candidate")) nil [4253 4835])
			("helm-el-run-visit-homepage" function nil nil [4837 4979])
			("put" code nil nil [4980 5026])
			("helm-el-package-install-1" function (:arguments ("pkg-list")) nil [5028 5926])
			("helm-el-package-install" function (:arguments ("_candidate")) nil [5928 6027])
			("helm-el-run-package-install" function nil nil [6029 6165])
			("put" code nil nil [6166 6213])
			("helm-el-package-uninstall-1" function (:arguments ("pkg-list" "force")) nil [6215 8618])
			("helm-el-package-uninstall" function (:arguments ("_candidate")) nil [8620 8747])
			("helm-el-run-package-uninstall" function nil nil [8749 8889])
			("put" code nil nil [8890 8939])
			("helm-el-package-menu--find-upgrades" function nil nil [8941 9835])
			("helm-el-package-upgrade-1" function (:arguments ("pkg-list")) nil [9837 10677])
			("helm-el-package-upgrade" function (:arguments ("_candidate")) nil [10679 10975])
			("helm-el-run-package-upgrade" function nil nil [10977 11113])
			("put" code nil nil [11114 11161])
			("helm-el-package-upgrade-all" function nil nil [11163 11592])
			("helm-el-package-upgrade-all-action" function (:arguments ("_candidate")) nil [11594 11681])
			("helm-el-run-package-upgrade-all" function nil nil [11683 11834])
			("put" code nil nil [11835 11886])
			("helm-el-package--transformer" function (:arguments ("candidates" "_source")) nil [11888 13688])
			("helm-el-package-show-built-in" function nil nil [13690 13834])
			("put" code nil nil [13835 13884])
			("helm-el-package-show-upgrade" function nil nil [13886 14028])
			("put" code nil nil [14029 14077])
			("helm-el-package-show-installed" function nil nil [14079 14225])
			("put" code nil nil [14226 14276])
			("helm-el-package-show-all" function nil nil [14278 14412])
			("put" code nil nil [14413 14457])
			("helm-el-package-show-uninstalled" function nil nil [14459 14609])
			("put" code nil nil [14610 14662])
			("helm-el-package-map" variable (:default-value (let ((map (make-sparse-keymap))) (set-keymap-parent map helm-map) (define-key map (kbd "M-I") (quote helm-el-package-show-installed)) (define-key map (kbd "M-O") (quote helm-el-package-show-uninstalled)) (define-key map (kbd "M-U") (quote helm-el-package-show-upgrade)) (define-key map (kbd "M-B") (quote helm-el-package-show-built-in)) (define-key map (kbd "M-A") (quote helm-el-package-show-all)) (define-key map (kbd "C-c i") (quote helm-el-run-package-install)) (define-key map (kbd "C-c r") (quote helm-el-run-package-reinstall)) (define-key map (kbd "C-c d") (quote helm-el-run-package-uninstall)) (define-key map (kbd "C-c u") (quote helm-el-run-package-upgrade)) (define-key map (kbd "C-c U") (quote helm-el-run-package-upgrade-all)) (define-key map (kbd "C-c @") (quote helm-el-run-visit-homepage)) map)) nil [14664 15493])
			("helm-source-list-el-package" variable nil nil [15495 15535])
			("helm-list-el-package-source" type
			(:superclasses "helm-source-in-buffer"
			:members
			( ("init" variable (:default-value "(quote helm-el-package--init)") nil nil)
			("get-line" variable (:default-value "(quote buffer-substring)") nil nil)
			("filtered-candidate-transformer" variable (:default-value "(quote helm-el-package--transformer)") nil nil)
			("action-transformer" variable (:default-value "(quote helm-el-package--action-transformer)") nil nil)
			("help-message" variable (:default-value "(quote helm-el-package-help-message)") nil nil)
			("keymap" variable (:default-value "helm-el-package-map") nil nil)
			("update" variable (:default-value "(quote helm-el-package--update)") nil nil)
			("candidate-number-limit" variable (:default-value "9999") nil nil)
			("action" variable (:default-value "(quote ((\"Describe package\" . helm-el-package-describe) (\"Visit homepage\" . helm-el-package-visit-homepage)))") nil nil)
			("group" variable (:default-value "(quote helm-el-package)") nil nil))
			:type "class")
			nil [15536 16207])
			("helm-el-package--action-transformer" function (:arguments ("actions" "candidate")) nil [16209 18058])
			("helm-el-package--update" function nil nil [18060 18138])
			("helm-el-package-recompile" function (:arguments ("_pkg")) nil [18140 18664])
			("helm-el-package-reinstall" function (:arguments ("_pkg")) nil [18666 19762])
			("helm-el-run-package-reinstall" function nil nil [19764 19904])
			("put" code nil nil [19905 19954])
			("helm-list-elisp-packages" function
			(:user-visible-flag t
			:arguments ("arg"))
			nil [19971 20455])
			("helm-list-elisp-packages-no-fetch" function
			(:user-visible-flag t
			:arguments ("arg"))
			nil [20472 20801])
			("helm-elisp-package" package nil nil [20803 20832]))
			:file "helm-elisp-package.el"
			:pointmax 20870
			:fsize 20869
			:lastmodtime '(23537 22013 0 0)
			:unmatched-syntax nil)
			(semanticdb-table "semanticdb-table"
			:major-mode emacs-lisp-mode
			:tags
			'( ("helm-for-files" include nil nil [823 848])
			("helm-files-in-all-dired-candidates" function nil nil [908 1224])
			("helm-files-dired-source" type
			(:interfaces ("helm-type-file")
			:superclasses "helm-source-sync"
			:members
			( ("candidates" variable (:default-value "(function helm-files-in-all-dired-candidates)") nil nil))
			:type "class")
			nil [1300 1432])
			("helm-source-files-in-all-dired" variable (:default-value (helm-make-source "Files in all dired buffer." (quote helm-files-dired-source))) nil [1434 1548])
			("session-file-alist" variable nil nil [1705 1732])
			("helm-source-session-class" type
			(:superclasses "helm-source-sync"
			:members
			( ("candidates" variable (:default-value "(lambda nil (cl-delete-if-not (lambda (f) (or (string-match helm-tramp-file-name-regexp f) (file-exists-p f))) (mapcar (quote car) session-file-alist)))") nil nil)
			("keymap" variable (:default-value "helm-generic-files-map") nil nil)
			("help-message" variable (:default-value "helm-generic-file-help-message") nil nil)
			("action" variable (:default-value "(quote helm-type-file-actions)") nil nil))
			:type "class")
			nil [1733 2269])
			("helm-source-session" variable nil nil [2271 2337])
			("helm-session-fuzzy-match" variable nil nil [2339 2673])
			("helm-source-tracker-transformer" function (:arguments ("candidates" "_source")) nil [2742 3150])
			("helm-source-tracker-search" variable (:default-value (helm-build-async-source "Tracker Search" :candidates-process (lambda nil (start-process "tracker-search-process" nil "tracker" "search" "--disable-snippets" "--disable-color" "--limit=512" helm-pattern)) :filtered-candidate-transformer (function helm-source-tracker-transformer) :keymap helm-generic-files-map :action (quote helm-type-file-actions) :action-transformer (quote (helm-transform-file-load-el helm-transform-file-browse-url)) :requires-pattern 3)) nil [3152 4181])
			("helm-mac-spotlight-source" type
			(:interfaces ("helm-type-file")
			:superclasses "helm-source-async"
			:members
			( ("candidates-process" variable (:default-value "(lambda nil (start-process \"mdfind-process\" nil \"mdfind\" helm-pattern))") nil nil)
			("requires-pattern" variable (:default-value "3") nil nil))
			:type "class")
			nil [4221 4506])
			("helm-source-mac-spotlight" variable (:default-value (helm-make-source "mdfind" (quote helm-mac-spotlight-source))) nil [4508 4676])
			("helm-x-files" package nil nil [4678 4701]))
			:file "helm-x-files.el"
			:pointmax 4845
			:fsize 4844
			:lastmodtime '(23537 22013 0 0)
			:unmatched-syntax nil)
			(semanticdb-table "semanticdb-table"
			:major-mode emacs-lisp-mode
			:tags
			'( ("cl-lib" include nil nil [808 825])
			("helm" include nil nil [826 841])
			("helm-help" include nil nil [842 862])
			("helm-types" include nil nil [863 884])
			("declare-function" code nil nil [886 941])
			("display-time-world-list" variable nil nil [942 974])
			("declare-function" code nil nil [975 1024])
			("declare-function" code nil nil [1025 1076])
			("declare-function" code nil nil [1077 1131])
			("helm-misc" customgroup (:user-visible-flag t) nil [1135 1223])
			("helm-time-zone-home-location" variable (:default-value "Paris") nil [1225 1340])
			("helm-timezone-actions" variable (:default-value (quote (("Set timezone env (TZ)" lambda (candidate) (setenv "TZ" candidate))))) nil [1342 1592])
			("helm-time-zone-current" variable
			(:default-value (quote ((t (:foreground "green"))))
			:type "face")
			nil [1594 1740])
			("helm-time-zone-home" variable
			(:default-value (quote ((t (:foreground "red"))))
			:type "face")
			nil [1742 1880])
			("LaTeX-math-menu" variable nil nil [2334 2358])
			("helm-latex-math-candidates" function nil nil [2359 2731])
			("helm-source-latex-math" variable (:default-value (helm-build-sync-source "Latex Math Menu" :init (lambda nil (with-helm-current-buffer (LaTeX-math-mode 1))) :candidate-number-limit 9999 :candidates (quote helm-latex-math-candidates) :action (lambda (candidate) (call-interactively candidate)))) nil [2733 3059])
			("helm-jabber-online-contacts" function nil nil [3095 3410])
			("helm-source-jabber-contacts" variable (:default-value (helm-build-sync-source "Jabber Contacts" :init (lambda nil (require (quote jabber))) :candidates (lambda nil (mapcar (quote car) (helm-jabber-online-contacts))) :action (lambda (x) (jabber-chat-with (jabber-read-account) (symbol-name (cdr (assoc x (helm-jabber-online-contacts)))))))) nil [3412 3791])
			("zoneinfo-style-world-list" variable nil nil [3811 3845])
			("legacy-style-world-list" variable nil nil [3846 3878])
			("helm-time-zone-transformer" function (:arguments ("candidates" "_source")) nil [3880 4366])
			("helm-source-time-world" variable (:default-value (helm-build-in-buffer-source "Time World List" :init (lambda nil (require (quote time)) (unless (and display-time-world-list (listp display-time-world-list)) (setq display-time-world-list (let ((nyt (format-time-string "%z" nil "America/New_York")) (gmt (format-time-string "%z" nil "Europe/London"))) (if (string-equal nyt gmt) legacy-style-world-list zoneinfo-style-world-list))))) :data (lambda nil (with-temp-buffer (display-time-world-display display-time-world-list) (buffer-string))) :action (quote helm-timezone-actions) :filtered-candidate-transformer (quote helm-time-zone-transformer))) nil [4368 5588])
			("helm-call-interactively" function (:arguments ("cmd-or-name")) nil [5606 6209])
			("helm-minibuffer-history-map" variable (:default-value (let ((map (make-sparse-keymap))) (set-keymap-parent map helm-map) (define-key map [remap helm-minibuffer-history] (quote undefined)) map)) nil [6240 6422])
			("helm-minibuffer-history-must-match" variable (:default-value t) nil [6424 6696])
			("helm-comint-input-ring-action" function (:arguments ("candidate")) nil [6722 6927])
			("helm-source-comint-input-ring" variable (:default-value (helm-build-sync-source "Comint history" :candidates (lambda nil (with-helm-current-buffer (ring-elements comint-input-ring))) :action (quote helm-comint-input-ring-action))) nil [6929 7250])
			("helm-source-ratpoison-commands" variable (:default-value (helm-build-in-buffer-source "Ratpoison Commands" :init (quote helm-ratpoison-commands-init) :action (helm-make-actions "Execute the command" (quote helm-ratpoison-commands-execute)) :display-to-real (quote helm-ratpoison-commands-display-to-real) :candidate-number-limit 999999)) nil [7282 7611])
			("helm-ratpoison-commands-init" function nil nil [7613 8240])
			("helm-ratpoison-commands-display-to-real" function (:arguments ("display")) nil [8242 8376])
			("helm-ratpoison-commands-execute" function (:arguments ("candidate")) nil [8378 8486])
			("helm-source-stumpwm-commands" variable (:default-value (helm-build-in-buffer-source "Stumpwm Commands" :init (quote helm-stumpwm-commands-init) :action (helm-make-actions "Execute the command" (quote helm-stumpwm-commands-execute)) :candidate-number-limit 999999)) nil [8514 8773])
			("helm-stumpwm-commands-init" function nil nil [8775 9150])
			("helm-stumpwm-commands-execute" function (:arguments ("candidate")) nil [9152 9252])
			("helm-world-time" function (:user-visible-flag t) nil [9269 9486])
			("helm-insert-latex-math" function (:user-visible-flag t) nil [9503 9671])
			("helm-ratpoison-commands" function (:user-visible-flag t) nil [9688 9897])
			("helm-stumpwm-commands" function (:user-visible-flag t) nil [9914 10105])
			("helm-minibuffer-history" function (:user-visible-flag t) nil [10122 11930])
			("helm-comint-input-ring" function (:user-visible-flag t) nil [11947 12345])
			("helm-misc" package nil nil [12348 12368]))
			:file "helm-misc.el"
			:pointmax 12509
			:fsize 12508
			:lastmodtime '(23537 22014 0 0)
			:unmatched-syntax nil)
			(semanticdb-table "semanticdb-table"
			:major-mode emacs-lisp-mode
			:tags
			'( ("cl-lib" include nil nil [815 832])
			("helm" include nil nil [833 848])
			("helm-help" include nil nil [849 869])
			("helm-mode" include nil nil [870 890])
			("helm-elisp" include nil nil [891 912])
			("helm-command" customgroup (:user-visible-flag t) nil [916 1021])
			("helm-M-x-requires-pattern" variable nil nil [1023 1197])
			("helm-M-x-always-save-history" variable nil nil [1199 1361])
			("helm-M-x-reverse-history" variable nil nil [1363 1521])
			("helm-M-x-fuzzy-match" variable nil nil [1523 1654])
			("helm-M-x-default-sort-fn" variable (:default-value (function helm-M-x-fuzzy-sort-candidates)) nil [1656 1915])
			("helm-command-faces" customgroup (:user-visible-flag t) nil [1934 2075])
			("helm-M-x-key" variable
			(:default-value (quote ((t (:foreground "orange" :underline t))))
			:type "face")
			nil [2077 2217])
			("helm-M-x-input-history" variable nil nil [2221 2256])
			("helm-M-x-prefix-argument" variable nil nil [2257 2341])
			("helm-M-x-get-major-mode-command-alist" function (:arguments ("mode-map")) nil [2345 2695])
			("helm-get-mode-map-from-mode" function (:arguments ("mode")) nil [2697 3522])
			("helm-M-x-current-mode-map-alist" function nil nil [3524 3789])
			("helm-M-x-transformer-1" function (:arguments ("candidates" "sort")) nil [3792 5172])
			("helm-M-x-transformer" function (:arguments ("candidates" "_source")) nil [5174 5335])
			("helm-M-x-transformer-hist" function (:arguments ("candidates" "_source")) nil [5337 5481])
			("helm-M-x--notify-prefix-arg" function nil nil [5483 5676])
			("helm-cmd--get-current-function-name" function nil nil [5678 5882])
			("helm-cmd--get-preconfigured-commands" function (:arguments ("dir")) nil [5884 6377])
			("helm-M-x-map" variable (:default-value (let ((map (make-sparse-keymap))) (set-keymap-parent map helm-comp-read-map) (define-key map (kbd "C-u") nil) (define-key map (kbd "C-u") (quote helm-M-x-universal-argument)) map)) nil [6379 6591])
			("helm-M-x-universal-argument" function (:user-visible-flag t) nil [6593 7154])
			("put" code nil nil [7155 7202])
			("helm-M-x-fuzzy-sort-candidates" function (:arguments ("candidates" "_source")) nil [7204 7318])
			("helm-M-x-read-extended-command" function (:arguments ("collection" "history")) nil [7320 10348])
			("helm-M-x" function
			(:user-visible-flag t
			:arguments ("_arg" "command-name"))
			nil [10365 12045])
			("put" code nil nil [12046 12096])
			("helm-command" package nil nil [12098 12121]))
			:file "helm-command.el"
			:pointmax 12265
			:fsize 12264
			:lastmodtime '(23537 22013 0 0)
			:unmatched-syntax nil)
			(semanticdb-table "semanticdb-table"
			:major-mode emacs-lisp-mode
			:tags
			'( ("cl-lib" include nil nil [836 853])
			("helm" include nil nil [854 869])
			("helm-utils" include nil nil [870 891])
			("helm-help" include nil nil [892 912])
			("helm-elisp" include nil nil [913 934])
			("declare-function" code nil nil [936 1022])
			("helm-ring" customgroup (:user-visible-flag t) nil [1026 1119])
			("helm-kill-ring-threshold" variable (:default-value 3) nil [1121 1271])
			("helm-kill-ring-max-offset" variable (:default-value 400) nil [1273 1767])
			("helm-kill-ring-actions" variable (:default-value (quote (("Yank marked" . helm-kill-ring-action-yank) ("Delete marked" . helm-kill-ring-action-delete)))) nil [1769 2023])
			("helm-kill-ring-separator" variable (:default-value "
			") nil [2025 2169])
			("helm-register-max-offset" variable (:default-value 160) nil [2171 2308])
			("helm-kill-ring-map" variable (:default-value (let ((map (make-sparse-keymap))) (set-keymap-parent map helm-map) (define-key map (kbd "M-y") (quote helm-next-line)) (define-key map (kbd "M-u") (quote helm-previous-line)) (define-key map (kbd "M-D") (quote helm-kill-ring-delete)) (define-key map (kbd "C-]") (quote helm-kill-ring-toggle-truncated)) (define-key map (kbd "C-c C-k") (quote helm-kill-ring-kill-selection)) map)) nil [2331 2786])
			("helm-source-kill-ring" variable (:default-value (helm-build-sync-source "Kill Ring" :init (lambda nil (helm-attrset (quote last-command) last-command) (helm-attrset (quote multiline) helm-kill-ring-max-offset)) :candidates (function helm-kill-ring-candidates) :filtered-candidate-transformer (function helm-kill-ring-transformer) :action (quote helm-kill-ring-actions) :persistent-action (quote ignore) :help-message (quote helm-kill-ring-help-message) :persistent-help "DoNothing" :keymap helm-kill-ring-map :migemo t :multiline (quote helm-kill-ring-max-offset) :group (quote helm-ring))) nil [2788 3418])
			("helm-kill-ring-candidates" function nil nil [3420 3673])
			("helm-kill-ring-transformer" function (:arguments ("candidates" "_source")) nil [3675 3943])
			("helm-kill-ring--truncated-flag" variable nil nil [3945 3988])
			("helm-kill-ring-toggle-truncated" function (:user-visible-flag t) nil [3989 4562])
			("put" code nil nil [4563 4614])
			("helm-kill-ring-kill-selection" function (:user-visible-flag t) nil [4616 4824])
			("put" code nil nil [4825 4874])
			("helm-kill-ring--preselect-fn" function (:arguments ("candidate")) nil [4876 5378])
			("helm-kill-ring-action-yank" function (:arguments ("_str")) nil [5380 5964])
			("helm-kill-ring-action-yank-1" function (:arguments ("str")) nil [5966 8700])
			("define-obsolete-function-alias" code nil nil [8701 8792])
			("helm-kill-ring-action-delete" function (:arguments ("_candidate")) nil [8794 9008])
			("helm-kill-ring-delete" function (:user-visible-flag t) nil [9010 9237])
			("helm-mark-ring-line-string-at-pos" function (:arguments ("pos")) nil [9405 9756])
			("helm-mark-ring-get-candidates" function nil nil [9758 10474])
			("helm-mark-ring-default-action" function (:arguments ("candidate")) nil [10476 11111])
			("helm-source-mark-ring" variable (:default-value (helm-build-sync-source "mark-ring" :candidates (function helm-mark-ring-get-candidates) :action (quote (("Goto line" . helm-mark-ring-default-action))) :persistent-help "Show this line" :group (quote helm-ring))) nil [11113 11351])
			("helm-source-global-mark-ring" variable (:default-value (helm-build-sync-source "global-mark-ring" :candidates (function helm-global-mark-ring-get-candidates) :action (quote (("Goto line" . helm-mark-ring-default-action))) :persistent-help "Show this line" :group (quote helm-ring))) nil [11374 11633])
			("helm-global-mark-ring-format-buffer" function (:arguments ("marker")) nil [11635 12196])
			("helm-global-mark-ring-get-candidates" function nil nil [12198 12711])
			("helm-source-register" variable (:default-value (helm-build-sync-source "Registers" :candidates (function helm-register-candidates) :action-transformer (function helm-register-action-transformer) :persistent-help "" :multiline t :action (quote (("Delete Register(s)" lambda (_candidate) (cl-loop for candidate in (helm-marked-candidates) for register = (car candidate) do (setq register-alist (delq (assoc register register-alist) register-alist)))))) :group (quote helm-ring))) nil [12755 13402])
			("helm-register-candidates" function nil nil [13404 16262])
			("helm-register-action-transformer" function (:arguments ("actions" "register-and-functions")) nil [16264 17706])
			("helm-mark-ring" function (:user-visible-flag t) nil [17723 17915])
			("helm-global-mark-ring" function (:user-visible-flag t) nil [17932 18152])
			("helm-all-mark-rings" function (:user-visible-flag t) nil [18169 18458])
			("helm-register" function (:user-visible-flag t) nil [18475 18661])
			("helm-show-kill-ring" function (:user-visible-flag t) nil [18678 19095])
			("helm-execute-kmacro" function (:user-visible-flag t) nil [19112 20560])
			("helm-kbd-macro-execute" function (:arguments ("candidate")) nil [20562 20829])
			("helm-kbd-macro-concat-macros" function (:arguments ("_candidate")) nil [20831 21464])
			("helm-kbd-macro-delete-macro" function (:arguments ("_candidate")) nil [21466 21688])
			("helm-kbd-macro-edit-macro" function (:arguments ("candidate")) nil [21690 21870])
			("helm-ring" package nil nil [21872 21892]))
			:file "helm-ring.el"
			:pointmax 22033
			:fsize 22032
			:lastmodtime '(23537 22013 0 0)
			:unmatched-syntax nil)
			(semanticdb-table "semanticdb-table"
			:file "helm-easymenu.el"
			:fsize 3108
			:lastmodtime '(23537 22013 0 0))
			(semanticdb-table "semanticdb-table"
			:major-mode emacs-lisp-mode
			:tags
			'( ("cl-lib" include nil nil [827 844])
			("helm" include nil nil [845 860])
			("helm-utils" include nil nil [861 882])
			("org" include nil nil [883 897])
			("org-macs" include nil nil [968 987])
			("declare-function" code nil nil [990 1045])
			("helm-org" customgroup (:user-visible-flag t) nil [1047 1121])
			("helm-org-headings-fontify" variable nil nil [1123 1348])
			("helm-org-format-outline-path" variable nil nil [1350 1462])
			("helm-org-show-filename" variable nil nil [1464 1671])
			("helm-org-headings-min-depth" variable (:default-value 1) nil [1673 1799])
			("helm-org-headings-max-depth" variable (:default-value 8) nil [1801 1929])
			("helm-org-headings-actions" variable (:default-value (quote (("Go to heading" . helm-org-goto-marker) ("Open in indirect buffer `C-c i'" . helm-org--open-heading-in-indirect-buffer) ("Refile heading(s) (marked-to-selected\|current-to-selected) `C-c w`" . helm-org--refile-heading-to) ("Insert link to this heading `C-c l`" . helm-org-insert-link-to-heading-at-marker)))) nil [1931 2435])
			("helm-org-truncate-lines" variable (:default-value t) nil [2437 2553])
			("helm-org-ignore-autosaves" variable nil nil [2555 2706])
			("org-capture-templates" variable nil nil [2742 2772])
			("helm-source-org-capture-templates" function nil nil [2773 3136])
			("helm-org-goto-marker" function (:arguments ("marker")) nil [3162 3360])
			("helm-org--open-heading-in-indirect-buffer" function (:arguments ("marker")) nil [3362 3757])
			("helm-org-run-open-heading-in-indirect-buffer" function (:user-visible-flag t) nil [3759 3984])
			("put" code nil nil [3985 4049])
			("helm-org-headings-map" variable (:default-value (let ((map (make-sparse-keymap))) (set-keymap-parent map helm-map) (define-key map (kbd "C-c i") (quote helm-org-run-open-heading-in-indirect-buffer)) (define-key map (kbd "C-c w") (quote helm-org-run-refile-heading-to)) (define-key map (kbd "C-c l") (quote helm-org-run-insert-link-to-heading-at-marker)) map)) nil [4051 4446])
			("helm-org-headings-class" type
			(:superclasses "helm-source-sync"
			:members
			( ("parents" variable (:default-value "nil") nil nil)
			("match" variable (:default-value "(lambda (candidate) (string-match helm-pattern (helm-aif (get-text-property 0 (quote helm-real-display) candidate) it candidate)))") nil nil)
			("help-message" variable (:default-value "(quote helm-org-headings-help-message)") nil nil)
			("action" variable (:default-value "(quote helm-org-headings-actions)") nil nil)
			("keymap" variable (:default-value "(quote helm-org-headings-map)") nil nil)
			("group" variable (:default-value "(quote helm-org)") nil nil))
			:type "class")
			nil [4448 4985])
			("helm--setup-source" function
			(:parent "helm-org-headings-class"
			:arguments ("source"))
			nil [4987 5317])
			("helm-source-org-headings-for-files" function (:arguments ("filenames" "parents")) nil [5319 5564])
			("helm-org-startup-visibility" function (:arguments ("candidates" "_source")) nil [5566 7954])
			("helm-org-get-candidates" function (:arguments ("filenames" "parents")) nil [7956 8321])
			("helm-org--get-candidates-in-file" function (:arguments ("filename" "fontify" "nofname" "parents")) nil [8323 11553])
			("helm-org-insert-link-to-heading-at-marker" function (:arguments ("marker")) nil [11555 11979])
			("helm-org-run-insert-link-to-heading-at-marker" function nil nil [11981 12158])
			("helm-org--refile-heading-to" function (:arguments ("marker")) nil [12160 13070])
			("helm-org-in-buffer-preselect" function nil nil [13072 13345])
			("helm-org-run-refile-heading-to" function nil nil [13347 13490])
			("put" code nil nil [13491 13541])
			("helm-org-agenda-files-headings" function (:user-visible-flag t) nil [13559 14427])
			("helm-org-in-buffer-headings" function (:user-visible-flag t) nil [14444 14862])
			("helm-org-parent-headings" function (:user-visible-flag t) nil [14879 15399])
			("helm-org-capture-templates" function (:user-visible-flag t) nil [15416 15698])
			("crm-separator" variable nil nil [15862 15884])
			("helm-org-completing-read-tags" function (:arguments ("prompt" "collection" "pred" "req" "initial" "hist" "def" "inherit-input-method" "_name" "_buffer")) nil [15901 17468])
			("helm-org" package nil nil [17470 17489]))
			:file "helm-org.el"
			:pointmax 17629
			:fsize 17628
			:lastmodtime '(23537 22013 0 0)
			:unmatched-syntax '((close-paren 987 . 988) (symbol 948 . 965) (open-paren 947 . 948)))
			(semanticdb-table "semanticdb-table"
			:major-mode emacs-lisp-mode
			:tags
			'( ("helm" include nil nil [817 832])
			("helm-lib" include nil nil [833 852])
			("helm-help" include nil nil [853 873])
			("helm-elisp" include nil nil [874 895])
			("helm-dabbrev" customgroup (:user-visible-flag t) nil [921 1020])
			("helm-dabbrev-always-search-all" variable (:default-value t) nil [1022 1285])
			("helm-dabbrev-candidates-number-limit" variable (:default-value 1000) nil [1287 1615])
			("helm-dabbrev-ignored-buffers-regexps" variable (:default-value (quote ("\\helm" "\\Messages" "\\Echo Area" "\\Buffer List"))) nil [1617 1856])
			("helm-dabbrev-related-buffer-fn" variable (:default-value (function helm-dabbrev--same-major-mode-p)) nil [1858 2340])
			("helm-dabbrev-major-mode-assoc" variable nil nil [2342 3047])
			("helm-dabbrev-lineno-around" variable (:default-value 30) nil [3049 3194])
			("helm-dabbrev-cycle-threshold" variable (:default-value 5) nil [3196 3427])
			("helm-dabbrev-case-fold-search" variable (:default-value (quote smart)) nil [3429 3843])
			("helm-dabbrev-use-thread" variable nil nil [3845 4649])
			("defvaralias" code nil nil [4651 4717])
			("make-obsolete-variable" code nil nil [4718 4827])
			("helm-dabbrev-separator-regexp" variable (:default-value "\\s-\\\| \\\|[(\\[\\{\"'`=<$;,@.#+]\\\|\\s\\\\\|^
			\\\|^") nil [4890 5039])
			("helm-dabbrev-map" variable (:default-value (let ((map (make-sparse-keymap))) (set-keymap-parent map helm-map) (define-key map (kbd "M-/") (quote helm-next-line)) (define-key map (kbd "M-:") (quote helm-previous-line)) map)) nil [5043 5252])
			("helm-dabbrev--cache" variable nil nil [5266 5298])
			("helm-dabbrev--data" variable nil nil [5299 5330])
			("cl-defstruct" code nil nil [5331 5387])
			("helm-dabbrev--already-tried" variable nil nil [5388 5428])
			("helm-dabbrev--current-thread" variable nil nil [5429 5470])
			("helm-dabbrev--buffer-list" function nil nil [5474 5714])
			("helm-dabbrev--same-major-mode-p" function (:arguments ("start-buffer")) nil [5716 5897])
			("helm-dabbrev--collect" function (:arguments ("str" "limit" "ignore-case" "all")) nil [5899 9149])
			("helm-dabbrev--search" function (:arguments ("pattern" "beg" "sep-regexp")) nil [9151 10041])
			("helm-dabbrev--get-candidates" function (:arguments ("dabbrev" "limit")) nil [10043 10396])
			("helm-dabbrev-default-action" function (:arguments ("candidate")) nil [10399 10742])
			("cl-defun" code nil nil [10759 16739])
			("helm-dabbrev" package nil nil [16741 16764]))
			:file "helm-dabbrev.el"
			:pointmax 16908
			:fsize 16907
			:lastmodtime '(23537 22013 0 0)
			:unmatched-syntax nil)
			(semanticdb-table "semanticdb-table"
			:major-mode emacs-lisp-mode
			:tags
			'( ("cl-lib" include nil nil [798 815])
			("helm" include nil nil [816 831])
			("helm-help" include nil nil [832 852])
			("woman-topic-all-completions" variable nil nil [854 890])
			("woman-manpath" variable nil nil [891 913])
			("woman-path" variable nil nil [914 933])
			("woman-expanded-directory-path" variable nil nil [934 972])
			("declare-function" code nil nil [973 1045])
			("declare-function" code nil nil [1046 1115])
			("declare-function" code nil nil [1116 1177])
			("declare-function" code nil nil [1178 1260])
			("declare-function" code nil nil [1261 1325])
			("declare-function" code nil nil [1326 1389])
			("helm-man" customgroup (:user-visible-flag t) nil [1391 1470])
			("helm-man-or-woman-function" variable (:default-value (quote Man-getpage-in-background)) nil [1472 1755])
			("helm-man-format-switches" variable (:default-value (cl-case system-type ((darwin macos) "%s") (t "-l %s"))) nil [1757 2068])
			("helm-man--pages" variable nil nil [2082 2207])
			("helm-man-default-action" function (:arguments ("candidate")) nil [2209 3219])
			("helm-man--init" function nil nil [3221 3659])
			("helm-source-man-pages" variable (:default-value (helm-build-in-buffer-source "Manual Pages" :init (function helm-man--init) :persistent-action (function ignore) :filtered-candidate-transformer (lambda (candidates _source) (sort candidates (function helm-generic-sort-fn))) :action (quote (("Display Man page" . helm-man-default-action))) :group (quote helm-man))) nil [3661 4000])
			("helm-man-woman" function
			(:user-visible-flag t
			:arguments ("arg"))
			nil [4017 4277])
			("helm-man" package nil nil [4279 4298]))
			:file "helm-man.el"
			:pointmax 4438
			:fsize 4437
			:lastmodtime '(23537 22014 0 0)
			:unmatched-syntax nil)
			(semanticdb-table "semanticdb-table"
			:major-mode emacs-lisp-mode
			:tags
			'( ("cl-lib" include nil nil [979 996])
			("semantic" include nil nil [997 1016])
			("helm-help" include nil nil [1017 1037])
			("helm-imenu" include nil nil [1038 1059])
			("declare-function" code nil nil [1061 1148])
			("helm-semantic" customgroup (:user-visible-flag t) nil [1150 1256])
			("helm-semantic-lynx-style-map" variable (:default-value t) nil [1258 1384])
			("helm-semantic-display-style" variable (:default-value (quote ((python-mode . semantic-format-tag-summarize) (c-mode . semantic-format-tag-concise-prototype-c-mode) (emacs-lisp-mode . semantic-format-tag-abbreviate-emacs-lisp-mode)))) nil [1386 2235])
			("helm-semantic-map" variable (:default-value (let ((map (make-sparse-keymap))) (set-keymap-parent map helm-map) (when helm-semantic-lynx-style-map (define-key map (kbd "<left>") (quote helm-maybe-exit-minibuffer)) (define-key map (kbd "<right>") (quote helm-execute-persistent-action))) (delq nil map))) nil [2248 2545])
			("helm-semantic--tags-cache" variable nil nil [2565 2603])
			("helm-semantic--fetch-candidates" function (:arguments ("tags" "depth" "class")) nil [2605 4148])
			("helm-semantic-default-action" function (:arguments ("_candidate" "persistent")) nil [4150 4710])
			("helm-semantic--maybe-set-needs-update" function nil nil [4712 4882])
			("helm-source-semantic" variable nil nil [4884 4917])
			("helm-semantic-source" type
			(:superclasses "helm-source-in-buffer"
			:members
			( ("init" variable (:default-value "(lambda nil (helm-semantic--maybe-set-needs-update) (setq helm-semantic--tags-cache (semantic-fetch-tags)) (with-current-buffer (helm-candidate-buffer (quote global)) (let ((major-mode (with-helm-current-buffer major-mode))) (helm-semantic--fetch-candidates helm-semantic--tags-cache 0))))") nil nil)
			("get-line" variable (:default-value "(quote buffer-substring)") nil nil)
			("persistent-help" variable (:default-value "Show this entry") nil nil)
			("keymap" variable (:default-value "(quote helm-semantic-map)") nil nil)
			("help-message" variable (:default-value "(quote helm-semantic-help-message)") nil nil)
			("persistent-action" variable (:default-value "(lambda (elm) (helm-semantic-default-action elm t) (helm-highlight-current-line))") nil nil)
			("action" variable (:default-value "(quote helm-semantic-default-action)") nil nil))
			:type "class")
			nil [4919 5811])
			("helm-semantic-fuzzy-match" variable nil nil [5813 6163])
			("helm-semantic" function
			(:user-visible-flag t
			:arguments ("arg"))
			nil [6180 7145])
			("helm-semantic-or-imenu" function
			(:user-visible-flag t
			:arguments ("arg"))
			nil [7162 8903])
			("helm-semantic" package nil nil [8905 8929]))
			:file "helm-semantic.el"
			:pointmax 9074
			:fsize 9077
			:lastmodtime '(23537 22013 0 0)
			:unmatched-syntax nil)
			(semanticdb-table "semanticdb-table"
			:major-mode emacs-lisp-mode
			:tags
			'( ("cl-lib" include nil nil [1233 1250])
			("helm" include nil nil [1251 1266])
			("helm-lib" include nil nil [1267 1286])
			("helm-help" include nil nil [1287 1307])
			("helm-elisp" include nil nil [1308 1329])
			("declare-function" code nil nil [1331 1385])
			("declare-function" code nil nil [1386 1475])
			("declare-function" code nil nil [1476 1516])
			("declare-function" code nil nil [1517 1578])
			("declare-function" code nil nil [1579 1649])
			("declare-function" code nil nil [1650 1701])
			("declare-function" code nil nil [1702 1751])
			("eshell-special-chars-outside-quoting" variable nil nil [1752 1797])
			("helm-eshell" customgroup (:user-visible-flag t) nil [1801 1882])
			("helm-eshell-fuzzy-match" variable nil nil [1886 2029])
			("helm-eshell-history-map" variable (:default-value (let ((map (make-sparse-keymap))) (set-keymap-parent map helm-map) (define-key map (kbd "M-p") (quote helm-next-line)) map)) nil [2033 2234])
			("helm-esh-completion-map" variable (:default-value (let ((map (make-sparse-keymap))) (set-keymap-parent map helm-map) (define-key map (kbd "TAB") (quote helm-next-line)) map)) nil [2236 2436])
			("helm-eshell--quit-flag" variable nil nil [2438 2473])
			("helm-esh-source" type
			(:superclasses "helm-source-sync"
			:members
			( ("init" variable (:default-value "(lambda nil (setq pcomplete-current-completions nil pcomplete-last-completion-raw nil) (remove-hook (quote minibuffer-setup-hook) (quote eshell-mode)))") nil nil)
			("candidates" variable (:default-value "(quote helm-esh-get-candidates)") nil nil)
			("persistent-action" variable (:default-value "(quote ignore)") nil nil)
			("nohighlight" variable (:default-value "t") nil nil)
			("filtered-candidate-transformer" variable (:default-value "(lambda (candidates _sources) (cl-loop for i in candidates collect (cond ((string-match \"\\\\`~/?\" helm-ec-target) (abbreviate-file-name i)) ((string-match \"\\\\`/\" helm-ec-target) i) (t (file-relative-name i))) into lst finally return (sort lst (quote helm-generic-sort-fn))))") nil nil)
			("action" variable (:default-value "(quote helm-ec-insert)") nil nil))
			:type "class")
			nil [2477 3547])
			("helm-ec-target" variable nil nil [3562 3588])
			("helm-ec-insert" function (:arguments ("_candidate")) nil [3589 4978])
			("helm-esh-get-candidates" function nil nil [4980 8065])
			("helm-eshell-history-source" type
			(:superclasses "helm-source-sync"
			:members
			( ("init" variable (:default-value "(lambda nil (remove-hook (quote minibuffer-setup-hook) (quote eshell-mode)))") nil nil)
			("candidates" variable (:default-value "(lambda nil (with-helm-current-buffer (cl-loop for c from 0 to (ring-length eshell-history-ring) collect (eshell-get-history c))))") nil nil)
			("nomark" variable (:default-value "t") nil nil)
			("multiline" variable (:default-value "t") nil nil)
			("keymap" variable (:default-value "helm-eshell-history-map") nil nil)
			("candidate-number-limit" variable (:default-value "9999") nil nil)
			("action" variable (:default-value "(lambda (candidate) (eshell-kill-input) (insert candidate))") nil nil))
			:type "class")
			nil [8094 8820])
			("helm-esh-pcomplete" function (:user-visible-flag t) nil [8839 14517])
			("helm-eshell--quit-hook-fn" function nil nil [14519 14589])
			("helm-eshell-history" function (:user-visible-flag t) nil [14606 15340])
			("helm-eshell-prompts-promptidx" variable
			(:default-value (quote ((t (:foreground "cyan"))))
			:type "face")
			nil [15366 15511])
			("helm-eshell-prompts-buffer-name" variable
			(:default-value (quote ((t (:foreground "green"))))
			:type "face")
			nil [15513 15660])
			("helm-eshell-prompts-promptidx-p" variable (:default-value t) nil [15662 15770])
			("helm-eshell-prompts-keymap" variable (:default-value (let ((map (make-sparse-keymap))) (set-keymap-parent map helm-map) (define-key map (kbd "C-c o") (quote helm-eshell-prompts-other-window)) (define-key map (kbd "C-c C-o") (quote helm-eshell-prompts-other-frame)) map)) nil [15772 16071])
			("eshell-prompt-regexp" variable nil nil [16073 16102])
			("eshell-highlight-prompt" variable nil nil [16103 16135])
			("helm-eshell-prompts-list" function (:arguments ("buffer")) nil [16137 17051])
			("helm-eshell-prompts-list-all" function nil nil [17053 17250])
			("helm-eshell-prompts-transformer" function (:arguments ("candidates" "all")) nil [17252 18049])
			("helm-eshell-prompts-all-transformer" function (:arguments ("candidates")) nil [18051 18156])
			("cl-defun" code nil nil [18158 18493])
			("helm-eshell-prompts-goto-other-window" function (:arguments ("candidate")) nil [18495 18622])
			("helm-eshell-prompts-goto-other-frame" function (:arguments ("candidate")) nil [18624 18749])
			("helm-eshell-prompts-other-window" function nil nil [18751 18906])
			("put" code nil nil [18907 18959])
			("helm-eshell-prompts-other-frame" function nil nil [18961 19114])
			("put" code nil nil [19115 19166])
			("helm-eshell-prompts" function (:user-visible-flag t) nil [19183 19703])
			("helm-eshell-prompts-all" function (:user-visible-flag t) nil [19720 20435])
			("helm-eshell" package nil nil [20437 20459]))
			:file "helm-eshell.el"
			:pointmax 20599
			:fsize 20598
			:lastmodtime '(23537 22013 0 0)
			:unmatched-syntax nil)
			(semanticdb-table "semanticdb-table"
			:major-mode emacs-lisp-mode
			:tags
			'( ("cl-lib" include nil nil [799 816])
			("helm" include nil nil [817 832])
			("helm-help" include nil nil [833 853])
			("helm-elisp" include nil nil [854 875])
			("helm-custom-faces-init" function nil nil [902 1342])
			("helm-source-customize-face" variable (:default-value (helm-build-in-buffer-source "Customize Face" :init (quote helm-custom-faces-init) :get-line (quote buffer-substring) :persistent-action (lambda (candidate) (helm-elisp--persistent-help (intern (car (split-string candidate))) (quote helm-describe-face))) :persistent-help "Describe face" :action (quote (("Customize" lambda (line) (customize-face (intern (car (split-string line))))) ("Copy name" lambda (line) (kill-new (car (split-string line " " t)))))))) nil [1344 2030])
			("helm-colors-init" function nil nil [2057 2352])
			("helm-color-insert-name" function (:arguments ("candidate")) nil [2354 2471])
			("helm-color-kill-name" function (:arguments ("candidate")) nil [2473 2559])
			("helm-color-insert-rgb" function (:arguments ("candidate")) nil [2561 2676])
			("helm-color-kill-rgb" function (:arguments ("candidate")) nil [2678 2762])
			("helm-color-run-insert-name" function (:user-visible-flag t) nil [2764 2945])
			("put" code nil nil [2946 2992])
			("helm-color-run-kill-name" function (:user-visible-flag t) nil [2994 3169])
			("put" code nil nil [3170 3214])
			("helm-color-run-insert-rgb" function (:user-visible-flag t) nil [3216 3394])
			("put" code nil nil [3395 3440])
			("helm-color-run-kill-rgb" function (:user-visible-flag t) nil [3442 3614])
			("put" code nil nil [3615 3658])
			("helm-color-map" variable (:default-value (let ((map (make-sparse-keymap))) (set-keymap-parent map helm-map) (define-key map (kbd "C-c n") (quote helm-color-run-insert-name)) (define-key map (kbd "C-c N") (quote helm-color-run-kill-name)) (define-key map (kbd "C-c r") (quote helm-color-run-insert-rgb)) (define-key map (kbd "C-c R") (quote helm-color-run-kill-rgb)) map)) nil [3660 4011])
			("helm-source-colors" variable (:default-value (helm-build-in-buffer-source "Colors" :init (quote helm-colors-init) :get-line (quote buffer-substring) :keymap helm-color-map :persistent-help "Kill entry in RGB format." :persistent-action (quote helm-color-kill-rgb) :help-message (quote helm-colors-help-message) :action (quote (("Copy Name (C-c N)" . helm-color-kill-name) ("Copy RGB (C-c R)" . helm-color-kill-rgb) ("Insert Name (C-c n)" . helm-color-insert-name) ("Insert RGB (C-c r)" . helm-color-insert-rgb))))) nil [4013 4526])
			("helm-colors-get-name" function (:arguments ("candidate")) nil [4528 4821])
			("helm-colors-get-rgb" function (:arguments ("candidate")) nil [4823 5115])
			("helm-colors" function (:user-visible-flag t) nil [5132 5305])
			("helm-color" package nil nil [5307 5328]))
			:file "helm-color.el"
			:pointmax 5470
			:fsize 5469
			:lastmodtime '(23537 22013 0 0)
			:unmatched-syntax nil)
			(semanticdb-table "semanticdb-table"
			:major-mode emacs-lisp-mode
			:tags
			'( ("cl-lib" include nil nil [816 833])
			("helm" include nil nil [834 849])
			("helm-help" include nil nil [850 870])
			("helm-utils" include nil nil [871 892])
			("helm-sys" customgroup (:user-visible-flag t) nil [896 967])
			("helm-top-columns" variable
			(:default-value (quote ((t :inherit helm-header)))
			:type "face")
			nil [969 1091])
			("helm-top-command" variable (:default-value (cl-case system-type (darwin "env COLUMNS=%s ps -axo pid,user,pri,nice,ucomm,tty,start_time,vsz,%%cpu,%%mem,etime,command") (t "env COLUMNS=%s top -b -n 1"))) nil [1095 2244])
			("helm-top-sort-columns-alist" variable (:default-value (quote ((com . 11) (mem . 9) (cpu . 8) (user . 1)))) nil [2246 2810])
			("helm-top-poll-delay" variable (:default-value 1.5) nil [2812 3030])
			("helm-top-poll-delay-post-command" variable (:default-value 1.0) nil [3032 3238])
			("helm-top-poll-preselection" variable (:default-value (quote linum)) nil [3240 3644])
			("helm-top-sort-fn" variable nil nil [3671 3700])
			("helm-top-map" variable (:default-value (let ((map (make-sparse-keymap))) (set-keymap-parent map helm-map) (define-key map (kbd "M-P") (quote helm-top-run-sort-by-cpu)) (define-key map (kbd "M-C") (quote helm-top-run-sort-by-com)) (define-key map (kbd "M-M") (quote helm-top-run-sort-by-mem)) (define-key map (kbd "M-U") (quote helm-top-run-sort-by-user)) map)) nil [3701 4049])
			("helm-top-after-init-hook" variable nil nil [4051 4117])
			("helm-top--poll-timer" variable nil nil [4119 4152])
			("helm-top-poll" function (:arguments ("no-update" "delay")) nil [4154 5277])
			("helm-top--poll-delay" function nil nil [5279 5342])
			("helm-top-poll-no-update" function nil nil [5344 5480])
			("helm-top-initialize-poll-hooks" function nil nil [5482 6017])
			("define-minor-mode" code nil nil [6034 6497])
			("helm-source-top" variable (:default-value (helm-build-in-buffer-source "Top" :header-name (lambda (name) (concat name (if helm-top-poll-mode " (auto updating)" " (Press C-c C-u to refresh)"))) :init (function helm-top-init) :after-init-hook (quote helm-top-after-init-hook) :cleanup (lambda nil (when helm-top--poll-timer (cancel-timer helm-top--poll-timer)) (remove-hook (quote post-command-hook) (quote helm-top-poll-no-update)) (remove-hook (quote focus-in-hook) (quote helm-top-poll-no-update))) :display-to-real (function helm-top-display-to-real) :persistent-action (quote (helm-top-sh-persistent-action . never-split)) :persistent-help "SIGTERM" :help-message (quote helm-top-help-message) :mode-line (quote helm-top-mode-line) :follow (quote never) :keymap helm-top-map :filtered-candidate-transformer (function helm-top-sort-transformer) :action-transformer (function helm-top-action-transformer) :group (quote helm-sys))) nil [6499 7516])
			("helm-top--line" variable nil nil [7518 7545])
			("helm-top-transformer" function (:arguments ("candidates" "_source")) nil [7546 8064])
			("helm-top--skip-top-line" function nil nil [8066 8394])
			("helm-top-action-transformer" function (:arguments ("actions" "_candidate")) nil [8396 9962])
			("helm-top--marked-pids" function nil nil [9964 10065])
			("helm-top-sh" function (:arguments ("sig" "pids")) nil [10067 10353])
			("helm-top-sh-persistent-action" function (:arguments ("pid")) nil [10355 10466])
			("helm-top-init" function nil nil [10468 10795])
			("helm-top-display-to-real" function (:arguments ("line")) nil [10797 10895])
			("helm-top-set-mode-line" function (:arguments ("str")) nil [10918 11183])
			("helm-top-sort-transformer" function (:arguments ("candidates" "source")) nil [11185 11642])
			("helm-top-sort-by-com" function (:arguments ("s1" "s2")) nil [11644 11913])
			("helm-top-sort-by-mem" function (:arguments ("s1" "s2")) nil [11915 12216])
			("helm-top-sort-by-cpu" function (:arguments ("s1" "s2")) nil [12218 12519])
			("helm-top-sort-by-user" function (:arguments ("s1" "s2")) nil [12521 12796])
			("helm-top--preselect-fn" function nil nil [12798 13094])
			("helm-top-run-sort-by-com" function nil nil [13096 13269])
			("helm-top-run-sort-by-cpu" function nil nil [13271 13552])
			("helm-top-run-sort-by-mem" function nil nil [13554 13727])
			("helm-top-run-sort-by-user" function nil nil [13729 13905])
			("helm-xrandr-info" function nil nil [13985 14508])
			("helm-xrandr-screen" function nil nil [14510 14602])
			("helm-xrandr-output" function nil nil [14604 14696])
			("helm-source-xrandr-change-resolution" variable (:default-value (helm-build-sync-source "Change Resolution" :candidates (lambda nil (with-temp-buffer (call-process "xrandr" nil (current-buffer) nil "--screen" (helm-xrandr-screen) "-q") (goto-char 1) (cl-loop while (re-search-forward " \$[0-9]+x[0-9]+\$" nil t) for mode = (match-string 1) unless (member mode modes) collect mode into modes finally return modes))) :action (helm-make-actions "Change Resolution" (lambda (mode) (call-process "xrandr" nil nil nil "--screen" (helm-xrandr-screen) "--output" (helm-xrandr-output) "--mode" mode))))) nil [14698 15579])
			("helm-source-emacs-process" variable (:default-value (helm-build-sync-source "Emacs Process" :init (lambda nil (let (tabulated-list-use-header-line) (list-processes--refresh))) :candidates (lambda nil (mapcar (function process-name) (process-list))) :persistent-action (lambda (elm) (delete-process (get-process elm)) (helm-delete-current-selection)) :persistent-help "Kill Process" :action (helm-make-actions "Kill Process" (lambda (_elm) (cl-loop for p in (helm-marked-candidates) do (delete-process (get-process p))))))) nil [15607 16304])
			("helm-top" function (:user-visible-flag t) nil [16323 16872])
			("helm-list-emacs-process" function (:user-visible-flag t) nil [16889 17049])
			("helm-xrandr-set" function (:user-visible-flag t) nil [17066 17231])
			("helm-sys" package nil nil [17233 17252]))
			:file "helm-sys.el"
			:pointmax 17392
			:fsize 17391
			:lastmodtime '(23537 22013 0 0)
			:unmatched-syntax nil)
			(semanticdb-table "semanticdb-table"
			:major-mode emacs-lisp-mode
			:tags
			'( ("helm-grep" include nil nil [815 835])
			("helm-help" include nil nil [836 856])
			("helm-id-utils" customgroup (:user-visible-flag t) nil [858 959])
			("helm-gid-program" variable (:default-value "gid") nil [961 1317])
			("helm-gid-db-file-name" variable (:default-value "ID") nil [1319 1468])
			("helm-gid-candidates-process" function nil nil [1470 3099])
			("helm-gid-filtered-candidate-transformer" function (:arguments ("candidates" "_source")) nil [3101 3338])
			("helm-gid-source" type
			(:superclasses "helm-source-async"
			:members
			( ("header-name" variable (:default-value "(lambda (name) (concat name \" [\" (helm-attr (quote db-dir)) \"]\"))") nil nil)
			("db-dir" variable
			(:documentation " Location of ID file."
			:default-value "nil")
			nil nil)
			("candidates-process" variable (:default-value "(function helm-gid-candidates-process)") nil nil)
			("filtered-candidate-transformer" variable (:default-value "(function helm-gid-filtered-candidate-transformer)") nil nil)
			("candidate-number-limit" variable (:default-value "99999") nil nil)
			("action" variable (:default-value "(helm-make-actions \"Find File\" (quote helm-grep-action) \"Find file other frame\" (quote helm-grep-other-frame) \"Save results in grep buffer\" (quote helm-grep-save-results) \"Find file other window\" (quote helm-grep-other-window))") nil nil)
			("persistent-action" variable (:default-value "(quote helm-grep-persistent-action)") nil nil)
			("history" variable (:default-value "(quote helm-grep-history)") nil nil)
			("nohighlight" variable (:default-value "t") nil nil)
			("help-message" variable (:default-value "(quote helm-grep-help-message)") nil nil)
			("requires-pattern" variable (:default-value "2") nil nil))
			:type "class")
			nil [3340 4346])
			("helm-gid" function (:user-visible-flag t) nil [4363 5154])
			("helm-id-utils" package nil nil [5156 5180]))
			:file "helm-id-utils.el"
			:pointmax 5322
			:fsize 5321
			:lastmodtime '(23537 22013 0 0)
			:unmatched-syntax nil)
			(semanticdb-table "semanticdb-table"
			:major-mode emacs-lisp-mode
			:tags
			'( ("helm-files" include nil nil [815 836])
			("helm-external" include nil nil [837 861])
			("helm-findutils-skip-boring-files" variable (:default-value t) nil [863 997])
			("helm-findutils-search-full-path" variable nil nil [999 1213])
			("helm-find-map" variable (:default-value (let ((map (make-sparse-keymap))) (set-keymap-parent map helm-generic-files-map) (define-key map (kbd "DEL") (quote helm-delete-backward-no-update)) map)) nil [1215 1398])
			("helm-source-findutils" variable (:default-value (helm-build-async-source "Find" :header-name (lambda (name) (concat name " in [" (helm-default-directory) "]")) :candidates-process (quote helm-find-shell-command-fn) :filtered-candidate-transformer (quote helm-findutils-transformer) :action-transformer (quote helm-transform-file-load-el) :persistent-action (quote helm-ff-kill-or-find-buffer-fname) :action (quote helm-type-file-actions) :help-message (quote helm-generic-file-help-message) :keymap helm-find-map :candidate-number-limit 9999 :requires-pattern 3)) nil [1400 1964])
			("helm-findutils-transformer" function (:arguments ("candidates" "_source")) nil [1966 2969])
			("helm-find--build-cmd-line" function nil nil [2971 4530])
			("helm-find-shell-command-fn" function nil nil [4532 5892])
			("helm-find-1" function (:arguments ("dir")) nil [5894 6162])
			("helm-find" function
			(:user-visible-flag t
			:arguments ("arg"))
			nil [6214 7127])
			("helm-find" package nil nil [7129 7149]))
			:file "helm-find.el"
			:pointmax 7290
			:fsize 7289
			:lastmodtime '(23537 22013 0 0)
			:unmatched-syntax nil))
			:file "!drive_c!Users!joelg!.emacs.d!elpa!helm-20181117.731!semantic.cache"
			:semantic-tag-version "2.0"
			:semanticdb-version "2.2")