diff --git a/.emacs.d/one-file-mode/bind-key.el b/.emacs.d/one-file-mode/bind-key.el
new file mode 100644
index 0000000..995e481
--- /dev/null
+++ b/.emacs.d/one-file-mode/bind-key.el
@@ -0,0 +1,413 @@
+;;; bind-key.el --- A simple way to manage personal keybindings
+
+;; Copyright (c) 2012-2015 john wiegley
+
+;; Author: John Wiegley <jwiegley@gmail.com>
+;; Maintainer: John Wiegley <jwiegley@gmail.com>
+;; Created: 16 Jun 2012
+;; Version: 1.0
+;; Keywords: keys keybinding config dotemacs
+;; URL: https://github.com/jwiegley/use-package
+
+;; This program is free software; you can redistribute it and/or
+;; modify it under the terms of the gnu general public license as
+;; published by the free software foundation; either version 2, or (at
+;; your option) any later version.
+
+;; This program is distributed in the hope that it will be useful, but
+;; without any warranty; without even the implied warranty of
+;; merchantability or fitness for a particular purpose.  see the gnu
+;; general public license for more details.
+
+;; You should have received a copy of the gnu general public license
+;; along with gnu emacs; see the file copying.  if not, write to the
+;; free software foundation, inc., 59 temple place - suite 330,
+;; boston, ma 02111-1307, usa.
+
+;;; Commentary:
+
+;; If you have lots of keybindings set in your .emacs file, it can be hard to
+;; know which ones you haven't set yet, and which may now be overriding some
+;; new default in a new emacs version.  This module aims to solve that
+;; problem.
+;;
+;; Bind keys as follows in your .emacs:
+;;
+;;   (require 'bind-key)
+;;
+;;   (bind-key "C-c x" 'my-ctrl-c-x-command)
+;;
+;; If you want the keybinding to override all minor modes that may also bind
+;; the same key, use the `bind-key*' form:
+;;
+;;   (bind-key* "<C-return>" 'other-window)
+;;
+;; If you want to rebind a key only in a particular keymap, use:
+;;
+;;   (bind-key "C-c x" 'my-ctrl-c-x-command some-other-mode-map)
+;;
+;; To unbind a key within a keymap (for example, to stop your favorite major
+;; mode from changing a binding that you don't want to override everywhere),
+;; use `unbind-key':
+;;
+;;   (unbind-key "C-c x" some-other-mode-map)
+;;
+;; To bind multiple keys at once, or set up a prefix map, a `bind-keys' macro
+;; is provided.  It accepts keyword arguments, please see its documentation
+;; for a detailed description.
+;;
+;; To add keys into a specific map, use :map argument
+;;
+;;    (bind-keys :map dired-mode-map
+;;               ("o" . dired-omit-mode)
+;;               ("a" . some-custom-dired-function))
+;;
+;; To set up a prefix map, use `:prefix-map' and `:prefix' arguments (both are
+;; required)
+;;
+;;    (bind-keys :prefix-map my-customize-prefix-map
+;;               :prefix "C-c c"
+;;               ("f" . customize-face)
+;;               ("v" . customize-variable))
+;;
+;; You can combine all the keywords together.  Additionally,
+;; `:prefix-docstring' can be specified to set documentation of created
+;; `:prefix-map' variable.
+;;
+;; To bind multiple keys in a `bind-key*' way (to be sure that your bindings
+;; will not be overridden by other modes), you may use `bind-keys*' macro:
+;;
+;;    (bind-keys*
+;;     ("C-o" . other-window)
+;;     ("C-M-n" . forward-page)
+;;     ("C-M-p" . backward-page))
+;;
+;; After Emacs loads, you can see a summary of all your personal keybindings
+;; currently in effect with this command:
+;;
+;;   M-x describe-personal-keybindings
+;;
+;; This display will tell you if you've overriden a default keybinding, and
+;; what the default was.  Also, it will tell you if the key was rebound after
+;; your binding it with `bind-key', and what it was rebound it to.
+
+(require 'cl-lib)
+(require 'easy-mmode)
+
+(defgroup bind-key nil
+  "A simple way to manage personal keybindings"
+  :group 'emacs)
+
+(defcustom bind-key-column-widths '(18 . 40)
+  "Width of columns in `describe-personal-keybindings'."
+  :type '(cons integer integer)
+  :group 'bind-key)
+
+(defcustom bind-key-segregation-regexp
+  "\\`\\(\\(C-[chx] \\|M-[gso] \\)\\([CM]-\\)?\\|.+-\\)"
+  "Regular expression used to divide key sets in the output from
+\\[describe-personal-keybindings]."
+  :type 'regexp
+  :group 'bind-key)
+
+(defcustom bind-key-describe-special-forms nil
+  "If non-nil, extract docstrings from lambdas, closures and keymaps if possible."
+  :type 'boolean
+  :group 'bind-key)
+
+;; Create override-global-mode to force key remappings
+
+(defvar override-global-map (make-keymap)
+  "override-global-mode keymap")
+
+(define-minor-mode override-global-mode
+  "A minor mode so that keymap settings override other modes."
+  t "")
+
+;; the keymaps in `emulation-mode-map-alists' take precedence over
+;; `minor-mode-map-alist'
+(add-to-list 'emulation-mode-map-alists
+             `((override-global-mode . ,override-global-map)))
+
+(defvar personal-keybindings nil
+  "List of bindings performed by `bind-key'.
+
+Elements have the form ((KEY . [MAP]) CMD ORIGINAL-CMD)")
+
+;;;###autoload
+(defmacro bind-key (key-name command &optional keymap predicate)
+  "Bind KEY-NAME to COMMAND in KEYMAP (`global-map' if not passed).
+
+KEY-NAME may be a vector, in which case it is passed straight to
+`define-key'. Or it may be a string to be interpreted as
+spelled-out keystrokes, e.g., \"C-c C-z\". See documentation of
+`edmacro-mode' for details.
+
+If PREDICATE is non-nil, it is a form evaluated to determine when
+a key should be bound. It must return non-nil in such cases.
+Emacs can evaluate this form at any time that it does redisplay
+or operates on menu data structures, so you should write it so it
+can safely be called at any time."
+  (let ((namevar (make-symbol "name"))
+        (keyvar (make-symbol "key"))
+        (kdescvar (make-symbol "kdesc"))
+        (bindingvar (make-symbol "binding")))
+    `(let* ((,namevar ,key-name)
+            (,keyvar (if (vectorp ,namevar) ,namevar
+                       (read-kbd-macro ,namevar)))
+            (,kdescvar (cons (if (stringp ,namevar) ,namevar
+                               (key-description ,namevar))
+                             (quote ,keymap)))
+            (,bindingvar (lookup-key (or ,keymap global-map) ,keyvar)))
+       (add-to-list 'personal-keybindings
+                    (list ,kdescvar ,command
+                          (unless (numberp ,bindingvar) ,bindingvar)))
+       ,(if predicate
+            `(define-key (or ,keymap global-map) ,keyvar
+               '(menu-item "" nil :filter (lambda (&optional _)
+                                            (when ,predicate
+                                              ,command))))
+          `(define-key (or ,keymap global-map) ,keyvar ,command)))))
+
+;;;###autoload
+(defmacro unbind-key (key-name &optional keymap)
+  "Unbind the given KEY-NAME, within the KEYMAP (if specified).
+See `bind-key' for more details."
+  `(progn
+     (bind-key ,key-name nil ,keymap)
+     (setq personal-keybindings
+           (cl-delete-if #'(lambda (k)
+                             ,(if keymap
+                                  `(and (consp (car k))
+                                        (string= (caar k) ,key-name)
+                                        (eq (cdar k) ',keymap))
+                                `(and (stringp (car k))
+                                      (string= (car k) ,key-name))))
+                         personal-keybindings))))
+
+;;;###autoload
+(defmacro bind-key* (key-name command &optional predicate)
+  "Similar to `bind-key', but overrides any mode-specific bindings."
+  `(bind-key ,key-name ,command override-global-map ,predicate))
+
+(defun bind-keys-form (args)
+  "Bind multiple keys at once.
+
+Accepts keyword arguments:
+:map MAP               - a keymap into which the keybindings should be
+                         added
+:prefix KEY            - prefix key for these bindings
+:prefix-map MAP        - name of the prefix map that should be created
+                         for these bindings
+:prefix-docstring STR  - docstring for the prefix-map variable
+:menu-name NAME        - optional menu string for prefix map
+:filter FORM           - optional form to determine when bindings apply
+
+The rest of the arguments are conses of keybinding string and a
+function symbol (unquoted)."
+  ;; jww (2016-02-26): This is a hack; this whole function needs to be
+  ;; rewritten to normalize arguments the way that use-package.el does.
+  (if (and (eq (car args) :package)
+           (not (eq (car (cdr (cdr args))) :map)))
+      (setq args (cons :map (cons 'global-map args))))
+  (let* ((map (plist-get args :map))
+         (doc (plist-get args :prefix-docstring))
+         (prefix-map (plist-get args :prefix-map))
+         (prefix (plist-get args :prefix))
+         (filter (plist-get args :filter))
+         (menu-name (plist-get args :menu-name))
+         (pkg (plist-get args :package))
+         (key-bindings (progn
+                         (while (keywordp (car args))
+                           (pop args)
+                           (pop args))
+                         args)))
+    (when (or (and prefix-map (not prefix))
+              (and prefix (not prefix-map)))
+      (error "Both :prefix-map and :prefix must be supplied"))
+    (when (and menu-name (not prefix))
+      (error "If :menu-name is supplied, :prefix must be too"))
+    (let ((args key-bindings)
+          saw-map first next)
+      (while args
+        (if (keywordp (car args))
+            (progn
+              (setq next args)
+              (setq args nil))
+          (if first
+              (nconc first (list (car args)))
+            (setq first (list (car args))))
+          (setq args (cdr args))))
+      (cl-flet
+          ((wrap (map bindings)
+                 (if (and map pkg (not (eq map 'global-map)))
+                     (if (boundp map)
+                         bindings
+                       `((eval-after-load
+                             ,(if (symbolp pkg) `',pkg pkg)
+                           '(progn ,@bindings))))
+                   bindings)))
+        (append
+         (when prefix-map
+           `((defvar ,prefix-map)
+             ,@(when doc `((put ',prefix-map 'variable-documentation ,doc)))
+             ,@(if menu-name
+                   `((define-prefix-command ',prefix-map nil ,menu-name))
+                 `((define-prefix-command ',prefix-map)))
+             ,@(if (and map (not (eq map 'global-map)))
+                   (wrap map `((bind-key ,prefix ',prefix-map ,map ,filter)))
+                 `((bind-key ,prefix ',prefix-map nil ,filter)))))
+         (wrap map
+               (cl-mapcan
+                (lambda (form)
+                  (if prefix-map
+                      `((bind-key ,(car form) ',(cdr form) ,prefix-map ,filter))
+                    (if (and map (not (eq map 'global-map)))
+                        `((bind-key ,(car form) ',(cdr form) ,map ,filter))
+                      `((bind-key ,(car form) ',(cdr form) nil ,filter)))))
+                first))
+         (when next
+           (bind-keys-form
+            (if pkg
+                (cons :package (cons pkg next))
+              next))))))))
+
+;;;###autoload
+(defmacro bind-keys (&rest args)
+  "Bind multiple keys at once.
+
+Accepts keyword arguments:
+:map MAP               - a keymap into which the keybindings should be
+                         added
+:prefix KEY            - prefix key for these bindings
+:prefix-map MAP        - name of the prefix map that should be created
+                         for these bindings
+:prefix-docstring STR  - docstring for the prefix-map variable
+:menu-name NAME        - optional menu string for prefix map
+:filter FORM           - optional form to determine when bindings apply
+
+The rest of the arguments are conses of keybinding string and a
+function symbol (unquoted)."
+  (macroexp-progn (bind-keys-form args)))
+
+;;;###autoload
+(defmacro bind-keys* (&rest args)
+  (macroexp-progn
+   (bind-keys-form `(:map override-global-map ,@args))))
+
+(defun get-binding-description (elem)
+  (cond
+   ((listp elem)
+    (cond
+     ((eq 'lambda (car elem))
+      (if (and bind-key-describe-special-forms
+               (stringp (nth 2 elem)))
+          (nth 2 elem)
+        "#<lambda>"))
+     ((eq 'closure (car elem))
+      (if (and bind-key-describe-special-forms
+               (stringp (nth 3 elem)))
+          (nth 3 elem)
+        "#<closure>"))
+     ((eq 'keymap (car elem))
+      "#<keymap>")
+     (t
+      elem)))
+   ;; must be a symbol, non-symbol keymap case covered above
+   ((and bind-key-describe-special-forms (keymapp elem))
+    (let ((doc (get elem 'variable-documentation)))
+      (if (stringp doc) doc elem)))
+   ((symbolp elem)
+    elem)
+   (t
+    "#<byte-compiled lambda>")))
+
+(defun compare-keybindings (l r)
+  (let* ((regex bind-key-segregation-regexp)
+         (lgroup (and (string-match regex (caar l))
+                      (match-string 0 (caar l))))
+         (rgroup (and (string-match regex (caar r))
+                      (match-string 0 (caar r))))
+         (lkeymap (cdar l))
+         (rkeymap (cdar r)))
+    (cond
+     ((and (null lkeymap) rkeymap)
+      (cons t t))
+     ((and lkeymap (null rkeymap))
+      (cons nil t))
+     ((and lkeymap rkeymap
+           (not (string= (symbol-name lkeymap) (symbol-name rkeymap))))
+      (cons (string< (symbol-name lkeymap) (symbol-name rkeymap)) t))
+     ((and (null lgroup) rgroup)
+      (cons t t))
+     ((and lgroup (null rgroup))
+      (cons nil t))
+     ((and lgroup rgroup)
+      (if (string= lgroup rgroup)
+          (cons (string< (caar l) (caar r)) nil)
+        (cons (string< lgroup rgroup) t)))
+     (t
+      (cons (string< (caar l) (caar r)) nil)))))
+
+;;;###autoload
+(defun describe-personal-keybindings ()
+  "Display all the personal keybindings defined by `bind-key'."
+  (interactive)
+  (with-output-to-temp-buffer "*Personal Keybindings*"
+    (princ (format (concat "Key name%s Command%s Comments\n%s %s "
+                           "---------------------\n")
+                   (make-string (- (car bind-key-column-widths) 9) ? )
+                   (make-string (- (cdr bind-key-column-widths) 8) ? )
+                   (make-string (1- (car bind-key-column-widths)) ?-)
+                   (make-string (1- (cdr bind-key-column-widths)) ?-)))
+    (let (last-binding)
+      (dolist (binding
+               (setq personal-keybindings
+                     (sort personal-keybindings
+                           (lambda (l r)
+                             (car (compare-keybindings l r))))))
+
+        (if (not (eq (cdar last-binding) (cdar binding)))
+            (princ (format "\n\n%s\n%s\n\n"
+                           (cdar binding)
+                           (make-string (+ 21 (car bind-key-column-widths)
+                                           (cdr bind-key-column-widths)) ?-)))
+          (if (and last-binding
+                   (cdr (compare-keybindings last-binding binding)))
+              (princ "\n")))
+
+        (let* ((key-name (caar binding))
+               (at-present (lookup-key (or (symbol-value (cdar binding))
+                                           (current-global-map))
+                                       (read-kbd-macro key-name)))
+               (command (nth 1 binding))
+               (was-command (nth 2 binding))
+               (command-desc (get-binding-description command))
+               (was-command-desc (and was-command
+                                      (get-binding-description was-command)))
+               (at-present-desc (get-binding-description at-present))
+               )
+          (let ((line
+                 (format
+                  (format "%%-%ds%%-%ds%%s\n" (car bind-key-column-widths)
+                          (cdr bind-key-column-widths))
+                  key-name (format "`%s\'" command-desc)
+                  (if (string= command-desc at-present-desc)
+                      (if (or (null was-command)
+                              (string= command-desc was-command-desc))
+                          ""
+                        (format "was `%s\'" was-command-desc))
+                    (format "[now: `%s\']" at-present)))))
+            (princ (if (string-match "[ \t]+\n" line)
+                       (replace-match "\n" t t line)
+                     line))))
+
+        (setq last-binding binding)))))
+
+(provide 'bind-key)
+
+;; Local Variables:
+;; indent-tabs-mode: nil
+;; End:
+
+;;; bind-key.el ends here
diff --git a/.emacs.d/one-file-mode/c++1x-minor-mode.el b/.emacs.d/one-file-mode/c++1x-minor-mode.el
new file mode 100644
index 0000000..114b831
--- /dev/null
+++ b/.emacs.d/one-file-mode/c++1x-minor-mode.el
@@ -0,0 +1,56 @@
+(require 'font-lock)
+;;###autoload
+(define-minor-mode c++1x-minor-mode
+  "Extra highlighting for c++-mode that includes c++11 and c++14 keywords and features"
+  :lighter "c++1x"
+
+  (defun --copy-face (new-face face)
+    "Define NEW-FACE from existing FACE."
+    (copy-face face new-face)
+    (eval `(defvar ,new-face nil))
+    (set new-face new-face))
+
+  (--copy-face 'font-lock-label-face  ; labels, case, public, private, proteced, namespace-tags
+	       'font-lock-keyword-face)
+  (--copy-face 'font-lock-doc-markup-face ; comment markups such as Javadoc-tags
+	       'font-lock-doc-face)
+  (--copy-face 'font-lock-doc-string-face ; comment markups
+	       'font-lock-comment-face)
+
+  (global-font-lock-mode t)
+  (setq font-lock-maximum-decoration t)
+
+
+  (font-lock-add-keywords
+   nil '(;; complete some fundamental keywords
+	 ("\\<\\(void\\|unsigned\\|signed\\|char\\|short\\|bool\\|int\\|long\\|float\\|double\\)\\>" . font-lock-keyword-face)
+	 ;; add the new C++11 keywords
+	 ("\\<\\(alignof\\|alignas\\|constexpr\\|noexcept\\|\\|static_assert\\|thread_local\\|override\\|final\\)\\>" . font-lock-keyword-face)
+	 ("\\<\\(decltype\\)\\>" . font-lock-builtin-face)
+	 ("\\<\\(nullptr\\)\\>" . font-lock-constant-face)
+	 ("\\<\\(char[0-9]+_t\\)\\>" . font-lock-keyword-face)
+	 ;; PREPROCESSOR_CONSTANT
+	 ("\\<[A-Z]+[A-Z_]+\\>" . font-lock-constant-face)
+	 ;; hexadecimal numbers
+	 ("\\<0[xX][0-9A-Fa-f]+\\>" . font-lock-constant-face)
+	 ;; integer/float/scientific numbers
+	 ("\\<[\\-+]*[0-9]*\\.?[0-9]+\\([ulUL]+\\|[eE][\\-+]?[0-9]+\\)?\\>" . font-lock-constant-face)
+	 ;; c++11 string literals
+	 ;;       L"wide string"
+	 ;;       L"wide string with UNICODE codepoint: \u2018"
+	 ;;       u8"UTF-8 string", u"UTF-16 string", U"UTF-32 string"
+	 ("\\<\\([LuU8]+\\)\".*?\"" 1 font-lock-keyword-face)
+	 ;;       R"(user-defined literal)"
+	 ;;       R"( a "quot'd" string )"
+	 ;;       R"delimiter(The String Data" )delimiter"
+	 ;;       R"delimiter((a-z))delimiter" is equivalent to "(a-z)"
+	 ("\\(\\<[uU8]*R\"[^\\s-\\\\()]\\{0,16\\}(\\)" 1 font-lock-keyword-face t) ; start delimiter
+	 (   "\\<[uU8]*R\"[^\\s-\\\\()]\\{0,16\\}(\\(.*?\\))[^\\s-\\\\()]\\{0,16\\}\"" 1 font-lock-string-face t)  ; actual string
+	 (   "\\<[uU8]*R\"[^\\s-\\\\()]\\{0,16\\}(.*?\\()[^\\s-\\\\()]\\{0,16\\}\"\\)" 1 font-lock-keyword-face t) ; end delimiter
+	 
+	 )))
+
+;;###autoload
+(add-hook 'c++-mode-hook 'c++1x-minor-mode)
+
+(provide 'c++1x-minor-mode)
diff --git a/.emacs.d/one-file-mode/use-package.el b/.emacs.d/one-file-mode/use-package.el
new file mode 100644
index 0000000..9437c21
--- /dev/null
+++ b/.emacs.d/one-file-mode/use-package.el
@@ -0,0 +1,1169 @@
+;;; use-package.el --- A use-package declaration for simplifying your .emacs
+
+;; Copyright (C) 2012 John Wiegley
+
+;; Author: John Wiegley <jwiegley@gmail.com>
+;; Maintainer: John Wiegley <jwiegley@gmail.com>
+;; Created: 17 Jun 2012
+;; Modified: 26 Sep 2015
+;; Version: 2.1
+;; Package-Requires: ((bind-key "1.0") (diminish "0.44"))
+;; Keywords: dotemacs startup speed config package
+;; URL: https://github.com/jwiegley/use-package
+
+;; This program is free software; you can redistribute it and/or
+;; modify it under the terms of the GNU General Public License as
+;; published by the Free Software Foundation; either version 2, or (at
+;; your option) any later version.
+
+;; This program is distributed in the hope that it will be useful, but
+;; WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+;; General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs; see the file COPYING.  If not, write to the
+;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+;; Boston, MA 02111-1307, USA.
+
+;;; Commentary:
+
+;; The `use-package' declaration macro allows you to isolate package
+;; configuration in your ".emacs" in a way that is performance-oriented and,
+;; well, just tidy.  I created it because I have over 80 packages that I use
+;; in Emacs, and things were getting difficult to manage.  Yet with this
+;; utility my total load time is just under 1 second, with no loss of
+;; functionality!
+;;
+;; Please see README.md from the same repository for documentation.
+
+;;; Code:
+
+(require 'bind-key)
+(require 'bytecomp)
+(require 'diminish nil t)
+(require 'bytecomp)
+(eval-when-compile (require 'cl))
+
+(declare-function package-installed-p 'package)
+
+(defgroup use-package nil
+  "A use-package declaration for simplifying your `.emacs'."
+  :group 'startup)
+
+(defcustom use-package-verbose nil
+  "Whether to report about loading and configuration details.
+
+If you customize this, then you should require the `use-package'
+feature in files that use `use-package', even if these files only
+contain compiled expansions of the macros.  If you don't do so,
+then the expanded macros do their job silently."
+  :type '(choice (const :tag "Quiet" nil) (const :tag "Verbose" t)
+                 (const :tag "Debug" debug))
+  :group 'use-package)
+
+(defcustom use-package-debug nil
+  "Whether to display use-package expansions in a *use-package* buffer."
+  :type 'boolean
+  :group 'use-package)
+
+(defcustom use-package-check-before-init nil
+  "If non-nil, check that package exists before executing its `:init' block.
+The check is performed by looking for the module using `locate-library'."
+  :type 'boolean
+  :group 'use-package)
+
+(defcustom use-package-always-defer nil
+  "If non-nil, assume `:defer t` unless `:demand t` is given."
+  :type 'boolean
+  :group 'use-package)
+
+(defcustom use-package-always-ensure nil
+  "Treat every package as though it had specified `:ensure SEXP`."
+  :type 'sexp
+  :group 'use-package)
+
+(defcustom use-package-always-pin nil
+  "Treat every package as though it had specified `:pin SYM."
+  :type 'symbol
+  :group 'use-package)
+
+(defcustom use-package-minimum-reported-time 0.1
+  "Minimal load time that will be reported.
+
+Note that `use-package-verbose' has to be set to t, for anything
+to be reported at all.
+
+If you customize this, then you should require the `use-package'
+feature in files that use `use-package', even if these files only
+contain compiled expansions of the macros.  If you don't do so,
+then the expanded macros do their job silently."
+  :type 'number
+  :group 'use-package)
+
+(defcustom use-package-inject-hooks nil
+  "If non-nil, add hooks to the `:init' and `:config' sections.
+In particular, for a given package `foo', the following hooks
+become available:
+
+  `use-package--foo--pre-init-hook'
+  `use-package--foo--post-init-hook'
+  `use-package--foo--pre-config-hook'
+  `use-package--foo--post-config-hook'
+
+This way, you can add to these hooks before evalaution of a
+`use-package` declaration, and exercise some control over what
+happens.
+
+Note that if either `pre-init' hooks returns a nil value, that
+block's user-supplied configuration is not evaluated, so be
+certain to return `t' if you only wish to add behavior to what
+the user specified."
+  :type 'boolean
+  :group 'use-package)
+
+(defcustom use-package-keywords
+  '(:disabled
+    :pin
+    :ensure
+    :if
+    :when
+    :unless
+    :requires
+    :load-path
+    :preface
+    :no-require
+    :bind
+    :bind*
+    :bind-keymap
+    :bind-keymap*
+    :interpreter
+    :mode
+    :commands
+    :defines
+    :functions
+    :defer
+    :after
+    :demand
+    :init
+    :config
+    :diminish
+    :delight)
+  "Establish which keywords are valid, and the order they are processed in.
+
+Note that `:disabled' is special, in that it causes nothing at all to happen,
+even if the rest of the use-package declaration is incorrect."
+  :type '(repeat symbol)
+  :group 'use-package)
+
+(defcustom use-package-expand-minimally nil
+  "If non-nil, make the expanded code as minimal as possible.
+This disables:
+  - Printing to the *Messages* buffer of slowly-evaluating forms
+  - Capture of load errors (normally redisplayed as warnings)
+  - Conditional loading of packages (load failures become errors)
+The only advantage is that, if you know your configuration works,
+then your byte-compiled init file is as minimal as possible."
+  :type 'boolean
+  :group 'use-package)
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; Utility functions
+;;
+
+(defun use-package-as-symbol (string-or-symbol)
+  "If STRING-OR-SYMBOL is already a symbol, return it.  Otherwise
+convert it to a symbol and return that."
+  (if (symbolp string-or-symbol) string-or-symbol
+    (intern string-or-symbol)))
+
+(defun use-package-as-string (string-or-symbol)
+  "If STRING-OR-SYMBOL is already a string, return it.  Otherwise
+convert it to a string and return that."
+  (if (stringp string-or-symbol) string-or-symbol
+    (symbol-name string-or-symbol)))
+
+(defun use-package-load-name (name &optional noerror)
+  "Return a form which will load or require NAME depending on
+whether it's a string or symbol."
+  (if (stringp name)
+      `(load ,name 'noerror)
+    `(require ',name nil 'noerror)))
+
+(defun use-package-expand (name label form)
+  "FORM is a list of forms, so `((foo))' if only `foo' is being called."
+  (declare (indent 1))
+  (when form
+    (if use-package-expand-minimally
+        form
+      (let ((err (make-symbol "err")))
+        (list
+         `(condition-case-unless-debug ,err
+              ,(macroexp-progn form)
+            (error
+             (ignore
+              (display-warning 'use-package
+                               (format "%s %s: %s"
+                                       ,name ,label (error-message-string ,err))
+                               :error)))))))))
+
+(put 'use-package-expand 'lisp-indent-function 'defun)
+
+(defun use-package-hook-injector (name-string keyword body)
+  "Wrap pre/post hook injections around a given keyword form.
+ARGS is a list of forms, so `((foo))' if only `foo' is being called."
+  (if (not use-package-inject-hooks)
+      (use-package-expand name-string (format "%s" keyword) body)
+    (let ((keyword-name (substring (format "%s" keyword) 1)))
+      (when body
+        `((when ,(macroexp-progn
+                  (use-package-expand name-string (format "pre-%s hook" keyword)
+                    `((run-hook-with-args-until-failure
+                       ',(intern (concat "use-package--" name-string
+                                         "--pre-" keyword-name "-hook"))))))
+            ,(macroexp-progn
+              (use-package-expand name-string (format "%s" keyword) body))
+            ,(macroexp-progn
+              (use-package-expand name-string (format "post-%s hook" keyword)
+                `((run-hooks
+                   ',(intern (concat "use-package--" name-string
+                                     "--post-" keyword-name "-hook"))))))))))))
+
+(defun use-package--with-elapsed-timer (text body)
+  "BODY is a list of forms, so `((foo))' if only `foo' is being called."
+  (declare (indent 1))
+  (if use-package-expand-minimally
+      body
+    (let ((nowvar (make-symbol "now")))
+      (if (bound-and-true-p use-package-verbose)
+          `((let ((,nowvar (current-time)))
+              (message "%s..." ,text)
+              (prog1
+                  ,(macroexp-progn body)
+                (let ((elapsed
+                       (float-time (time-subtract (current-time) ,nowvar))))
+                  (if (> elapsed ,use-package-minimum-reported-time)
+                      (message "%s...done (%.3fs)" ,text elapsed)
+                    (message "%s...done" ,text))))))
+        body))))
+
+(put 'use-package--with-elapsed-timer 'lisp-indent-function 1)
+
+(defsubst use-package-error (msg)
+  "Report MSG as an error, so the user knows it came from this package."
+  (error "use-package: %s" msg))
+
+(defsubst use-package-plist-maybe-put (plist property value)
+  "Add a VALUE for PROPERTY to PLIST, if it does not already exist."
+  (if (plist-member plist property)
+      plist
+    (plist-put plist property value)))
+
+(defsubst use-package-plist-cons (plist property value)
+  "Cons VALUE onto the head of the list at PROPERTY in PLIST."
+  (plist-put plist property (cons value (plist-get plist property))))
+
+(defsubst use-package-plist-append (plist property value)
+  "Append VALUE onto the front of the list at PROPERTY in PLIST."
+  (plist-put plist property (append value (plist-get plist property))))
+
+(defun use-package-plist-delete (plist property)
+  "Delete PROPERTY from PLIST.
+This is in contrast to merely setting it to 0."
+  (let (p)
+    (while plist
+      (if (not (eq property (car plist)))
+	  (setq p (plist-put p (car plist) (nth 1 plist))))
+      (setq plist (cddr plist)))
+    p))
+
+(defun use-package-split-list (pred xs)
+  (let ((ys (list nil)) (zs (list nil)) flip)
+    (dolist (x xs)
+      (if flip
+          (nconc zs (list x))
+        (if (funcall pred x)
+            (progn
+              (setq flip t)
+              (nconc zs (list x)))
+          (nconc ys (list x)))))
+    (cons (cdr ys) (cdr zs))))
+
+(defun use-package-keyword-index (keyword)
+  (loop named outer
+        with index = 0
+        for k in use-package-keywords do
+        (if (eq k keyword)
+            (return-from outer index))
+        (incf index)))
+
+(defun use-package-sort-keywords (plist)
+  (let (plist-grouped)
+    (while plist
+      (push (cons (car plist) (cadr plist))
+            plist-grouped)
+      (setq plist (cddr plist)))
+    (let (result)
+      (dolist (x
+               (nreverse
+                (sort plist-grouped
+                      #'(lambda (l r) (< (use-package-keyword-index (car l))
+                                    (use-package-keyword-index (car r)))))))
+        (setq result (cons (car x) (cons (cdr x) result))))
+      result)))
+
+(defsubst use-package-concat (&rest elems)
+  "Delete all empty lists from ELEMS (nil or (list nil)), and append them."
+  (apply #'nconc (delete nil (delete (list nil) elems))))
+
+(defconst use-package-font-lock-keywords
+  '(("(\\(use-package\\)\\_>[ \t']*\\(\\(?:\\sw\\|\\s_\\)+\\)?"
+     (1 font-lock-keyword-face)
+     (2 font-lock-constant-face nil t))))
+
+(font-lock-add-keywords 'emacs-lisp-mode use-package-font-lock-keywords)
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; Keyword processing
+;;
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; Normalization functions
+;;
+
+(defun use-package-normalize-plist (name input)
+  "Given a pseudo-plist, normalize it to a regular plist."
+  (unless (null input)
+    (let* ((keyword (car input))
+           (xs (use-package-split-list #'keywordp (cdr input)))
+           (args (car xs))
+           (tail (cdr xs))
+           (normalizer (intern (concat "use-package-normalize/"
+                                       (symbol-name keyword))))
+           (arg
+            (cond
+             ((eq keyword :disabled)
+              (use-package-normalize-plist name tail))
+             ((functionp normalizer)
+              (funcall normalizer name keyword args))
+             ((= (length args) 1)
+              (car args))
+             (t
+              args))))
+      (if (memq keyword use-package-keywords)
+          (cons keyword
+                (cons arg (use-package-normalize-plist name tail)))
+        (use-package-error (format "Unrecognized keyword: %s" keyword))))))
+
+(defun use-package-process-keywords (name plist &optional state)
+  "Process the next keyword in the free-form property list PLIST.
+The values in the PLIST have each been normalized by the function
+use-package-normalize/KEYWORD (minus the colon).
+
+STATE is a property list that the function may modify and/or
+query.  This is useful if a package defines multiple keywords and
+wishes them to have some kind of stateful interaction.
+
+Unless the KEYWORD being processed intends to ignore remaining
+keywords, it must call this function recursively, passing in the
+plist with its keyword and argument removed, and passing in the
+next value for the STATE."
+  (declare (indent 1))
+  (unless (null plist)
+    (let* ((keyword (car plist))
+           (arg (cadr plist))
+           (rest (cddr plist)))
+      (unless (keywordp keyword)
+        (use-package-error (format "%s is not a keyword" keyword)))
+      (let* ((handler (concat "use-package-handler/" (symbol-name keyword)))
+             (handler-sym (intern handler)))
+        (if (functionp handler-sym)
+            (funcall handler-sym name keyword arg rest state)
+          (use-package-error
+           (format "Keyword handler not defined: %s" handler)))))))
+
+(put 'use-package-process-keywords 'lisp-indent-function 'defun)
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; :pin
+;;
+
+(defun use-package-only-one (label args f)
+  "Call F on the first member of ARGS if it has exactly one element."
+  (declare (indent 1))
+  (cond
+   ((and (listp args) (listp (cdr args))
+         (= (length args) 1))
+    (funcall f label (car args)))
+   (t
+    (use-package-error
+     (concat label " wants exactly one argument")))))
+
+(put 'use-package-only-one 'lisp-indent-function 'defun)
+
+(defun use-package-normalize/:pin (name keyword args)
+  (use-package-only-one (symbol-name keyword) args
+    (lambda (label arg)
+      (cond
+       ((stringp arg) arg)
+       ((symbolp arg) (symbol-name arg))
+       (t
+        (use-package-error
+         ":pin wants an archive name (a string)"))))))
+
+(eval-when-compile
+  (defvar package-pinned-packages)
+  (defvar package-archives))
+
+(defun use-package--archive-exists-p (archive)
+  "Check if a given ARCHIVE is enabled.
+
+ARCHIVE can be a string or a symbol or 'manual to indicate a
+manually updated package."
+  (if (member archive '(manual "manual"))
+      't
+    (let ((valid nil))
+      (dolist (pa package-archives)
+        (when (member archive (list (car pa) (intern (car pa))))
+          (setq valid 't)))
+      valid)))
+
+(defun use-package-pin-package (package archive)
+  "Pin PACKAGE to ARCHIVE."
+  (unless (boundp 'package-pinned-packages)
+    (setq package-pinned-packages ()))
+  (let ((archive-symbol (if (symbolp archive) archive (intern archive)))
+        (archive-name   (if (stringp archive) archive (symbol-name archive))))
+    (if (use-package--archive-exists-p archive-symbol)
+        (add-to-list 'package-pinned-packages (cons package archive-name))
+      (error "Archive '%s' requested for package '%s' is not available."
+             archive-name package))
+    (unless (bound-and-true-p package--initialized)
+      (package-initialize t))))
+
+(defun use-package-handler/:pin (name keyword archive-name rest state)
+  (let ((body (use-package-process-keywords name rest state))
+        (pin-form (if archive-name
+                      `(use-package-pin-package ',(use-package-as-symbol name)
+                                                ,archive-name))))
+    ;; Pinning should occur just before ensuring
+    ;; See `use-package-handler/:ensure'.
+    (if (bound-and-true-p byte-compile-current-file)
+        (eval pin-form)              ; Eval when byte-compiling,
+      (push pin-form body))          ; or else wait until runtime.
+    body))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; :ensure
+;;
+(defvar package-archive-contents)
+(defun use-package-normalize/:ensure (name keyword args)
+  (if (null args)
+      t
+    (use-package-only-one (symbol-name keyword) args
+      (lambda (label arg)
+        (if (symbolp arg)
+            arg
+          (use-package-error
+           (concat ":ensure wants an optional package name "
+                   "(an unquoted symbol name)")))))))
+
+(defun use-package-ensure-elpa (package &optional no-refresh)
+  (if (package-installed-p package)
+      t
+    (if (or (assoc package package-archive-contents) no-refresh)
+        (if (boundp 'package-selected-packages)
+            (package-install package t)
+            (package-install package))
+      (progn
+        (package-refresh-contents)
+        (use-package-ensure-elpa package t)))))
+
+(defun use-package-handler/:ensure (name keyword ensure rest state)
+  (let* ((body (use-package-process-keywords name rest state))
+         (package-name (or (and (eq ensure t) (use-package-as-symbol name)) ensure))
+         (ensure-form (if package-name
+                          `(progn (require 'package)
+                                  (use-package-ensure-elpa ',package-name)))))
+    ;; We want to avoid installing packages when the `use-package'
+    ;; macro is being macro-expanded by elisp completion (see
+    ;; `lisp--local-variables'), but still do install packages when
+    ;; byte-compiling to avoid requiring `package' at runtime.
+    (if (bound-and-true-p byte-compile-current-file)
+        (eval ensure-form)              ; Eval when byte-compiling,
+      (push ensure-form body))          ; or else wait until runtime.
+    body))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; :if, :when and :unless
+;;
+
+(defsubst use-package-normalize-value (label arg)
+  "Normalize a value."
+  (cond ((symbolp arg)
+         `(symbol-value ',arg))
+        ((functionp arg)
+         `(funcall #',arg))
+        (t arg)))
+
+(defun use-package-normalize-test (name keyword args)
+  (use-package-only-one (symbol-name keyword) args
+    #'use-package-normalize-value))
+
+(defalias 'use-package-normalize/:if 'use-package-normalize-test)
+(defalias 'use-package-normalize/:when 'use-package-normalize-test)
+(defalias 'use-package-normalize/:unless 'use-package-normalize-test)
+
+(defun use-package-handler/:if (name keyword pred rest state)
+  (let ((body (use-package-process-keywords name rest state)))
+    `((when ,pred ,@body))))
+
+(defalias 'use-package-handler/:when 'use-package-handler/:if)
+
+(defun use-package-handler/:unless (name keyword pred rest state)
+  (let ((body (use-package-process-keywords name rest state)))
+    `((unless ,pred ,@body))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; :requires
+;;
+
+(defun use-package-as-one (label args f)
+  "Call F on the first element of ARGS if it has one element, or all of ARGS."
+  (declare (indent 1))
+  (if (and (listp args) (listp (cdr args)))
+      (if (= (length args) 1)
+          (funcall f label (car args))
+        (funcall f label args))
+    (use-package-error
+     (concat label " wants a list"))))
+
+(put 'use-package-as-one 'lisp-indent-function 'defun)
+
+(defun use-package-normalize-symbols (label arg &optional recursed)
+  "Normalize a list of symbols."
+  (cond
+   ((symbolp arg)
+    (list arg))
+   ((and (not recursed) (listp arg) (listp (cdr arg)))
+    (mapcar #'(lambda (x) (car (use-package-normalize-symbols label x t))) arg))
+   (t
+    (use-package-error
+     (concat label " wants a symbol, or list of symbols")))))
+
+(defun use-package-normalize-symlist (name keyword args)
+  (use-package-as-one (symbol-name keyword) args
+    #'use-package-normalize-symbols))
+
+(defalias 'use-package-normalize/:requires 'use-package-normalize-symlist)
+
+(defun use-package-handler/:requires (name keyword requires rest state)
+  (let ((body (use-package-process-keywords name rest state)))
+    (if (null requires)
+        body
+      `((when ,(if (listp requires)
+                   `(not (member nil (mapcar #'featurep ',requires)))
+                 `(featurep ',requires))
+          ,@body)))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; :load-path
+;;
+
+(defun use-package-normalize-paths (label arg &optional recursed)
+  "Normalize a list of filesystem paths."
+  (cond
+   ((and arg (or (symbolp arg) (functionp arg)))
+    (let ((value (use-package-normalize-value label arg)))
+      (use-package-normalize-paths label (eval value))))
+   ((stringp arg)
+    (let ((path (if (file-name-absolute-p arg)
+                    arg
+                  (expand-file-name arg user-emacs-directory))))
+      (list path)))
+   ((and (not recursed) (listp arg) (listp (cdr arg)))
+    (mapcar #'(lambda (x)
+                (car (use-package-normalize-paths label x t))) arg))
+   (t
+    (use-package-error
+     (concat label " wants a directory path, or list of paths")))))
+
+(defun use-package-normalize/:load-path (name keyword args)
+  (use-package-as-one (symbol-name keyword) args
+    #'use-package-normalize-paths))
+
+(defun use-package-handler/:load-path (name keyword arg rest state)
+  (let ((body (use-package-process-keywords name rest state)))
+    (use-package-concat
+     (mapcar #'(lambda (path)
+                 `(eval-and-compile (add-to-list 'load-path ,path))) arg)
+     body)))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; :no-require
+;;
+
+(defun use-package-normalize-predicate (name keyword args)
+  (if (null args)
+      t
+    (use-package-only-one (symbol-name keyword) args
+      #'use-package-normalize-value)))
+
+(defalias 'use-package-normalize/:no-require 'use-package-normalize-predicate)
+
+(defun use-package-handler/:no-require (name keyword arg rest state)
+  ;; This keyword has no functional meaning.
+  (use-package-process-keywords name rest state))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; :preface
+;;
+
+(defun use-package-normalize-form (label args)
+  "Given a list of forms, return it wrapped in `progn'."
+  (unless (listp (car args))
+    (use-package-error (concat label " wants a sexp or list of sexps")))
+  (mapcar #'(lambda (form)
+              (if (and (consp form)
+                       (eq (car form) 'use-package))
+                  (macroexpand form)
+                form)) args))
+
+(defun use-package-normalize-forms (name keyword args)
+  (use-package-normalize-form (symbol-name keyword) args))
+
+(defalias 'use-package-normalize/:preface 'use-package-normalize-forms)
+
+(defun use-package-handler/:preface (name keyword arg rest state)
+  (let ((body (use-package-process-keywords name rest state)))
+    (use-package-concat
+     (unless (null arg)
+       `((eval-and-compile ,@arg)))
+     body)))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; :bind, :bind*
+;;
+
+(defsubst use-package-is-sympair (x &optional allow-vector)
+  "Return t if X has the type (STRING . SYMBOL)."
+  (and (consp x)
+       (or (stringp (car x))
+           (and allow-vector (vectorp (car x))))
+       (symbolp (cdr x))))
+
+(defsubst use-package-is-string-pair (x)
+  "Return t if X has the type (STRING . STRING)."
+  (and (consp x)
+       (stringp (car x))
+       (stringp (cdr x))))
+
+(defun use-package-normalize-pairs
+    (name label arg &optional recursed allow-vector allow-string-cdrs)
+  "Normalize a list of string/symbol pairs.
+If RECURSED is non-nil, recurse into sublists.
+If ALLOW-VECTOR is non-nil, then the key to bind may specify a
+vector of keys, as accepted by `define-key'.
+If ALLOW-STRING-CDRS is non-nil, then the command name to bind to
+may also be a string, as accepted by `define-key'."
+  (cond
+   ((or (stringp arg) (and allow-vector (vectorp arg)))
+    (list (cons arg (use-package-as-symbol name))))
+   ((use-package-is-sympair arg allow-vector)
+    (list arg))
+   ((and (not recursed) (listp arg) (listp (cdr arg)))
+    (mapcar #'(lambda (x)
+                (let ((ret (use-package-normalize-pairs
+                            name label x t allow-vector allow-string-cdrs)))
+                  (if (listp ret)
+                      (car ret)
+                    ret))) arg))
+   ((and allow-string-cdrs (use-package-is-string-pair arg))
+    (list arg))
+   (t arg)))
+
+(defun use-package-normalize-binder (name keyword args)
+  (use-package-as-one (symbol-name keyword) args
+    (lambda (label arg)
+      (use-package-normalize-pairs name label arg nil t t))))
+
+(defalias 'use-package-normalize/:bind 'use-package-normalize-binder)
+(defalias 'use-package-normalize/:bind* 'use-package-normalize-binder)
+
+(defun use-package-handler/:bind
+    (name keyword arg rest state &optional bind-macro)
+  (let ((commands (remq nil (mapcar #'(lambda (arg)
+                                        (if (listp arg)
+                                            (cdr arg)
+                                          nil)) arg))))
+    (use-package-concat
+     (use-package-process-keywords name
+       (use-package-sort-keywords
+        (use-package-plist-maybe-put rest :defer t))
+       (use-package-plist-append state :commands commands))
+     `((ignore
+        ,(macroexpand
+          `(,(if bind-macro bind-macro 'bind-keys)
+            :package ,name ,@arg)))))))
+
+(defun use-package-handler/:bind* (name keyword arg rest state)
+  (use-package-handler/:bind name keyword arg rest state 'bind-keys*))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; :bind-keymap, :bind-keymap*
+;;
+
+(defalias 'use-package-normalize/:bind-keymap 'use-package-normalize-binder)
+(defalias 'use-package-normalize/:bind-keymap* 'use-package-normalize-binder)
+
+(defun use-package-autoload-keymap (keymap-symbol package override)
+  "Loads PACKAGE and then binds the key sequence used to invoke
+this function to KEYMAP-SYMBOL.  It then simulates pressing the
+same key sequence a again, so that the next key pressed is routed
+to the newly loaded keymap.
+
+This function supports use-package's :bind-keymap keyword.  It
+works by binding the given key sequence to an invocation of this
+function for a particular keymap.  The keymap is expected to be
+defined by the package.  In this way, loading the package is
+deferred until the prefix key sequence is pressed."
+  (if (not (require package nil t))
+      (use-package-error (format "Cannot load package.el: %s" package))
+    (if (and (boundp keymap-symbol)
+             (keymapp (symbol-value keymap-symbol)))
+        (let* ((kv (this-command-keys-vector))
+               (key (key-description kv))
+               (keymap (symbol-value keymap-symbol)))
+          (if override
+              (bind-key* key keymap)
+            (bind-key key keymap))
+          (setq unread-command-events
+                (listify-key-sequence kv)))
+      (use-package-error
+       (format "use-package: package.el %s failed to define keymap %s"
+               package keymap-symbol)))))
+
+(defun use-package-handler/:bind-keymap
+    (name keyword arg rest state &optional override)
+  (let ((form (mapcar
+               #'(lambda (binding)
+                   `(,(if override
+                          'bind-key*
+                        'bind-key)
+                     ,(car binding)
+                     #'(lambda ()
+                         (interactive)
+                         (use-package-autoload-keymap
+                          ',(cdr binding) ',(use-package-as-symbol name) ,override)))) arg)))
+    (use-package-concat
+     (use-package-process-keywords name
+       (use-package-sort-keywords
+        (use-package-plist-maybe-put rest :defer t))
+       state)
+     `((ignore ,@form)))))
+
+(defun use-package-handler/:bind-keymap* (name keyword arg rest state)
+  (use-package-handler/:bind-keymap name keyword arg rest state t))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; :interpreter
+;;
+
+(defun use-package-normalize-mode (name keyword args)
+  (use-package-as-one (symbol-name keyword) args
+    (apply-partially #'use-package-normalize-pairs name)))
+
+(defalias 'use-package-normalize/:interpreter 'use-package-normalize-mode)
+
+(defun use-package-handler/:interpreter (name keyword arg rest state)
+  (let* (commands
+         (form (mapcar #'(lambda (interpreter)
+                           (push (cdr interpreter) commands)
+                           `(add-to-list 'interpreter-mode-alist ',interpreter)) arg)))
+    (use-package-concat
+     (use-package-process-keywords name
+       (use-package-sort-keywords
+        (use-package-plist-maybe-put rest :defer t))
+       (use-package-plist-append state :commands commands))
+     `((ignore ,@form)))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; :mode
+;;
+
+(defalias 'use-package-normalize/:mode 'use-package-normalize-mode)
+
+(defun use-package-handler/:mode (name keyword arg rest state)
+  (let* (commands
+         (form (mapcar #'(lambda (mode)
+                           (push (cdr mode) commands)
+                           `(add-to-list 'auto-mode-alist ',mode)) arg)))
+    (use-package-concat
+     (use-package-process-keywords name
+       (use-package-sort-keywords
+        (use-package-plist-maybe-put rest :defer t))
+       (use-package-plist-append state :commands commands))
+     `((ignore ,@form)))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; :commands
+;;
+
+(defalias 'use-package-normalize/:commands 'use-package-normalize-symlist)
+
+(defun use-package-handler/:commands (name keyword arg rest state)
+  ;; The actual processing for commands is done in :defer
+  (use-package-process-keywords name
+    (use-package-sort-keywords
+     (use-package-plist-maybe-put rest :defer t))
+    (use-package-plist-append state :commands arg)))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; :defines
+;;
+
+(defalias 'use-package-normalize/:defines 'use-package-normalize-symlist)
+
+(defun use-package-handler/:defines (name keyword arg rest state)
+  (let ((body (use-package-process-keywords name rest state)))
+    body))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; :functions
+;;
+
+(defalias 'use-package-normalize/:functions 'use-package-normalize-symlist)
+
+(defun use-package-handler/:functions (name keyword arg rest state)
+  (let ((body (use-package-process-keywords name rest state)))
+    (if (not (bound-and-true-p byte-compile-current-file))
+        body
+      (use-package-concat
+       (unless (null arg)
+         `((eval-when-compile
+             ,@(mapcar
+                #'(lambda (fn)
+                    `(declare-function ,fn ,(use-package-as-string name))) arg))))
+       body))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; :defer
+;;
+
+(defalias 'use-package-normalize/:defer 'use-package-normalize-predicate)
+
+(defun use-package-handler/:defer (name keyword arg rest state)
+  (let ((body (use-package-process-keywords name rest
+                (plist-put state :deferred t)))
+        (name-string (use-package-as-string name)))
+    (use-package-concat
+     ;; Load the package after a set amount of idle time, if the argument to
+     ;; `:defer' was a number.
+     (when (numberp arg)
+       `((run-with-idle-timer ,arg nil #'require ',(use-package-as-symbol name) nil t)))
+
+     ;; Since we deferring load, establish any necessary autoloads, and also
+     ;; keep the byte-compiler happy.
+     (apply
+      #'nconc
+      (mapcar #'(lambda (command)
+                  (when (not (stringp command))
+                    (append
+                     `((unless (fboundp ',command)
+                         (autoload #',command ,name-string nil t)))
+                     (when (bound-and-true-p byte-compile-current-file)
+                       `((eval-when-compile
+                           (declare-function ,command ,name-string)))))))
+              (delete-dups (plist-get state :commands))))
+
+     body)))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; :after
+;;
+
+(defalias 'use-package-normalize/:after 'use-package-normalize-symlist)
+
+(defun use-package-require-after-load (features name)
+  "Return form for after any of FEATURES require NAME."
+  `(progn
+     ,@(mapcar
+        (lambda (feat)
+          `(eval-after-load
+               (quote ,feat)
+             (quote (require (quote ,name)))))
+        features)))
+
+(defun use-package-handler/:after (name keyword arg rest state)
+  (let ((body (use-package-process-keywords name rest
+                (plist-put state :deferred t)))
+        (name-string (use-package-as-string name)))
+    (use-package-concat
+     (when arg
+       (list (use-package-require-after-load arg name)))
+     body)))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; :demand
+;;
+
+(defalias 'use-package-normalize/:demand 'use-package-normalize-predicate)
+
+(defun use-package-handler/:demand (name keyword arg rest state)
+  (use-package-process-keywords name rest
+    (use-package-plist-delete state :deferred)))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; :init
+;;
+
+(defalias 'use-package-normalize/:init 'use-package-normalize-forms)
+
+(defun use-package-handler/:init (name keyword arg rest state)
+  (let ((body (use-package-process-keywords name rest state)))
+    (use-package-concat
+     ;; The user's initializations
+     (let ((init-body
+            (use-package-hook-injector (use-package-as-string name)
+                                       :init arg)))
+       (if use-package-check-before-init
+           `((if (locate-library ,(use-package-as-string name))
+                 ,(macroexp-progn init-body)))
+         init-body))
+     body)))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; :config
+;;
+
+(defalias 'use-package-normalize/:config 'use-package-normalize-forms)
+
+(defun use-package-handler/:config (name keyword arg rest state)
+  (let* ((body (use-package-process-keywords name rest state))
+         (name-symbol (use-package-as-symbol name))
+         (config-body
+          (if (equal arg '(t))
+              body
+            (use-package--with-elapsed-timer
+                (format "Configuring package %s" name-symbol)
+              (use-package-concat
+               (use-package-hook-injector (symbol-name name-symbol)
+                                          :config arg)
+               body
+               (list t))))))
+    (if (plist-get state :deferred)
+        (unless (or (null config-body) (equal config-body '(t)))
+          `((eval-after-load ,(if (symbolp name) `',name name)
+              ',(macroexp-progn config-body))))
+      (use-package--with-elapsed-timer
+          (format "Loading package %s" name)
+        (if use-package-expand-minimally
+            (use-package-concat
+             (list (use-package-load-name name))
+             config-body)
+          `((if (not ,(use-package-load-name name t))
+                (ignore
+                 (message (format "Cannot load %s" ',name)))
+              ,@config-body)))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; :diminish
+
+(defun use-package-normalize-diminish (name label arg &optional recursed)
+  "Normalize the arguments to diminish down to a list of one of two forms:
+     SYMBOL
+     (SYMBOL . STRING)"
+  (cond
+   ((symbolp arg)
+    (list arg))
+   ((stringp arg)
+    (list (cons (intern (concat (use-package-as-string name) "-mode")) arg)))
+   ((and (consp arg) (stringp (cdr arg)))
+    (list arg))
+   ((and (not recursed) (listp arg) (listp (cdr arg)))
+    (mapcar #'(lambda (x) (car (use-package-normalize-diminish
+                                name label x t))) arg))
+   (t
+    (use-package-error
+     (concat label " wants a string, symbol, "
+             "(symbol . string) or list of these")))))
+
+(defun use-package-normalize/:diminish (name keyword args)
+  (use-package-as-one (symbol-name keyword) args
+    (apply-partially #'use-package-normalize-diminish name)))
+
+(defun use-package-handler/:diminish (name keyword arg rest state)
+  (let ((body (use-package-process-keywords name rest state)))
+    (use-package-concat
+     (mapcar #'(lambda (var)
+                 `(if (fboundp 'diminish)
+                      ,(if (consp var)
+                           `(diminish ',(car var) ,(cdr var))
+                         `(diminish ',var))))
+             arg)
+     body)))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; :delight
+;;
+
+(defun use-package-normalize/:delight (name keyword args)
+  "Normalize arguments to delight."
+  (cond
+   ((and (= (length args) 1)
+         (symbolp (car args)))
+    (list (car args) nil name))
+   ((and (= (length args) 2)
+         (symbolp (car args)))
+    (list (car args) (cadr args) (use-package-as-symbol name)))
+   ((and (= (length args) 3)
+         (symbolp (car args)))
+    args)
+   (t
+    (use-package-error ":delight expects same args as delight function"))))
+
+(defun use-package-handler/:delight (name keyword args rest state)
+  (let ((body (use-package-process-keywords name rest state)))
+    (use-package-concat
+     body
+     `((delight (quote ,(nth 0 args)) ,(nth 1 args) (quote ,(nth 2 args))) t))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; The main macro
+;;
+
+;;;###autoload
+(defmacro use-package (name &rest args)
+  "Declare an Emacs package by specifying a group of configuration options.
+
+For full documentation, please see the README file that came with
+this file.  Usage:
+
+  (use-package package-name
+     [:keyword [option]]...)
+
+:init          Code to run before PACKAGE-NAME has been loaded.
+:config        Code to run after PACKAGE-NAME has been loaded.  Note that if
+               loading is deferred for any reason, this code does not execute
+               until the lazy load has occurred.
+:preface       Code to be run before everything except `:disabled'; this can
+               be used to define functions for use in `:if', or that should be
+               seen by the byte-compiler.
+
+:mode          Form to be added to `auto-mode-alist'.
+:interpreter   Form to be added to `interpreter-mode-alist'.
+
+:commands      Define autoloads for commands that will be defined by the
+               package.  This is useful if the package is being lazily loaded,
+               and you wish to conditionally call functions in your `:init'
+               block that are defined in the package.
+
+:bind          Bind keys, and define autoloads for the bound commands.
+:bind*         Bind keys, and define autoloads for the bound commands,
+               *overriding all minor mode bindings*.
+:bind-keymap   Bind a key prefix to an auto-loaded keymap defined in the
+               package.  This is like `:bind', but for keymaps.
+:bind-keymap*  Like `:bind-keymap', but overrides all minor mode bindings
+
+:defer         Defer loading of a package -- this is implied when using
+               `:commands', `:bind', `:bind*', `:mode' or `:interpreter'.
+               This can be an integer, to force loading after N seconds of
+               idle time, if the package has not already been loaded.
+
+:after         Defer loading of a package until after any of the named
+               features are loaded.
+
+:demand        Prevent deferred loading in all cases.
+
+:if EXPR       Initialize and load only if EXPR evaluates to a non-nil value.
+:disabled      The package is ignored completely if this keyword is present.
+:defines       Declare certain variables to silence the byte-compiler.
+:functions     Declare certain functions to silence the byte-compiler.
+:load-path     Add to the `load-path' before attempting to load the package.
+:diminish      Support for diminish.el (if installed).
+:ensure        Loads the package using package.el if necessary.
+:pin           Pin the package to an archive."
+  (declare (indent 1))
+  (unless (member :disabled args)
+    (let* ((name-symbol (if (stringp name) (intern name) name))
+           (args0 (use-package-plist-maybe-put
+                   (use-package-normalize-plist name args)
+                   :config '(t)))
+           (args* (use-package-sort-keywords
+                   (if use-package-always-ensure
+                       (use-package-plist-maybe-put
+                        args0 :ensure use-package-always-ensure)
+                     args0)))
+           (args* (use-package-sort-keywords
+                   (if use-package-always-pin
+                       (use-package-plist-maybe-put
+                        args* :pin use-package-always-pin)
+                     args*))))
+
+      ;; When byte-compiling, pre-load the package so all its symbols are in
+      ;; scope.
+      (if (bound-and-true-p byte-compile-current-file)
+          (setq args*
+                (use-package-plist-cons
+                 args* :preface
+                 `(eval-when-compile
+                    ,@(mapcar #'(lambda (var) `(defvar ,var))
+                              (plist-get args* :defines))
+                    (with-demoted-errors
+                        ,(format "Cannot load %s: %%S" name)
+                      ,(if (eq use-package-verbose 'debug)
+                           `(message "Compiling package %s" ',name-symbol))
+                      ,(unless (plist-get args* :no-require)
+                         (use-package-load-name name)))))))
+
+      (let ((body
+             (macroexp-progn
+              (use-package-process-keywords name args*
+                (and use-package-always-defer '(:deferred t))))))
+        (if use-package-debug
+            (display-buffer
+             (save-current-buffer
+               (let ((buf (get-buffer-create "*use-package*")))
+                 (with-current-buffer buf
+                   (delete-region (point-min) (point-max))
+                   (emacs-lisp-mode)
+                   (insert (pp-to-string body)))
+                 buf))))
+        body))))
+
+
+(put 'use-package 'lisp-indent-function 'defun)
+
+(provide 'use-package)
+
+;; Local Variables:
+;; indent-tabs-mode: nil
+;; End:
+
+;;; use-package.el ends here
diff --git a/.emacs.d/themes/hydandata-light-theme.el b/.emacs.d/themes/hydandata-light-theme.el
new file mode 100644
index 0000000..4f30c57
--- /dev/null
+++ b/.emacs.d/themes/hydandata-light-theme.el
@@ -0,0 +1,165 @@
+;;; hydandata-light-theme.el --- A light color theme that is easy on your eyes
+
+;;; Copyright (C) 2016 David Chkhikvadze
+;;; Copyright (C) 2010 Yves Senn
+
+;;; Author: David Chkhikvadze <david.chk@outlook.com>
+;;; Version: 0.2
+;;; Created: 01 January 2016
+;;; Keywords: color-theme theme
+
+;;; This file is NOT part of GNU Emacs.
+
+;;; License:
+
+;;; This program is free software; you can redistribute it and/or modify
+;;; it under the terms of the GNU General Public License as published by
+;;; the Free Software Foundation; either version 3, or (at your option)
+;;; any later version.
+;;;
+;;; This program is distributed in the hope that it will be useful,
+;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;;; GNU General Public License for more details.
+;;;
+;;; You should have received a copy of the GNU General Public License
+;;; along with GNU Emacs; see the file COPYING.  If not, write to the
+;;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+;;; Boston, MA 02110-1301, USA.
+
+;;; Commentary:
+
+;;; A light color theme with bluish tint that is very easy on your
+;;; eyes. Extracted from senny/theme-roller.el and modified for modern
+;;; Emacs deftheme.
+
+;;; Code:
+
+(deftheme hydandata-light
+  "Light theme based on the one included with theme-roller by Yves Senn.")
+
+(custom-theme-set-faces
+ 'hydandata-light
+ '(default ((t (:inherit nil :stipple nil :background "#f8f8ff" :foreground "black" :inverse-video nil :box nil :strike-through nil :overline nil :underline nil :slant normal :weight normal :width normal :bold nil))))
+ '(hl-line ((t (:background "#effca6"))))
+ '(highlight ((t (:background "#acc3e6"))))
+ '(region ((t (:background "#bcd5fa"))))
+ '(mode-line ((t (:background "#bcd5fa" :foreground "black"))))
+ '(minibuffer-prompt ((t (:foreground "#445588"))))
+ '(minibuffer-noticeable-prompt ((t (:foreground "#445588"))))
+ '(link ((t (:foreground "blue1" :underline t))))
+ '(fringe ((t (:background "gray95" :foreground "black"))))
+ '(linum ((t (:inherit fringe))))
+
+ '(show-paren-match ((t (:background "#bcd5fa" :foreground "white"))))
+ '(show-paren-mismatch ((t (:bold t :background "#9d1e15" :foreground "#f8f8f8"))))
+
+ '(font-lock-warning-face ((t (:background "#ffe4b5"))))
+ '(font-lock-comment-face ((t (:italic t :foreground "#999999" :slant italic))))
+ '(font-lock-comment-delimiter-face ((t (:inherit font-lock-comment-face))))
+ '(font-lock-builtin-face ((t (:inherit default))))
+ '(font-lock-constant-face ((t (:foreground "#3b5bb5"))))
+ '(font-lock-doc-face ((t (:foreground "#409b1c"))))
+ '(font-lock-doc-string-face ((t (:inherit font-lock-doc-face))))
+ '(font-lock-function-name-face ((t (:inherit default :bold t))))
+ '(font-lock-keyword-face ((t (:bold t :weight bold :foreground "#ff7800"))))
+ '(font-lock-preprocessor-face ((t (:foreground "#3a4a64" :background "gray95"))))
+
+ '(font-lock-reference-face ((t (nil))))
+ '(font-lock-negatoin-char-face ((t (nil))))
+
+ '(font-lock-regexp-grouping-backslash ((t (:inheirt font-lock-comment-face))))
+ '(font-lock-regexp-grouping-construct ((t (:foreground "red"))))
+ '(font-lock-string-face ((t (:foreground "#409b1c"))))
+ '(font-lock-type-face ((t (:foreground "#445588"))))
+ '(font-lock-variable-name-face ((t (:foreground "#671ebb"))))
+
+ '(mac-ts-caret-position ((t (:background "#effca6"))))
+
+ '(whitespace-line ((t (:inherit font-lock-code-warning))))
+ '(whitespace-tab ((t (:inherit font-lock-code-warning))))
+
+ '(compilation-info ((t (:inherit font-lock-string-face))))
+ '(compilation-line-number ((t (:foreground "#3b5bb5"))))
+
+ '(flymake-errline ((t (:bold t :background "#9d1e15" :foreground "#f8f8f8"))))
+ '(flymake-warnline ((t (:inherit font-lock-warning-face))))
+
+ '(flycheck-error ((t (:inherit font-lock-warning-face))))
+ '(flycheck-error-list-error ((t (:inherit font-lock-warning-face))))
+ '(flycheck-fringe-error ((t (:inherit font-lock-warning-face))))
+ '(flycheck-color-mode-line-info-face ((t (:inherit highlight))))
+ '(flycheck-color-mode-line-warning-face ((t (:inherit flycheck-fringe-error))))
+ '(flycheck-color-mode-line-error-face ((t (:inherit flycheck-fringe-error))))
+
+ '(diff-header ((t (:background "LightSteelBlue3"))))
+ '(diff-file-header ((t (:inherit diff-header :bold t))))
+ '(diff-added ((t (:background "DarkOliveGreen3"))))
+ '(diff-removed ((t (:background "IndianRed1"))))
+ '(diff-changed ((t (:background "burlywood3"))))
+ '(diff-context ((t (:background "gray90"))))
+ '(diff-index ((t (:inherit font-lock-comment-face))))
+ '(diff-refine-change ((t (:inherit font-lock-comment-face))))
+
+ '(magit-item-highlight ((t (:background nil :bold t))))
+ '(magit-diff-add ((t (:inherit diff-added))))
+ '(magit-diff-del ((t (:inherit diff-removed))))
+ '(magit-diff-none ((t (:inherit diff-context))))
+ '(magit-log-sha1 ((t (:inherit font-lock-code-keyword))))
+ '(magit-log-head-label-remote ((t (:inherit font-lock-string-face :box t))))
+ '(magit-log-head-label-local ((t (:inherit font-lock-variable-name-face :box t))))
+
+ '(ediff-current-diff-A ((t (:background "#01243C" :foreground "white"))))
+ '(ediff-current-diff-Ancestor ((t (:background "#4D0600" :foreground "white"))))
+ '(ediff-current-diff-B ((t (:background "#574A00" :foreground "white"))))
+ '(ediff-current-diff-C ((t (:background "#5C285C" :foreground "white"))))
+ '(ediff-even-diff-A ((t (:background "#222222"))))
+ '(ediff-even-diff-Ancestor ((t (:background "#222222"))))
+ '(ediff-even-diff-B ((t (:background "#222222"))))
+ '(ediff-even-diff-C ((t (:background "#222222"))))
+ '(ediff-fine-diff-A ((t (:background "#0B5C00" :foreground "white"))))
+ '(ediff-fine-diff-Ancestor ((t (:background "#0B5C00" :foreground "white"))))
+ '(ediff-fine-diff-B ((t (:background "#0B5C00" :foreground "white"))))
+ '(ediff-fine-diff-C ((t (:background "#0B5C00" :foreground "white"))))
+ '(ediff-odd-diff-A ((t (:background "#222222"))))
+ '(ediff-odd-diff-Ancestor ((t (:background "#222222"))))
+ '(ediff-odd-diff-B ((t (:background "#222222"))))
+ '(ediff-odd-diff-C ((t (:background "#222222"))))
+
+ '(org-done ((t (:inherit font-lock-string-face :bold t))))
+ '(org-todo ((t (:inherit font-lock-variable-name-face :bold t))))
+ '(org-level-1 ((t (:inherit default :underline t :bold t))))
+ '(org-level-2 ((t (:inherit font-lock-variable-name-face))))
+ '(org-level-3 ((t (:inherit font-lock-keyword-face))))
+ '(org-level-4 ((t (:inherit font-lock-type-face))))
+ '(org-special-keyword ((t (:inherit font-lock-doc-face))))
+
+ '(newsticker-treeview-selection-face ((t (:inherit highlight))))
+ '(newsticker-treeview-face ((t (:inherit default))))
+ '(newsticker-treeview-immortal-face ((t (:inherit font-lock-keyword-face))))
+
+ '(js2-error-face ((t (:bold t :background "#9d1e15" :foreground "#f8f8f8"))))
+ '(js2-external-variable-face ((t (:inherit font-lock-variable-name-face))))
+ '(js2-function-param-face ((t (:inherit font-lock-variable-name-face))))
+ '(js2-instance-member-face ((t (:inherit font-lock-variable-name-face))))
+ '(js2-private-function-call-face ((t (:inherit default))))
+ '(js2-private-member-face ((t (:inherit font-lock-variable-name-face))))
+ '(js2-warning-face ((t (:inherit font-lock-warning-face))))
+
+ '(html-tag-face ((t (:inherit font-lock-keyword-face))))
+
+ '(sgml-namespace ((t (:inherit font-locl-type-face))))
+ '(css-selector ((t (:inherit font-lock-keyword-face))))
+
+ '(border-glyph ((t (nil)))) ; flat borders
+ '(left-fringe ((t (nil)))))
+
+;;;###autoload
+(when load-file-name
+  (add-to-list
+   'custom-theme-load-path
+   (file-name-as-directory (file-name-directory load-file-name))))
+
+(provide-theme 'hydandata-light)
+
+;;; hydandata-light-theme.el ends here
diff --git a/.emacs.el b/.emacs.el
old mode 100755
new mode 100644
index 6c7ee1f..49c84e1
--- a/.emacs.el
+++ b/.emacs.el
@@ -1,4 +1,8 @@
-(require 'iso-transl)
+(add-to-list 'load-path "~/.emacs.d/one-file-mode/")
+
+;; Themes
+(setq custom-theme-directory "~/.emacs.d/themes/")
+(load-theme 'hydandata-light t)
 
 ;; Packages
 (require 'package) ;; You might already have this line
@@ -11,134 +15,8 @@
   (add-to-list 'package-archives '("gnu" . "http://elpa.gnu.org/packages/")))
 (package-initialize) ;; You might already have this line
 
-(add-to-list 'load-path "~/.emacs.d/one-file-mode/")
-
-;; Encoding
-(set-language-environment "UTF-8")
-(delete-selection-mode 1)
-
-;; Indentation mode
-(setq-default indent-tabs-mode nil)
-(setq inhibit-startup-screen t)
-(setq tab-width 4)
-
-;; Auto complete
-
-(require 'yasnippet)
-(yas-global-mode 1)
-(define-key yas-minor-mode-map (kbd "<C-tab>") 'yas-next-field)
-
-(require 'auto-complete)
-(require 'auto-complete-config)
-(ac-config-default)
-
-;; (require 'auto-complete-clang-async)
-(require 'ac-c-headers)
-(add-to-list 'ac-modes 'latex-mode)   ; make auto-complete aware of `latex-mode`
-(add-to-list 'ac-modes 'org-mode)
-(require 'ac-math)
-
-(defun ac-cc-mode-setup ()
-  (add-to-list 'ac-sources 'ac-source-c-headers)
-  (hs-minor-mode))
-
-(add-hook 'c-mode-common-hook 'ac-cc-mode-setup)
-(add-hook 'c++-mode-common-hook 'ac-cc-mode-setup)
-(add-hook 'auto-complete-mode-hook 'ac-common-setup)
-
-(defun ac-latex-mode-setup () ; add ac-sources to default ac-sources
-  (setq ac-sources
-        (append '(ac-source-math-unicode
-                  ac-source-math-latex
-                  ac-source-latex-commands)
-                ac-sources)))
-
-(add-hook 'LaTeX-mode-hook 'ac-latex-mode-setup)
-
-(global-auto-complete-mode t)
-(setq ac-math-unicode-in-math-p t)
-(ac-flyspell-workaround)
-
-;; Latex
-(require 'tex-mik)
-(setq TeX-auto-save t)
-(setq TeX-parse-self t)
-(setq-default TeX-master nil)
-
-(defun my-latex-mode-setup ()
-  "Redefines and updates variables for various customizations."
-  (setq LaTeX-paragraph-commands
-        '("If" "State" "Loop" "For" "ForAll"))
-  (setq LaTeX-begin-regexp
-        (concat LaTeX-begin-regexp "\\|If\\b" "\\|Loop\\b" "\\|For\\b" "\\|ForAll\\b"))
-  (setq LaTeX-end-regexp
-        (concat LaTeX-end-regexp "\\|EndIf\\b" "\\|EndLoop\\b"
-                "\\|EndFor\\b" "\\|Else\\b" "\\|ElsIf\\b"))
-  (setq LaTeX-paragraph-commands-regexp (LaTeX-paragraph-commands-regexp-make))
-  (defun LaTeX-indent-level-count ()
-    "Count indentation change caused by all \\left, \\right, \\begin, and
-\\end commands in the current line."
-    (save-excursion
-      (save-restriction
-        (let ((count 0))
-          (narrow-to-region (point)
-                            (save-excursion
-                              (re-search-forward
-                               (concat "[^" TeX-esc "]"
-                                       "\\(" LaTeX-indent-comment-start-regexp
-                                       "\\)\\|\n\\|\\'"))
-                              (backward-char)
-                              (point)))
-          (while (search-forward TeX-esc nil t)
-            (cond
-             ((looking-at "left\\b")
-              (setq count (+ count LaTeX-left-right-indent-level)))
-             ((looking-at "right\\b")
-              (setq count (- count LaTeX-left-right-indent-level)))
-             ((looking-at LaTeX-begin-regexp)
-              (setq count (+ count LaTeX-indent-level)))
-             ((looking-at "Else\\b"))
-             ((looking-at "ElsIf\\b"))
-             ((looking-at LaTeX-end-regexp)
-              (setq count (- count LaTeX-indent-level)))
-             ((looking-at (regexp-quote TeX-esc))
-              (forward-char 1))))
-          count)))))
-
-(add-hook 'LaTeX-mode-hook 'my-latex-mode-setup)
-
-(add-hook 'LaTeX-mode-hook 'visual-line-mode)
-(add-hook 'LaTeX-mode-hook 'flyspell-mode)
-(add-hook 'LaTeX-mode-hook 'LaTeX-math-mode)
-
-(add-hook 'LaTeX-mode-hook 'turn-on-reftex)
-(setq reftex-plug-into-AUCTeX t)
-
-(require 'tex)
-(TeX-global-PDF-mode t)
-
-;; C mode
-
-(setq c-default-style "k&r")
-(setq c-basic-offset 4)
-
-(setq c-doc-comment-style
-      '((java-mode . javadoc)
-        (pike-mode . autodoc)
-        (c-mode    . javadoc)
-        (c++-mode  . javadoc)))
-
-(defun my-cc-init-hook ()
-  "Initialization hook for CC-mode runs before any other hooks."
-  (hide-ifdef-mode)
-  (setq hide-ifdef-shadow t))
-(add-hook 'c-mode-hook 'my-cc-init-hook)
-(add-hook 'c++-mode-hook 'my-cc-init-hook)
-
-(add-to-list 'auto-mode-alist '("\\.hpp\\'" . c++-mode))
-
-;; CSS style
-(setq css-indent-offset 2)
+(require 'iso-transl)
+(require 'use-package)
 
 ;; No menu, scrollbar, display line and column
 (menu-bar-mode -1)
@@ -147,12 +25,109 @@
 (column-number-mode t)
 (line-number-mode t)
 
+;; No split screen at startup
+(setq inhibit-startup-screen t)
+
+;; Encoding
+(set-language-environment "UTF-8")
+
+;; Selection mode
+(delete-selection-mode 1)
+
+;; Indentation mode
+(setq-default indent-tabs-mode nil)
+(setq tab-width 4)
+
+;; Auto complete + Yasnippet
+
+(use-package yasnippet
+    :config
+    (yas-global-mode 1))
+
+(use-package auto-complete
+    :config
+    (require 'auto-complete-config)
+    (ac-config-default)
+    (require 'ac-c-headers)
+    (require 'ac-math)
+    (add-to-list 'ac-modes 'latex-mode)
+    (add-to-list 'ac-modes 'org-mode)
+    (add-to-list 'ac-sources 'ac-source-c-headers)
+    (defun ac-latex-mode-setup () ; add ac-sources to default ac-sources
+      (setq ac-sources
+            (append '(ac-source-math-unicode
+                      ac-source-math-latex
+                      ac-source-latex-commands)
+                    ac-sources)))
+    (add-hook 'LaTeX-mode-hook 'ac-latex-mode-setup)
+    (global-auto-complete-mode t)
+    (ac-flyspell-workaround)
+    :config
+    (setq ac-math-unicode-in-math-p t))
+
+;; Latex
+(use-package tex-mik
+    :config
+    (setq TeX-auto-save t)
+    (setq TeX-parse-self t)
+    (setq-default TeX-master nil)
+    (defun my-latex-mode-setup ()
+      "Redefines and updates variables for various customizations."
+      (setq LaTeX-paragraph-commands
+            '("If" "State" "Loop" "For" "ForAll"))
+      (setq LaTeX-begin-regexp
+            (concat LaTeX-begin-regexp "\\|If\\b" "\\|Loop\\b" "\\|For\\b" "\\|ForAll\\b"))
+      (setq LaTeX-end-regexp
+            (concat LaTeX-end-regexp "\\|EndIf\\b" "\\|EndLoop\\b"
+                    "\\|EndFor\\b" "\\|Else\\b" "\\|ElsIf\\b"))
+      (setq LaTeX-paragraph-commands-regexp (LaTeX-paragraph-commands-regexp-make))
+      (defun LaTeX-indent-level-count ()
+        "Count indentation change caused by all \\left, \\right, \\begin, and
+    \\end commands in the current line."
+        (save-excursion
+          (save-restriction
+            (let ((count 0))
+              (narrow-to-region (point)
+                                (save-excursion
+                                  (re-search-forward
+                                   (concat "[^" TeX-esc "]"
+                                           "\\(" LaTeX-indent-comment-start-regexp
+                                           "\\)\\|\n\\|\\'"))
+                                  (backward-char)
+                                  (point)))
+              (while (search-forward TeX-esc nil t)
+                (cond
+                 ((looking-at "left\\b")
+                  (setq count (+ count LaTeX-left-right-indent-level)))
+                 ((looking-at "right\\b")
+                  (setq count (- count LaTeX-left-right-indent-level)))
+                 ((looking-at LaTeX-begin-regexp)
+                  (setq count (+ count LaTeX-indent-level)))
+                 ((looking-at "Else\\b"))
+                 ((looking-at "ElsIf\\b"))
+                 ((looking-at LaTeX-end-regexp)
+                  (setq count (- count LaTeX-indent-level)))
+                 ((looking-at (regexp-quote TeX-esc))
+                  (forward-char 1))))
+              count)))))
+
+    (add-hook 'LaTeX-mode-hook 'my-latex-mode-setup)
+    (add-hook 'LaTeX-mode-hook 'visual-line-mode)
+    (add-hook 'LaTeX-mode-hook 'flyspell-mode)
+    (add-hook 'LaTeX-mode-hook 'LaTeX-math-mode)
+
+    (add-hook 'LaTeX-mode-hook 'turn-on-reftex)
+    (setq reftex-plug-into-AUCTeX t)
+    (require 'tex)
+    (TeX-global-PDF-mode t)
+)
+
+;; CSS style
+(setq css-indent-offset 2)
+
 ;; Markdown mode
-(autoload 'markdown-mode "markdown-mode"
-   "Major mode for editing Markdown files" t)
-(add-to-list 'auto-mode-alist '("\\.text\\'" . markdown-mode))
-(add-to-list 'auto-mode-alist '("\\.markdown\\'" . markdown-mode))
-(add-to-list 'auto-mode-alist '("\\.md\\'" . markdown-mode))
+(use-package markdown-mode
+    :mode "\\.text\\'" "\\.markdown\\'" "\\.md\\'")
 
 ;; White space mode
 (setq whitespace-line-column 100)
@@ -162,7 +137,6 @@
 (add-hook 'python-mode-hook (lambda () (setq whitespace-line-column 140)))
 (add-hook 'LaTeX-mode-hook (lambda () (setq whitespace-line-column -1)))
 
-
 (global-whitespace-mode 1)
 
 ;; Electric pair mode
@@ -170,6 +144,31 @@
 (show-paren-mode 1)
 (setq show-paren-delay 0)
 
+;; C mode
+
+(setq c-default-style "k&r")
+(setq c-basic-offset 4)
+
+(use-package c++1x-minor-mode)
+
+(defun ac-cc-mode-setup ()
+  "Initialization hook for CC-mode runs before any other hooks."
+  (hide-ifdef-mode)
+  (setq hide-ifdef-shadow t)
+  (hs-minor-mode))
+
+(add-hook 'c-mode-common-hook 'ac-cc-mode-setup)
+(add-hook 'c++-mode-common-hook 'ac-cc-mode-setup)
+(add-hook 'auto-complete-mode-hook 'ac-common-setup)
+
+(setq c-doc-comment-style
+      '((java-mode . javadoc)
+        (pike-mode . autodoc)
+        (c-mode    . javadoc)
+        (c++-mode  . javadoc)))
+
+(add-to-list 'auto-mode-alist '("\\.hpp\\'" . c++-mode))
+
 ;; Run C programs directly from within emacs
 (setq execute-command nil)
 (setq compile-command nil)
@@ -231,20 +230,3 @@
   (local-set-key [f8] 'fd-switch-dictionary))
 
 (add-hook 'LaTeX-mode-hook 'key-latex-mode-setup)
-
-(custom-set-variables
- ;; custom-set-variables was added by Custom.
- ;; If you edit it by hand, you could mess it up, so be careful.
- ;; Your init file should contain only one such instance.
- ;; If there is more than one, they won't work right.
- '(custom-safe-themes
-   (quote
-    ("737d9d0e0f6c4279e80f7479ec5138af6e4908a2d052126f254e1e6d1a0d0188" default))))
-(custom-set-faces
- ;; custom-set-faces was added by Custom.
- ;; If you edit it by hand, you could mess it up, so be careful.
- ;; Your init file should contain only one such instance.
- ;; If there is more than one, they won't work right.
- )
-
-(load-theme 'hydandata-light)