;ELC
;;; Compiled by haakon@haakon-laptop on Thu Aug 22 10:19:57 2013
;;; from file /home/haakon/.emacs.d/elpa/python-mode-6.0.10/python-mode.el
;;; in Emacs version 24.2.1
;;; with all optimizations.

;;; This file contains utf-8 non-ASCII characters,
;;; and so cannot be loaded into Emacs 22 or earlier.
(and (boundp 'emacs-version)
     (< (aref emacs-version (1- (length emacs-version))) ?A)
     (string-lessp emacs-version "23")
     (error "`%s' was compiled for Emacs 23 or later" load-file-name))

;;;;;;;;;;;;;;;;;


(byte-code "\300\301!\210\300\302!\210\300\303!\210\300\304!\210\300\305!\210\300\306!\210\300\307!\210\300\310!\210\300\311!\210\312\313\314\315\316\317\320\321&\207" [require comint custom compile ansi-color cc-cmds shell rx flymake imenu custom-declare-group python-mode nil "Support for the Python programming language, <http://www.python.org/>" :group languages :prefix "py-"] 8)
(defconst py-version "6.0.10")
#@19 Used internally. 
(defvar python-local-version nil (#$ . 954))
(make-variable-buffer-local 'python-local-version)
#@40 Returns locally used executable-name. 
(defvar py-local-command nil (#$ . 1074))
(make-variable-buffer-local 'py-local-command)
#@62 Returns locally used executable-name including its version. 
(defvar py-local-versioned-command nil (#$ . 1208))
(make-variable-buffer-local 'py-local-versioned-command)
#@38 String to display in Emacs modeline 
(custom-declare-variable 'python-mode-modeline-display '"Py" '(#$ . 1384) :type 'string :group 'python-mode)
#@152 *Amount of offset per level of indentation.
`\[py-guess-indent-offset]' can usually guess a good value when
you're editing someone else's Python code.
(custom-declare-variable 'py-indent-offset '4 '(#$ . -1537) :type 'integer :group 'python-mode)
(make-variable-buffer-local 'py-indent-offset)
#@130 Where to find pdb.py. Edit this according to your system.

If you ignore the location `M-x py-guess-pdb-path' might display it.

(custom-declare-variable 'pdb-path ''/usr/lib/python2\.7/pdb\.py '(#$ . 1838) :type 'variable :group 'python-mode)
#@78 If indenting functions should report reached indent level.

Default is nil. 
(custom-declare-variable 'py-verbose-p 'nil '(#$ . 2088) :type 'boolean :group 'python-mode)
#@58 If autopair-mode hook should be loaded. Default is `t'. 
(custom-declare-variable 'py-prepare-autopair-mode-p 't '(#$ . 2264) :type 'boolean :group 'python-mode)
#@250 If code in Python shell should be highlighted as in script buffer.

Default is nil.

If `t', related vars like `comment-start' will be set too.
Seems convenient when playing with stuff in IPython shell
Might not be TRT when a lot of output arrives 
(custom-declare-variable 'py-fontify-shell-buffer-p 'nil '(#$ . 2433) :type 'boolean :group 'python-mode)
#@185 If the full PATH/TO/PYTHON should be displayed in shell modeline.

Default is nil. Note: when `py-shell-name' is specified with path, it's shown as an acronym in buffer-name already. 
(custom-declare-variable 'py-modeline-display-full-path-p 'nil '(#$ . 2795) :type 'boolean :group 'python-mode)
#@94 If the modeline acronym should contain chars indicating the home-directory.

Default is nil 
(custom-declare-variable 'py-modeline-acronym-display-home-p 'nil '(#$ . 3097) :type 'boolean :group 'python-mode)
#@53 If py-pdb-path isn't set, find location of pdb.py. 
(defalias 'py-guess-pdb-path #[nil "\303\304\305!!\306\203\307\230\2030\310\311	@\"\203*\310\312	@\"\204*\304\313	@\314Q!	A\202\203E\n\203O\315 \203O\316\317\"\210\202O\315 \203O\316\317\320\"\210\321P*\207" [erg ele py-verbose-p split-string shell-command-to-string "whereis python" nil "" string-match "^/" "/man" "find " " -type f -name \"pdb.py\"" interactive-p message "%s" "pdb.py not found, please customize `pdb-path'" "'"] 4 (#$ . 3311) nil])
#@134 Directory where python-mode.el and it's subdirectories should be installed. Needed for completion and other environment stuff only. 
(custom-declare-variable 'py-install-directory '"" '(#$ . 3843) :type 'string :group 'python-mode)
#@109 If in cases, `py-install-directory' isn't set,  `py-set-load-path'should guess it from `buffer-file-name'. 
(custom-declare-variable 'py-guess-py-install-directory-p 't '(#$ . 4082) :type 'boolean :group 'python-mode)
#@113 If functions moving point like `py-forward-into-nomenclature' should report reached position.

Default is nil. 
(custom-declare-variable 'py-report-position-p 'nil '(#$ . 4307) :type 'boolean :group 'python-mode)
#@91 File where extensions to python-mode.el should be installed. Used by virtualenv support. 
(custom-declare-variable 'py-extensions '"py-extensions.el" '(#$ . 4526) :type 'string :group 'python-mode)
#@56 If hide-show minor-mode should be on, default is nil. 
(custom-declare-variable 'py-hide-show-minor-mode-p 'nil '(#$ . 4730) :type 'boolean :group 'python-mode)
#@90 When non-nil, command `org-cycle' is available at shift-TAB, <backtab>

Default is nil. 
(custom-declare-variable 'py-org-cycle-p 'nil '(#$ . 4897) :type 'boolean :group 'python-mode)
#@107 If `ipython-complete' should use a separate shell. Thus prompt-counter is not incremented by completion. 
(custom-declare-variable 'ipython-complete-use-separate-shell-p 'nil '(#$ . 5088) :type 'boolean :group 'python-mode)
#@54 If outline minor-mode should be on, default is `t'. 
(custom-declare-variable 'py-outline-minor-mode-p 't '(#$ . 5318) :type 'boolean :group 'python-mode)
#@36 Keywords composing visible heads. 
(custom-declare-variable 'py-outline-mode-keywords ''("class" "def" "elif" "else" "except" "for" "if" "while" "finally" "try" "with") '(#$ . 5479) :type '(repeat string) :group 'python-mode)
#@76 If `python-mode' should start a python-shell, `py-shell'. Default is `t'. 
(custom-declare-variable 'py-start-run-py-shell 't '(#$ . 5711) :type 'boolean :group 'python-mode)
#@165 If `python-mode' should start an ipython-shell. Default is `t'.

A running ipython-shell presently is needed by `ipython-complete', otherwise first try will fail. 
(custom-declare-variable 'py-start-run-ipython-shell 't '(#$ . 5893) :type 'boolean :group 'python-mode)
#@83 If a newline is inserted, when line after block isn't empty. Default is non-nil. 
(custom-declare-variable 'py-close-provides-newline 't '(#$ . 6168) :type 'boolean :group 'python-mode)
(make-variable-buffer-local 'py-close-provides-newline)
#@112 If point should follow dedent or kind of electric move to end of line. Default is t - keep relative position. 
(custom-declare-variable 'py-dedent-keep-relative-column 't '(#$ . 6417) :type 'boolean :group 'python-mode)
#@134 If `t', indents to 1+ column of opening delimiter. If `nil', indent adds one level to the beginning of statement. Default is `nil'. 
(custom-declare-variable 'py-indent-honors-multiline-listing 'nil '(#$ . 6644) :type 'boolean :group 'python-mode)
#@74 If non-nil, indents to column of inlined comment start.
Default is nil. 
(custom-declare-variable 'py-indent-honors-inline-comment 'nil '(#$ . 6898) :type 'boolean :group 'python-mode)
#@129 If non-nil, closing parentesis dedents onto column of statement, otherwise keeps additional `py-indent-offset', default is nil 
(custom-declare-variable 'py-closing-list-dedents-bos 'nil '(#$ . 7090) :type 'boolean :group 'python-mode)
#@81 `py-electric-colon' feature.  Default is `nil'. See lp:837065 for discussions. 
(custom-declare-variable 'py-electric-colon-active-p 'nil '(#$ . 7332) :type 'boolean :group 'python-mode)
#@60 If "#" should call `py-electric-comment'. Default is `t'. 
(custom-declare-variable 'py-electric-comment-p 't '(#$ . 7525) :type 'boolean :group 'python-mode)
#@64 If py-electric-comment should add a space.  Default is `nil'. 
(custom-declare-variable 'py-electric-comment-add-space-p 'nil '(#$ . 7690) :type 'boolean :group 'python-mode)
#@82 If py-mark-def-or-class functions should mark decorators too. Default is `nil'. 
(custom-declare-variable 'py-mark-decorators 'nil '(#$ . 7871) :type 'boolean :group 'python-mode)
#@59 *Non-nil means TAB in Python mode calls `py-indent-line'.
(custom-declare-variable 'py-tab-indent 't '(#$ . -8057) :type 'boolean :group 'python-mode)
#@145 When set, enforces function todo completion, default is nil.

Normally python-mode, resp. inferior-python-mode know best which functin to use. 
(custom-declare-variable 'py-complete-function ''nil '(#$ . 8215) :type '(choice (const :tag "default" nil) (const :tag "py-completion-at-point" py-completion-at-point) (const :tag "Pymacs based py-complete" py-complete) (const :tag "py-shell-complete" py-shell-complete) (const :tag "IPython's ipython-complete" ipython-complete)) :group 'python-mode)
#@1413 Function used for completion in IPython shell buffers.

Minor bug: `ipython-complete' raises the prompt counter when completion done

Richard Everson commented:

    I don't know how to stop IPython from incrementing the prompt
    counter, but using py-completion-at-point just hangs emacs for
    me. If I start with a new IPython shell, then

    In [1]: import sys

    In [2]: sys.pa

    then M-x py-completion-at-point, hoping to complete to sys.path, Emacs
    hangs.  Escaping out of it shows that the *Python* buffer has the
    contents:

    >>> Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    NameError: name 'nil' is not defined
    >>> =
    [ ... ]

    On the other hand, IPython's interaction and completion itself is pretty
    impressive (for versions greater than 0.10 at least): it inserts the
    correct indentation for for, if, etc and it will show completions even
    within a loop.  Here's an example from a terminal shell:

    In [1]:

    In [1]: for i in range(3):
       ...:     print i, sys.p<------------ Pressed tab here; indentation inser=
    ted automatically
    sys.path                 sys.path_importer_cache  sys.prefix
    sys.path_hooks           sys.platform             sys.py3kwarning
       ...:     print i, sys.path<------------ Pressed tab again
    sys.path                 sys.path_hooks           sys.path_importer_cache

(custom-declare-variable 'ipython-complete-function ''ipython-complete '(#$ . 8720) :type '(choice (const :tag "py-completion-at-point" py-completion-at-point) (const :tag "py-shell-complete" py-shell-complete) (const :tag "Pymacs based py-complete" py-complete) (const :tag "IPython's ipython-complete" ipython-complete)) :group 'python-mode)
(make-variable-buffer-local 'ipython-complete-function)
#@97 Set by python-mode-hook resp. to environment.

`py-complete-function', when set, overrides it. 
(defvar py-local-complete-function nil (#$ . 10538))
(make-variable-buffer-local 'py-local-complete-function)
#@55 Default string specifying encoding of a Python file. 
(custom-declare-variable 'py-encoding-string '" # -*- coding: utf-8 -*-" '(#$ . 10750) :type 'string :group 'python-mode)
#@44 Matches encoding string of a Python file. 
(defvar py-encoding-string-re "^[ 	]*#[ 	]*-\\*-[ 	]*coding:.+-\\*-" (#$ . 10932))
(byte-code "\301\302\207" [symbol-definition-start-re "^[ 	]*(\\(defun\\|defvar\\|defcustom\\)" nil] 1)
#@39 Detecting the shell in head of file. 
(custom-declare-variable 'py-shebang-startstring '"#! /bin/env" '(#$ . 11169) :type 'string :group 'python-mode)
#@39 Detecting the shell in head of file. 
(defvar py-shebang-regexp "#![ 	]?\\([^ 	\n]+\\)[ 	]?\\([biptj]+ython[^ 	\n]*\\)" (#$ . 11326))
#@68 *List of string arguments to be used when starting a Python shell.
(custom-declare-variable 'py-python-command-args ''("-i") '(#$ . -11466) :type '(repeat string) :group 'python-mode)
(byte-code "\300\301!\210\302\301\303\"\210\304\305\306\307#\207" [make-variable-buffer-local py-python-command-args set-default ("-i") make-obsolete-variable py-jpython-command-args py-jython-command-args nil] 4)
#@68 *List of string arguments to be used when starting a Jython shell.
(custom-declare-variable 'py-jython-command-args ''("-i") '(#$ . -11870) :type '(repeat string) :group 'python-mode :tag "Jython Command Args")
#@98 If temporary buffers and files used by functions executing region should be deleted afterwards. 
(custom-declare-variable 'py-cleanup-temporary 't '(#$ . 12087) :type 'boolean :group 'python-mode)
#@125 When line starts a multiline-assignment: How many colums indent should be more than opening bracket, brace or parenthesis. 
(custom-declare-variable 'py-lhs-inbound-indent '1 '(#$ . 12291) :type 'integer :group 'python-mode)
(make-variable-buffer-local 'py-lhs-inbound-indent)
#@120 When inside a multiline-assignment: How many colums indent should be more than opening bracket, brace or parenthesis. 
(custom-declare-variable 'py-rhs-inbound-indent '1 '(#$ . 12575) :type 'integer :group 'python-mode)
(make-variable-buffer-local 'py-rhs-inbound-indent)
#@150 *Additional amount of offset to give for some continuation lines.
Continuation lines are those that immediately follow a backslash
terminated line. 
(custom-declare-variable 'py-continuation-offset '2 '(#$ . -12854) :type 'integer :group 'python-mode)
#@87 Python-mode starts `indent-tabs-mode' with the value specified here, default is nil. 
(custom-declare-variable 'py-indent-tabs-mode 'nil '(#$ . 13112) :type 'boolean :group 'python-mode)
#@958 *Should `python-mode' try to automagically set some indentation variables?
When this variable is non-nil, two things happen when a buffer is set
to `python-mode':

    1. `py-indent-offset' is guessed from existing code in the buffer.
       Only guessed values between 2 and 8 are considered.  If a valid
       guess can't be made (perhaps because you are visiting a new
       file), then the value in `py-indent-offset' is used.

    2. `indent-tabs-mode' is turned off if `py-indent-offset' does not
       equal `tab-width' (`indent-tabs-mode' is never turned on by
       Python mode).  This means that for newly written code, tabs are
       only inserted in indentation if one tab is one indentation
       level, otherwise only spaces are used.

Note that both these settings occur *after* `python-mode-hook' is run,
so if you want to defeat the automagic configuration, you must also
set `py-smart-indentation' to nil in your `python-mode-hook'.
(custom-declare-variable 'py-smart-indentation 't '(#$ . -13306) :type 'boolean :group 'python-mode)
(make-variable-buffer-local 'py-smart-indentation)
#@238 *Flag describing how multi-line triple quoted strings are aligned.
When this flag is non-nil, continuation lines are lined up under the
preceding line's indentation.  When this flag is nil, continuation
lines are aligned to column zero.
(custom-declare-variable 'py-align-multiline-strings-p 't '(#$ . -14422) :type '(choice (const :tag "Align under preceding line" t) (const :tag "Align to column zero" nil)) :group 'python-mode)
#@345 *String used by \[comment-region] to comment out a block of code.
This should follow the convention for non-indenting comment lines so
that the indentation commands won't get confused (i.e., the string
should be of the form `#x...' where `x' is not a blank or a tab, and
`...' is arbitrary).  However, this string should not end in whitespace.
(custom-declare-variable 'py-block-comment-prefix '"##" '(#$ . -14860) :type 'string :group 'python-mode)
#@38 When t, comment lines are indented. 
(custom-declare-variable 'py-indent-comments 't '(#$ . 15316) :type 'boolean :group 'python-mode)
#@63 Values set by defcustom only will not be seen in batch-mode. 
(defvar py-separator-char 47 (#$ . 15457))
#@143 The character, which separates the system file-path components.

Precedes guessing when not empty, returned by function `py-separator-char'. 
(custom-declare-variable 'py-separator-char '47 '(#$ . 15569) :type 'character :group 'python-mode)
#@149 If set, will take precedence over guessed values from `py-temp-directory'. Default is the empty string.

When set, make sure the directory exists. 
(custom-declare-variable 'py-custom-temp-directory '"" '(#$ . 15818) :type 'string :group 'python-mode)
#@331 *Directory used for temporary files created by a *Python* process.
By default, guesses the first directory from this list that exists and that you
can write into: the value (if any) of the environment variable TMPDIR,
/usr/tmp, /tmp, /var/tmp, or the current directory.

`py-custom-temp-directory' will take precedence when setq 
(defvar py-temp-directory (byte-code "\306\307\n\310\230\204,	\n!\203\311\n!\211\202)\312\311\n!!\203&\313\314!\202)\313\315!\204\250	\316\317!!\203<\316\317!\211\204\250	\316\320!!\203L\316\320!\211\204\250	\321!\203X\321\211\204\250	\322!\203d\322\211\204\250	\323!\203p\323\211\204\250\324=\203\202	\325!\203\202\325\211\204\250\326=\204\216\327=\203\244	\330\331\f!\332Q!\203\244\330\331\f!\332Q\211\204\250\313\333!\210\205\257\211*\207" [erg ok py-custom-temp-directory system-type py-separator-char py-temp-directory (lambda (x) (and x (setq x (expand-file-name x)) (file-directory-p x) (file-writable-p x) x)) nil "" expand-file-name file-directory-p error "py-custom-temp-directory set but not writable" "py-custom-temp-directory not an existing directory" getenv "TMPDIR" "TEMP/TMP" "/usr/tmp" "/tmp" "/var/tmp" darwin "/var/folders" ms-dos windows-nt "c:" char-to-string "Users" "Couldn't find a usable temp directory -- set `py-temp-directory'"] 4) (#$ . -16077))
#@420 *Ring the bell if `tab-width' is changed.
If a comment of the form

  	# vi:set tabsize=<number>:

is found before the first code line when the file is entered, and the
current value of (the general Emacs variable) `tab-width' does not
equal <number>, `tab-width' is set to <number>, a message saying so is
displayed in the echo area, and if `py-beep-if-tab-change' is non-nil
the Emacs bell is also rung as a warning.
(custom-declare-variable 'py-beep-if-tab-change 't '(#$ . -17431) :type 'boolean :group 'python-mode)
#@243 *Jump to innermost exception frame in *Python Output* buffer.
When this variable is non-nil and an exception occurs when running
Python code synchronously in a subprocess, jump immediately to the
source code of the innermost traceback frame.
(custom-declare-variable 'py-jump-on-exception 't '(#$ . -17959) :type 'boolean :group 'python-mode)
#@131 If not nil, ask about which buffers to save before executing some code.
Otherwise, all modified buffers are saved without asking.
(custom-declare-variable 'py-ask-about-save 't '(#$ . 18309) :type 'boolean :group 'python-mode)
#@70 *Function called by `py-electric-backspace' when deleting backwards.
(custom-declare-variable 'py-backspace-function ''backward-delete-char-untabify '(#$ . -18542) :type 'function :group 'python-mode)
#@66 *Function called by `py-electric-delete' when deleting forwards.
(custom-declare-variable 'py-delete-function ''delete-char '(#$ . -18749) :type 'function :group 'python-mode)
#@381 *Controls whether the pdbtrack feature is enabled or not.
When non-nil, pdbtrack is enabled in all comint-based buffers,
e.g. shell buffers and the *Python* buffer.  When using pdb to debug a
Python program, pdbtrack notices the pdb prompt and displays the
source file and line that the program is stopped at, much the same way
as gud-mode does for debugging C programs with gdb.
(custom-declare-variable 'py-pdbtrack-do-tracking-p 't '(#$ . -18932) :type 'boolean :group 'python-mode)
(make-variable-buffer-local 'py-pdbtrack-do-tracking-p)
#@157 Supports mapping file paths when opening file buffers in pdbtrack.
When non-nil this is an alist mapping paths in the Python interpreter
to paths in Emacs.
(custom-declare-variable 'py-pdbtrack-filename-mapping 'nil '(#$ . 19481) :type 'alist :group 'python-mode)
#@65 *String to use in the minor mode list when pdbtrack is enabled.
(custom-declare-variable 'py-pdbtrack-minor-mode-string '" PDB" '(#$ . -19751) :type 'string :group 'python-mode)
#@326 Maximum number of characters to search for a Java-ish import statement.
When `python-mode' tries to calculate the shell to use (either a
CPython or a Jython shell), it looks at the so-called `shebang' line
-- i.e. #! line.  If that's not available, it looks at some of the
file heading imports to see if they look Java-like.
(custom-declare-variable 'py-import-check-point-max '20000 '(#$ . 19936) :type 'integer :group 'python-mode)
#@45 Imported packages that imply `jython-mode'.
(custom-declare-variable 'py-jython-packages ''("java" "javax") '(#$ . 20376) :type '(repeat string) :group 'python-mode)
(make-obsolete-variable 'py-jpython-packages 'py-jython-packages nil)
#@166 If `py-current-defun' should jump to the definition, highlight it while waiting PY-WHICH-FUNC-DELAY seconds, before returning to previous position.

Default is `t'.
(custom-declare-variable 'py-current-defun-show 't '(#$ . 20619) :type 'boolean :group 'python-mode)
#@157 When called interactively, `py-current-defun' should wait PY-WHICH-FUNC-DELAY seconds at the definition name found, before returning to previous position. 
(custom-declare-variable 'py-current-defun-delay '2 '(#$ . 20892) :type 'number :group 'python-mode)
#@61 Seconds to wait for output, used by `python-send-receive'. 
(custom-declare-variable 'py-send-receive-delay '5 '(#$ . 21155) :type 'number :group 'python-mode)
#@31 Mode commands will set this. 
(defvar py-exec-command nil (#$ . 21321))
(make-variable-buffer-local 'py-exec-command)
#@31 Mode commands will set this. 
(defvar py-exec-string-command nil (#$ . 21445))
(make-variable-buffer-local 'py-exec-string-command)
(defvar py-which-bufname "Python")
(make-variable-buffer-local 'py-which-bufname)
#@382 If non-nil, \[py-execute-buffer] executes the named
master file instead of the buffer's file.  If the file name has a
relative path, the value of variable `default-directory' for the
buffer is prepended to come up with a file name.

Beside you may set this variable in the file's local
variable section, e.g.:

    # Local Variables:
    # py-master-file: "master.py"
    # End:


(custom-declare-variable 'py-master-file 'nil '(#$ . 21666) :type 'string :group 'python-mode)
(make-variable-buffer-local 'py-master-file)
(defvar py-pychecker-history nil)
#@39 *Shell command used to run Pychecker.
(custom-declare-variable 'py-pychecker-command '"pychecker" '(#$ . -22227) :type 'string :group 'python-mode :tag "Pychecker Command")
#@54 *List of string arguments to be passed to pychecker.
(custom-declare-variable 'py-pychecker-command-args ''("--stdlib") '(#$ . -22406) :type '(repeat string) :group 'python-mode :tag "Pychecker Command Args")
(defvar py-pep8-history nil)
#@34 *Shell command used to run pep8.
(custom-declare-variable 'py-pep8-command '"pep8" '(#$ . -22650) :type 'string :group 'python-mode :tag "PEP 8 Command")
#@65 *List of string arguments to be passed to pep8.

Default is "" 
(custom-declare-variable 'py-pep8-command-args ''("") '(#$ . -22810) :type '(repeat string) :group 'python-mode :tag "PEP 8 Command Args")
(defvar py-pyflakespep8-history nil)
#@44 *Shell command used to run `pyflakespep8'.
(custom-declare-variable 'py-pyflakespep8-command '(concat py-install-directory "pyflakespep8.py") '(#$ . -23056) :type 'string :group 'python-mode :tag "Pyflakespep8 Command")
#@73 *List of string arguments to be passed to pyflakespep8.

Default is "" 
(custom-declare-variable 'py-pyflakespep8-command-args ''("") '(#$ . -23282) :type '(repeat string) :group 'python-mode :tag "Pyflakes-pep8 Command Args")
(defvar py-pyflakes-history nil)
#@38 *Shell command used to run Pyflakes.
(custom-declare-variable 'py-pyflakes-command '"pyflakes" '(#$ . -23548) :type 'string :group 'python-mode :tag "Pyflakes Command")
#@69 *List of string arguments to be passed to pyflakes.

Default is "" 
(custom-declare-variable 'py-pyflakes-command-args ''("") '(#$ . -23723) :type '(repeat string) :group 'python-mode :tag "Pyflakes Command Args")
#@67 *List of string arguments to be passed to pylint.

Default is "" 
(custom-declare-variable 'py-pep8-command-args ''("") '(#$ . -23943) :type '(repeat string) :group 'python-mode :tag "PEP 8 Command Args")
(defvar py-pylint-history nil)
#@36 *Shell command used to run Pylint.
(custom-declare-variable 'py-pylint-command '"pylint" '(#$ . -24185) :type 'string :group 'python-mode :tag "Pylint Command")
#@80 *List of string arguments to be passed to pylint.

Default is "--errors-only" 
(custom-declare-variable 'py-pylint-command-args ''("--errors-only") '(#$ . -24352) :type '(repeat string) :group 'python-mode :tag "Pylint Command Args")
#@131 *Alist of interpreters and python shells. Used by `py-choose-shell'
to select the appropriate python interpreter mode for a file.
(defvar py-shell-alist '(("jython" quote jython) ("python" quote cpython)) (#$ . -24593))
#@63 *A regular expression to match the input prompt of the shell.
(custom-declare-variable 'py-shell-input-prompt-1-regexp '"^>>> " '(#$ . -24819) :type 'string :group 'python-mode)
#@95 *A regular expression to match the input prompt of the shell after the
  first line of input.
(custom-declare-variable 'py-shell-input-prompt-2-regexp '"^[.][.][.] " '(#$ . -25003) :type 'string :group 'python-mode)
#@47 When non-nil switch to the new Python shell. 
(custom-declare-variable 'py-shell-switch-buffers-on-execute-p 't '(#$ . 25225) :type 'boolean :group 'python-mode)
#@51 When non-nil switch to the Python output buffer. 
(custom-declare-variable 'py-switch-buffers-on-execute-p 'nil '(#$ . 25393) :type 'boolean :group 'python-mode)
#@30 When non-nil split windows. 
(custom-declare-variable 'py-split-windows-on-execute-p 't '(#$ . 25561) :type 'boolean :group 'python-mode)
#@81 How window should get splitted to display results of py-execute-... functions. 
(custom-declare-variable 'py-split-windows-on-execute-function ''split-window-vertically '(#$ . 25705) :type '(choice (const :tag "split-window-vertically" split-window-vertically) (const :tag "split-window-horizontally" split-window-horizontally)) :group 'python-mode)
(make-variable-buffer-local 'py-split-windows-on-execute-function)
#@70 Keywords composing visible heads.
Also used by (minor-)outline-mode 
(custom-declare-variable 'py-hide-show-keywords ''("class" "def" "elif" "else" "except" "for" "if" "while" "finally" "try" "with") '(#$ . 26128) :type '(repeat string) :group 'python-mode)
#@53 *Controls if doc strings can be hidden by hide-show
(custom-declare-variable 'py-hide-show-hide-docstrings 't '(#$ . -26392) :type 'boolean :group 'python-mode)
#@37 Hook run when entering Python mode.
(custom-declare-variable 'python-mode-hook 'nil '(#$ . 26559) :group 'python-mode :type 'hook)
(byte-code "\300\301\302\"\210\300\301\303\"\210\300\301\304\"\210\300\301\305\"\210\300\301\306\"\207" [custom-add-option python-mode-hook imenu-add-menubar-index #[nil "\301\211\207" [indent-tabs-mode nil] 2 "Turn off Indent Tabs mode."] turn-on-eldoc-mode abbrev-mode python-setup-brm] 3)
#@98 Non-nil means Python mode creates and displays an index menu of functions and global variables. 
(custom-declare-variable 'py-imenu-create-index-p 'nil '(#$ . 26989) :type 'boolean :group 'python-mode)
#@102 A PATH/TO/EXECUTABLE or default value `py-shell' may look for, if no shell is specified by command. 
(custom-declare-variable 'py-shell-name '"python" '(#$ . 27198) :type 'string :group 'python-mode)
(make-variable-buffer-local 'py-shell-name)
#@67 A PATH/TO/EXECUTABLE or default value used by `py-toggle-shell'. 
(custom-declare-variable 'py-shell-toggle-1 'py-shell-name '(#$ . 27448) :type 'string :group 'python-mode)
(make-variable-buffer-local 'py-shell-toggle-1)
#@67 A PATH/TO/EXECUTABLE or default value used by `py-toggle-shell'. 
(custom-declare-variable 'py-shell-toggle-2 '"python3" '(#$ . 27676) :type 'string :group 'python-mode)
(make-variable-buffer-local 'py-shell-toggle-2)
#@226 Used to determine if a buffer contains Python source code.

If a file is loaded into a buffer that is in one of these major modes, it is considered Python source by `py-load-file', which uses the
value to determine defaults.
(custom-declare-variable 'py-source-modes ''(python-mode jython-mode) '(#$ . 27901) :type '(repeat function) :group 'python-mode)
#@308 Alist of Python input prompts.
Each element has the form (PROGRAM . REGEXP), where PROGRAM is
the value of `py-shell-name' for the python process and
REGEXP is a regular expression matching the Python prompt.
PROGRAM can also be t, which specifies the default when no other
element matches `py-shell-name'.
(custom-declare-variable 'py-shell-prompt-alist ''(("ipython" . "^In \\[[0-9]+\\]: *") (t . "^>>> ")) '(#$ . 28263) :type 'string :group 'python-mode)
#@337 Alist of Python continued-line prompts.
Each element has the form (PROGRAM . REGEXP), where PROGRAM is
the value of `py-shell-name' for the python process and
REGEXP is a regular expression matching the Python prompt for
continued lines.
PROGRAM can also be t, which specifies the default when no other
element matches `py-shell-name'.
(custom-declare-variable 'py-shell-continuation-prompt-alist ''(("ipython" . "^   [.][.][.]+: *") (t . "^[.][.][.] ")) '(#$ . 28728) :type 'string :group 'python-mode)
#@221 A regular expression to match the IPython input prompt and the python
command after it. The first match group is for a command that is rewritten,
the second for a 'normal' command, and the third for a multiline command.
(defvar ipython-de-input-prompt-regexp "\\(?:\nIn \\[[0-9]+\\]: *.*\n----+> \\(.*\n\\)[\n]?\\)\\|\\(?:\nIn \\[[0-9]+\\]: *\\(.*\n\\)\\)\\|^[ ]\\{3\\}[.]\\{3,\\}: *\\(.*\n\\)" (#$ . 29239))
#@61 A regular expression to match the output prompt of IPython.
(defvar ipython-de-output-prompt-regexp "^Out\\[[0-9]+\\]: " (#$ . 29654))
#@199 *Non-nil means, cursor will jump to beginning or end of a block.
This vice versa, to beginning first.
Sets `py-match-paren-key' in python-mode-map.
Customize `py-match-paren-key' which key to use. 
(custom-declare-variable 'py-match-paren-mode 'nil '(#$ . -29796) :type 'boolean :group 'python-mode)
#@345 *String used by \[comment-region] to comment out a block of code.
This should follow the convention for non-indenting comment lines so
that the indentation commands won't get confused (i.e., the string
should be of the form `#x...' where `x' is not a blank or a tab, and
`...' is arbitrary).  However, this string should not end in whitespace.
(custom-declare-variable 'py-match-paren-key '"%" '(#$ . -30103) :type 'string :group 'python-mode)
#@51 *If t, py-indent-forward-line kills empty lines. 
(custom-declare-variable 'py-kill-empty-line 't '(#$ . -30553) :type 'boolean :group 'python-mode)
#@321 Whether to allow loading of Python modules from the current directory.
If this is non-nil, Emacs removes '' from sys.path when starting
an inferior Python process.  This is the default, for security
reasons, as it is easy for the Python process to be started
without the user's realization (e.g. to perform completion).
(custom-declare-variable 'py-remove-cwd-from-path 't '(#$ . 30709) :type 'boolean :group 'python-mode)
#@113 *Controls echoing of arguments of functions & methods in the Imenu buffer.
When non-nil, arguments are printed.
(custom-declare-variable 'py-imenu-show-method-args-p 'nil '(#$ . -31139) :type 'boolean :group 'python-mode)
#@636 *Which Python interpreter is used by default.
The value for this variable can be either `cpython' or `jpython'.

When the value is `cpython', the variables `python-python-command' and
`python-python-command-args' are consulted to determine the interpreter
and arguments to use.

When the value is `jpython', the variables `python-jpython-command' and
`python-jpython-command-args' are consulted to determine the interpreter
and arguments to use.

Note that this variable is consulted only the first time that a Python
mode buffer is visited during an Emacs session.  After that, use
\[py-toggle-shell] to change the interpreter shell.
(custom-declare-variable 'python-default-interpreter ''cpython '(#$ . -31368) :type '(choice (const :tag "Python (a.k.a. CPython)" cpython) (const :tag "JPython" jpython)) :group 'python-mode)
#@68 *List of string arguments to be used when starting a Python shell.
(custom-declare-variable 'python-python-command-args ''("-i") '(#$ . -32202) :type '(repeat string) :group 'python-mode)
#@68 *List of string arguments to be used when starting a Jython shell.
(custom-declare-variable 'python-jython-command-args ''("-i") '(#$ . -32396) :type '(repeat string) :group 'python-mode :tag "JPython Command Args")
#@458 *Controls whether the pdbtrack feature is enabled or not.

When non-nil, pdbtrack is enabled in all comint-based buffers,
e.g. shell interaction buffers and the *Python* buffer.

When using pdb to debug a Python program, pdbtrack notices the
pdb prompt and presents the line in the source file where the
program is stopped in a pop-up buffer.  It's similar to what
gud-mode does for debugging C programs with gdb, but without
having to restart the program.
(custom-declare-variable 'python-pdbtrack-do-tracking-p 't '(#$ . -32619) :type 'boolean :group 'python-mode)
(make-variable-buffer-local 'python-pdbtrack-do-tracking-p)
#@59 *Minor-mode sign to be displayed when pdbtrack is active.
(custom-declare-variable 'python-pdbtrack-minor-mode-string '" PDB" '(#$ . -33252) :type 'string :group 'python-mode)
#@324 Alist of Python input prompts.
Each element has the form (PROGRAM . REGEXP), where PROGRAM is
the value of `python-python-command' for the python process and
REGEXP is a regular expression matching the Python prompt.
PROGRAM can also be t, which specifies the default when no other
element matches `python-python-command'.
(custom-declare-variable 'python-shell-prompt-alist ''(("ipython" . "^In \\[[0-9]+\\]: *") (t . "^>>> ")) '(#$ . 33435) :type 'string :group 'python-mode)
#@353 Alist of Python continued-line prompts.
Each element has the form (PROGRAM . REGEXP), where PROGRAM is
the value of `python-python-command' for the python process and
REGEXP is a regular expression matching the Python prompt for
continued lines.
PROGRAM can also be t, which specifies the default when no other
element matches `python-python-command'.
(custom-declare-variable 'python-shell-continuation-prompt-alist ''(("ipython" . "^   [.][.][.]+: *") (t . "^[.][.][.] ")) '(#$ . 33920) :type 'string :group 'python-mode)
#@82 Shell command to run Python interpreter.
Any arguments can't contain whitespace.
(custom-declare-variable 'python-python-command '"python" '(#$ . 34450) :group 'python-mode :type 'string)
#@82 Shell command to run Jython interpreter.
Any arguments can't contain whitespace.
(custom-declare-variable 'python-jython-command '"jython" '(#$ . 34644) :group 'python-mode :type 'string)
#@125 Input matching this regexp is not saved on the history list.
Default ignores all inputs of 0, 1, or 2 non-blank characters.
(custom-declare-variable 'py-history-filter-regexp '"\\`\\s-*\\S-?\\S-?\\s-*\\'" '(#$ . 34839) :type 'regexp :group 'python-mode)
#@321 Whether to allow loading of Python modules from the current directory.
If this is non-nil, Emacs removes '' from sys.path when starting
an inferior Python process.  This is the default, for security
reasons, as it is easy for the Python process to be started
without the user's realization (e.g. to perform completion).
(custom-declare-variable 'python-remove-cwd-from-path 't '(#$ . 35100) :type 'boolean :group 'python-mode :version "23.3")
#@226 Used to determine if a buffer contains Python source code.

If a file is loaded into a buffer that is in one of these major modes, it is considered Python source by `py-load-file', which uses the
value to determine defaults.
(custom-declare-variable 'python-source-modes ''(python-mode jython-mode) '(#$ . 35550) :type '(repeat function) :group 'python-mode)
#@137 Packages implying `jython-mode'.
If these are imported near the beginning of the buffer, `python-mode'
actually punts to `jython-mode'.
(custom-declare-variable 'python-jython-packages ''("java" "javax" "org" "com") '(#$ . 35916) :type '(repeat string) :group 'python-mode)
(custom-declare-face 'py-number-face '((t (:inherit default))) "Highlight numbers. " :group 'python-mode)
(defvar py-number-face 'py-number-face)
(custom-declare-face 'py-XXX-tag-face '((t (:inherit font-lock-string-face))) "XXX\\|TODO\\|FIXME " :group 'python-mode)
(defvar py-XXX-tag-face 'py-XXX-tag-face)
(custom-declare-face 'py-pseudo-keyword-face '((t (:inherit font-lock-keyword-face))) "Face for pseudo keywords in Python mode, like self, True, False, Ellipsis." :group 'python-mode)
(defvar py-pseudo-keyword-face 'py-pseudo-keyword-face)
(custom-declare-face 'py-variable-name-face '((t (:inherit default))) "Face method decorators." :group 'python-mode)
(defvar py-variable-name-face 'py-variable-name-face)
(custom-declare-face 'py-decorators-face '((t (:inherit font-lock-keyword-face))) "Face method decorators." :group 'python-mode)
(defvar py-decorators-face 'py-decorators-face)
(custom-declare-face 'py-builtins-face '((t (:inherit font-lock-builtin-face))) "Face for builtins like TypeError, object, open, and exec." :group 'python-mode)
(defvar py-builtins-face 'py-builtins-face)
(custom-declare-face 'py-class-name-face '((t (:inherit font-lock-type-face))) "Face for classes." :group 'python-mode)
(defvar py-class-name-face 'py-class-name-face)
(custom-declare-face 'py-exception-name-face '((t (:inherit font-lock-builtin-face))) "." :group 'python-mode)
(defvar py-exception-name-face 'py-exception-name-face)
#@235 If `t', py-shell will use `py-shell-local-path' instead
  of default Python.

Making switch between several virtualenv's easier,
 `python-mode' should deliver an installer, so named-shells pointing to virtualenv's will be available. 
(custom-declare-variable 'py-use-local-default 'nil '(#$ . 37634) :type 'boolean :group 'python-mode)
#@98 If `py-use-local-default' is non-nil, `py-shell' will use EXECUTABLE indicated here incl. path. 
(custom-declare-variable 'py-shell-local-path '"" '(#$ . 37976) :type 'string :group 'python-mode)
#@131 If level of indentation should be displayed at start.
Toggle buffer local status via `M-x highlight-indentation' during session. 
(custom-declare-variable 'highlight-indentation 'nil '(#$ . 38179) :type 'boolean :group 'python-mode)
(make-variable-buffer-local 'highlight-indentation)
(defvar highlight-indent-active nil)
(byte-code "\300\301!\210\302\303\304\305#\207" [make-variable-buffer-local highlight-indent-active custom-declare-face highlight-indent-face ((((class color) (background dark)) (:background "grey33")) (((class color) (background light)) (:background "grey"))) "Basic face for highlighting indentation guides."] 4)
(defvar highlight-indent-offset 4)
(set-default 'highlight-indent-offset 4)
(defvar ruby-indent-level nil)
(defvar nxml-child-indent nil)
#@43 Make sure `highlight-indentation' is on. 
(defalias 'highlight-indentation-on #[nil "\301\300!\210\302\303 \210\304\305!\205\306\307!\207" [highlight-indent-active make-local-variable nil highlight-indentation called-interactively-p any message "highlight-indentation ON"] 2 (#$ . 38960) nil])
#@44 Make sure `highlight-indentation' is off. 
(defalias 'highlight-indentation-off #[nil "\301\300!\210\302\303 \210\304\305!\205\306\307!\207" [highlight-indent-active make-local-variable t highlight-indentation called-interactively-p any message "highlight-indentation OFF"] 2 (#$ . 39263) nil])
#@197 Toggle highlight indentation.
Optional argument INDENT-WIDTH specifies which indentation
level (spaces only) should be highlighted, if omitted
indent-width will be guessed from current major-mode
(defalias 'highlight-indentation #[(&optional indent-width) "\306\307S\"\n\204h\310\300!\210\203\202O\f\311=\203+\312\305!\203&
\202O\202O\f\313=\2036\202O\f\314=\203A\202O\315\316!\203L\202O\317\300!\310\302!\210\320\321\322	\323BC\"\210\324\306\325\"!\210\202z\310\302!\210\322\326\322	\327BC\"\210\324\330!\210\331 )\207" [highlight-indent-offset re highlight-indent-active indent-width major-mode python-indent format "\\( \\) \\{%s\\}" make-local-variable python-mode boundp ruby-mode nxml-mode local-variable-p c-basic-offset default-value t font-lock-add-keywords nil ((1 'highlight-indent-face)) message "highlight-indentation with indent-width %s" font-lock-remove-keywords ((1 'highlight-indent-face)) "highlight-indentation OFF" font-lock-fontify-buffer py-indent-offset ruby-indent-level nxml-child-indent] 4 (#$ . 39568) "P"])
#@207 If underscore chars should be of syntax-class `word', not of `symbol'.

Underscores in word-class makes `forward-word' etc. travel the indentifiers. Default is `t'.

See bug report at launchpad, lp:940812 
(custom-declare-variable 'py-underscore-word-syntax-p 't '(#$ . 40642) :type 'boolean :group 'python-mode)
#@147 When `t' `python-mode' will not take resort nor check for installed Python executables. Default is nil.

See bug report at launchpad, lp:944093. 
(custom-declare-variable 'py-edit-only-p 'nil '(#$ . 40962) :type 'boolean :group 'python-mode)
#@51 Used internally, see `toggle-force-local-shell'. 
(defvar py-force-local-shell-p nil (#$ . 41210))
#@126 When `t', execution with kind of Python specified in `py-shell-name' is enforced, possibly shebang doesn't take precedence. 
(custom-declare-variable 'py-force-py-shell-name-p 'nil '(#$ . 41316) :type 'boolean :group 'python-mode)
(defvar python-mode-v5-behavior nil)
#@146 Execute region through `shell-command-on-region' as
v5 did it - lp:990079. This might fail with certain chars - see UnicodeEncodeError lp:550661
(custom-declare-variable 'python-mode-v5-behavior-p 'nil '(#$ . 41591) :type 'boolean :group 'python-mode)
#@138 Messages a warning, when `py-temp-directory' contains files susceptible being left by previous Python-mode sessions. See also lp:987534 
(custom-declare-variable 'py-warn-tmp-files-left-p 'nil '(#$ . 41850) :type 'boolean :group 'python-mode)
#@70 Delay needed by execute functions when no IPython shell is running. 
(custom-declare-variable 'py-ipython-execute-delay '0.3 '(#$ . 42099) :type 'float :group 'python-mode)
#@45 Default buffer name for Python interpreter.
(custom-declare-variable 'python-shell-buffer-name '"Python" '(#$ . 42278) :type 'string :group 'python-mode :safe 'stringp)
#@39 Default Python interpreter for shell.
(custom-declare-variable 'python-shell-interpreter '"python" '(#$ . 42453) :type 'string :group 'python-mode :safe 'stringp)
#@58 Default buffer name for the Internal Python interpreter.
(custom-declare-variable 'python-shell-internal-buffer-name '"Python Internal" '(#$ . 42622) :type 'string :group 'python-mode :safe 'stringp)
#@47 Default arguments for the Python interpreter.
(custom-declare-variable 'python-shell-interpreter-args '"-i" '(#$ . 42828) :type 'string :group 'python-mode :safe 'stringp)
#@121 Regular Expression matching top-level input prompt of python shell.
It should not contain a caret (^) at the beginning.
(custom-declare-variable 'python-shell-prompt-regexp '">>> " '(#$ . 43007) :type 'string :group 'python-mode :safe 'stringp)
#@117 Regular Expression matching block input prompt of python shell.
It should not contain a caret (^) at the beginning.
(custom-declare-variable 'python-shell-prompt-block-regexp '"[.][.][.] " '(#$ . 43259) :type 'string :group 'python-mode :safe 'stringp)
#@112 Regular Expression matching output prompt of python shell.
It should not contain a caret (^) at the beginning.
(custom-declare-variable 'python-shell-prompt-output-regexp '"" '(#$ . 43519) :type 'string :group 'python-mode :safe 'stringp)
#@115 Regular Expression matching pdb input prompt of python shell.
It should not contain a caret (^) at the beginning.
(custom-declare-variable 'python-shell-prompt-pdb-regexp '"[(<]*[Ii]?[Pp]db[>)]+ " '(#$ . 43765) :type 'string :group 'python-mode :safe 'stringp)
#@167 Seconds to wait for process output before code setup.
If output is received before the especified time then control is
returned in that moment and not after waiting.
(custom-declare-variable 'python-shell-send-setup-max-wait '5 '(#$ . 44033) :type 'integer :group 'python-mode :safe 'integerp)
#@276 List of environment variables for Python shell.
This variable follows the same rules as `process-environment'
since it merges with it before the process creation routines are
called.  When this variable is nil, the Python shell is run with
the default `process-environment'.
(custom-declare-variable 'python-shell-process-environment 'nil '(#$ . 44334) :type '(repeat string) :group 'python-mode :safe 'listp)
#@158 List of extra pythonpaths for Python shell.
The values of this variable are added to the existing value of
PYTHONPATH in the `process-environment' variable.
(custom-declare-variable 'python-shell-extra-pythonpaths 'nil '(#$ . 44751) :type '(repeat string) :group 'python-mode :safe 'listp)
#@244 List of path to search for binaries.
This variable follows the same rules as `exec-path' since it
merges with it before the process creation routines are called.
When this variable is nil, the Python shell is run with the
default `exec-path'.
(custom-declare-variable 'python-shell-exec-path 'nil '(#$ . 45048) :type '(repeat string) :group 'python-mode :safe 'listp)
#@231 Path to virtualenv root.
This variable, when set to a string, makes the values stored in
`python-shell-process-environment' and `python-shell-exec-path'
to be modified properly so shells are started with the specified
virtualenv.
(custom-declare-variable 'python-shell-virtualenv-path 'nil '(#$ . 45423) :type 'string :group 'python-mode :safe 'stringp)
#@35 Python code to get a module path.
(custom-declare-variable 'python-ffap-setup-code '"def __FFAP_get_module_path(module):\n    try:\n        import os\n        path = __import__(module).__file__\n        if path[-4:] == '.pyc' and os.path.exists(path[0:-1]):\n            path = path[:-1]\n        return path\n    except:\n        return ''" '(#$ . 45783) :type 'string :group 'python-mode :safe 'stringp)
#@61 Python code used to get a string with the path of a module.
(custom-declare-variable 'python-ffap-string-code '"__FFAP_get_module_path('''%s''')\n" '(#$ . 46195) :type 'string :group 'python-mode :safe 'stringp)
(defvar python--prompt-regexp nil)
#@206 Actual command used to run Python.
May be `python-python-command' or `python-jython-command', possibly
modified by the user.  Additional arguments are added when the command
is used by `run-python' et al.
(defvar python-command python-python-command (#$ . 46449))
#@677 *The current Python process buffer.

Commands that send text from source buffers to Python processes have
to choose a process to send to.  This is determined by buffer-local
value of `python-buffer'.  If its value in the current buffer,
i.e. both any local value and the default one, is nil, `run-python'
and commands that send to the Python process will start a new process.

Whenever \[run-python] starts a new process, it resets the default
value of `python-buffer' to be the new process's buffer and sets the
buffer-local value similarly if the current buffer is in Python mode
or Inferior Python mode, so that source buffer stays associated with a
specific sub-process. 
(defvar python-buffer nil (#$ . -46720))
(make-variable-buffer-local 'python-buffer)
#@54 Function for `ffap-alist' to return path for MODULE.
(defalias 'python-ffap-module-path #[(module) "\305=\203\f\306p!\206\307 \211\205%\310\311\n\"	\"\211\205$\312\f\313\314#))\207" [major-mode process python-ffap-string-code module module-file inferior-python-mode get-buffer-process python-shell-get-process python-shell-send-string-no-output format substring-no-properties 1 -1] 5 (#$ . 47487)])
(eval-after-load "ffap" '(progn (push '(python-mode . python-ffap-module-path) ffap-alist) (push '(inferior-python-mode . python-ffap-module-path) ffap-alist)))
#@50 List of code run by `py-shell-send-setup-codes'.
(custom-declare-variable 'python-shell-setup-codes ''(python-shell-completion-setup-code python-ffap-setup-code python-eldoc-setup-code) '(#$ . 48062) :type '(repeat symbol) :group 'python-mode :safe 'listp)
#@55 `compilation-error-regexp-alist' for inferior Python.
(custom-declare-variable 'python-shell-compilation-regexp-alist '`((,(rx line-start (1+ (any " 	")) "File \"" (group (1+ (not (any "\"<")))) "\", line " (group (1+ digit))) 1 2) (,(rx " in file " (group (1+ not-newline)) " on line " (group (1+ digit))) 1 2) (,(rx line-start "> " (group (1+ (not (any "(\"<")))) "(" (group (1+ digit)) ")" (1+ (not (any "("))) "()") 1 2)) '(#$ . 48325) :type '(alist string) :group 'python-mode)
#@32 Syntax table for Python files.
(defvar python-mode-syntax-table nil (#$ . 48814))
(byte-code "\306 \307\310 \311\312\fW\203-\313U\204&\n	H\232\203&\314\315#\210T\211\202
,\314\316\315#\210\314\317\315#\210\314\320\321#\210\314\322\323#\210\314\324\325#\210\314\326\327#\210
\203\\\314\313\330#\210)\306\207" [table sst symbol i #:--cl-dotimes-temp-- py-underscore-word-syntax-p make-syntax-table (3) standard-syntax-table 128 0 95 modify-syntax-entry "." 36 37 35 "<" 10 ">" 39 "\"" 96 "$" "w" python-mode-syntax-table] 5)
#@92 Syntax table giving `.' symbol syntax.
Otherwise inherits from `python-mode-syntax-table'.
(defconst python-dotty-syntax-table (byte-code "\302 \303	\"\210\304\305\306#\210)\207" [table python-mode-syntax-table make-syntax-table set-char-table-parent modify-syntax-entry 46 "_"] 4) (#$ . 49370))
#@121 Clone local variables from FROM-BUFFER.
Optional argument REGEXP selects variables to clone and defaults
to "^python-".
(defalias 'python-util-clone-local-variables #[(from-buffer &optional regexp) "\301\302\303!\"\207" [from-buffer mapc #[(pair) "@9\205\302	\206\f\303\304@!\"\205\305@!AL\207" [pair regexp string-match "^python-" symbol-name make-local-variable] 4] buffer-local-variables] 4 (#$ . 49677)])
#@125 Send all setup code for shell.
This function takes the list of setup code to send from the
`python-shell-setup-codes' list.
(defalias 'py-send-shell-setup-code #[nil "\304p!\305\306\"\210	\307\211\205&@\211\203\310\nJ\"\210A\211\204\307+\207" [process python-shell-setup-codes code #1=#:--cl-dolist-temp-- get-buffer-process accept-process-output 1 nil py-send-string] 4 (#$ . 50103)])
#@387 Calculate the appropiate process name for inferior Python process.
If DEDICATED is t and the variable `buffer-file-name' is non-nil
returns a string with the form
`python-shell-buffer-name'[variable `buffer-file-name'] else
returns the value of `python-shell-buffer-name'.  After
calculating the process name adds the buffer name for the process
in the `same-window-buffer-names' list.
(defalias 'python-shell-get-process-name #[(dedicated) "\203	\203\304\305\n	#\202\304\306\n\"\307\310\311\304\312\"!\"\210)\207" [dedicated buffer-file-name python-shell-buffer-name process-name format "%s[%s]" "%s" add-to-list same-window-buffer-names purecopy "*%s*"] 6 (#$ . 50510)])
#@248 Calculate the appropiate process name for Internal Python process.
The name is calculated from `python-shell-global-buffer-name' and
a hash of all relevant global shell settings in order to ensure
uniqueness for different types of configurations.
(defalias 'python-shell-internal-get-process-name #[nil "\306\307\310\311 	\n\312\313\f\314#\312\315
\314#\312\315\314#\312\315\314#\206%\314\312\315\314#\260\n!#\207" [python-shell-internal-buffer-name python-shell-prompt-regexp python-shell-prompt-block-regexp python-shell-prompt-output-regexp python-shell-setup-codes python-shell-process-environment format "%s [%s]" md5 python-shell-parse-command mapconcat symbol-value "" identity python-shell-extra-pythonpaths python-shell-exec-path python-shell-virtualenv-path] 17 (#$ . 51200)])
#@67 Calculate the string used to execute the inferior Python process.
(defalias 'python-shell-parse-command #[nil "\302\303	#\207" [python-shell-interpreter python-shell-interpreter-args format "%s %s"] 4 (#$ . 52004)])
#@69 Calculate process environment given `python-shell-virtualenv-path'.
(defalias 'python-shell-calculate-process-environment #[nil "\306	\307#\n\205\f\310\n!\f\203&\311\312\313\314\315\316\f
#
\317\312!\206#\320$\"\210\204/	\210\202I\311\321\307\"\210\311\322\313\323
\317\322!\206A\320$\"\210\311\324\"\210	*\207" [python-shell-process-environment process-environment python-shell-virtualenv-path virtualenv python-shell-extra-pythonpaths path-separator append nil directory-file-name setenv "PYTHONPATH" format "%s%s%s" mapconcat identity getenv "" "PYTHONHOME" "PATH" "%s/bin%s%s" "VIRTUAL_ENV"] 8 (#$ . 52227)])
#@59 Calculate exec path given `python-shell-virtualenv-path'.
(defalias 'python-shell-calculate-exec-path #[nil "\304	\305#\204\n\202\306\307\310!\"\nB)\207" [python-shell-exec-path exec-path path python-shell-virtualenv-path append nil format "%s/bin" directory-file-name] 4 (#$ . 52858)])
#@167 Seconds to wait for process output before code setup.
If output is received before the especified time then control is
returned in that moment and not after waiting.
(custom-declare-variable 'python-shell-send-setup-max-wait '5 '(#$ . 53160) :type 'integer :group 'python-mode :safe 'integerp)
#@258 Create a python shell comint buffer.
CMD is the python command to be executed and PROC-NAME is the
process name the comint buffer will get.  After the comint buffer
is created the `inferior-python-mode' is activated.  If POP is
non-nil the buffer is shown.
(defalias 'python-shell-make-comint #[(cmd proc-name &optional pop) "\212\306\307\"\310 \311 \312	!\2042\313\f!\314\315
@\316
A%prq\210\317 \210\320!\210,\203;\321	!\210	,\207" [proc-name proc-buffer-name process-environment exec-path cmd cmdlist format "*%s*" python-shell-calculate-process-environment python-shell-calculate-exec-path comint-check-proc split-string-and-unquote apply make-comint nil inferior-python-mode python-util-clone-local-variables pop-to-buffer buffer current-buffer pop] 6 (#$ . 53461)])
#@61 Code used to setup completion in inferior Python processes.
(custom-declare-variable 'python-shell-completion-setup-code '"try:\n    import readline\nexcept ImportError:\n    def __COMPLETER_all_completions(text): []\nelse:\n    import rlcompleter\n    readline.set_completer(rlcompleter.Completer().complete)\n    def __COMPLETER_all_completions(text):\n        import sys\n        completions = []\n        try:\n            i = 0\n            while True:\n                res = readline.get_completer()(text, i)\n                if not res: break\n                i += 1\n                completions.append(res)\n        except NameError:\n            pass\n        return completions" '(#$ . 54257) :type 'string :group 'python-mode :safe 'stringp)
#@74 Python code used to get a string of completions separated by semicolons.
(custom-declare-variable 'python-shell-completion-string-code '"';'.join(__COMPLETER_all_completions('''%s'''))\n" '(#$ . 55016) :type 'string :group 'python-mode :safe 'stringp)
#@309 Python code used to get completions separated by semicolons for imports.

For IPython v0.11, add the following line to
`python-shell-completion-setup-code':

from IPython.core.completerlib import module_completion

and use the following as the value of this variable:

';'.join(module_completion('''%s'''))

(custom-declare-variable 'python-shell-module-completion-string-code '"" '(#$ . 55275) :type 'string :group 'python-mode :safe 'stringp)
(defvar python-completion-original-window-configuration nil)
#@674 Run an inferior Internal Python process.
Input and output via buffer named after
`python-shell-internal-buffer-name' and what
`python-shell-internal-get-process-name' returns.  This new kind
of shell is intended to be used for generic communication related
to defined configurations.  The main difference with global or
dedicated shells is that these ones are attached to a
configuration, not a buffer.  This means that can be used for
example to retrieve the sys.path and other stuff, without messing
with user shells.  Runs the hook
`inferior-python-mode-hook' (after the `comint-mode-hook' is
run).  (Type \[describe-mode] in the process buffer for a list
of commands.)
(defalias 'run-python-internal #[nil "\300\301\302\303 \304 \"!\305\"\207" [set-process-query-on-exit-flag get-buffer-process python-shell-make-comint python-shell-parse-command python-shell-internal-get-process-name nil] 5 (#$ . 55788) nil])
#@63 Get inferior Python process for current buffer and return it.
(defalias 'python-shell-get-process #[nil "\306\307!\310\311\"\306\312!\310\311\n\"\313	!\313!\314\f\203#	\206(
\205(!.\207" [dedicated-proc-name dedicated-proc-buffer-name global-proc-name global-proc-buffer-name dedicated-running global-running python-shell-get-process-name t format "*%s*" nil comint-check-proc get-buffer-process] 3 (#$ . 56710)])
#@76 Get or create an inferior Python process for current buffer and return it.
(defalias 'python-shell-get-or-create-process #[nil "p\306\307!\310\311	\"\306\312!\310\311\"\313\n!\313\f!\314
\2047\2047\315\316!\2034\307\2027\307\317!\210\320
\203D\n\202E\f!.\207" [old-buffer dedicated-proc-name dedicated-proc-buffer-name global-proc-name global-proc-buffer-name dedicated-running python-shell-get-process-name t format "*%s*" nil comint-check-proc 4 call-interactively run-python switch-to-buffer get-buffer-process global-running current-prefix-arg] 3 (#$ . 57143)])
#@52 Get or create an inferior Internal Python process.
(defalias 'python-shell-internal-get-or-create-process #[nil "\302 \303\304\"\305 \210\306	!*\207" [proc-name proc-buffer-name python-shell-internal-get-process-name format "*%s*" run-python-internal get-buffer-process] 3 (#$ . 57739)])
#@115 Send STRING to inferior Python PROCESS.
When `py-verbose-p' and MSG is non-nil messages the first line of STRING.
(defalias 'python-shell-send-string #[(string &optional process msg) "\206\306 \307	\310\311#\312!\313P\314 \206\f\nG\315V\203P\f\316\317\320!!\321\216rq\210	c\210\322 \210)rq\210\323\324\211\324\325%\210,\326
\f#\202g\327	\"\210\330\331	\"\203c\330\332	\"\205g\327\310\",\207" [process string lines py-temp-directory temp-file-name file-name python-shell-get-or-create-process split-string "\n" t py-normalize-directory "psss-temp.py" buffer-file-name 1 get-buffer-create generate-new-buffer-name " *temp file*" ((byte-code "\301!\203\n\302!\210\301\207" [#1=#:temp-buffer buffer-name kill-buffer] 2)) delete-trailing-whitespace write-region nil 0 python-shell-send-file comint-send-string string-match "\n$" "\n[ 	].*\n?$" #1# #2=#:temp-file] 6 (#$ . 58037) "sPython command: "])
#@119 Send STRING to PROCESS and inhibit output.
When MSG is non-nil messages the first line of STRING.  Return
the output.
(defalias 'python-shell-send-string-no-output #[(string &optional process msg) "\306	\206\307 \310\n\311\"\312	\f#\210\313	\314\"\210\205:\315
G\316V\2032\317\320
\206.\321#\2027\317\322\"\321#+\207" [output-buffer process comint-preoutput-filter-functions string msg python-shell-prompt-output-regexp nil python-shell-get-or-create-process append (ansi-color-filter-apply (lambda (string) (setq output-buffer (concat output-buffer string)) #1="")) python-shell-send-string accept-process-output 1 replace-regexp-in-string 0 format "\n*%s$\\|^%s\\|\n$" #1# "\n*$\\|^%s\\|\n$" python-shell-prompt-regexp] 5 (#$ . 58970)])
#@112 Send STRING to the Internal Python interpreter.
Returns the output.  See `python-shell-send-string-no-output'.
(defalias 'python-shell-internal-send-string #[(string) "\301\302\303\304#\305 \306#\207" [string python-shell-send-string-no-output replace-regexp-in-string "_emacs_out +" "" python-shell-internal-get-or-create-process nil] 5 (#$ . 59732)])
#@72 Send the region delimited by START and END to inferior Python process.
(defalias 'python-shell-send-region #[(start end) "\303\304	\n{\303\305#)\207" [deactivate-mark start end nil python-shell-send-string t] 4 (#$ . 60092) "r"])
#@52 Send the entire buffer to inferior Python process.
(defalias 'python-shell-send-buffer #[nil "\214~\210\300ed\")\207" [python-shell-send-region] 3 (#$ . 60329) nil])
#@108 Send the current defun to inferior Python process.
When argument ARG is non-nil sends the innermost defun.
(defalias 'python-shell-send-defun #[(arg) "\212\300\301 \206\f\302 \210\303 \304 \206\305\210\303 \")\207" [python-shell-send-region python-beginning-of-defun-function beginning-of-line point-marker python-end-of-defun-function nil] 3 (#$ . 60502) "P"])
#@178 Send FILE-NAME to inferior Python PROCESS.
If TEMP-FILE-NAME is passed then that file is used for processing
instead, while internally the shell will continue to use
FILE-NAME.
(defalias 'python-shell-send-file #[(file-name &optional process temp-file-name) "\206\304 	\205\305	!\305\n!\206	\306\n\204!\307\310!\210\311\312\313	\206)\n\n#\",\207" [process temp-file-name file-name py-python-command-args python-shell-get-or-create-process expand-file-name nil error "If FILE-NAME is nil then TEMP-FILE-NAME must be non-nil" python-shell-send-string format "__pyfile = open('''%s''');exec(compile(__pyfile.read(), '''%s''', 'exec'));__pyfile.close()"] 5 (#$ . 60875) "fFile to send: "])
#@43 Switch to inferior Python process buffer.
(defalias 'python-shell-switch-to-shell #[nil "\300\301\302 !\303\"\207" [pop-to-buffer process-buffer python-shell-get-or-create-process t] 3 (#$ . 61581) nil])
#@114 Regular Expression matching stacktrace information.
Used to extract the current line and module being inspected.
(custom-declare-variable 'python-pdbtrack-stacktrace-info-regexp '"^> \\([^\"(<]+\\)(\\([0-9]+\\))\\([?a-zA-Z0-9_<>]+\\)()" '(#$ . 61792) :type 'string :group 'python-mode :safe 'stringp)
#@47 Python code to setup documentation retrieval.
(custom-declare-variable 'python-eldoc-setup-code '"def __PYDOC_get_help(obj):\n    try:\n        import inspect\n        if hasattr(obj, 'startswith'):\n            obj = eval(obj, globals())\n        doc = inspect.getdoc(obj)\n        if not doc and callable(obj):\n            target = None\n            if inspect.isclass(obj) and hasattr(obj, '__init__'):\n                target = obj.__init__\n                objtype = 'class'\n            else:\n                target = obj\n                objtype = 'def'\n            if target:\n                args = inspect.formatargspec(\n                    *inspect.getargspec(target)\n                )\n                name = obj.__name__\n                doc = '{objtype} {name}{args}'.format(\n                    objtype=objtype, name=name, args=args\n                )\n        else:\n            doc = doc.splitlines()[0]\n    except:\n        doc = ''\n    try:\n        exec('print doc')\n    except SyntaxError:\n        print(doc)" '(#$ . 62099) :type 'string :group 'python-mode :safe 'stringp)
#@71 Python code used to get a string with the documentation of an object.
(custom-declare-variable 'python-eldoc-string-code '"__PYDOC_get_help('''%s''')\n" '(#$ . 63210) :type 'string :group 'python-mode :safe 'stringp)
#@146 Variable containing the value of the current tracked buffer.
Never set this variable directly, use
`python-pdbtrack-set-tracked-buffer' instead.
(defvar python-pdbtrack-tracked-buffer nil (#$ . 63434))
(make-variable-buffer-local 'python-pdbtrack-tracked-buffer)
#@56 List of buffers to be deleted after tracking finishes.
(defvar python-pdbtrack-buffers-to-kill nil (#$ . 63703))
(make-variable-buffer-local 'python-pdbtrack-buffers-to-kill)
#@147 Set the buffer for FILE-NAME as the tracked buffer.
Internally it uses the `python-pdbtrack-tracked-buffer' variable.
Returns the tracked buffer.
(defalias 'python-pdbtrack-set-tracked-buffer #[(file-name) "\304!\211\203
	\202\305!\211\235\204\306\303	\"\210	)\207" [file-name file-buffer python-pdbtrack-tracked-buffer python-pdbtrack-buffers-to-kill get-file-buffer find-file-noselect add-to-list] 4 (#$ . 63885)])
#@128 Move overlay arrow to current pdb line in tracked buffer.
Argument OUTPUT is a string with the output from the comint process.
(defalias 'python-pdbtrack-comint-output-filter-function #[(output) "\306\230\204\264\307	d{!\310\311\312!r\fq\210\313\216\nc\210eb\210\314
!\204/\310y\2058\314
!\2058\315\316\317!!\316\320!+\211\203\226\203\226\321!p \322!!\310\"rq\210\323\324!\210\325\323\326!\210\327 eb\210Sy\210\330 \"!\203\200\331!\"\"\210\"\310\223\210)\332!\210\333 !\210,\202\263#\203\263r#q\210\310\211\223\210)\334\335$\"\210\310\211#$+\207" [output comint-last-input-end full-output line-number #1=#:temp-buffer python-pdbtrack-stacktrace-info-regexp "" ansi-color-filter-apply nil generate-new-buffer " *temp*" ((byte-code "\301!\203\n\302!\210\301\207" [#1# buffer-name kill-buffer] 2)) looking-at string-to-number match-string-no-properties 2 1 python-pdbtrack-set-tracked-buffer get-buffer-window make-local-variable overlay-arrow-string "=>" overlay-arrow-position make-marker point-marker set-window-point pop-to-buffer switch-to-buffer-other-window mapc #[(buffer) "\300\301\302\217\207" [nil (kill-buffer buffer) ((error))] 3] file-name tracked-buffer shell-buffer tracked-buffer-window tracked-buffer-line-pos python-pdbtrack-tracked-buffer python-pdbtrack-buffers-to-kill] 4 (#$ . 64320)])
#@149 Retrieve available completions for INPUT using PROCESS.
Argument COMPLETION-CODE is the python code used to get
completions on the current context.
(defalias 'python-shell-completion--get-completions #[(input process completion-code) "r\304!q\210\305\306	\n\"\"\211G\307V\205\310\311\312#*\207" [process completion-code input completions process-buffer python-shell-send-string-no-output format 2 split-string "^'\\|^\"\\|;\\|'$\\|\"$" t] 5 (#$ . 65687)])
#@37 Do completion at point for PROCESS.
(defalias 'python-shell-completion--do-completion-at-point #[(process imports input) "\306 p\307\216\310\n!\210\203\fP\202\f\311
#\211\205*\312\"\211\313=\203K !=\203D\"\203D\314\"!\210\315\211\"\202\273\204]\316\317\"\210\320 \210\315\202\273\230\204t\321G[!\210c\210\315\202\273\"\204}\322 \"#$r\323\324!q\210p\325 \210$#\315\211%&\313\211'\313()\326 \210\327\330!\210+\211*+\331\332\"!\210\333*!\210+\315.\207" [#1=#:buffer #2=#:table python-dotty-syntax-table imports python-shell-module-completion-string-code code syntax-table ((byte-code "rq\210\302	!\210)\302\207" [#1# #2# set-syntax-table] 2)) set-syntax-table python-shell-completion--get-completions try-completion t set-window-configuration nil message "Can't find completion for \"%s\"" ding delete-char current-window-configuration get-buffer-create "*Python Completions*" kill-all-local-variables erase-buffer run-hooks temp-buffer-setup-hook display-completion-list all-completions internal-temp-output-buffer-show input process completions completion this-command last-command python-completion-original-window-configuration default-directory #3=#:old-dir buffer-read-only buffer-file-name buffer-undo-list inhibit-modification-hooks inhibit-read-only #4=#:buf standard-output] 5 (#$ . 66155)])
#@57 Perform completion at point in inferior Python process.
(defalias 'python-shell-completion-complete-at-point #[nil "\205\304 \305!V\205\306\307p!\310	\n\"#\207" [comint-last-prompt-overlay beg end word point-marker overlay-end python-shell-completion--do-completion-at-point get-buffer-process buffer-substring-no-properties] 5 (#$ . 67528) nil])
#@123 Complete or indent depending on the context.
If content before pointer is all whitespace indent.  If not try
to complete.
(defalias 'python-shell-completion-complete-or-indent #[nil "\300\301\302 \303 {\"\203\304 \207\305 \207" [string-match "^[[:space:]]*$" comint-line-beginning-position point-marker indent-for-tab-command comint-dynamic-complete] 4 (#$ . 67889) nil])
(defvar ipython-version nil)
#@58 Used by `py-completion-at-point', derived from python.el
(defvar python-command "python" (#$ . 68298))
(byte-code "\300\301\302\"\210\300\303\304\"\210\300\305\304\"\210\300\306\304\"\210\300\307\304\"\207" [defvaralias python-python-command-args py-python-command-args py-python-command py-shell-name py-jpython-command py-jython-command py-default-interpreter] 3)
(defvar py-shell-template "\n(defun NAME (&optional argprompt)\n  \"Start an DOCNAME interpreter in another window.\n\nWith optional \\\\[universal-argument] user is prompted\nfor options to pass to the DOCNAME interpreter. \"\n  (interactive \"P\")\n  (let* ((py-shell-name \"FULLNAME\"))\n    (py-shell argprompt)\n    (when (interactive-p) (switch-to-buffer (current-buffer))\n          (goto-char (point-max)))))\n")
(byte-code "\301\302\207" [py-shell-template "\n(defun NAME (&optional argprompt)\n  \"Start an DOCNAME interpreter in another window.\n\nWith optional \\\\[universal-argument] user is prompted\nfor options to pass to the DOCNAME interpreter. \"\n  (interactive \"P\")\n  (let* ((py-shell-name \"FULLNAME\"))\n    (py-shell argprompt)\n    (when (interactive-p) (switch-to-buffer (current-buffer))\n          (goto-char (point-max)))))\n" nil] 1)
#@70 Stores the file's directory-name py-execute-... functions act upon. 
(defvar py-execute-directory nil (#$ . 69539))
#@123 Caches (directory . file) pair used in the last `py-load-file' command.
Used for determining the default in the next one.
(defvar py-prev-dir/file nil (#$ . 69662))
(defvar py-exception-buffer nil)
(defvar py-output-buffer "*Python Output*")
(make-variable-buffer-local 'py-output-buffer)
#@67 For tests only. Excute functions delete temporary files default. 
(defvar py-execute-keep-temporary-file-p nil (#$ . 69957))
#@85 py-expression assumes chars indicated possible composing a py-expression, skip it. 
(defvar py-expression-skip-regexp "^ =:#	
\n\f" (#$ . 70088))
#@102 py-expression assumes chars indicated possible composing a py-expression, when looking-at or -back. 
(defvar py-expression-looking-regexp "[^ =:#	
\n\f]+" (#$ . 70241))
#@83 py-expression assumes chars indicated probably will not compose a py-expression. 
(defvar py-not-expression-regexp "[ .=:#	
\n\f)]" (#$ . 70416))
#@101 py-partial-expression assumes chars indicated possible composing a py-partial-expression, skip it. 
(defvar py-partial-expression-skip-regexp "^ .()[]{}=:#	
\n\f" (#$ . 70569))
#@101 py-partial-expression assumes chars indicated possible composing a py-partial-expression, skip it. 
(defvar py-partial-expression-forward-regexp "^ .)}=:#	
\n\f" (#$ . 70753))
#@101 py-partial-expression assumes chars indicated possible composing a py-partial-expression, skip it. 
(defvar py-partial-expression-backward-regexp "^ .({=:#	
\n\f" (#$ . 70936))
#@98 py-partial-expression assumes chars indicated may not compose a py-partial-expression, skip it. 
(defvar py-not-partial-expression-skip-regexp " \\.=:#	
\n\f" (#$ . 71119))
#@118 py-partial-expression assumes chars indicated possible composing a py-partial-expression, when looking-at or -back. 
(defvar py-partial-expression-looking-regexp "[^ .=:#	
\n\f]" (#$ . 71299))
#@99 py-partial-expression assumes chars indicated probably will not compose a py-partial-expression. 
(defvar py-not-partial-expression-regexp "[ .=:#	
\n\f)]" (#$ . 71498))
#@257 When an exception occurs as a result of py-execute-region, a
subsequent py-up-exception needs the line number where the region
started, in order to jump to the correct file line.  This variable is
set in py-execute-region and used in py-jump-to-exception.
(defvar py-line-number-offset 0 (#$ . 71675))
(defvar match-paren-no-use-syntax-pps nil)
#@35 Keep the region active in XEmacs.
(defalias 'py-keep-region-active #[nil "\301\300!\205	\302\211\207" [zmacs-region-stays boundp t] 2 (#$ . 72026)])
(put 'py-keep-region-active 'byte-optimizer 'byte-compile-inline-expand)
#@54 Regular expression matching a blank or comment line.
(defconst py-blank-or-comment-re "[ 	]*\\($\\|#\\)" (#$ . 72256))
#@66 Matches the beginning of a class, method or compound statement. 
(defconst py-block-closing-keywords-re "[ 	]*\\<\\(return\\|raise\\|break\\|continue\\|pass\\)\\_>[ \n	]" (#$ . 72381))
#@64 Regular expression matching keyword which closes a try-block. 
(defconst py-finally-re "[ 	]*\\_<finally\\_>[: \n	]" (#$ . 72572))
#@66 Regular expression matching keyword which composes a try-block. 
(defconst py-except-re "[ 	]*\\_<except\\_>[: \n	]" (#$ . 72709))
#@76 Regular expression matching keyword which closes a for- if- or try-block. 
(defconst py-else-re "[ 	]*\\_<else\\_>[: \n	]" (#$ . 72846))
#@73 Regular expression matching keyword which typically closes a function. 
(defconst py-return-re ".*:?[ 	]*\\_<\\(return\\)\\_>[ \n	]" (#$ . 72989))
(defconst py-no-outdent-re "\\(try:\\|except\\(\\s +.*\\)?:\\|while\\s +.*:\\|for\\s +.*:\\|if\\s +.*:\\|elif\\s +.*:\\)\\([ 	]*\\_<\\(return\\|raise\\|break\\|continue\\|pass\\)\\_>[ 	\n]\\)")
#@111 Regular expression that describes tracebacks.
Inludes Python shell-prompt in order to stop further searches. 
(defvar py-traceback-line-re "^IPython\\|^In \\[[0-9]+\\]: *\\|^>>>\\|^[^ 	>]+>[^0-9]+\\([0-9]+\\)\\|^[ 	]+File \"\\([^\"]+\\)\", line \\([0-9]+\\)" (#$ . 73337))
#@48 If looking at the beginning of an assignment. 
(defconst py-assignment-re "\\<\\w+\\>[ 	]*\\(=\\|+=\\|*=\\|%=\\|&=\\|^=\\|<<=\\|-=\\|/=\\|**=\\||=\\|>>=\\|//=\\)" (#$ . 73616))
#@49 Matches the beginning of a compound statement. 
(defconst py-block-re "[ 	]*\\_<\\(class\\|def\\|for\\|if\\|try\\|while\\|with\\)\\_>[: \n	]" (#$ . 73799))
#@58 Matches the beginning of an `for', `if' or `try' block. 
(defconst py-minor-block-re "[ 	]*\\_<\\(for\\|if\\|try\\)\\_>[: \n	]" (#$ . 73961))
#@51 Matches the beginning of an `if' or `try' block. 
(defconst py-try-block-re "[ 	]*\\_<try\\_>[: \n	]" (#$ . 74109))
#@47 Matches the beginning of a class definition. 
(defconst py-class-re "[ 	]*\\_<\\(class\\)\\_>[ \n	]" (#$ . 74231))
#@61 Matches the beginning of a class- or functions definition. 
(defconst py-def-or-class-re "[ 	]*\\_<\\(def\\|class\\)\\_>[ \n	]" (#$ . 74352))
#@51 Matches the beginning of a functions definition. 
(defconst py-def-re "[ 	]*\\_<\\(def\\)\\_>[ \n	]" (#$ . 74500))
#@64 Matches the beginning of a compound statement or it's clause. 
(defconst py-block-or-clause-re "[ 	]*\\_<\\(if\\|else\\|elif\\|while\\|for\\|def\\|class\\|try\\|except\\|finally\\|with\\)\\_>[: \n	]" (#$ . 74621))
#@58 Matches the beginning of a compound statement's clause. 
(defconst py-clause-re "[ 	]*\\_<\\(else\\|elif\\|except\\|finally\\)\\_>[: \n	]" (#$ . 74841))
#@73 Matches the beginning of a compound if-statement's clause exclusively. 
(defconst py-elif-re "[ 	]*\\_<\\elif\\_>[: \n	]" (#$ . 75000))
#@62 Matches the beginning of a compound try-statement's clause. 
(defconst py-try-clause-re "[ 	]*\\_<\\(except\\|else\\|finally\\)\\_>[: \n	]" (#$ . 75142))
#@61 Matches the beginning of a compound statement saying `if'. 
(defconst py-if-re "[ 	]*\\_<if\\_>[ \n	]" (#$ . 75302))
#@62 Matches the beginning of a compound statement saying `try'. 
(defconst py-try-re "[ 	]*\\_<try\\_>[: \n	]" (#$ . 75425))
#@75 Returns beginning position if inside a string or comment, nil otherwise. 
(defalias 'py-in-string-or-comment-p '(macro . #[nil "\300\207" [(or (nth 8 (syntax-ppss)) (when (or (looking-at "\"") (looking-at "[ 	]*#[ 	]*")) (match-beginning 0)))] 1 (#$ . 75552)]))
#@90 Returns t if cursor is at an line with nothing but whitespace-characters, nil otherwise.
(defalias 'empty-line-p '(macro . #[nil "\300\207" [(save-excursion (progn (beginning-of-line) (looking-at "\\s-*$")))] 1 (#$ . 75820) "p"]))
#@64 Return t if char is preceded by an odd number of backslashes. 
(defalias 'py-escaped '(macro . #[nil "\300\207" [(save-excursion (< 0 (% (abs (skip-chars-backward "\\\\")) 2)))] 1 (#$ . 76057)]))
#@65 Return t if preceding line is a backslashed continuation line. 
(defalias 'py-preceding-line-backslashed-p '(macro . #[nil "\300\207" [(save-excursion (beginning-of-line) (skip-chars-backward " 	
\n\f") (and (eq (char-before (point)) 92) (py-escaped)))] 1 (#$ . 76259)]))
#@63 Return t if current line is a backslashed continuation line. 
(defalias 'py-current-line-backslashed-p '(macro . #[nil "\300\207" [(save-excursion (end-of-line) (skip-chars-backward " 	
\n\f") (and (eq (char-before (point)) 92) (py-escaped)))] 1 (#$ . 76537)]))
#@51 Return t iff current line is a continuation line.
(defalias 'py-continuation-line-p '(macro . #[nil "\300\207" [(save-excursion (beginning-of-line) (or (py-preceding-line-backslashed-p) (< 0 (nth 0 (syntax-ppss)))))] 1 (#$ . 76805)]))
#@107 Count lines in accessible part until current line.

See http://debbugs.gnu.org/cgi/bugreport.cgi?bug=7115
(defalias 'py-count-lines #[(&optional start end) "\212\302`eb\210`W\2033m\2043\303w\2033	T`W\203m\204\304u\210	\305\306w!\\\202n\203:	T\307 \203D\310\311	\"\210	+\207" [orig count 0 "^\n" 1 abs "\n" interactive-p message "%s"] 4 (#$ . 77047) nil])
#@78 Python mode specialized rx macro which supports common python named REGEXPS.
(defalias 'python-rx '(macro . #[(&rest regexps) "\303	\"\n\204\304\305!\202\"\nA\203\306\307\nB\310\"\202\"\306\n@\310\")\207" [python-rx-constituents rx-constituents regexps append error "No regexp" rx-to-string and t] 3 (#$ . 77428)]))
(byte-code "\300\301!\204\302\301\303\"\210\304\301\305\306#\210\307\310!\204\302\310\311\"\210\300\207" [functionp syntax-ppss-context defalias #[(ppss) "\3018\203\302\207\3038\203\304\207\305\207" [ppss 3 string 4 comment nil] 2] put byte-optimizer byte-compile-inline-expand fboundp string-to-syntax #[(s) "\301\232\203\302\207\303\232\203\304\207\305\306\"\207" [s "|" (15) "_" (3) error "Unhandled string: %s"] 3]] 4)
#@118 `comint-input-filter' function for inferior Python.
Don't save anything for STR matching `py-history-filter-regexp'.
(defalias 'py-history-input-filter #[(str) "\302	\"?\207" [py-history-filter-regexp str string-match] 3 (#$ . 78199)])
(defalias 'python-args-to-list #[(string) "\303\304\"\211\204C\2023	\305U\204#\305	O\306	T\307O!B\2023\303\310\"\211\2052\306\n\307O!))\207" [string where pos string-match "[ 	]" 0 python-args-to-list nil "[^ 	]"] 6])
#@64 Data from last `_emacs_out' line seen by the preoutput filter.
(defvar python-preoutput-result nil (#$ . 78674))
#@75 If non-nil, funcall this when `python-preoutput-filter' sees `_emacs_ok'.
(defvar python-preoutput-continuation nil (#$ . 78793))
(defvar python-preoutput-leftover nil)
(defvar python-preoutput-skip-next-prompt nil)
#@74 `comint-preoutput-filter-functions' function: ignore prompts not at bol.
(defalias 'python-preoutput-filter #[(s) "\203\n	P\306\307\310\311\312	#\203V	\307\225\211O
\2032\311\f\"\2032\306\f\307\225\306O\311\313\f\"\203N\314\315!\203N\316\317\f\"
\320\305!\210\321\202R\n\fP)\202\322!\204a	\306O\311	\"\203\206
\204\200\322\nG!\203yn?\202}\311\323\n\"\203\206\306\n\202\253\324G	G^\325	\306\324\306&)\321=\203\250\320\300!\210	\n\202\253\n	P*\207" [python-preoutput-leftover s res start line python-preoutput-skip-next-prompt nil 0 "" string-match "\n" "\\`_emacs_out \\(.*\\)\n\\'" local-variable-p python-preoutput-result match-string 1 make-local-variable t zerop ".\\'" "_emacs_out " compare-strings comint-prompt-regexp end] 7 (#$ . 79015)])
(defvar python-version-checked nil)
#@51 Check that CMD runs a suitable version of Python.
(defalias 'python-check-version #[(cmd) "\206\f\304\305	!\n\"\306\232?\2050\307\n!\204\310\311\n\"\210\307\n\312P!\304\313\"\204,\310\314!\210)\315\211\207" [python-version-checked python-python-command cmd res string-match regexp-quote 0 shell-command-to-string error "Can't run Python command `%s'" " -c \"from sys import version_info;print version_info >= (2, 2) and version_info < (3, 0)\"" "True" "Only Python versions >= 2.2 and < 3.0 are supported" t] 3 (#$ . 79852)])
#@831 Run an inferior Python process, input and output via buffer *Python*.

CMD is the Python command to run.  NOSHOW non-nil means don't
show the buffer automatically.

Interactively, a prefix arg means to prompt for the initial
Python command line (default is `python-command').

A new process is started if one isn't running attached to
`python-buffer', or if called from Lisp with non-nil arg NEW.
Otherwise, if a process is already running in `python-buffer',
switch to that buffer.

This command runs the hook `inferior-python-mode-hook' after
running `comint-mode-hook'.  Type \[describe-mode] in the
process buffer for a list of commands.

By default, Emacs inhibits the loading of Python modules from the
current working directory, for security reasons.  To disable this
behavior, change `python-remove-cwd-from-path' to nil.
(defalias 'run-python #[(&optional cmd noshow new) "\204	\n\204\306!\204]r\307\310!\311\f\205\312#\313\314!\"\315\"\205/\"#P$Q%B%\316\317\320\321\322!
@\323
A&+q\210\324\303p\"\210p\325\326!\327\"\210\330 \210\331\332!\210)\333\334!\203g\335\303!\336\337\340\"\210&?\205v\341\340\"\207" [cmd python-command new python-buffer python-remove-cwd-from-path cmdlist comint-check-proc append python-args-to-list ("-i") ("-c" "import sys; sys.path.remove('')") getenv "PYTHONPATH" "PYTHONPATH=" apply make-comint-in-buffer "Python" generate-new-buffer "*Python*" nil set-default accept-process-output get-buffer-process 5 inferior-python-mode py-send-string "import emacs" derived-mode-p python-mode default-value sit-for 1 t pop-to-buffer path path-separator data-directory process-environment noshow] 7 (#$ . 80394) (byte-code "\203\f\302\303	\"\304\305E\207	C\207" [current-prefix-arg python-command read-string "Run Python: " nil t] 3)])
#@70 Like `python-send-string' but resets `compilation-shell-minor-mode'.
(defalias 'python-send-command #[(command) "\302 \205r\303\304 !q\210db\210\305 \210\306!\210p\211)\207" [command compilation-last-buffer python-check-comint-prompt process-buffer py-proc compilation-forget-errors py-send-string] 2 (#$ . 82197)])
#@49 Send the region to the inferior Python process.
(defalias 'python-send-region #[(start end) "\305\306!\307\310\311 \"\204\307\312\311 \"\203\313\314\"\202\313\315\"\316\n!\212\nb\210\317 \320U)\204D\212b\210\321\320!\322\223\210)\323\324\322\322\325%\210\323\n\f\326\325%\210\327	!\210r\330\331 !q\210\332\",\207" [f command start orig-start end make-temp-file "py" string-match "[iI][pP]ython[^[:alpha:]]*$" py-choose-shell "[pP]ython3[[:alnum:]:]*$" format "execfile %S" "emacs.eexecfile(%S)" copy-marker current-indentation 0 line-beginning-position nil write-region "if True:\n" nomsg t python-send-command process-buffer py-proc compilation-fake-loc] 6 (#$ . 82523) "r"])
#@45 Evaluate STRING in inferior Python process.
(defalias 'python-send-string #[(string) "\301\302 \"\210\303\304\"\204\301\302 \305\"\210\303\306\"\205\301\302 \305\"\207" [string comint-send-string py-proc string-match "\n\\'" "\n" "\n[ 	].*\n?\\'"] 3 (#$ . 83224) "sPython command: "])
#@57 Send the current buffer to the inferior Python process.
(defalias 'python-send-buffer #[nil "\300ed\"\207" [python-send-region] 3 (#$ . 83522) nil])
#@74 Send the current defun (class or method) to the inferior Python process.
(defalias 'python-send-defun #[nil "\212\300\301 \210`\302 \210`\")\207" [python-send-region beginning-of-defun end-of-defun] 3 (#$ . 83677) nil])
#@117 Switch to the Python process buffer, maybe starting new process.
With prefix arg, position cursor at end of buffer.
(defalias 'python-switch-to-python #[(eob-p) "\301\302\303 !\304\"\210\205\305 \210db\207" [eob-p pop-to-buffer process-buffer py-proc t push-mark] 3 (#$ . 83904) "P"])
#@84 Send the region to the inferior Python process.
Then switch to the process buffer.
(defalias 'python-send-region-and-go #[(start end) "\302	\"\210\303\304!\207" [start end python-send-region python-switch-to-python t] 3 (#$ . 84198) "r"])
#@127 Caches (directory . file) pair used in the last `python-load-file' command.
Used for determining the default in the next one.
(defvar python-prev-dir/file nil (#$ . 84445))
#@287 Load a Python file FILE-NAME into the inferior Python process.
If the file has extension `.py' import or reload it as a module.
Treating it as a module keeps the global namespace clean, provides
function location information for debugging, and supports users of
module-qualified names.
(defalias 'python-load-file #[(file-name) "\303!\210\304!\305!Br\306\307 !q\210\310\311\312\"\203,\313\305!!\314\315\n\304!#)\2020\314\316\"!\210\317\320\")\207" [file-name python-prev-dir/file module comint-check-source file-name-directory file-name-nondirectory process-buffer py-proc python-send-command string-match "\\.py\\'" file-name-sans-extension format "emacs.eimport(%S,%S)" "execfile(%S)" message "%s loaded"] 6 (#$ . 84625) (comint-get-source "Load Python file: " python-prev-dir/file python-source-modes t)])
#@103 Return the current Python process.

See variable `python-buffer'.  Starts a new process if necessary.
(defalias 'py-proc #[nil "\301!\204\302\303\304\"\210\305\306\307!\203p\202!\207" [python-buffer comint-check-proc run-python nil t get-buffer-process derived-mode-p inferior-python-mode] 3 (#$ . 85453)])
#@337 Set the default value of `python-buffer' to correspond to this buffer.
If the current buffer has a local value of `python-buffer', set the
default (global) value to that.  The associated Python process is
the one that gets input from \[python-send-region] et al when used
in a buffer that doesn't have a local value of `python-buffer'.
(defalias 'python-set-proc #[nil "\301\300!\203\302\300\"\207\303\304!\207" [python-buffer local-variable-p set-default error "No local value of `python-buffer'"] 3 (#$ . 85775) nil])
(add-to-list 'debug-ignored-errors "^No symbol")
#@176 Send STRING to inferior Python (if any) and return result.
The result is what follows `_emacs_out' in the output.
This is a no-op if `python-check-comint-prompt' returns nil.
(defalias 'python-send-receive #[(string) "\303!\210\304 r\305	!q\210\306	!\205'\307\302!\210\310\311	\312\"\210\n\203\n\313\302!\210*\207" [string proc python-preoutput-result py-send-string py-proc process-buffer python-check-comint-prompt make-local-variable nil accept-process-output 5 kill-local-variable] 3 (#$ . 86354)])
#@228 Return non-nil if and only if there's a normal prompt in the inferior buffer.
If there isn't, it's probably not appropriate to send input to return Eldoc
information etc.  If PROC is non-nil, check the buffer for that process.
(defalias 'python-check-comint-prompt #[(&optional proc) "r\303\206\304 !q\210\212\305 \306\216\307\n\310P\311\312#,\207" [proc save-match-data-internal python--prompt-regexp process-buffer py-proc match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) re-search-backward " *\\=" nil t] 4 (#$ . 86870)])
#@161 `eldoc-documentation-function' for Python.
Only works when point is in a function name, not its arg list, for
instance.  Assumes an inferior Python is running.
(defalias 'python-eldoc-function #[nil "\304 p\305\216\306\n!\210\307 +\310\311\312\217)\207" [#1=#:buffer #2=#:table python-dotty-syntax-table symbol syntax-table ((byte-code "rq\210\302	!\210)\302\207" [#1# #2# set-syntax-table] 2)) set-syntax-table current-word nil (byte-code "\305	\203\306\307\310	\n#!\206F\311 \312@!?\205EA@f\313=\205E\212A@b\210\314\315!\210`\316\305x\210`\fW\205D\317\307\310\320`\f\"\n#!*))\207" [inhibit-quit symbol python-imports s point nil py-send-receive format "emacs.eargs(%S, %s)" syntax-ppss zerop 40 skip-syntax-backward "-" "a-zA-Z._" python-send-receive buffer-substring-no-properties] 6) ((quit (byte-code "\301\302\303!\207" [quit-flag t eval (ignore nil)] 2)))] 3 (#$ . 87454)])
#@59 Set up info-look for Python.
Used with `eval-after-load'.
(defalias 'python-after-info-look #[nil "\305\306P!\307\310	\"\210\311\312	\")\313\314!rq\210\315\216\316 \210\317\320\321\217+\322\323\324\325\326\327\f\203q\330\n\331Q\332B\330\n\333\317\334\260C\330\n\335\317\334\260C\330\n\336\317\334\260C\330\n\337\317\334\260C\330\n\340\317\334\260C\330\n\341\317\334\260C\330\n\342\317\334\260C\257\202r\343&*\207" [py-shell-name s version #1=#:temp-buffer versioned shell-command-to-string " -V" string-match "^Python \\([0-9]+\\.[0-9.]+\\_>\\)" match-string 1 generate-new-buffer " *temp*" ((byte-code "\301!\203\n\302!\210\301\207" [#1# buffer-name kill-buffer] 2)) Info-mode nil (byte-code "\301\302\303\"!\210\304\207" [version Info-goto-node format "(python%s-lib)Miscellaneous Index" t] 4) ((error)) info-lookup-maybe-add-help :mode python-mode :regexp "[[:alnum:]_]+" :doc-spec "(python" "-ref)Miscellaneous Index" (nil #2="") "-ref)Module Index" #2# "-ref)Function-Method-Variable Index" "-ref)Class-Exception-Object Index" "-lib)Module Index" "-lib)Class-Exception-Object Index" "-lib)Function-Method-Variable Index" "-lib)Miscellaneous Index" (("(python-ref)Miscellaneous Index" nil #2#) ("(python-ref)Module Index" nil #2#) ("(python-ref)Function-Method-Variable Index" nil #2#) ("(python-ref)Class-Exception-Object Index" nil #2#) ("(python-lib)Module Index" nil #2#) ("(python-lib)Class-Exception-Object Index" nil #2#) ("(python-lib)Function-Method-Variable Index" nil #2#) ("(python-lib)Miscellaneous Index" nil #2#))] 18 (#$ . 88358)])
(eval-after-load "info-look" '(python-after-info-look))
#@212 Invoke `jython-mode' if the buffer appears to contain Jython code.
The criterion is either a match for `jython-mode' via
`interpreter-mode-alist' or an import of a module from the list
`python-jython-packages'.
(defalias 'python-maybe-jython #[nil "\212\214~\210eb\210\303!\205\304\305!\211\203&\306\307	!\n\"A\310=\203&\310 \202.\311\312\215\205.\310 +\207" [auto-mode-interpreter-regexp interpreter interpreter-mode-alist looking-at match-string 2 assoc file-name-nondirectory jython-mode done (byte-code "\301\302e\303\\\304#\205\305\306!\235\203\307\310\304\"\210\202\207" [python-jython-packages re-search-forward "^\\(?:from\\|import\\)[[:space:]]+\\([^	\n .]+\\)" 10000 t match-string 1 throw done] 4)] 4 (#$ . 89994)])
#@243 `fill-paragraph-function' handling multi-line strings and possibly comments.
If any of the current line is in or at the end of a multi-line string,
fill the string or the paragraph of it that point is in, preserving
the string's indentation.
(defalias 'python-fill-paragraph #[(&optional justify) "\306!\204i\212\307\210\310 `\307\211\311	8\203#\307\312!\210)\202M\313	8\314=\203;\315	8b\210\316 \307\317\320\217\202M\321\322\307\314#\203M\307u\210`\307\323\324\217\210\f\203h\214\f}\210\nb\210\325\326\327R\307\312!\210+-\314\207" [justify syntax orig start end fill-paragraph-function fill-comment-paragraph nil syntax-ppss 4 fill-paragraph 3 t 8 line-beginning-position (byte-code "\300 \210`\301Z\207" [forward-sexp 3] 2) ((error (point-max))) re-search-backward "\\s|\\s-*\\=" (byte-code "\301 \210\302 \301\207" [start backward-sexp line-beginning-position] 1) ((error)) ".*\\(\\s|\\)\\1\\{2\\}[	 ]*$\\|\\([\"']\\)\\2\\s|" "\\(?:" "\\)" paragraph-separate] 5 (#$ . 90743) "P"])
#@303 Shift lines in region COUNT (the prefix arg) columns to the left.
COUNT defaults to `py-indent-offset'.  If region isn't active, just shift
current line.  The region shifted includes the lines in which START and
END lie.  It is an error if any lines in the region are indented less than
COUNT columns.
(defalias 'python-shift-left #[(start end &optional count) "\203\304!\202
	\305V\205;\212\nb\210`W\2034\306 W\203.\307\310!\204.\311\312!\210\313y\210\202\314\n[#)\207" [count py-indent-offset start end prefix-numeric-value 0 current-indentation looking-at "[ 	]*$" error "Can't shift all lines enough" nil indent-rigidly] 4 (#$ . 91760) (byte-code "\203\302 \303 	E\207\304 \305 	E\207" [mark-active current-prefix-arg region-beginning region-end line-beginning-position line-end-position] 3)])
(add-to-list 'debug-ignored-errors "^Can't shift all lines enough")
#@223 Shift lines in region COUNT (the prefix arg) columns to the right.
COUNT defaults to `py-indent-offset'.  If region isn't active, just shift
current line.  The region shifted includes the lines in which START and
END lie.
(defalias 'python-shift-right #[(start end &optional count) "\203\304!\202
	\305\n#\207" [count py-indent-offset start end prefix-numeric-value indent-rigidly] 4 (#$ . 92654) (byte-code "\203\302 \303 	E\207\304 \305 	E\207" [mark-active current-prefix-arg region-beginning region-end line-beginning-position line-end-position] 3)])
#@127 `outline-level' function for Python mode.
The level is the number of `py-indent-offset' steps of indentation
of current line.
(defalias 'python-outline-level #[nil "\301 \245T\207" [py-indent-offset current-indentation] 2 (#$ . 93228)])
#@46 `add-log-current-defun-function' for Python.
(defalias 'python-current-defun #[(&optional length-limit) "\212\303\304\305\306\215\210	\205 \n\203\nV\203	\307\240\210\310\311	\312#+\207" [length accum length-limit nil -1 done (byte-code "\203	A\203\nW\203I`\304 \210\305\210\306 \210`U\203%\307\310\305\"\210)\311\312!\203:\313\314!	B\315\n\314	@G#\316 \317U\203\307\310\305\"\210\202\305\207" [length-limit accum length started-from python-beginning-of-block nil beginning-of-defun throw done looking-at "[[:space:]]*\\(?:class\\|def\\)[[:space:]]+\\(\\(?:[[:word:]]\\|\\s_\\)+\\)" match-string 1 + current-indentation 0] 4) ".." mapconcat identity "."] 4 (#$ . 93472)])
#@87 Mark the block around point.
Uses `python-beginning-of-block', `python-end-of-block'.
(defalias 'python-mark-block #[nil "\300 \210\301 \210\300`\302\303#\210\304 \210\305 \207" [push-mark python-beginning-of-block nil t python-end-of-block exchange-point-and-mark] 4 (#$ . 94175) nil])
#@73 String of top-level import statements updated by `python-find-imports'.
(defvar python-imports "None" (#$ . 94468))
(make-variable-buffer-local 'python-imports)
#@52 Find top-level imports, updating `python-imports'.
(defalias 'python-find-imports #[nil "\212\304eb\210\305\306\304\307#\203I\310 \311	8\203\312\202&\313	8\203%\314\202&\304)\204\315 \316 Sf\317=\203=\320y\321U\204-\n\315\322!{B)\202\203U\323\324\237\"\202V\325\205o\326\321G\304$\210\327\330\331\332\333\"\307\211%\211*\207" [lines ppss start python-imports nil re-search-forward "^import\\_>\\|^from\\_>" t syntax-ppss 3 string 4 comment line-beginning-position line-end-position 92 1 0 2 apply concat "None" set-text-properties replace-regexp-in-string "\n" "\\n" format "%S"] 6 (#$ . 94635) nil])
(defalias 'python-completion-at-point #[nil "`\212\302\303\304\305#\205\f\306\224)\205	\307\310!E*\207" [start end re-search-backward "\\(?:\\`\\|[^[:alnum:]._]\\)\\([[:alnum:]._]+\\)\\=" nil t 1 completion-table-dynamic python-symbol-completions] 5])
#@53 Function for `ffap-alist' to return path to MODULE.
(defalias 'python-module-path #[(module) "\301\302\303\"!\207" [module python-send-receive format "emacs.modpath (%S)"] 4 (#$ . 95529)])
(eval-after-load "ffap" '(push '(python-mode . python-module-path) ffap-alist))
#@77 Find source of definition of function NAME.
Interactively, prompt for name.
(defalias 'python-find-function #[(name) "\204\305\306!\210\307\310\311	#!\312\n!@\211@\nA\204$\305\313	\"\210\314\315!!\210\f\250\2055eb\210\fSy,\207" [python-imports name loc file line error "Not called from buffer visiting Python file" python-send-receive format "emacs.location_of (%S, %s)" read-from-string "Don't know where `%s' is defined" pop-to-buffer find-file-noselect] 6 (#$ . 95805) (let ((symbol (let ((#1=#:table (syntax-table)) (#2=#:buffer (current-buffer))) (unwind-protect (progn (set-syntax-table python-dotty-syntax-table) (current-word)) (save-current-buffer (set-buffer #2#) (set-syntax-table #1#))))) (enable-recursive-minibuffers t)) (list (read-string (if symbol (format "Find location of (default %s): " symbol) "Find location of: ") nil nil symbol)))])
(defvar py-mode-syntax-table nil)
(byte-code "\306 \307\310\311 \312\313\f
W\2030\f\314U\204)\n\f\"\232\203)\315\f\316	#\210\fT\211\202,\315\317\316	#\210\315\320\316	#\210\315\321\322	#\210\315\323\324	#\210\315\325\326	#\210\315\327\330	#\210\315\314\331	#\210	*\306\207" [tablelookup table sst symbol i #:--cl-dotimes-temp-- make-syntax-table aref (3) standard-syntax-table 128 0 95 modify-syntax-entry "." 36 37 35 "<" 10 ">" 39 "\"" 96 "$" "w" py-mode-syntax-table] 5)
(defvar py-help-mode-syntax-table (byte-code "\302!\303\304\305	#\210\303\306\305	#\210	)\207" [py-mode-syntax-table st make-syntax-table modify-syntax-entry 39 "." 34] 4))
#@64 `py-mode-syntax-table' with backslash given whitespace syntax.
(defconst py-space-backslash-table (byte-code "\302!\303\304\305	#\210	)\207" [py-mode-syntax-table table copy-syntax-table modify-syntax-entry 92 " "] 4) (#$ . 97345))
#@98 Queue of Python temp files awaiting execution.
Currently-active file is at the head of the list.
(defvar py-file-queue nil (#$ . 97585))
(defvar python-mode-abbrev-table nil)
(define-abbrev-table 'python-mode-abbrev-table nil)
#@13 Not in use.
(defvar inferior-python-mode-abbrev-table nil (#$ . 97818))
(define-abbrev-table 'inferior-python-mode-abbrev-table nil)
#@63 Regular expression pdbtrack uses to find a stack trace entry.
(defconst py-pdbtrack-stack-entry-regexp (concat ".*\\(" py-shell-input-prompt-1-regexp ">\\|>\\) *\\(.*\\)(\\([0-9]+\\))\\([?a-zA-Z0-9_<>()]+\\)()") (#$ . 97957))
(byte-code "\302\303\304\207" [py-pdbtrack-input-prompt py-pydbtrack-input-prompt "^[(<]*[Ii]?[Pp]y?db[>)]+ " "^[(]*ipydb[>)]+ " nil] 1)
#@70 Group position in gud-pydb-marker-regexp that matches the file name.
(defconst py-pdbtrack-marker-regexp-file-group 2 (#$ . 98328))
#@72 Group position in gud-pydb-marker-regexp that matches the line number.
(defconst py-pdbtrack-marker-regexp-line-group 3 (#$ . 98466))
#@74 Group position in gud-pydb-marker-regexp that matches the function name.
(defconst py-pdbtrack-marker-regexp-funcname-group 4 (#$ . 98606))
#@72 Max number of characters from end of buffer to search for stack entry.
(defconst py-pdbtrack-track-range 10000 (#$ . 98752))
(defvar py-pdbtrack-is-tracking-p nil)
(byte-code "\300\301\302\303!\304B\"\210\300\305\302\306!\304B\"\210\300\305\302\307!\310B\"\210\300\311\302\312!\"\207" [add-to-list auto-mode-alist purecopy "\\.py\\'" python-mode interpreter-mode-alist "python" "jython" jython-mode same-window-buffer-names "*Python*"] 4)
(defconst python-font-lock-syntactic-keywords (byte-code "\300\301BC\207" ["\\(?:^\\|[^\\]\\(?:\\\\.\\)*\\)\\(?1:\"\\)\\(?2:\"\\)\\(?3:\"\\)\\(?4:\"\\)\\(?5:\"\\)\\(?6:\"\\)\\|\\(?1:\"\\)\\(?2:\"\\)\\(?3:\"\\)\\|\\('\\)\\('\\)\\('\\)\\|\\('\\)\\('\\)\\('\\)\\('\\)\\('\\)\\('\\)" ((1 (python-quote-syntax 1) t t) (2 (python-quote-syntax 2) t t) (3 (python-quote-syntax 3) t t) (6 (python-quote-syntax 1) t t))] 2))
#@121 Put `syntax-table' property correctly on triple quote.
Used for syntactic keywords.  N is the match number (1, 2 or 3).
(defalias 'python-quote-syntax #[(n) "\212\304\224b\210\305U\203+\306\307 \305\n8\310=\205'\311\n8b\210\306f\312\224f=\205'\313*\202d\312U\2036\314\225\203A\314U\205d\314\225\205d\306\307 \3058\203P\315\202[\3168\203Z\317\202[\306)\315=?\205c\313))\207" [n font-lock-syntactic-keywords syntax ppss 0 3 nil syntax-ppss t 8 2 (15) 1 string 4 comment] 2 (#$ . 99613)])
#@40 Keymap used in *Python* shell buffers.
(defvar py-shell-map nil (#$ . 100127))
#@40 Keymap used in *Python* shell buffers.
(defvar python-shell-map (byte-code "\302!\303	\304\305#\210\303	\306\307#\210\303	\310\311#\210	)\207" [comint-mode-map map copy-keymap define-key [tab] py-shell-complete "-" py-up-exception "=" py-down-exception] 4) (#$ . 100212))
#@388 Returns the value of point at certain commonly referenced POSITIONs.
POSITION can be one of the following symbols:

  bol -- beginning of line
  eol -- end of line
  bod -- beginning of def or class
  eod -- end of def or class
  bob -- beginning of buffer
  eob -- end of buffer
  boi -- back to indentation
  bos -- beginning of statement

This function does not modify point or mark.
(defalias 'py-point #[(position) "\302\212	\303=\203\304 \210\202h	\305=\203\302\210\202h	\306=\203'\307 \210\202h	\310=\2033\311 \210\202h	\312=\203?eb\210\202h	\313=\203Kdb\210\202h	\314=\203W\315 \210\202h	\316=\203c\317 \210\202h\320\321	\"\210`))\207" [erg position nil bol beginning-of-line eol bod py-beginning-of-def-or-class eod py-end-of-def-or-class bob eob boi back-to-indentation bos py-beginning-of-statement error "Unknown buffer position requested: %s"] 3 (#$ . 100495)])
#@159 Return non-nil if point is on TYPE using SYNTAX-PPSS.
TYPE can be 'comment, 'string or 'paren.  It returns the start
character address of the specified TYPE.
(defalias 'python-info-ppss-context #[(type &optional syntax-ppss) "\206\300 \n\303=\203\304	8\2052\305	8\2022\n\306=\203%\305	8\2022\n\307=\2031	A@\2022\310)\207" [syntax-ppss ppss type comment 4 8 string paren nil] 2 (#$ . 101399)])
#@53 Additional expressions to highlight in Python mode.
(defvar python-font-lock-keywords nil (#$ . 101810))
(byte-code "\301\302\303B\304\305B\306\307B\310\311B\312\313B\314\307B\315\316B\317\320B\321\322B\323\324B\325\326B\257\f\307\207" [python-font-lock-keywords "\\_<\\(?:\\(?:a\\(?:nd\\|s\\(?:sert\\)?\\)\\|break\\|continue\\|de[fl]\\|e\\(?:l\\(?:if\\|se\\)\\|xec\\)\\|f\\(?:inally\\|or\\|rom\\)\\|global\\|i\\(?:mport\\|[fns]\\)\\|lambda\\|not\\|or\\|p\\(?:ass\\|rint\\)\\|return\\|try\\|w\\(?:hile\\|ith\\)\\|yield\\)\\)\\_>" "\\_<def[[:space:]]+\\(\\(?:[[:word:]]\\|_\\)+\\)" ((1 font-lock-function-name-face)) "\\_<\\(class\\)[[:space:]]+\\(\\(?:[[:word:]]\\|_\\)+\\)" ((1 font-lock-keyword-face) (2 py-class-name-face)) "\\_<\\(?:except\\|raise\\)\\_>" py-exception-name-face "\\_<\\(?:\\(?:Ellipsis\\|False\\|No\\(?:ne\\|tImplemented\\)\\|True\\|__debug__\\|cls\\|self\\)\\)\\_>" py-pseudo-keyword-face "^[	 ]*\\(@\\(?:[[:word:]]\\|_\\)+\\(?:\\.\\(?:[[:word:]]\\|_\\)+\\)*\\)" ((1 py-decorators-face)) "\\_<\\(?:\\(?:A\\(?:\\(?:rithmetic\\|ssertion\\|ttribute\\)Error\\)\\|B\\(?:aseException\\|ufferError\\|ytesWarning\\)\\|DeprecationWarning\\|E\\(?:OFError\\|nvironmentError\\|xception\\)\\|F\\(?:loatingPointError\\|utureWarning\\)\\|GeneratorExit\\|I\\(?:OError\\|mport\\(?:Error\\|Warning\\)\\|nde\\(?:\\(?:ntation\\|x\\)Error\\)\\)\\|Key\\(?:Error\\|boardInterrupt\\)\\|LookupError\\|MemoryError\\|N\\(?:\\(?:ame\\|otImplemented\\)Error\\)\\|O\\(?:\\(?:S\\|verflow\\)Error\\)\\|PendingDeprecationWarning\\|R\\(?:eferenceError\\|untime\\(?:Error\\|Warning\\)\\)\\|S\\(?:t\\(?:andardError\\|opIteration\\)\\|y\\(?:ntax\\(?:Error\\|Warning\\)\\|stemE\\(?:rror\\|xit\\)\\)\\)\\|T\\(?:\\(?:ab\\|ype\\)Error\\)\\|U\\(?:n\\(?:boundLocalError\\|icode\\(?:DecodeError\\|E\\(?:\\(?:ncodeE\\)?rror\\)\\|TranslateError\\|Warning\\)\\)\\|serWarning\\)\\|ValueError\\|Warning\\|ZeroDivisionError\\)\\)\\_>" "\\(?:[[:space:]]\\|^\\)\\_<\\(?:\\(?:_\\(?:_\\(?:\\(?:doc\\|import\\|\\(?:nam\\|packag\\)e\\)__\\)\\)?\\|a\\(?:bs\\|ll\\|\\(?:n\\|ppl\\)y\\)\\|b\\(?:asestring\\|in\\|ool\\|uffer\\|yte\\(?:array\\|s\\)\\)\\|c\\(?:allable\\|hr\\|lassmethod\\|mp\\|o\\(?:erce\\|mp\\(?:ile\\|lex\\)\\)\\)\\|d\\(?:elattr\\|i\\(?:ct\\|r\\|vmod\\)\\)\\|e\\(?:numerate\\|val\\|xecfile\\)\\|f\\(?:il\\(?:e\\|ter\\)\\|\\(?:loa\\|orma\\|rozense\\)t\\)\\|g\\(?:etattr\\|lobals\\)\\|h\\(?:as\\(?:attr\\|h\\)\\|e\\(?:lp\\|x\\)\\)\\|i\\(?:d\\|n\\(?:put\\|t\\(?:ern\\)?\\)\\|s\\(?:instance\\|subclass\\)\\|ter\\)\\|l\\(?:en\\|ist\\|o\\(?:cals\\|ng\\)\\)\\|m\\(?:a[px]\\|in\\)\\|next\\|o\\(?:bject\\|ct\\|pen\\|rd\\)\\|p\\(?:ow\\|r\\(?:int\\|operty\\)\\)\\|r\\(?:a\\(?:nge\\|w_input\\)\\|e\\(?:duce\\|load\\|pr\\|versed\\)\\|ound\\)\\|s\\(?:et\\(?:attr\\)?\\|lice\\|orted\\|t\\(?:aticmethod\\|r\\)\\|u\\(?:m\\|per\\)\\)\\|t\\(?:\\(?:upl\\|yp\\)e\\)\\|unic\\(?:hr\\|ode\\)\\|vars\\|xrange\\|zip\\)\\)\\_>" py-builtins-face "^[	 ]*\\(_\\{0,2\\}[[:word:]]\\(?:[[:word:]]\\|_\\)*_\\{0,2\\}\\)[	 ]*\\(?:\\(?:\\*\\*\\|//\\|<<\\|>>\\|[%&*+/|^-]\\)?=\\)" (1 py-variable-name-face) #[(limit) "\302\303	\304#\205-\305\306!\203\303	\304#\204\n\305\306!\204*\307 f\310\232\204*\304\202-\311\312!)\207" [re limit "\\([._[:word:]]+\\)\\(?:\\[[^]]+]\\)?[[:space:]]*\\(?:\\(?:\\*\\*\\|//\\|<<\\|>>\\|[%&*+/|^-]\\)?=\\)" re-search-forward t python-info-ppss-context paren point-marker 61 set-match-data nil] 4] ((1 py-variable-name-face nil nil)) #[(limit) "\302\303	\304#\2056\305\306 8b\2056\307\310!\203)\303	\304#\203)\305\306 8b\210\202\307\310!\2043\304\2026\311\312!)\207" [re limit "\\([._[:word:]]+\\)[[:space:]]*\\(?:,[[:space:]]*[._[:word:]]+[[:space:]]*\\)*,[[:space:]]*[._[:word:]]+[[:space:]]*\\(?:\\(?:\\*\\*\\|//\\|<<\\|>>\\|[%&*+/|^-]\\)?=\\)" re-search-forward t 3 match-data python-info-ppss-context paren set-match-data nil] 4] ((1 py-variable-name-face nil nil)) "\\_<\\(?:[[:digit:]]+\\|[[:xdigit:]]+\\)\\_>" py-number-face] 13)
(defconst py-font-lock-syntactic-keywords '(("[^\\]\\\\\\(?:\\\\\\\\\\)*\\(\\s\"\\)\\1\\(\\1\\)" (2 (7))) ("\\([RUBrub]?\\)[Rr]?\\(\\s\"\\)\\2\\(\\2\\)" (1 (py-quote-syntax 1)) (2 (py-quote-syntax 2)) (3 (py-quote-syntax 3)))))
#@121 Put `syntax-table' property correctly on triple quote.
Used for syntactic keywords.  N is the match number (1, 2 or 3).
(defalias 'py-quote-syntax #[(n) "\212\304\224b\210\305U\203/\306\307 \305\n8\310=\205+\311\n8b\210\312\306w\210\306f\313\224f=\205+\314*\202o\313U\203=\315\224\315\225U\204L\315U\205o\315\224\315\225U?\205o\306\307 \3058\203[\316\202f\3178\203e\320\202f\306)\316=?\205n\314))\207" [n font-lock-syntactic-keywords syntax ppss 0 3 nil syntax-ppss t 8 "uUrRbB" 2 (15) 1 string 4 comment] 2 (#$ . 105975)])
#@88 Syntax table giving `.' symbol syntax.
Otherwise inherits from `py-mode-syntax-table'.
(defconst python-dotty-syntax-table (byte-code "\302 \303	\"\210\304\305\306#\210)\207" [table py-mode-syntax-table make-syntax-table set-char-table-parent modify-syntax-entry 46 "_"] 4) (#$ . 106527))
#@58 Syntax table used to identify Python dotted expressions.
(defvar py-dotted-expression-syntax-table (byte-code "\302!\303\304\305	#\210\303\306\305	#\210	)\207" [python-mode-syntax-table table make-syntax-table modify-syntax-entry 95 "_" 46] 4) (#$ . 106826))
(defalias 'py-beg-of-defun-function #[nil "\301\300!\210\302\211\207" [beginning-of-defun-function make-local-variable py-beginning-of-def-or-class] 2])
(defalias 'py-end-of-defun-function #[nil "\301\300!\210\302\211\207" [end-of-defun-function make-local-variable py-end-of-def-or-class] 2])
(make-obsolete-variable 'jpython-mode-hook 'jython-mode-hook nil)
#@77 *Hook called by `jython-mode'. `jython-mode' also calls
`python-mode-hook'.
(defvar jython-mode-hook nil (#$ . -107455))
#@29 *Hook called by `py-shell'.
(defvar py-shell-hook nil (#$ . -107582))
(byte-code "\300\301!\203\f\301\302\303\304#\210\304\207" [fboundp make-obsolete-variable py-mode-hook python-mode-hook nil] 4)
#@36 Contents like py-fond-lock-keyword
(defvar py-keywords "\\_<\\(ArithmeticError\\|AssertionError\\|AttributeError\\|BaseException\\|BufferError\\|BytesWarning\\|DeprecationWarning\\|EOFError\\|Ellipsis\\|EnvironmentError\\|Exception\\|False\\|FloatingPointError\\|FutureWarning\\|GeneratorExit\\|IOError\\|ImportError\\|ImportWarning\\|IndentationError\\|IndexError\\|KeyError\\|KeyboardInterrupt\\|LookupError\\|MemoryError\\|NameError\\|NoneNotImplementedError\\|NotImplemented\\|OSError\\|OverflowError\\|PendingDeprecationWarning\\|ReferenceError\\|RuntimeError\\|RuntimeWarning\\|StandardError\\|StopIteration\\|SyntaxError\\|SyntaxWarning\\|SystemError\\|SystemExit\\|TabError\\|True\\|TypeError\\|UnboundLocalError\\|UnicodeDecodeError\\|UnicodeEncodeError\\|UnicodeError\\|UnicodeTranslateError\\|UnicodeWarning\\|UserWarning\\|ValueError\\|Warning\\|ZeroDivisionError\\|__debug__\\|__import__\\|__name__\\|abs\\|all\\|and\\|any\\|apply\\|as\\|assert\\|basestring\\|bin\\|bool\\|break\\|buffer\\|bytearray\\|callable\\|chr\\|class\\|classmethod\\|cmp\\|coerce\\|compile\\|complex\\|continue\\|copyright\\|credits\\|def\\|del\\|delattr\\|dict\\|dir\\|divmod\\|elif\\|else\\|enumerate\\|eval\\|except\\|exec\\|execfile\\|exit\\|file\\|filter\\|float\\|for\\|format\\|from\\|getattr\\|global\\|globals\\|hasattr\\|hash\\|help\\|hex\\|id\\|if\\|import\\|in\\|input\\|int\\|intern\\|is\\|isinstance\\|issubclass\\|iter\\|lambda\\|len\\|license\\|list\\|locals\\|long\\|map\\|max\\|memoryview\\|min\\|next\\|not\\|object\\|oct\\|open\\|or\\|ord\\|pass\\|pow\\|print\\|property\\|quit\\|raise\\|range\\|raw_input\\|reduce\\|reload\\|repr\\|return\\|round\\|set\\|setattr\\|slice\\|sorted\\|staticmethod\\|str\\|sum\\|super\\|tuple\\|type\\|unichr\\|unicode\\|vars\\|while\\|with\\|xrange\\|yield\\|zip\\|\\)\\_>" (#$ . 107787))
#@56 Insert in buffer shebang of installed default Python. 
(defalias 'py-insert-default-shebang #[nil "\203	\202\304	!\305\nP\211c*\207" [py-edit-only-p py-shell-name erg sheb executable-find "#! "] 3 (#$ . 109621) "*"])
#@240 Insert a comment. If starting a comment, indent accordingly.

If a numeric argument ARG is provided, that many colons are inserted
non-electrically.
With \[universal-argument] "#" electric behavior is inhibited inside a string or comment.
(defalias 'py-electric-comment #[(arg) "\203c	\203c\306\307\310\217\203\311c\207\n\312=\203!\313\314!\203!\315u\210\316 \203/\317\320!!\210\2022\311c\210\321`!\322 \323 \f=\204O
b\210\324 \210\325 \210\fj\210
b\210\203]\326\327!\204]\314c\210*\211\207\317\320!!\207" [py-indent-comments py-electric-comment-p last-command arg indent orig nil (byte-code "\242\301=\207" [arg 4] 2) ((error)) "#" py-electric-comment looking-back " " -1 interactive-p self-insert-command prefix-numeric-value copy-marker py-compute-indentation current-indentation beginning-of-line delete-horizontal-space looking-at "[ 	]" py-electric-comment-add-space-p this-command] 3 (#$ . 109852) "*P"])
#@274 Insert a colon and indent accordingly.

If a numeric argument ARG is provided, that many colons are inserted
non-electrically.

Electric behavior is inhibited inside a string or
comment or by universal prefix C-u.
Default is nil, controlled by `py-electric-colon-active-p'
(defalias 'py-electric-colon #[(arg) "\204\n\304\305	!!\207\305	!\306=\203\304\307!\207\304\305	!!\210\310\311 8\2061\312\313!\204/\312\314!\2051\315\224?\205[\316`!\317 \320 \n=\204X\321 \203O\320 \nW\204X\322 \210\323 \210\nj\210b*\207" [py-electric-colon-active-p arg indent orig self-insert-command prefix-numeric-value 4 1 8 syntax-ppss looking-at "\"" "[ 	]*#[ 	]*" 0 copy-marker py-compute-indentation current-indentation py-top-level-form-p beginning-of-line delete-horizontal-space] 3 (#$ . 110793) "*P"])
#@120 Return non-nil, if line starts with a top level definition.

Used by `py-electric-colon', which will not indent than. 
(defalias 'py-top-level-form-p #[nil "\303\212\304 \210\305	!\206\305\n!))\207" [erg py-class-re py-def-re nil beginning-of-line looking-at] 2 (#$ . 111602)])
#@107 Delete preceding character or level of indentation.

With ARG do that ARG times.
Returns column reached. 
(defalias 'py-electric-backspace #[(&optional arg) "\206\306\307\211\310\nW\203@\311\312!\2035i\f\246\310
W\203*\313
[!\210\2021\314\315 \fZ!\210)\2029\313\316!\210\nT\211\202
*i\317 \203R\203R\320\321	\"\210	*\207" [arg erg i #1=#:--cl-dotimes-temp-- py-indent-offset remains 1 nil 0 looking-back "^[ 	]+" delete-char indent-line-to current-indentation -1 interactive-p message "%s" py-verbose-p] 4 (#$ . 111892) "*p"])
#@83 Delete following character or levels of whitespace.

With ARG do that ARG times. 
(defalias 'py-electric-delete #[(&optional arg) "\206\305\211\306	\nW\205Jn\204\307\310!\203?\311\312!\203?i\306\225\306\224Z\\\246\306\fW\2037\313\f!\210\202;\313!\210)\202C\313\305!\210	T\211\202+\207" [arg i #1=#:--cl-dotimes-temp-- py-indent-offset remains 1 0 looking-back "^[ 	]+" looking-at "[ 	]+" delete-char] 4 (#$ . 112446) "*p"])
(byte-code "\300\301\302\303#\210\300\301\304\303#\210\300\305\302\306#\210\300\305\304\306#\210\300\307\302\306#\210\300\307\304\306#\207" [put py-electric-colon delete-selection t pending-delete py-electric-backspace supersede py-electric-delete] 4)
#@166 Indent the current line to the outmost reasonable indent.

With optional \[universal-argument] an indent with length `py-indent-offset' is inserted unconditionally 
(defalias 'py-indent-line-outmost #[(&optional arg) "\305`!\306 i\307!\310=\203\311\f\312\"c\2022	=\203*\n	=\204*\313 \2022\314 \210\315 \210j+\207" [need cui cuc arg py-indent-offset py-compute-indentation current-indentation prefix-numeric-value 4 make-string 32 back-to-indentation beginning-of-line delete-horizontal-space] 3 (#$ . 113149) "*P"])
#@35 Used internal by `py-indent-line'
(defvar py-indent-line-indent nil (#$ . 113683))
(defalias 'py-indent-line-intern #[(need cui) "\203v	\n=\203)\f=\205u\306 \210\307 \210\310 `
\nZ\\X\203&
\nZu\207\306 \207\n	W\203Z\f=\203L\306 \210\307 \210\n\n\245\n_\n\\j\210
\nZu\207\306 \210\307 \210	j\210
\nZu\207\306 \210\307 \210	j\210\310 `
\nZ\\X\203s
\nZu\207\306 \207\311 \207" [py-tab-indent need cui this-command last-command col beginning-of-line delete-horizontal-space line-beginning-position insert-tab py-indent-offset] 4])
#@608 Indent the current line according to Python rules.

When called interactivly with \[universal-argument], ignore dedenting rules for block closing statements
(e.g. return, raise, break, continue, pass)

An optional \[universal-argument] followed by a numeric argument neither 1 nor 4 will switch off `py-smart-indentation' for this execution. This permits to correct allowed but unwanted indents.
Similar to `toggle-py-smart-indentation' resp. `py-smart-indentation-off' followed by TAB.

This function is normally used by `indent-line-function' resp.
\[indent-for-tab-command].
Returns current indentation 
(defalias 'py-indent-line #[(&optional arg) "\306 i\307 \310
!\311=\203!\312 \210\313 \210	\\j\210\2029\310
!\314=\2044\315 \210\316 \210\n\2029\316	\f\"\210,\317 \203J\203J\320\321\306 \"\210\306 \207" [py-smart-indentation need psi col cui arg current-indentation py-compute-indentation prefix-numeric-value 4 beginning-of-line delete-horizontal-space 1 py-smart-indentation-off py-indent-line-intern interactive-p message "%s" py-indent-offset py-verbose-p] 4 (#$ . 114230) "P"])
#@128 Add a newline and indent to outmost reasonable indent.
When indent is set back manually, this is honoured in following lines. 
(defalias 'py-newline-and-indent #[nil "\304 `\305\211iW\203\306 \210\212	b\210\307 \210)\310 j\202<\311 \210\312\313\314\"\210\315\310 \211\316\"c\210\317\320!\203<\314\224\314\225|\210\317\321!\203O\322 A@\203O\323\224\323\225|\210\324 \203]\203]\325\326\"\210+\207" [erg orig ci py-verbose-p current-indentation nil newline delete-trailing-whitespace py-compute-indentation beginning-of-line insert-char 10 1 make-string 32 looking-at "\\([ 	]+\\)" "[ 	]+" syntax-ppss 0 interactive-p message "%s"] 4 (#$ . 115343) "*"])
(defalias 'py-newline-and-close-block 'py-newline-and-dedent)
#@71 Add a newline and indent to one level below current.
Returns column. 
(defalias 'py-newline-and-dedent #[nil "\304 \305\306 \210\307	W\203\310 \nZ\211j\210\311 \203$\203$\312\313\"\210*\207" [erg cui py-indent-offset py-verbose-p current-indentation nil newline 0 py-compute-indentation interactive-p message "%s"] 4 (#$ . 116078) "*"])
#@408 If locally indicated Python shell should be taken and
enforced upon sessions execute commands.

Toggles boolean `py-force-local-shell-p' along with `py-force-py-shell-name-p'
Returns value of `toggle-force-local-shell' switched to.

When on, kind of an option 'follow', local shell sets `py-shell-name', enforces its use afterwards.

See also commands
`py-force-local-shell-on'
`py-force-local-shell-off'
 
(defalias 'toggle-force-local-shell #[(&optional arg) "\206
	\203\f\305\202
\306\307W\203 \n\206\310 \311\202&\312\303!\313\314 \203D	\203;\f\203D\315\316\"\210\202D\f\203D\315\317\"\210)\207" [arg py-force-local-shell-p py-local-command py-shell-name py-verbose-p -1 1 0 py-choose-shell t default-value nil interactive-p message "Enforce %s" "py-shell-name default restored to: %s"] 3 (#$ . 116432) (list arg)])
#@183 Make sure, `py-py-force-local-shell-p' is on.

Returns value of `py-force-local-shell-p'.

Kind of an option 'follow', local shell sets `py-shell-name', enforces its use afterwards 
(defalias 'py-force-local-shell-on #[nil "\303\304!	\204
\305 \205\306\307\n\")\207" [erg py-verbose-p py-shell-name toggle-force-local-shell 1 interactive-p message "Enforce %s"] 3 (#$ . 117281) nil])
#@57 Restore `py-shell-name' default value and `behaviour'. 
(defalias 'py-force-local-shell-off #[nil "\303\304!	\204
\305 \205\306\307\n\"\210\306\310\n\")\207" [erg py-verbose-p py-shell-name toggle-force-local-shell 1 interactive-p message "py-shell-name default restored to: %s" "Enforce %s"] 3 (#$ . 117675) nil])
#@299 If customized default `py-shell-name' should be enforced upon execution.

If `py-force-py-shell-name-p' should be on or off.
Returns value of `py-force-py-shell-name-p' switched to.

See also commands
force-py-shell-name-p-on
force-py-shell-name-p-off

Caveat: Completion might not work that way.

(defalias 'toggle-force-py-shell-name-p #[(&optional arg) "\206
	\203\f\303\202
\304\305W\203\306\202\307\n\204$\310 \203)\311\312	\"\210	)\207" [arg py-force-py-shell-name-p py-verbose-p -1 1 0 t nil interactive-p message "py-force-py-shell-name-p: %s"] 3 (#$ . 118001) "p"])
#@201 Switches `py-force-py-shell-name-p' on.

Customized default `py-shell-name' will be enforced upon execution.
Returns value of `py-force-py-shell-name-p'.

Caveat: Completion might not work that way.

(defalias 'force-py-shell-name-p-on #[(&optional arg) "\206\303\304!\210)	\204\305 \203\306\307\n\"\210\n\207" [arg py-verbose-p py-force-py-shell-name-p 1 toggle-force-py-shell-name-p interactive-p message "py-force-py-shell-name-p: %s"] 3 (#$ . 118597) "p"])
#@156 Make sure, `py-force-py-shell-name-p' is off.

Function to use by executes will be guessed from environment.
Returns value of `py-force-py-shell-name-p'. 
(defalias 'force-py-shell-name-p-off #[nil "\302\303!\210\204
\304 \203\305\306	\"\210	\207" [py-verbose-p py-force-py-shell-name-p toggle-force-py-shell-name-p -1 interactive-p message "py-force-py-shell-name-p: %s"] 3 (#$ . 119074) nil])
#@79 Toggle `indent-tabs-mode'.

Returns value of `indent-tabs-mode' switched to. 
(defalias 'py-toggle-indent-tabs-mode #[nil "?\211\203		\203\304 \203\305\306	#\210\207" [indent-tabs-mode py-indent-offset tab-width py-verbose-p interactive-p message "indent-tabs-mode %s  py-indent-offset %s"] 4 (#$ . 119479) nil])
#@149 With positive ARG switch `indent-tabs-mode' on.

With negative ARG switch `indent-tabs-mode' off.
Returns value of `indent-tabs-mode' switched to. 
(defalias 'py-indent-tabs-mode #[(arg &optional iact) "\306W\203
\307\n\202\310\f\203\"
\204\311 \203\"\312\313	\n#\210	\207" [arg indent-tabs-mode py-indent-offset tab-width py-verbose-p iact 0 t nil interactive-p message "indent-tabs-mode %s   py-indent-offset %s"] 4 (#$ . 119810) "p"])
#@32 Switch `indent-tabs-mode' on. 
(defalias 'py-indent-tabs-mode-on #[(arg) "\301\302!\303 \"\207" [arg indent-tabs-mode abs interactive-p] 3 (#$ . 120265) "p"])
#@32 Switch `indent-tabs-mode' on. 
(defalias 'py-indent-tabs-mode-off #[(arg) "\301\302![\303 \"\207" [arg indent-tabs-mode abs interactive-p] 3 (#$ . 120431) "p"])
(defalias 'py-guessed-sanity-check #[(guessed) "\301Y\205\302X\205\301\246\303=\207" [guessed 2 8 0] 2])
#@300 Guess a value for, and change, `py-indent-offset'.

By default, make a buffer-local copy of `py-indent-offset' with the
new value.
With optional argument GLOBAL change the global value of `py-indent-offset'.

Indent might be guessed savely only from beginning of a block.
Returns `py-indent-offset'
(defalias 'py-guess-indent-offset #[(&optional global orig origline) "\212\206`	\206
\306 \211\306 =\205'\307 \210	\306 =\203&\307 \210i\202'i\211\205\\\310 \210i\nW\2039i\202\\b\210\310 \210\311 \211\205\\	\306 =\203S\310 \210\311 \312\313\314\217\205\\\311 \211\205f\315\nZ!\211\203v\316\f!\203v\f\202z\317\305!\203\203\320\202\204\321\305!\210\203\240\322 \203\240\323\324\203\234\325\202\235\326
#\210
.\207" [orig origline firstindent erg guessed py-indent-offset py-count-lines py-beginning-of-statement py-beginning-of-block current-indentation nil (byte-code "\301 W\207" [firstindent py-down-statement] 2) ((error)) abs py-guessed-sanity-check default-value kill-local-variable make-local-variable interactive-p message "%s value of py-indent-offset:  %d" "Global" "Local" global py-verbose-p] 5 (#$ . 120712) "P"])
#@46 Python version of `comment-indent-function'.
(defalias 'py-comment-indent-function #[nil "\212\303 \210\304 	\203\305	\306#\203\307\224b\210\310\311x\210\nin\203'\307\202(\312\\]*\207" [eol comment-start-skip comment-column beginning-of-line line-end-position re-search-forward t 0 " 	" nil 1] 4 (#$ . 121884)])
#@120 Make text outside current def or class invisible.

The defun visible is the one that contains point or follows point. 
(defalias 'py-narrow-to-defun #[nil "\212~\210\301 \210`\302 \210`}*\207" [end py-end-of-def-or-class py-beginning-of-def-or-class] 2 (#$ . 122213) "P"])
(byte-code "\300\301\302\"\210\300\303\304\"\210\300\305\306\"\207" [defalias py-beginning-of-paragraph backward-paragraph py-end-of-paragraph forward-paragraph py-shift-region-left py-shift-left] 3)
#@144 Dedent region according to `py-indent-offset' by COUNT times.

If no region is active, current line is dedented.
Returns indentation reached. 
(defalias 'py-shift-left #[(&optional count start end) "\305[	\n#\306 \203\f\203\307\310\"\210)\207" [count start end erg py-verbose-p py-shift-intern interactive-p message "%s"] 4 (#$ . 122695) "p"])
(defalias 'py-shift-region-right 'py-shift-right)
#@144 Indent region according to `py-indent-offset' by COUNT times.

If no region is active, current line is indented.
Returns indentation reached. 
(defalias 'py-shift-right #[(&optional count beg end) "\305	\n#\306 \203\f\203\307\310\"\210)\207" [count beg end erg py-verbose-p py-shift-intern interactive-p message "%s"] 4 (#$ . 123104) "p"])
(defalias 'py-shift-intern #[(count &optional start end) "\212\306\307\n\206\310 \203\212\311 b)\202\312 \f\206,\310 \203*\212\313 b)\202,\314 \211\315!\315\f!\316W\203H\317\f#\210\202P\317\f[#\210\320\306\"\210\fb\210\321\307x\210-\322 )\207" [inhibit-point-motion-hooks deactivate-mark start beg end orig t nil region-active-p region-beginning line-beginning-position region-end line-end-position copy-marker 0 indent-rigidly push-mark " 	
\n\f" py-indentation-of-statement count py-indent-offset] 5])
(defalias 'py-shift-forms-base #[(form arg &optional beg end) "\306\307P!\306\310P!\311`!\f\206+\312 \203$\212\313 b\210\314 )\202+\212	 \210\314 )
\206<\312 \203:\315 \202<\n \316\f
#b\210.\207" [form begform endform orig beg end intern-soft "py-beginning-of-" "py-end-of-" copy-marker region-active-p region-beginning line-beginning-position region-end py-shift-intern arg erg] 4])
#@168 Indent paragraph by COUNT spaces.

COUNT defaults to `py-indent-offset',
use [universal-argument] to specify a different value.

Returns outmost indentation reached. 
(defalias 'py-shift-paragraph-right #[(&optional arg) "\304\305\206	\"\306 \203\203\307\310\n\"\210\n)\207" [arg py-indent-offset erg py-verbose-p py-shift-forms-base "paragraph" interactive-p message "%s"] 3 (#$ . 124396) "*P"])
#@168 Dedent paragraph by COUNT spaces.

COUNT defaults to `py-indent-offset',
use [universal-argument] to specify a different value.

Returns outmost indentation reached. 
(defalias 'py-shift-paragraph-left #[(&optional arg) "\304\305\206	[\"\306 \203\203\307\310\n\"\210\n)\207" [arg py-indent-offset erg py-verbose-p py-shift-forms-base "paragraph" interactive-p message "%s"] 3 (#$ . 124809) "*P"])
#@164 Indent block by COUNT spaces.

COUNT defaults to `py-indent-offset',
use [universal-argument] to specify a different value.

Returns outmost indentation reached. 
(defalias 'py-shift-block-right #[(&optional arg) "\304\305\206	\"\306 \203\203\307\310\n\"\210\n)\207" [arg py-indent-offset erg py-verbose-p py-shift-forms-base "block" interactive-p message "%s"] 3 (#$ . 125222) "*P"])
#@164 Dedent block by COUNT spaces.

COUNT defaults to `py-indent-offset',
use [universal-argument] to specify a different value.

Returns outmost indentation reached. 
(defalias 'py-shift-block-left #[(&optional arg) "\304\305\206	[\"\306 \203\203\307\310\n\"\210\n)\207" [arg py-indent-offset erg py-verbose-p py-shift-forms-base "block" interactive-p message "%s"] 3 (#$ . 125623) "*P"])
#@165 Indent clause by COUNT spaces.

COUNT defaults to `py-indent-offset',
use [universal-argument] to specify a different value.

Returns outmost indentation reached. 
(defalias 'py-shift-clause-right #[(&optional arg) "\304\305\206	\"\306 \203\203\307\310\n\"\210\n)\207" [arg py-indent-offset erg py-verbose-p py-shift-forms-base "clause" interactive-p message "%s"] 3 (#$ . 126024) "*P"])
#@165 Dedent clause by COUNT spaces.

COUNT defaults to `py-indent-offset',
use [universal-argument] to specify a different value.

Returns outmost indentation reached. 
(defalias 'py-shift-clause-left #[(&optional arg) "\304\305\206	[\"\306 \203\203\307\310\n\"\210\n)\207" [arg py-indent-offset erg py-verbose-p py-shift-forms-base "clause" interactive-p message "%s"] 3 (#$ . 126428) "*P"])
#@162 Indent def by COUNT spaces.

COUNT defaults to `py-indent-offset',
use [universal-argument] to specify a different value.

Returns outmost indentation reached. 
(defalias 'py-shift-def-right #[(&optional arg) "\304\305\206	\"\306 \203\203\307\310\n\"\210\n)\207" [arg py-indent-offset erg py-verbose-p py-shift-forms-base "def" interactive-p message "%s"] 3 (#$ . 126832) "*P"])
#@162 Dedent def by COUNT spaces.

COUNT defaults to `py-indent-offset',
use [universal-argument] to specify a different value.

Returns outmost indentation reached. 
(defalias 'py-shift-def-left #[(&optional arg) "\304\305\206	[\"\306 \203\203\307\310\n\"\210\n)\207" [arg py-indent-offset erg py-verbose-p py-shift-forms-base "def" interactive-p message "%s"] 3 (#$ . 127227) "*P"])
#@164 Indent class by COUNT spaces.

COUNT defaults to `py-indent-offset',
use [universal-argument] to specify a different value.

Returns outmost indentation reached. 
(defalias 'py-shift-class-right #[(&optional arg) "\304\305\206	\"\306 \203\203\307\310\n\"\210\n)\207" [arg py-indent-offset erg py-verbose-p py-shift-forms-base "class" interactive-p message "%s"] 3 (#$ . 127622) "*P"])
#@164 Dedent class by COUNT spaces.

COUNT defaults to `py-indent-offset',
use [universal-argument] to specify a different value.

Returns outmost indentation reached. 
(defalias 'py-shift-class-left #[(&optional arg) "\304\305\206	[\"\306 \203\203\307\310\n\"\210\n)\207" [arg py-indent-offset erg py-verbose-p py-shift-forms-base "class" interactive-p message "%s"] 3 (#$ . 128023) "*P"])
#@163 Indent line by COUNT spaces.

COUNT defaults to `py-indent-offset',
use [universal-argument] to specify a different value.

Returns outmost indentation reached. 
(defalias 'py-shift-line-right #[(&optional arg) "\304\305\206	\"\306 \203\203\307\310\n\"\210\n)\207" [arg py-indent-offset erg py-verbose-p py-shift-forms-base "line" interactive-p message "%s"] 3 (#$ . 128424) "*P"])
#@163 Dedent line by COUNT spaces.

COUNT defaults to `py-indent-offset',
use [universal-argument] to specify a different value.

Returns outmost indentation reached. 
(defalias 'py-shift-line-left #[(&optional arg) "\304\305\206	[\"\306 \203\203\307\310\n\"\210\n)\207" [arg py-indent-offset erg py-verbose-p py-shift-forms-base "line" interactive-p message "%s"] 3 (#$ . 128822) "*P"])
#@168 Indent statement by COUNT spaces.

COUNT defaults to `py-indent-offset',
use [universal-argument] to specify a different value.

Returns outmost indentation reached. 
(defalias 'py-shift-statement-right #[(&optional arg) "\304\305\206	\"\306 \203\203\307\310\n\"\210\n)\207" [arg py-indent-offset erg py-verbose-p py-shift-forms-base "statement" interactive-p message "%s"] 3 (#$ . 129220) "*P"])
#@168 Dedent statement by COUNT spaces.

COUNT defaults to `py-indent-offset',
use [universal-argument] to specify a different value.

Returns outmost indentation reached. 
(defalias 'py-shift-statement-left #[(&optional arg) "\304\305\206	[\"\306 \203\203\307\310\n\"\210\n)\207" [arg py-indent-offset erg py-verbose-p py-shift-forms-base "statement" interactive-p message "%s"] 3 (#$ . 129633) "*P"])
#@64 Indent current line according to mode, move one line forward. 
(defalias 'py-indent-and-forward #[nil "\300 \210\301 \210\302 j\210m\203\303 \210\202\304y\210\305 \207" [beginning-of-line fixup-whitespace py-compute-indentation newline-and-indent 1 back-to-indentation] 1 (#$ . 130045) "*"])
#@200 Reindent a region of Python code.

With optional INDENT-OFFSET specify a different value than `py-indent-offset' at place.

Guesses the outmost reasonable indent
Returns and keeps relative position 
(defalias 'py-indent-region #[(start end &optional indent-offset) "\306`!\306	!\307\n\206
!\fb\210\310 	W\203\"\311 \210\202\212\312 \210\313\314!)\2040\315 \210
b,\207" [start end indent-offset py-indent-offset beg orig copy-marker prefix-numeric-value line-end-position py-indent-and-forward beginning-of-line looking-at "\\s-*$" py-indent-line] 5 (#$ . 130348) "*r\nP"])
#@43 Returns beginning of paragraph position. 
(defalias 'py-beginning-of-paragraph-position #[nil "\212\302 	\203\303 \203\304\305\"\210*\207" [erg py-verbose-p py-beginning-of-paragraph interactive-p message "%s"] 3 (#$ . 130938) nil])
#@37 Returns end of paragraph position. 
(defalias 'py-end-of-paragraph-position #[nil "\212\302 	\203\303 \203\304\305\"\210*\207" [erg py-verbose-p py-end-of-paragraph interactive-p message "%s"] 3 (#$ . 131184) nil])
#@39 Returns beginning of block position. 
(defalias 'py-beginning-of-block-position #[nil "\212\302 	\203\303 \203\304\305\"\210*\207" [erg py-verbose-p py-beginning-of-block interactive-p message "%s"] 3 (#$ . 131412) nil])
#@33 Returns end of block position. 
(defalias 'py-end-of-block-position #[nil "\212\302 	\203\303 \203\304\305\"\210*\207" [erg py-verbose-p py-end-of-block interactive-p message "%s"] 3 (#$ . 131646) nil])
#@40 Returns beginning of clause position. 
(defalias 'py-beginning-of-clause-position #[nil "\212\302 	\203\303 \203\304\305\"\210*\207" [erg py-verbose-p py-beginning-of-clause interactive-p message "%s"] 3 (#$ . 131862) nil])
#@34 Returns end of clause position. 
(defalias 'py-end-of-clause-position #[nil "\212\302 	\203\303 \203\304\305\"\210*\207" [erg py-verbose-p py-end-of-clause interactive-p message "%s"] 3 (#$ . 132099) nil])
#@49 Returns beginning of block-or-clause position. 
(defalias 'py-beginning-of-block-or-clause-position #[nil "\212\302 	\203\303 \203\304\305\"\210*\207" [erg py-verbose-p py-beginning-of-block-or-clause interactive-p message "%s"] 3 (#$ . 132318) nil])
#@43 Returns end of block-or-clause position. 
(defalias 'py-end-of-block-or-clause-position #[nil "\212\302 	\203\303 \203\304\305\"\210*\207" [erg py-verbose-p py-end-of-block-or-clause interactive-p message "%s"] 3 (#$ . 132582) nil])
#@37 Returns beginning of def position. 
(defalias 'py-beginning-of-def-position #[nil "\212\302 	\203\303 \203\304\305\"\210*\207" [erg py-verbose-p py-beginning-of-def interactive-p message "%s"] 3 (#$ . 132828) nil])
#@31 Returns end of def position. 
(defalias 'py-end-of-def-position #[nil "\212\302 	\203\303 \203\304\305\"\210*\207" [erg py-verbose-p py-end-of-def interactive-p message "%s"] 3 (#$ . 133056) nil])
#@39 Returns beginning of class position. 
(defalias 'py-beginning-of-class-position #[nil "\212\302 	\203\303 \203\304\305\"\210*\207" [erg py-verbose-p py-beginning-of-class interactive-p message "%s"] 3 (#$ . 133266) nil])
#@33 Returns end of class position. 
(defalias 'py-end-of-class-position #[nil "\212\302 	\203\303 \203\304\305\"\210*\207" [erg py-verbose-p py-end-of-class interactive-p message "%s"] 3 (#$ . 133500) nil])
#@46 Returns beginning of def-or-class position. 
(defalias 'py-beginning-of-def-or-class-position #[nil "\212\302 	\203\303 \203\304\305\"\210*\207" [erg py-verbose-p py-beginning-of-def-or-class interactive-p message "%s"] 3 (#$ . 133716) nil])
#@40 Returns end of def-or-class position. 
(defalias 'py-end-of-def-or-class-position #[nil "\212\302 	\203\303 \203\304\305\"\210*\207" [erg py-verbose-p py-end-of-def-or-class interactive-p message "%s"] 3 (#$ . 133971) nil])
#@38 Returns beginning of line position. 
(defalias 'py-beginning-of-line-position #[nil "\212\302 	\203\303 \203\304\305\"\210*\207" [erg py-verbose-p py-beginning-of-line interactive-p message "%s"] 3 (#$ . 134208) nil])
#@32 Returns end of line position. 
(defalias 'py-end-of-line-position #[nil "\212\302 	\203\303 \203\304\305\"\210*\207" [erg py-verbose-p py-end-of-line interactive-p message "%s"] 3 (#$ . 134439) nil])
#@43 Returns beginning of statement position. 
(defalias 'py-beginning-of-statement-position #[nil "\212\302 	\203\303 \203\304\305\"\210*\207" [erg py-verbose-p py-beginning-of-statement interactive-p message "%s"] 3 (#$ . 134652) nil])
#@37 Returns end of statement position. 
(defalias 'py-end-of-statement-position #[nil "\212\302 	\203\303 \203\304\305\"\210*\207" [erg py-verbose-p py-end-of-statement interactive-p message "%s"] 3 (#$ . 134898) nil])
#@44 Returns beginning of expression position. 
(defalias 'py-beginning-of-expression-position #[nil "\212\302 	\203\303 \203\304\305\"\210*\207" [erg py-verbose-p py-beginning-of-expression interactive-p message "%s"] 3 (#$ . 135126) nil])
#@38 Returns end of expression position. 
(defalias 'py-end-of-expression-position #[nil "\212\302 	\203\303 \203\304\305\"\210*\207" [erg py-verbose-p py-end-of-expression interactive-p message "%s"] 3 (#$ . 135375) nil])
#@52 Returns beginning of partial-expression position. 
(defalias 'py-beginning-of-partial-expression-position #[nil "\212\302 	\203\303 \203\304\305\"\210*\207" [erg py-verbose-p py-beginning-of-partial-expression interactive-p message "%s"] 3 (#$ . 135606) nil])
#@46 Returns end of partial-expression position. 
(defalias 'py-end-of-partial-expression-position #[nil "\212\302 	\203\303 \203\304\305\"\210*\207" [erg py-verbose-p py-end-of-partial-expression interactive-p message "%s"] 3 (#$ . 135879) nil])
#@159 Returns bounds of statement at point.

With optional POSITION, a number, report bounds of statement at POSITION.
Returns a list, whose car is beg, cdr - end.
(defalias 'py-bounds-of-statement #[(&optional position) "\212\214~\210\203b\210\304 \305 \211\203+	\203+\205.\306 \205.\307\310\n	D\"\202.\n	D,\207" [position end beg py-verbose-p py-beginning-of-statement-position py-end-of-statement-position interactive-p message "%s"] 5 (#$ . 136135) nil])
#@151 Returns bounds of block at point.

With optional POSITION, a number, report bounds of block at POSITION.
Returns a list, whose car is beg, cdr - end.
(defalias 'py-bounds-of-block #[(&optional position) "\212\214~\210\203b\210\304 \305 \211\203+	\203+\205.\306 \205.\307\310\n	D\"\202.\n	D,\207" [position end beg py-verbose-p py-beginning-of-block-position py-end-of-block-position interactive-p message "%s"] 5 (#$ . 136607) nil])
#@153 Returns bounds of clause at point.

With optional POSITION, a number, report bounds of clause at POSITION.
Returns a list, whose car is beg, cdr - end.
(defalias 'py-bounds-of-clause #[(&optional position) "\212\214~\210\203b\210\304 \305 \211\203+	\203+\205.\306 \205.\307\310\n	D\"\202.\n	D,\207" [position end beg py-verbose-p py-beginning-of-clause-position py-end-of-clause-position interactive-p message "%s"] 5 (#$ . 137059) nil])
#@171 Returns bounds of block-or-clause at point.

With optional POSITION, a number, report bounds of block-or-clause at POSITION.
Returns a list, whose car is beg, cdr - end.
(defalias 'py-bounds-of-block-or-clause #[(&optional position) "\212\214~\210\203b\210\304 \305 \211\203+	\203+\205.\306 \205.\307\310\n	D\"\202.\n	D,\207" [position end beg py-verbose-p py-beginning-of-block-or-clause-position py-end-of-block-or-clause-position interactive-p message "%s"] 5 (#$ . 137516) nil])
#@147 Returns bounds of def at point.

With optional POSITION, a number, report bounds of def at POSITION.
Returns a list, whose car is beg, cdr - end.
(defalias 'py-bounds-of-def #[(&optional position) "\212\214~\210\203b\210\304 \305 \211\203+	\203+\205.\306 \205.\307\310\n	D\"\202.\n	D,\207" [position end beg py-verbose-p py-beginning-of-def-position py-end-of-def-position interactive-p message "%s"] 5 (#$ . 138018) nil])
#@151 Returns bounds of class at point.

With optional POSITION, a number, report bounds of class at POSITION.
Returns a list, whose car is beg, cdr - end.
(defalias 'py-bounds-of-class #[(&optional position) "\212\214~\210\203b\210\304 \305 \211\203+	\203+\205.\306 \205.\307\310\n	D\"\202.\n	D,\207" [position end beg py-verbose-p py-beginning-of-class-position py-end-of-class-position interactive-p message "%s"] 5 (#$ . 138460) nil])
#@82 Returns bounds of region at point.

Returns a list, whose car is beg, cdr - end.
(defalias 'py-bounds-of-region #[nil "\212\214~\210\303 \304 \211\203$\203$\n\205'\305 \205'\306\307	D\"\202'	D,\207" [end beg py-verbose-p region-beginning region-end interactive-p message "%s"] 5 (#$ . 138911) nil])
(defalias 'py-beginning-of-buffer-position #[nil "e\207" [] 1])
(defalias 'py-end-of-buffer-position #[nil "d\207" [] 1])
#@153 Returns bounds of buffer at point.

With optional POSITION, a number, report bounds of buffer at POSITION.
Returns a list, whose car is beg, cdr - end.
(defalias 'py-bounds-of-buffer #[(&optional position) "\212\214~\210\203b\210\304 \305 \211\203+	\203+\205.\306 \205.\307\310\n	D\"\202.\n	D,\207" [position end beg py-verbose-p py-beginning-of-buffer-position py-end-of-buffer-position interactive-p message "%s"] 5 (#$ . 139349) nil])
#@161 Returns bounds of expression at point.

With optional POSITION, a number, report bounds of expression at POSITION.
Returns a list, whose car is beg, cdr - end.
(defalias 'py-bounds-of-expression #[(&optional position) "\212\214~\210\203b\210\304 \305 \211\203+	\203+\205.\306 \205.\307\310\n	D\"\202.\n	D,\207" [position end beg py-verbose-p py-beginning-of-expression-position py-end-of-expression-position interactive-p message "%s"] 5 (#$ . 139806) nil])
#@177 Returns bounds of partial-expression at point.

With optional POSITION, a number, report bounds of partial-expression at POSITION.
Returns a list, whose car is beg, cdr - end.
(defalias 'py-bounds-of-partial-expression #[(&optional position) "\212\214~\210\203b\210\304 \305 \211\203+	\203+\205.\306 \205.\307\310\n	D\"\202.\n	D,\207" [position end beg py-verbose-p py-beginning-of-partial-expression-position py-end-of-partial-expression-position interactive-p message "%s"] 5 (#$ . 140283) nil])
#@259 Bounds of consecutive multitude of assigments resp. statements around point.

Indented same level, which don't open blocks.
Typically declarations resp. initialisations of variables following
a class or function definition.
See also py-bounds-of-statements 
(defalias 'py-bounds-of-declarations #[nil "\306 \210\307 \204\310 \210\311 ?\205\312 `\313\211\313\205\225\314 \307 \204+\310 \210\314 \203G\310 \203G\311 \204G\312 =\203G\314 \202#	b\210\315 \211\203d\316 \211\203d\311 \204d\317 =\204J\nb\210\203\206\f\203\206
\203\200\320 \203\200\321\322\f#\210\fB\202\225
\203\224\320 \203\224\321\323\313\"\210\313-\207" [orig-indent orig last beg end py-verbose-p back-to-indentation py-beginning-of-statement-p py-beginning-of-statement py-beginning-of-block-p current-indentation nil line-beginning-position line-end-position py-down-statement py-indentation-of-statement interactive-p message "%s %s" "%s"] 5 (#$ . 140800) nil])
(defalias 'py-backward-declarations 'py-beginning-of-declarations)
#@96 Got to the beginning of assigments resp. statements in current level which don't open blocks.

(defalias 'py-beginning-of-declarations #[nil "\303 \211@\211\203
	b\210\n\203\304 \203\305\306	\"\210	*\207" [bounds erg py-verbose-p py-bounds-of-declarations interactive-p message "%s"] 4 (#$ . 141843) nil])
(defalias 'py-forward-of-declarations 'py-end-of-declarations)
#@90 Got to the end of assigments resp. statements in current level which don't open blocks. 
(defalias 'py-end-of-declarations #[nil "\303 \211A\211\203
	b\210\n\203\304 \203\305\306	\"\210	*\207" [bounds erg py-verbose-p py-bounds-of-declarations interactive-p message "%s"] 4 (#$ . 142225) nil])
(defalias 'py-copy-declarations 'py-declarations)
#@215 Copy and mark assigments resp. statements in current level which don't open blocks or start with a keyword.

See also `py-statements', which is more general, taking also simple statements starting with a keyword. 
(defalias 'py-declarations #[nil "\303 \211@A	\205#\n\205#	b\210\304 \210\nb\210\305\306	\n\"!\210\307 +\207" [bounds beg end py-bounds-of-declarations push-mark kill-new buffer-substring-no-properties exchange-point-and-mark] 5 (#$ . 142583) nil])
#@84 Delete variables declared in current level.

Store deleted variables in kill-ring 
(defalias 'py-kill-declarations #[nil "\303 \211@A	\205$\n\205$	b\210\304 \210\nb\210\305\306	\n\"!\210	\n|+\207" [bounds beg end py-bounds-of-declarations push-mark kill-new buffer-substring-no-properties] 5 (#$ . 143058) "*"])
#@109 Bounds of consecutive multitude of statements around point.

Indented same level, which don't open blocks. 
(defalias 'py-bounds-of-statements #[nil "\306 \210\307 \204\310 \210\311 ?\205\312 `\313\211\313\205\235`\211\203E\310 \205/\314 \211\203E\315 \204E\311 \204E\312 =\204\"\n	b\210\316 \316 \211\203l\317 \211\203l\311 \204l\315 \204l\320 =\204M\n	b\210\203\216\f\203\216
\203\210\321 \203\210\322\323\f#\210\fB\202\235
\203\234\321 \203\234\322\324\313\"\210\313-\207" [orig-indent orig last beg end py-verbose-p back-to-indentation py-beginning-of-statement-p py-beginning-of-statement py-beginning-of-block-p current-indentation nil line-beginning-position py-in-string-p line-end-position py-down-statement py-indentation-of-statement interactive-p message "%s %s" "%s"] 5 (#$ . 143383) nil])
(defalias 'py-backward-statements 'py-beginning-of-statements)
#@79 Got to the beginning of statements in current level which don't open blocks. 
(defalias 'py-beginning-of-statements #[nil "\303 \211@\211\203
	b\210\n\203\304 \203\305\306	\"\210	*\207" [bounds erg py-verbose-p py-bounds-of-statements interactive-p message "%s"] 4 (#$ . 144298) nil])
(defalias 'py-forward-of-statements 'py-end-of-statements)
#@73 Got to the end of statements in current level which don't open blocks. 
(defalias 'py-end-of-statements #[nil "\303 \211A\211\203
	b\210\n\203\304 \203\305\306	\"\210	*\207" [bounds erg py-verbose-p py-bounds-of-statements interactive-p message "%s"] 4 (#$ . 144655) nil])
(defalias 'py-copy-statements 'py-statements)
#@165 Copy and mark simple statements in current level which don't open blocks.

More general than py-declarations, which would stop at keywords like a print-statement. 
(defalias 'py-statements #[nil "\303 \211@A	\205#\n\205#	b\210\304 \210\nb\210\305\306	\n\"!\210\307 +\207" [bounds beg end py-bounds-of-statements push-mark kill-new buffer-substring-no-properties exchange-point-and-mark] 5 (#$ . 144988) nil])
#@86 Delete statements declared in current level.

Store deleted statements in kill-ring 
(defalias 'py-kill-statements #[nil "\303 \211@A	\205$\n\205$	b\210\304 \210\nb\210\305\306	\n\"!\210	\n|+\207" [bounds beg end py-bounds-of-statements push-mark kill-new buffer-substring-no-properties] 5 (#$ . 145409) "*"])
#@67 Like `comment-region' but uses double hash (`#') comment starter.
(defalias 'py-comment-region #[(beg end &optional arg) "\305\n\f#)\207" [py-block-comment-prefix comment-start beg end arg comment-region] 4 (#$ . 145731) "r\nP"])
(defalias 'py-join-words-wrapping #[(words separator line-prefix line-length) "\306\2036@	\f
Q\211GV\203)	\307\310O\nB\f
\311R\202.\311P*A\211\204	\307\312\307
G\313#O\nB\314\315\n\237\316#*\207" [line-prefix current-line lines words word separator nil 0 -1 " " - 1 mapconcat identity "\n" maybe-line line-length] 7])
#@37 Fill the comment paragraph at point
(defalias 'py-fill-comment #[(&optional justify) "\306\211\212\307 \210\310\311!\203\312\313\224\313\225{\202Q\310\314!\204>\315\306w\210`f\316=\2030\317u\210\202`f\320>\203\321\322!\210\202\310\323!\203Q\312\324i\325\"\313\224\313\225{P)	\204]\326\n!\210\202\224\214\212\327\330y!\203l\310\331!\204_\310\331!\204u\322y\210`)\212\322y\210\310\331!\204x`)}\210\332P\f\332P\326\n!\210,*\312\207" [comment-fill-prefix has-comment justify paragraph-start paragraph-separate fill-prefix nil beginning-of-line looking-at "[ 	]*#[# 	]*" t 0 "#\\|$" "^#\n\"'\\" 92 2 (34 39) forward-sexp 1 "#+[	 ]*" make-string 32 fill-paragraph zerop -1 "^[ 	]*#" "\\|[ 	#]*$"] 3 (#$ . 146312)])
(defalias 'py-fix-this-indent #[(indent) "\301 i=\205\ni=?\205\302 \210j\210`\303\304w\210`|\207" [indent current-indentation beginning-of-line " 	" nil] 3])
#@67 Fill the paragraph around (point) in the string starting at start
(defalias 'py-fill-string #[(start &optional justify) "\306\211\211\211\212\fb\210\307\310!\203%\311\225\312\225\312\224Z\313\312\224\312\225\"\202)\314\315!\210\212\316 \210Sf\317U\204?\307\320P!\203?`)\321 \210`	Z)\214\n}\210dSf\317U\322!\210
\204mdSf\317U\203m\212db\210\323\324!\210).\325\207" [delim delim-length string-end string-start start ends-with-newline nil looking-at "\\([urbURB]*\\(?:'''\\|\"\"\"\\|'\\|\"\\)\\)\\\\?\n?" 0 1 buffer-substring-no-properties error "The parameter start is not the beginning of a python string" beginning-of-line 10 "[ 	]*" forward-sexp fill-paragraph delete-char -1 t justify] 4 (#$ . 147219)])
#@282 Like \[fill-paragraph], but handle Python comments and strings.

If any of the current line is a comment, fill the comment or the
paragraph of it that point is in, preserving the comment's indentation
and initial `#'s.
If point is inside a string, narrow to that string and fill.

(defalias 'py-fill-paragraph #[(&optional justify) "\212\214~\210\302 \3038\203\304	!\202G\212\305 \210\306\307!)\203$\304	!\202G\3108\2032\311\3128!\202G\212\313u\210\3108)\205G\212\313u\210\311\3128!)+\207" [pps justify syntax-ppss 4 py-fill-comment beginning-of-line looking-at "[ 	]*#" 3 py-fill-string 8 1] 3 (#$ . 147954) "P"])
#@326 Insert a function "super()" from current environment.

As example given in Python v3.1 documentation Â» The Python Standard Library Â»

class C(B):
    def method(self, arg):
        super().method(arg) # This does the same thing as:
                               # super(C, self).method(arg)

Returns the string inserted. 
(defalias 'py-insert-super #[nil "`\306 \210\307	\310P!\205\311\312!\311\313!\314 \315\211\f\313W\203G\316 \210\307\317P!\2033\311\312!b\210\320
\321\n\322\323\260\211c\210\202Vb\210\324\n\322\323\260\211c\210.\207" [orig py-def-re funcname args ver classname py-beginning-of-def looking-at " *\\([^(]+\\) *(\\(?:[^),]*\\),? *\\([^)]*\\))" match-string-no-properties 2 3 py-which-python nil py-beginning-of-class " *\\([^( ]+\\)" "super(" ", self)." "(" ")" "super()." erg py-class-re] 8 (#$ . 148590) "*"])
#@46 Accepts the output of `parse-partial-sexp'. 
(defalias 'py-nesting-level #[(&optional pps) "\303\304\305\217\206	\306 \211@\n\203\307 \203\310\311	\"\210	*\207" [pps erg py-verbose-p nil (car pps) ((error)) syntax-ppss interactive-p message "%s"] 4 (#$ . 149457) nil])
(defalias 'py-count-indentation 'py-compute-indentation)
#@167 Compute Python indentation.

When HONOR-BLOCK-CLOSE-P is non-nil, statements such as `return',
`raise', `break', `continue', and `pass' force one level of dedenting.
(defalias 'py-compute-indentation #[(&optional orig origline closing line inside repeat) "\212\214~\210\206	`	\206\306 \n\307 
88\310\2119:\310;
\2042\fA@8\311o\203B	\306 =\203B\312 \202\262o\203`\313 \203`<\203X\314\310	#\202Z=\312 \\\202\262o\203n\313 \204n\312 \202\262\315\f8\203\264\316\f8\203\264	\306 =\203\257\317y\210\310\210\320\310x\210\310\321\322\217\203\227\312 \202\262\310\323\324\217\210\325 \210\326 \210\327	\n8
&\202\262\312 \202\262\330\331!\203\316o\204\316\332 \210\327	\n8
&\202\262\316\f8\203	\306 =\203\364\316\f8b\210\325 \210\333\310x\210\327	\n8
&\202\262\316\f8b\210\203\f>\204\334\335!\203\fi\202\262\317u\210\327	\n8
&\202\262\330\336!\2038\334\335!\2038?\2048	\306 =\2038\337\202\262\330\336!\203`\334\335!\203`\340 e=\204`\317y\210\310\210\311\327	\n8
&\202\262\fA@\203O8\203	\204	`=\203~\330\341!\203~\337\224\212\fA@b\210\306 ;\337	;ZW\203\365\342	;ZW\203\266\n\203\260@\203\250\312 \202\312 =\\\202\343!\202\330\344!\203\336\212\326 \210\330A!)\203\324\326 \210i=\345_\\\202\326 \210i=\\\202\330\346!\203\354\342\224b\210i\202i\f@\337\\\\\202\326 \210\332 \210\327	\n8
&)\202\2628\204\"\203\"\332 \210\327	\n8
&\202\2628\204=B\fA@\\b\210\330\347!\2039\337\225b\210i\202\262\fA@b\210\327	\n8
&\202\262\212\350 \210\320\310x\210`Sf\351=\205j\212\337\352\353\310x!\345\246W))\203\226\332 \210\306 ;\342	;ZW\203\204\343!\202\262\330\354!\203\216\355\202\262\312 C\\\202\262\330D!\203\274\306 	=\203\267\326 \210\325 \210\327	\n8
&\202\262\312 \202\262\330E!\203\342\306 	=\203\342\356 \210<\203\332\314\310	#\202\334=\312 \\\202\262\330E!\203\363\356\312 !\210\312 \202\262\330F!\203\306 	=\203\325 \210\357F\317\310	%@\202\262\330G!\203v	\306 =\203v\330H!\2031\357H\317\310	%@\202\262\330I!\203D\357I\317\310	%@\202\262\330J!\203W\357J\317\310	%@\202\262\330F!\203j\357F\317\310	%@\202\262\357A\317\310	%@\202\262\330A!\203\251	\306 =\203\224\325 \210\327	\n8\311&\202\262<\203\241\314\310	#\202\243=\312 \\\202\262\330E!\203\270\360 \210\312 \202\262\312 iW\203\331\326 \210\204\314\307 A@8\327	\n8
&\202\262\361 \204\fo\203\346i\202\262`=\203\374\325 \210\327	\n8
&\202\262\332 \210\327	\n8
&\202\262\313 \203:\306 	W\203-<\203%\314\310	#\202'=\312 \\\202\262\327	\n8\311&\202\262\306 	W\203M\330K!\203M\312 \202\262\330K!\203d\332 \210\327	\n8
&\202\262	\306 =\203\224\212\362A!\2119\205z\310\363\364\217)\203\2249@<\203\216\314\310	#\202\220=\\\202\262	\306 =\203\260\361 \203\260\332 \210\327	\n8
&\202\262\312 :L\203\304\365 \203\304\366\367:\"\210:.\f\207" [orig origline closing line pps repeat py-count-lines syntax-ppss nil t current-indentation py-statement-opens-block-p py-guess-indent-offset 3 8 -1 " 	
\n\f" (byte-code "\300\301 8\302 W\207" [2 syntax-ppss line-beginning-position] 2) ((error)) (byte-code "\3018b\207" [pps 2] 2) ((error)) py-line-backward-maybe back-to-indentation py-compute-indentation looking-at "\"\"\"\\|'''" py-beginning-of-statement " 	" looking-back "^[ 	]*" "[ 	]*#" 0 line-beginning-position "[ 	]*\\()\\)[ 	]*$" 1 py-fetch-previous-indent "\\s([ 	]*$" 2 "\\s([ 	]*\\([^ 	]+.*\\)$" "[ 	]+" beginning-of-line 92 abs "\\\\" "from +\\([^ 	\n]+\\) +import" 5 py-beginning-of-block-or-clause py-clause-lookup-keyword py-beginning-of-block py-beginning-of-statement-p py-go-to-keyword (byte-code "\301 W\207" [orig py-end-of-block-or-clause] 2) ((error)) interactive-p message "%s" inside erg indent this-line py-smart-indentation py-indent-offset py-indent-honors-inline-comment py-indent-comments py-closing-list-dedents-bos py-block-or-clause-re py-lhs-inbound-indent py-continuation-offset py-no-outdent-re py-block-closing-keywords-re py-elif-re py-clause-re py-finally-re py-except-re py-else-re py-assignment-re py-verbose-p] 8 (#$ . 149797) "P"])
(defalias 'py-line-backward-maybe #[nil "\301\302 x\210\303\304\305\306x!W\205\307\211\207" [line " 	\f" line-beginning-position 0 abs " 	
\n\f" nil t] 4])
#@31 Report the preceding indent. 
(defalias 'py-fetch-previous-indent #[(orig) "\212b\210\301y\210\302\210\303\302x\210\304 )\207" [orig -1 nil " 	
\n\f" current-indentation] 2 (#$ . 154163)])
#@113 With numeric ARG different from 1 py-continuation-offset is set to that value; returns py-continuation-offset. 
(defalias 'py-continuation-offset #[(&optional arg) "\304=\203\n	\202\247\205\211\203!\305 \203!\306\307	\"\210	)\207" [arg py-continuation-offset erg py-verbose-p 1 interactive-p message "%s"] 3 (#$ . 154361) "p"])
(byte-code "\300\301\302\"\210\300\303\302\"\207" [defalias pios py-indentation-of-statement ios] 3)
#@52 Returns the indenation of the statement at point. 
(defalias 'py-indentation-of-statement #[nil "\212\302 \210\303 \204\f\304 \210\305 )	\203\306 \203\307\310\"\210)\207" [erg py-verbose-p back-to-indentation py-beginning-of-statement-p py-beginning-of-statement current-indentation interactive-p message "%s"] 3 (#$ . 154809) nil])
(defalias 'py-in-list-p 'py-list-beginning-position)
#@120 Return lists beginning position, nil if not inside.

Optional ARG indicates a start-position for `parse-partial-sexp'.
(defalias 'py-list-beginning-position #[(&optional start) "\206e\303 A@\304 \203\305\306\n\"\210\n*\207" [start ppstart erg syntax-ppss interactive-p message "%s"] 3 (#$ . 155210) nil])
#@108 Return end position, nil if not inside.

Optional ARG indicates a start-position for `parse-partial-sexp'.
(defalias 'py-end-of-list-position #[(&optional arg) "\206e\306 \211A@\307\203\212b\210\310\311!\210`)
\203,\312 \203,\313\314\f\"\210\f,\207" [arg ppstart erg beg end py-verbose-p syntax-ppss nil forward-list 1 interactive-p message "%s"] 4 (#$ . 155529) nil])
#@61 Return the beginning of current line's comment, if inside. 
(defalias 'py-in-comment-p #[nil "\214~\210\303 \3048\205\3058\211\204\306\307\nP!\203`	+\207" [pps erg comment-start-skip syntax-ppss 4 8 looking-at "^[ 	]*"] 4 (#$ . 155918)])
#@68 Returns character address of start tqs-string, nil if not inside. 
(defalias 'py-in-triplequoted-string-p #[nil "\303 \3048\205\3058\205\3068\212	\2045\307\310!\2054\311\225b\210\303 \3048\2054\3058\2054\3068)\n\203D\312 \203D\313\314	\"\210	*\207" [pps erg py-verbose-p syntax-ppss 3 8 2 looking-at "\"\"\"\\|''''" 0 interactive-p message "%s"] 3 (#$ . 156173) nil])
#@67 Returns character address of start of string, nil if not inside. 
(defalias 'py-in-string-p #[nil "\303 \3048\205\f\3058\212	\204(\306\307!\205'\310u\210\303 \3048\205'\3058)\n\2037\311 \2037\312\313	\"\210	*\207" [pps erg py-verbose-p syntax-ppss 3 8 looking-at "\"\\|'" 1 interactive-p message "%s"] 3 (#$ . 156567) nil])
#@133 Returns list of beginning and end-position if inside.

Result is useful for booleans too: (when (py-in-statement-p)...)
will work.

(defalias 'py-in-statement-p #[nil "`\305\211\211\212\306 \307 \211X\205.	X\205.\n	B\f\203-\310 \203-\311\312\"\210-\207" [erg end beg orig py-verbose-p nil py-end-of-statement py-beginning-of-statement interactive-p message "%s"] 5 (#$ . 156912) nil])
#@76 Returns position, if cursor is at the beginning of a line, nil otherwise. 
(defalias 'py-beginning-of-line-p #[nil "n\205`\207" [] 1 (#$ . 157318)])
#@76 Returns position, if cursor is at the beginning of buffer, nil otherwise. 
(defalias 'py-beginning-of-buffer-p #[nil "o\205`\207" [] 1 (#$ . 157475)])
#@81 Returns position, if cursor is at the beginning of a paragraph, nil otherwise. 
(defalias 'py-beginning-of-paragraph-p #[nil "`\303n\203\304\n!\203`\211\202%\212\305 \210\306 \210	`=\203#	)*\207" [erg orig paragraph-separate nil looking-at py-end-of-paragraph py-beginning-of-paragraph] 2 (#$ . 157634)])
#@81 Returns position, if cursor is at the beginning of a statement, nil otherwise. 
(defalias 'py-beginning-of-statement-p #[nil "`\302\212\303 \210\304 \210	`=\203	+\207" [erg orig nil py-end-of-statement py-beginning-of-statement] 2 (#$ . 157956)])
#@82 Returns position, if cursor is at the beginning of a expression, nil otherwise. 
(defalias 'py-beginning-of-expression-p #[nil "`\302\212\303 \210\304 \210	`=\203	+\207" [erg orig nil py-end-of-expression py-beginning-of-expression] 2 (#$ . 158215)])
#@90 Returns position, if cursor is at the beginning of a partial-expression, nil otherwise. 
(defalias 'py-beginning-of-partial-expression-p #[nil "`\302\212\303 \210\304 \210	`=\203	+\207" [erg orig nil py-end-of-partial-expression py-beginning-of-partial-expression] 2 (#$ . 158478)])
#@77 Returns position, if cursor is at the beginning of a block, nil otherwise. 
(defalias 'py-beginning-of-block-p #[nil "\301!\205 \302\303 8\206\301\304!\204\301\305!\205\306\224?\205 `\207" [py-block-re looking-at 8 syntax-ppss "\"" "[ 	]*#[ 	]*" 0] 2 (#$ . 158773)])
#@78 Returns position, if cursor is at the beginning of a clause, nil otherwise. 
(defalias 'py-beginning-of-clause-p #[nil "\301!\205 \302\303 8\206\301\304!\204\301\305!\205\306\224?\205 `\207" [py-clause-re looking-at 8 syntax-ppss "\"" "[ 	]*#[ 	]*" 0] 2 (#$ . 159055)])
#@87 Returns position, if cursor is at the beginning of a block-or-clause, nil otherwise. 
(defalias 'py-beginning-of-block-or-clause-p #[nil "\301!\205 \302\303 8\206\301\304!\204\301\305!\205\306\224?\205 `\207" [py-block-or-clause-re looking-at 8 syntax-ppss "\"" "[ 	]*#[ 	]*" 0] 2 (#$ . 159340)])
#@75 Returns position, if cursor is at the beginning of a def, nil otherwise. 
(defalias 'py-beginning-of-def-p #[nil "\301!\205 \302\303 8\206\301\304!\204\301\305!\205\306\224?\205 `\207" [py-def-re looking-at 8 syntax-ppss "\"" "[ 	]*#[ 	]*" 0] 2 (#$ . 159652)])
#@77 Returns position, if cursor is at the beginning of a class, nil otherwise. 
(defalias 'py-beginning-of-class-p #[nil "\301!\205 \302\303 8\206\301\304!\204\301\305!\205\306\224?\205 `\207" [py-class-re looking-at 8 syntax-ppss "\"" "[ 	]*#[ 	]*" 0] 2 (#$ . 159928)])
#@84 Returns position, if cursor is at the beginning of a def-or-class, nil otherwise. 
(defalias 'py-beginning-of-def-or-class-p #[nil "\301!\205 \302\303 8\206\301\304!\204\301\305!\205\306\224?\205 `\207" [py-def-or-class-re looking-at 8 syntax-ppss "\"" "[ 	]*#[ 	]*" 0] 2 (#$ . 160210)])
#@121 Return position if the current statement opens a block
in stricter or wider sense.

For stricter sense specify regexp. 
(defalias 'py-statement-opens-block-p #[(&optional regexp) "\206	\304!\203\305 \203\306\307\n\"\210\n*\207" [regexp py-block-re erg py-verbose-p py-statement-opens-base interactive-p message "%s"] 3 (#$ . 160514) nil])
(defalias 'py-statement-opens-base #[(regexp) "`\304\212\305 \210\306 \210\307 \210\310\311!\203#\312 `X\203#\313\n!\203#`)\2032\314 \2032\315\316\"\210*\207" [erg orig regexp py-verbose-p nil back-to-indentation py-end-of-statement py-beginning-of-statement looking-back "^[ 	]*" line-beginning-position looking-at interactive-p message "%s"] 3])
#@66 Return position if the current statement opens block or clause. 
(defalias 'py-statement-opens-clause-p #[nil "\301!\207" [py-clause-re py-statement-opens-base] 2 (#$ . 161229) nil])
#@66 Return position if the current statement opens block or clause. 
(defalias 'py-statement-opens-block-or-clause-p #[nil "\301!\207" [py-block-or-clause-re py-statement-opens-base] 2 (#$ . 161419) nil])
#@84 Return `t' if the statement opens a functions or class definition, nil otherwise. 
(defalias 'py-statement-opens-class-p #[nil "\301!\207" [py-class-re py-statement-opens-base] 2 (#$ . 161627) nil])
#@84 Return `t' if the statement opens a functions or class definition, nil otherwise. 
(defalias 'py-statement-opens-def-p #[nil "\301!\207" [py-def-re py-statement-opens-base] 2 (#$ . 161833) nil])
#@84 Return `t' if the statement opens a functions or class definition, nil otherwise. 
(defalias 'py-statement-opens-def-or-class-p #[nil "\301!\207" [py-def-or-class-re py-statement-opens-base] 2 (#$ . 162035) nil])
#@175 Return t iff the current statement closes a block.
I.e., if the line starts with `return', `raise', `break', `continue',
and `pass'.  This doesn't catch embedded statements.
(defalias 'py-statement-closes-block-p #[nil "`\302 \204\n\303 \210\304	!b\210)\207" [here py-block-closing-keywords-re py-beginning-of-statement-p py-beginning-of-statement looking-at] 2 (#$ . 162256)])
#@53 Used internal by functions going to the end forms. 
(defalias 'py-end-base #[(regexp &optional orig) "\206`\305	!\203`\202\306	!\210\305	!\205`\307\2034\f\310 \\\311 \210\312y\210\313\n!\202A\314	!\210m\204A\315	\"\210`W\203L`\202Y\314	!\211\203Y\315	\"\210+\207" [orig regexp ind erg py-indent-offset py-statement-opens-block-p py-go-to-keyword nil current-indentation py-end-of-statement 1 py-travel-current-indent py-look-downward-for-beginning py-end-base] 4 (#$ . 162643)])
#@53 When above any beginning of FORM, search downward. 
(defalias 'py-look-downward-for-beginning #[(regexp) "\302\303\304\305$\211\203,\306\307 8\204,\310\311!\204\310\312!\203#\313\224\204,\314 \204,	\2024m?\2054\315!)\207" [regexp erg re-search-forward nil move 1 8 syntax-ppss looking-at "\"" "[ 	]*#[ 	]*" 0 py-in-list-p py-look-downward-for-beginning] 6 (#$ . 163155)])
#@342 Go to the outermost method or class definition in current scope.

Python value for `add-log-current-defun-function'.
This tells add-log.el how to find the current function/method/variable.
Returns name of class or methods definition, if found, nil otherwise.

See customizable variables `py-current-defun-show' and `py-current-defun-delay'.
(defalias 'py-current-defun #[(&optional iact) "\214~\210\212\304 \205\305v\210\306\307w\210\310\311 !\211\2034	\2034\312`\313\211#\2034\314\307w\2034\315 \2034\316\n!\210\203>\317\310!!\210+\207" [erg py-current-defun-show py-current-defun-delay iact py-beginning-of-def-or-class 1 " 	" nil prin1-to-string symbol-at-point push-mark t "^ (" exchange-point-and-mark sit-for message] 5 (#$ . 163546) "p"])
#@62 Returns non-nil if the current line should dedent one level.
(defalias 'py-outdent-p #[nil "\212\303 \210\304!\205&o?\205&\305y\210\306 \210\303 \210\304	!\203\"\307\310!\210\304\n!?)\207" [py-clause-re py-blank-or-comment-re py-no-outdent-re back-to-indentation looking-at -1 py-beginning-of-statement backward-to-indentation 1] 2 (#$ . 164310)])
#@146 Sort multiline imports.

Put point inside the parentheses of a multiline import and hit
\[py-sort-imports] to sort the imports lexicographically
(defalias 'py-sort-imports #[nil "\212\212\303\304!\210`)\212\303\305!\210`)\306\211Tb\210\307\306w\210\310\311\312`\212	Sb\210\307\306x\210`){\313\"!\314\"\n	|\210\nb\210\315c\210\316\317\320\"\321\322\323$c\210\324c,\207" [sorted-imports close-paren open-paren up-list -1 1 nil " \n	" sort delete-dups split-string ", *\\(\n *\\)?" string-lessp "(\n" py-join-words-wrapping remove "" "," "    " 78 ")"] 7 (#$ . 164669) nil])
#@181 Return non-nil if point is in a Python literal (a comment or string).
Optional argument LIM indicates the beginning of the containing form,
i.e. the limit on how far back to scan.
(defalias 'py-in-literal #[(&optional lim) "\206e\302 \303	8\203\304\202\305	8\205\306*\207" [lim state syntax-ppss 3 string 4 comment] 2 (#$ . 165253)])
#@83 Return the name of the function or class, if curser is in, return nil otherwise. 
(defalias 'py-which-function #[nil "\212\214~\210`\304\305P!\203+\306\307 8\204+\304\310!\204 \304\311!\203%\312\224\204+\313\314!\2029\315 \210\304\305P!\2059\313\314!	\203V\n\316 W\203V\205g\317 \205g\320\321	\"\202g\322\203f\317 \203f\320\321\323\"\210	,\207" [py-def-or-class-re erg orig py-verbose-p looking-at " +\\([^(]+\\)(.+" 8 syntax-ppss "\"" "[ 	]*#[ 	]*" 0 match-string-no-properties 2 py-beginning-of-def-or-class py-end-of-def-or-class interactive-p message "%s" nil "Not inside a function or class"] 4 (#$ . 165604) nil])
#@171 List dealing with usage and developing python-mode.

Also accepts submission of bug reports, whilst a ticket at
http://launchpad.net/python-mode
is preferable for that. 
(defconst py-help-address "python-mode@python.org" (#$ . 166252))
#@165 Returns beginning of block if successful, nil otherwise.

Referring python program structures see for example:
http://docs.python.org/reference/compound_stmts.html
(defalias 'py-beginning-of-block #[(&optional indent) "\300\301\302\217\207" [nil (byte-code "\302	\"A\207" [py-block-re indent py-go-to-keyword] 3) ((error))] 4 (#$ . 166495) nil])
#@182 Go to the end of block.

Returns position reached, if any, nil otherwise.

Referring python program structures see for example:
http://docs.python.org/reference/compound_stmts.html
(defalias 'py-end-of-block #[nil "`\304	\"\203\305 \203\306\307\n\"\210\n*\207" [orig py-block-re erg py-verbose-p py-end-base interactive-p message "%s"] 3 (#$ . 166849) nil])
#@166 Returns beginning of clause if successful, nil otherwise.

Referring python program structures see for example:
http://docs.python.org/reference/compound_stmts.html
(defalias 'py-beginning-of-clause #[(&optional indent) "\300\301\302\217\207" [nil (byte-code "\302	\"A\207" [py-clause-re indent py-go-to-keyword] 3) ((error))] 4 (#$ . 167222) nil])
#@183 Go to the end of clause.

Returns position reached, if any, nil otherwise.

Referring python program structures see for example:
http://docs.python.org/reference/compound_stmts.html
(defalias 'py-end-of-clause #[nil "`\304	\"\203\305 \203\306\307\n\"\210\n*\207" [orig py-clause-re erg py-verbose-p py-end-base interactive-p message "%s"] 3 (#$ . 167579) nil])
#@175 Returns beginning of block-or-clause if successful, nil otherwise.

Referring python program structures see for example:
http://docs.python.org/reference/compound_stmts.html
(defalias 'py-beginning-of-block-or-clause #[(&optional indent) "\300\301\302\217\207" [nil (byte-code "\302	\"A\207" [py-block-or-clause-re indent py-go-to-keyword] 3) ((error))] 4 (#$ . 167955) nil])
#@192 Go to the end of block-or-clause.

Returns position reached, if any, nil otherwise.

Referring python program structures see for example:
http://docs.python.org/reference/compound_stmts.html
(defalias 'py-end-of-block-or-clause #[nil "`\304	\"\203\305 \203\306\307\n\"\210\n*\207" [orig py-block-or-clause-re erg py-verbose-p py-end-base interactive-p message "%s"] 3 (#$ . 168339) nil])
#@163 Returns beginning of def if successful, nil otherwise.

Referring python program structures see for example:
http://docs.python.org/reference/compound_stmts.html
(defalias 'py-beginning-of-def #[(&optional indent) "\300\301\302\217\207" [nil (byte-code "\302	\"A\207" [py-def-re indent py-go-to-keyword] 3) ((error))] 4 (#$ . 168742) nil])
#@180 Go to the end of def.

Returns position reached, if any, nil otherwise.

Referring python program structures see for example:
http://docs.python.org/reference/compound_stmts.html
(defalias 'py-end-of-def #[nil "`\304	\"\203\305 \203\306\307\n\"\210\n*\207" [orig py-def-re erg py-verbose-p py-end-base interactive-p message "%s"] 3 (#$ . 169090) nil])
#@165 Returns beginning of class if successful, nil otherwise.

Referring python program structures see for example:
http://docs.python.org/reference/compound_stmts.html
(defalias 'py-beginning-of-class #[(&optional indent) "\300\301\302\217\207" [nil (byte-code "\302	\"A\207" [py-class-re indent py-go-to-keyword] 3) ((error))] 4 (#$ . 169457) nil])
#@182 Go to the end of class.

Returns position reached, if any, nil otherwise.

Referring python program structures see for example:
http://docs.python.org/reference/compound_stmts.html
(defalias 'py-end-of-class #[nil "`\304	\"\203\305 \203\306\307\n\"\210\n*\207" [orig py-class-re erg py-verbose-p py-end-base interactive-p message "%s"] 3 (#$ . 169811) nil])
#@172 Returns beginning of def-or-class if successful, nil otherwise.

Referring python program structures see for example:
http://docs.python.org/reference/compound_stmts.html
(defalias 'py-beginning-of-def-or-class #[(&optional indent) "\300\301\302\217\207" [nil (byte-code "\302	\"A\207" [py-def-or-class-re indent py-go-to-keyword] 3) ((error))] 4 (#$ . 170184) nil])
#@189 Go to the end of def-or-class.

Returns position reached, if any, nil otherwise.

Referring python program structures see for example:
http://docs.python.org/reference/compound_stmts.html
(defalias 'py-end-of-def-or-class #[nil "\214~\210`\306 \307	8\204\310\n!\203`\202*\311\n!\210\307	8?\205*\310\n!\205*`\312\203Z
\203G\212b\210\313 \210\313 \210\314\312`\")\202I\315 \\\313 \210\316y\210\317\f!\202\210\320\n!\210m\204\210
\203x\212b\210\313 \210\313 \210\314\312`\")\202z\315 \\\313 \210\316y\210\317\f!`W\203\223`\202\253\320\n!\211\203\253\315 \\\313 \210\316y\210\317\f!\203\272\321 \203\272\322\323\"\210-\207" [orig pps py-def-or-class-re erg ind py-smart-indentation syntax-ppss 8 looking-at py-go-to-keyword nil py-end-of-statement py-guess-indent-offset current-indentation 1 py-travel-current-indent py-look-downward-for-beginning interactive-p message "%s" py-indent-offset py-verbose-p] 4 (#$ . 170559) nil])
#@168 Returns beginning of if-block if successful, nil otherwise.

Referring python program structures see for example:
http://docs.python.org/reference/compound_stmts.html
(defalias 'py-beginning-of-if-block #[(&optional indent) "\300\301\302\217\207" [nil (byte-code "\302	\"A\207" [py-if-re indent py-go-to-keyword] 3) ((error))] 4 (#$ . 171536) nil])
#@185 Go to the end of if-block.

Returns position reached, if any, nil otherwise.

Referring python program structures see for example:
http://docs.python.org/reference/compound_stmts.html
(defalias 'py-end-of-if-block #[nil "`\304	\"\203\305 \203\306\307\n\"\210\n*\207" [orig py-if-re erg py-verbose-p py-end-base interactive-p message "%s"] 3 (#$ . 171893) nil])
#@169 Returns beginning of try-block if successful, nil otherwise.

Referring python program structures see for example:
http://docs.python.org/reference/compound_stmts.html
(defalias 'py-beginning-of-try-block #[(&optional indent) "\300\301\302\217\207" [nil (byte-code "\302	\"A\207" [py-try-block-re indent py-go-to-keyword] 3) ((error))] 4 (#$ . 172269) nil])
#@186 Go to the end of try-block.

Returns position reached, if any, nil otherwise.

Referring python program structures see for example:
http://docs.python.org/reference/compound_stmts.html
(defalias 'py-end-of-try-block #[nil "`\304	\"\203\305 \203\306\307\n\"\210\n*\207" [orig py-try-block-re erg py-verbose-p py-end-base interactive-p message "%s"] 3 (#$ . 172635) nil])
#@171 Returns beginning of minor-block if successful, nil otherwise.

Referring python program structures see for example:
http://docs.python.org/reference/compound_stmts.html
(defalias 'py-beginning-of-minor-block #[(&optional indent) "\300\301\302\217\207" [nil (byte-code "\302	\"A\207" [py-minor-block-re indent py-go-to-keyword] 3) ((error))] 4 (#$ . 173020) nil])
#@188 Go to the end of minor-block.

Returns position reached, if any, nil otherwise.

Referring python program structures see for example:
http://docs.python.org/reference/compound_stmts.html
(defalias 'py-end-of-minor-block #[nil "`\304	\"\203\305 \203\306\307\n\"\210\n*\207" [orig py-minor-block-re erg py-verbose-p py-end-base interactive-p message "%s"] 3 (#$ . 173392) nil])
#@46 Go to beginning-of-buffer, return position. 
(defalias 'py-beginning-of-buffer #[nil "o?\205eb\207" [] 2 (#$ . 173782)])
#@109 Go to end-of-buffer, return position.

If already at end-of-buffer and not at EOB, go to end of next line. 
(defalias 'py-end-of-buffer #[nil "m?\205db\207" [] 2 (#$ . 173912)])
(byte-code "\300\301\302\"\210\300\303\304\"\210\300\305\306\"\210\300\307\310\"\210\300\311\312\"\210\300\313\312\"\210\300\314\315\"\210\300\316\315\"\210\300\317\315\"\210\300\320\321\"\210\300\322\321\"\210\300\323\321\"\210\300\324\325\"\210\300\326\325\"\210\300\327\325\"\210\300\330\331\"\210\300\332\331\"\210\300\333\331\"\210\300\334\335\"\210\300\336\335\"\210\300\337\340\"\207" [defalias py-forward-block py-end-of-block py-forward-block-or-clause py-end-of-block-or-clause py-forward-class py-end-of-class py-forward-clause py-end-of-clause end-of-def-or-class py-end-of-def-or-class py-forward-def-or-class py-previous-block py-beginning-of-block py-goto-block-up py-backward-block py-previous-block-or-clause py-beginning-of-block-or-clause py-goto-block-or-clause-up py-backward-block-or-clause beginning-of-class py-beginning-of-class py-backward-class py-previous-class py-previous-clause py-beginning-of-clause py-goto-clause-up py-backward-clause py-backward-def-or-class py-beginning-of-def-or-class py-previous-def-or-class py-backward-expression py-beginning-of-expression] 3)
#@471 Go to the beginning of a compound python expression.

A a compound python expression might be concatenated by "." operator, thus composed by minor python expressions.

If already at the beginning or before a expression, go to next expression in buffer upwards

Expression here is conceived as the syntactical component of a statement in Python. See http://docs.python.org/reference
Operators however are left aside resp. limit py-expression designed for edit-purposes.

(defalias 'py-beginning-of-expression #[(&optional orig done) "\214~\210o?\205\207\206
`\306 \307 \310\311\n8\203D\312\n8\203D\312\n8b\203D\313\314\315!\204<\316\n8\203<\316\n8b\210\317\f\"\210\202h\312\n8\203X\312\n8Sb\210\317\f\"\210\202h\320\321!\203v\314\322!\203v\323y\210o\204h\310\210\317\f\"\210\202h\nA@\203\233\nA@b\210\314\324!\204\223\325\326
\310x!W\203\223\313\317\f\"\210\202h\320\327!\203\265\325\224Sb\210\330\310x\210\323u\210\317\f\"\210\202h\314\331!\203\306\323u\210\317\f\"\210\202h`=\203\345o\204\345\314\"!\203\345
\310x\210\313\317\f\"\210\202h\320\332!\203\330\310x\210o\204\366\323u\210\326\333\310x!\325=\204h\317\f\"\210\202h`=\2037o\2047\314\334!\2037\335\310x\210o\204#\323u\210\326\336\310x!\325=\204h\313\317\f\"\210\202h`=\203_o\204_\314\"!\203_\323u\210\325\326
\310x!W\203W\313\317\f\"\210\202h\320\"!\203h\313`=\204v\320\321!\204v`#\203\205\337 \203\205\340\341	\"\210	,)\207" [orig erg pps cui done py-expression-skip-regexp current-indentation syntax-ppss nil 3 8 t looking-back "\\(=\\|:\\|+\\|-\\|*\\|/\\|//\\|&\\|%\\||\\||>>\\|<<\\)[ 	]*" 2 py-beginning-of-expression looking-at "[ 	]*#" "^[ 	]*" -1 "[ 	]+" 0 abs "\\(=\\|:\\|+\\|-\\|*\\|/\\|//\\|&\\|%\\||\\||>>\\|<<\\)" " 	
\n\f" "[])}]" "[ 	
\n\f]" "^ 	
\n\f" "[ .	
\n\f]" "=:+-*/&%^><. 	
\n\f" "^=:+-*/&%^>< 	
\n\f" interactive-p message "%s" py-expression-looking-regexp py-verbose-p] 4 (#$ . 175201) nil])
#@373 Go to the end of a compound python expression.

A a compound python expression might be concatenated by "." operator, thus composed by minor python expressions.

Expression here is conceived as the syntactical component of a statement in Python. See http://docs.python.org/reference

Operators however are left aside resp. limit py-expression designed for edit-purposes. 
(defalias 'py-end-of-expression #[(&optional orig done) "\214~\210m?\205u\206
`\306 \n\307\211	A@\2030	A@b\210\310\311 \210\312\n\"\210)\202\\\313	8\203K`\314\315!\210`W\204C\315y\210\312\n\"\210\202\\\212\316 \210\317\320!)\203\n\204m\204\212\316 \210\317\320!)\203w\n\204wm\204w\315y\210\202^\312\n\"\210\202\\\321 \203\253\317\322!\203\216\323\225b\210\324\306 8\203\233\315u\210\202\216\317\325!\203\243\310\312\n\"\210\202\\\317\326!\203\344\327\330!\203\344\n\204\344\317\326!\203\317\315y\203\317m\204\317\316 \204\273\307\210\331\307x\210n\204\334\310\312\n\"\210\202\\\n\204\317
!\203m\204\323\225b\210\331\307w\210\312\n\"\210\202\\\n\204 \317 !\203 m\204 
\307w\210\332u\210\312\n\"\210\202\\m\204K\317!!\203K\323\225b\210\310\323 \307wW\204C\317\333!\204C\315u\210\312\n\"\210\202\\\317\334!\203\\\310\323\225b\210\312\n\"\210`=\204d`\"\203s\335 \203s\336\337\"\210-)\207" [orig pps done erg parse-sexp-ignore-comments py-not-expression-regexp syntax-ppss nil t forward-list py-end-of-expression 4 forward-comment 1 beginning-of-line looking-at "\\s-*$" py-in-string-p "\"\"\"\\|'''\\|\"\\|'" 0 3 "[ 	]*$" "[ 	]*#" looking-back "^[ 	]*" " 	
\n\f" -1 "[ 	
\n\f]" "\\(+\\|-\\|*\\|/\\|//\\|&\\|%\\||\\||>>\\|<<\\)[ 	]*" interactive-p message "%s" py-expression-skip-regexp py-expression-looking-regexp py-verbose-p] 4 (#$ . 177162) nil])
(defalias 'py-backward-partial-expression 'py-beginning-of-partial-expression)
#@427 Go to the beginning of a minor python expression.

"." operators delimit a minor expression on their level.
Expression here is conceived as the syntactical component of a statement in Python. See http://docs.python.org/reference
Operators however are left aside resp. limit py-expression designed for edit-purposes.

If already at the beginning or before a partial-expression, go to next partial-expression in buffer upwards 
(defalias 'py-beginning-of-partial-expression #[(&optional orig erg) "\214~\210o?\205<\206
`\306 \307 	\nA@\203&\nA@b\210`\202+\310\n8\203G\311\n8\2037\311\n8b\210\310\n8Sb\210`\312	\"\210\202+\313\314!\203g\315\316!\203g\317y\210o\204+\320\210`\312	\"\210\202+\313\321!\203\205\322\224Sb\210\323\320x\210o\204}\317u\210\312	\"\210\202+\313\324!\203\250\323\320x\210o\204\226\317u\210\325\326\320x!\322=\204+\312	\"\210\202+`=\203\325o\204\325\315\327!\203\325\330\320x\210o\204\303\317u\210\325\331\320x!\322=\204+\312	\"\210\202+`=\203\374o\204\374\315\f!\203\374\317u\210\322\325
\320x!W\203\364`\312	\"\210\202+\313\f!\203`\202+`=\203o\204\323\320x\210\312	\"\210\202+\313\314!\203)\315\316!\204+`\203:\332 \203:\333\334	\"\210	,)\207" [orig erg pps cui py-partial-expression-looking-regexp py-partial-expression-skip-regexp current-indentation syntax-ppss 8 2 py-beginning-of-partial-expression looking-at "[ 	]*#" looking-back "^[ 	]*" -1 nil "\\(=\\|:\\|+\\|-\\|*\\|/\\|//\\|&\\|%\\||\\||>>\\|<<\\)" 0 " 	
\n\f" "[ 	
\n\f]" abs "^ .	
\n\f" "[ .	
\n\f]" "=:+-*/&%^><. 	
\n\f" "^=:+-*/&%^><. 	
\n\f" interactive-p message "%s" py-verbose-p] 4 (#$ . 179050) nil])
(defalias 'py-forward-partial-expression 'py-end-of-partial-expression)
#@312 Go to the end of a minor python expression.

"." operators delimit a minor expression on their level.
Expression here is conceived as the syntactical component of a statement in Python. See http://docs.python.org/reference
Operators however are left aside resp. limit py-expression designed for edit-purposes. 
(defalias 'py-end-of-partial-expression #[(&optional orig origline done) "\214~\210m?\205\240\206
`	\206\306 \307 \310\211\212\311 \210\312\313!)\203S\204Sm\204S\212\311 \210\312\313!)\203J\204Jm\204J\314y\210\2021\315	#\210\202\206\316\n8\203|\312\317!\203c\320\225b\210\321\322\310\323\314$\203s\316\307 8\204c\315	#\210\202\206\324\n8\203\216\314y\210\315	#\210\202\206\312\325!\203\302\326\327!\203\302\204\302\312\325!\203\262\314y\203\262m\204\262\311 \204\236\310\210\330\310x\210\315	#\210\202\206\nA@\203\333\nA@X\203\333\nA@b\210\331 \210\202\206\204\373\310\332\333\217\203\373\334\n8b\210\335#\310w\210\315	#\210\202\206\312\336!\203`W\204\206\2040\312\337!\2030\320\225b\210\320\330\310wW\203 \314u\210#\310w\210\335\315	#\210\202\206\204O\312$!\203Om\204O#\310w\210\335\315	#\210\202\206\204s\312%!\203sm\204s&\310w\210#\310w\210\335\315	#\210\202\206`=\203\206m\204\206\314u\210\315	#\210`=\204\216`'\203\235\340 \203\235\341\342\f\"\210\f.)\207" [orig origline pps done erg parse-sexp-ignore-comments py-count-lines syntax-ppss nil beginning-of-line looking-at "\\s-*$" 1 py-end-of-partial-expression 3 "\"\"\"\\|'''\\|\"\\|'" 0 re-search-forward "[^\\]\"\"\"\\|[^\\]'''\\|[^\\]\"\\|[^\\]'" move 4 "[ 	]*#" looking-back "^[ 	]*" " 	
\n\f" forward-list (byte-code "\302	8X\207" [orig pps 2] 3) ((error)) 2 t "\\." "\\.\\|=\\|:\\|+\\|-\\|*\\|/\\|//\\|&\\|%\\||\\||>>\\|<<\\|<\\|<=\\|>\\|>=\\|==\\|!=" interactive-p message "%s" py-partial-expression-forward-regexp py-partial-expression-looking-regexp py-not-partial-expression-regexp py-not-partial-expression-skip-regexp py-verbose-p] 6 (#$ . 180789) nil])
#@127 Go to beginning-of-line, return position.

If already at beginning-of-line and not at BOB, go to beginning of previous line. 
(defalias 'py-beginning-of-line #[nil "o?\205n\203\302y\210\303 \210`\202\303 \210`	\203&\304 \203&\305\306\"\210)\207" [erg py-verbose-p -1 beginning-of-line interactive-p message "%s"] 3 (#$ . 182837) nil])
#@105 Go to end-of-line, return position.

If already at end-of-line and not at EOB, go to end of next line. 
(defalias 'py-end-of-line #[nil "m?\205l\203\302y\210\303\210`\202\303\210`	\203&\304 \203&\305\306\"\210)\207" [erg py-verbose-p 1 nil interactive-p message "%s"] 3 (#$ . 183190) nil])
(byte-code "\300\301\302\"\210\300\303\302\"\210\300\304\302\"\207" [defalias py-backward-statement py-beginning-of-statement py-previous-statement py-statement-backward] 3)
#@267 Go to the initial line of a simple statement.

For beginning of compound statement use py-beginning-of-block.
For beginning of clause py-beginning-of-clause.

Referring python program structures see for example:
http://docs.python.org/reference/compound_stmts.html

(defalias 'py-beginning-of-statement #[(&optional orig done) "o?\205\360\206\n`\306 \307 	\310\212\311 \210\312\313!)\203,\314\310x\210\315	\"\210\202\314\3168\203B\3168Sb\210\317\315	\"\210\202\314A@\203XA@Sb\210\317\315	\"\210\202\314	\204n\314\310x\320=\204n\317\315	\"\210\202\314i\306 =\204\202\321 \210\317\315	\"\210\202\314\312\322!\203\226\314\310x\210\317\315	\"\210\202\314\212\311 \210\212\311 \210\314\310x\210`Sf\323=\205\265\212\320\324\325\310x!\326\246W))\206\276\320\307 @W)\203\314\327y\210\317\315	\"\210\312\322!\203\330\330\331!\204\340`W\203\340`
\203\356\332 \203\356\333\334\n\"\210\n-\207" [orig done erg pps cui py-verbose-p current-indentation syntax-ppss nil beginning-of-line looking-at "\\s-*$" " 	
\n\f" py-beginning-of-statement 8 t 0 back-to-indentation "[ 	]*#" 92 abs "\\\\" 2 -1 looking-back "^[ 	]*" interactive-p message "%s"] 5 (#$ . 183674) nil])
#@58 Returns a list, whose car is indentation, cdr position. 
(defalias 'py-go-to-keyword #[(regexp &optional maxindent) "`\306 \307\211\211\2046o\2046\310 \210\311\f!\203
\203*\312 W\202+\313\203
`\313\211\203\n\203?\312 \nB\n.\207" [maxindent cui erg done origline orig py-count-lines nil py-beginning-of-statement looking-at current-indentation t regexp] 7 (#$ . 184882)])
(byte-code "\300\301\302\"\210\300\303\302\"\210\300\304\302\"\207" [defalias py-statement-forward py-end-of-statement py-next-statement py-forward-statement] 3)
#@132 Go to the last char of current statement.

To go just beyond the final line of the current statement, use `py-down-statement-lc'. 
(defalias 'py-end-of-statement #[(&optional orig done) "m?\205\212\306 `\307\211\f\204D\310\311\307wW\203D\307\210\312 \210\311\313 x\210`\n=\203:\307\210\314\315!\210\316\n\f\"\210\202l\317\316\n\f\"\210\202lA@\203\201\n`W\203R`A@b\210\317\307\320\321\217\203z\322\323!\203i\324u\210\317\307\210\311\307x\210\316\n\f\"\210\202}\nb\210)\202l\3258\203\306\3268\203\306\3258b\210\322\327!\203\237\310\225b\210\202\242\324u\210\330\331\310!\307\332\324$\203\264\326\306 8\204\242\317\307\210\311\313 x\210\316\n\f\"\210\202l\3338\203\355m\204l\317\314\315!\210\307\210\311\313 x\210\312 \210\311\307x\210\316\n\f\"\210\202l\322\334!\203\307\210\314\315!\210\317\307\210\311\307x\210\312 \210\311\307x\210\316\n\f\"\210\202l\212\307\210\311\307x\210`Sf\335=\205-\212\310\336\337\307x!\340\246W))\203M\311\307w\210\307\210\311\307x\210\312 \210\311\307x\210\317\316\n\f\"\210\202l\f\204l`\n=\203l\307\210\311\307x\210\312 \210\311\307x\210\317\316\n\f\"\210`\n=\204zi\310=\204z`
\203\210\341 \203\210\342\343\"\210,\207" [erg parse-sexp-ignore-comments orig pps done py-verbose-p syntax-ppss nil 0 " 	
\n\f" py-beginning-of-comment line-beginning-position forward-comment 99999 py-end-of-statement t (forward-list) ((error)) looking-at ":[ 	]*$" 1 8 3 "\"\"\"\\|'''" re-search-forward match-string-no-properties move 4 "#" 92 abs "\\\\" 2 interactive-p message "%s"] 5 (#$ . 185446) nil])
#@36 Goto beginning of next statement. 
(defalias 'py-goto-statement-below #[nil "`\302 \303 \210`	W\205b\210\302 \210\303 *\207" [erg orig py-end-of-statement py-beginning-of-statement] 2 (#$ . 187033) nil])
(defalias 'py-mark-base #[(form &optional py-mark-decorators) "\306\307P!\306\310P!\306\307\311Q!`\312\211\312 \211\203(
\202*	 \203=\212\313 \211\203<)\n \314
\315\211#\210\204U
`W\203U`\316 \203a\317\320
#\210
.B\207" [form begform endform begcheckform orig beg intern-soft "py-beginning-of-" "py-end-of-" "-p" nil py-beginning-of-decorator push-mark t interactive-p message "%s %s" end erg py-mark-decorators] 5])
#@88 Mark paragraph at point.

Returns beginning and end positions of marked area, a cons. 
(defalias 'py-mark-paragraph #[nil "\302\303\304!\305 \210	\203\306 \203\307\310\"\210)\207" [erg py-verbose-p nil py-mark-base "paragraph" exchange-point-and-mark interactive-p message "%s"] 3 (#$ . 187705) nil])
#@84 Mark block at point.

Returns beginning and end positions of marked area, a cons. 
(defalias 'py-mark-block #[nil "\302\303\304!\305 \210	\203\306 \203\307\310\"\210)\207" [erg py-verbose-p nil py-mark-base "block" exchange-point-and-mark interactive-p message "%s"] 3 (#$ . 188020) nil])
#@85 Mark clause at point.

Returns beginning and end positions of marked area, a cons. 
(defalias 'py-mark-clause #[nil "\302\303\304!\305 \210	\203\306 \203\307\310\"\210)\207" [erg py-verbose-p nil py-mark-base "clause" exchange-point-and-mark interactive-p message "%s"] 3 (#$ . 188323) nil])
#@94 Mark block-or-clause at point.

Returns beginning and end positions of marked area, a cons. 
(defalias 'py-mark-block-or-clause #[nil "\302\303\304!\305 \210	\203\306 \203\307\310\"\210)\207" [erg py-verbose-p nil py-mark-base "block-or-clause" exchange-point-and-mark interactive-p message "%s"] 3 (#$ . 188629) nil])
#@172 Mark def at point.

With \[universal argument] or `py-mark-decorators' set to `t', decorators are marked too.
Returns beginning and end positions of marked area, a cons. 
(defalias 'py-mark-def #[(&optional arg) "\206	\304\305\306	\"\210\307 \210\203\310 \203\311\312\n\"\210\n*\207" [arg py-mark-decorators erg py-verbose-p nil py-mark-base "def" exchange-point-and-mark interactive-p message "%s"] 3 (#$ . 188963) "P"])
#@174 Mark class at point.

With \[universal argument] or `py-mark-decorators' set to `t', decorators are marked too.
Returns beginning and end positions of marked area, a cons. 
(defalias 'py-mark-class #[(&optional arg) "\206	\304\305\306	\"\210\307 \210\203\310 \203\311\312\n\"\210\n*\207" [arg py-mark-decorators erg py-verbose-p nil py-mark-base "class" exchange-point-and-mark interactive-p message "%s"] 3 (#$ . 189402) "P"])
#@181 Mark def-or-class at point.

With \[universal argument] or `py-mark-decorators' set to `t', decorators are marked too.
Returns beginning and end positions of marked area, a cons. 
(defalias 'py-mark-def-or-class #[(&optional arg) "\206	\304\305\306	\"\210\307 \210\203\310 \203\311\312\n\"\210\n*\207" [arg py-mark-decorators erg py-verbose-p nil py-mark-base "def-or-class" exchange-point-and-mark interactive-p message "%s"] 3 (#$ . 189847) "P"])
#@83 Mark line at point.

Returns beginning and end positions of marked area, a cons. 
(defalias 'py-mark-line #[nil "\302\303\304!\305 \210	\203\306 \203\307\310\"\210)\207" [erg py-verbose-p nil py-mark-base "line" exchange-point-and-mark interactive-p message "%s"] 3 (#$ . 190312) nil])
#@88 Mark statement at point.

Returns beginning and end positions of marked area, a cons. 
(defalias 'py-mark-statement #[nil "\302\303\304!\305 \210	\203\306 \203\307\310\"\210)\207" [erg py-verbose-p nil py-mark-base "statement" exchange-point-and-mark interactive-p message "%s"] 3 (#$ . 190612) nil])
#@89 Mark expression at point.

Returns beginning and end positions of marked area, a cons. 
(defalias 'py-mark-expression #[nil "\302\303\304!\305 \210	\203\306 \203\307\310\"\210)\207" [erg py-verbose-p nil py-mark-base "expression" exchange-point-and-mark interactive-p message "%s"] 3 (#$ . 190927) nil])
#@97 Mark partial-expression at point.

Returns beginning and end positions of marked area, a cons. 
(defalias 'py-mark-partial-expression #[nil "\302\303\304!\305 \210	\203\306 \203\307\310\"\210)\207" [erg py-verbose-p nil py-mark-base "partial-expression" exchange-point-and-mark interactive-p message "%s"] 3 (#$ . 191245) nil])
#@69 Go to the beginning of a decorator.

Returns position if succesful 
(defalias 'py-beginning-of-decorator #[nil "\302 \210\303\304!\204#\212\305 \210\303\306!)\204#o\204#\307y\203#\302 \210\202\303\304!\205+\310\224	\203:\311 \203:\312\313\"\210)\207" [erg py-verbose-p back-to-indentation looking-at "@\\w+" beginning-of-line "\\s-*$" -1 0 interactive-p message "%s"] 3 (#$ . 191587) nil])
#@63 Go to the end of a decorator.

Returns position if succesful 
(defalias 'py-end-of-decorator #[nil "`\304\305\306!\204
\307 \205W\310\n\304\311#\203,\312 \210\313\304x\210\314 \210\313\304x\210`\202H	b\210\304\210\313\304x\210\304\315\316\217\203@\317 \210	`W\203H`\203V\320 \203V\321\322\"\210*\207" [erg orig py-def-or-class-re py-verbose-p nil looking-at "@\\w+" py-beginning-of-decorator re-search-forward t back-to-indentation " 	
\n\f" py-leave-comment-or-string-backward (byte-code "\300 b\207" [py-in-list-p] 1) ((error)) forward-list interactive-p message "%s"] 4 (#$ . 191995) nil])
(defalias 'py-expression 'py-copy-expression)
#@89 Mark expression at point.

Returns beginning and end positions of marked area, a cons. 
(defalias 'py-copy-expression #[nil "\302\303!\304\305@A\"!\210	\203\306 \203\307\310\"\210)\207" [erg py-verbose-p py-mark-base "expression" kill-new buffer-substring-no-properties interactive-p message "%s"] 4 (#$ . 192658) nil])
(defalias 'py-partial-expression 'py-copy-partial-expression)
#@924 Mark partial-expression at point.

Returns beginning and end positions of marked area, a cons.

"." operators delimit a partial-expression expression on it's level, that's the difference to compound expressions.

Given the function below, `py-partial-expression'
called at pipe symbol would copy and return:

def usage():
    print """Usage: %s
    ....""" % (
        os.path.basename(sys.argv[0]))
------------|-------------------------
==> path

        os.path.basename(sys.argv[0]))
------------------|-------------------
==> basename(sys.argv[0]))

        os.path.basename(sys.argv[0]))
--------------------------|-----------
==> sys

        os.path.basename(sys.argv[0]))
------------------------------|-------
==> argv[0]

while `py-expression' would copy and return

(
        os.path.basename(sys.argv[0]))

;;;;;

Also for existing commands a shorthand is defined:

(defalias 'py-statement 'py-copy-statement)
(defalias 'py-copy-partial-expression #[nil "\301\302!\303\304@A\"!)\207" [erg py-mark-base "partial-expression" kill-new buffer-substring-no-properties] 4 (#$ . 193056) nil])
(defalias 'py-statement 'py-copy-statement)
#@88 Mark statement at point.

Returns beginning and end positions of marked area, a cons. 
(defalias 'py-copy-statement #[nil "\301\302!\303\304@A\"!)\207" [erg py-mark-base "statement" kill-new buffer-substring-no-properties] 4 (#$ . 194208) nil])
(defalias 'py-block 'py-copy-block)
#@84 Mark block at point.

Returns beginning and end positions of marked area, a cons. 
(defalias 'py-copy-block #[nil "\301\302!\303\304@A\"!)\207" [erg py-mark-base "block" kill-new buffer-substring-no-properties] 4 (#$ . 194498) nil])
(defalias 'py-block-or-clause 'py-copy-block-or-clause)
#@94 Mark block-or-clause at point.

Returns beginning and end positions of marked area, a cons. 
(defalias 'py-copy-block-or-clause #[nil "\301\302!\303\304@A\"!)\207" [erg py-mark-base "block-or-clause" kill-new buffer-substring-no-properties] 4 (#$ . 194796) nil])
(defalias 'py-def 'py-copy-def)
#@167 Mark def at point.

With universal argument or `py-mark-decorators' set to `t' decorators are copied too.
Returns beginning and end positions of marked area, a cons.
(defalias 'py-copy-def #[(&optional arg) "\206	\303\304	\"\305\306\n@\nA\"!*\207" [arg py-mark-decorators erg py-mark-base "def" kill-new buffer-substring-no-properties] 4 (#$ . 195101) "P"])
#@176 Mark def-or-class at point.

With universal argument or `py-mark-decorators' set to `t' decorators are copied too.
Returns beginning and end positions of marked area, a cons.
(defalias 'py-copy-def-or-class #[(&optional arg) "\206	\303\304	\"\305\306\n@\nA\"!*\207" [arg py-mark-decorators erg py-mark-base "def-or-class" kill-new buffer-substring-no-properties] 4 (#$ . 195471) "P"])
(defalias 'py-class 'py-copy-class)
#@169 Mark class at point.

With universal argument or `py-mark-decorators' set to `t' decorators are copied too.
Returns beginning and end positions of marked area, a cons.
(defalias 'py-copy-class #[(&optional arg) "\206	\303\304	\"\305\306\n@\nA\"!*\207" [arg py-mark-decorators erg py-mark-base "class" kill-new buffer-substring-no-properties] 4 (#$ . 195904) "P"])
(defalias 'py-clause 'py-copy-clause)
#@86 Mark clause at point.
  Returns beginning and end positions of marked area, a cons. 
(defalias 'py-copy-clause #[nil "\301\302!\303\304@A\"!)\207" [erg py-mark-base "clause" kill-new buffer-substring-no-properties] 4 (#$ . 196317) nil])
#@92 Delete expression at point.
  Stores data in kill ring. Might be yanked back using `C-y'. 
(defalias 'py-kill-expression #[nil "\301\302!\303@A\")\207" [erg py-mark-base "expression" kill-region] 3 (#$ . 196563) nil])
#@216 Delete partial-expression at point.
  Stores data in kill ring. Might be yanked back using `C-y'.

"." operators delimit a partial-expression expression on it's level, that's the difference to compound expressions.
(defalias 'py-kill-partial-expression #[nil "\301\302!\303@A\")\207" [erg py-mark-base "partial-expression" kill-region] 3 (#$ . 196791) nil])
#@90 Delete statement at point.

Stores data in kill ring. Might be yanked back using `C-y'. 
(defalias 'py-kill-statement #[nil "\301\302!\303@A\")\207" [erg py-mark-base "statement" kill-region] 3 (#$ . 197158) "*"])
#@86 Delete block at point.

Stores data in kill ring. Might be yanked back using `C-y'. 
(defalias 'py-kill-block #[nil "\301\302!\303@A\")\207" [erg py-mark-base "block" kill-region] 3 (#$ . 197381) "*"])
#@96 Delete block-or-clause at point.

Stores data in kill ring. Might be yanked back using `C-y'. 
(defalias 'py-kill-block-or-clause #[nil "\301\302!\303\304 \305 \")\207" [erg py-mark-base "block-or-clause" kill-region region-beginning region-end] 3 (#$ . 197592) "*"])
#@93 Delete def-or-class at point.

Stores data in kill ring. Might be yanked back using `C-y'. 
(defalias 'py-kill-def-or-class #[nil "\301\302!\303@A\")\207" [erg py-mark-base "def-or-class" kill-region] 3 (#$ . 197867) "*"])
#@86 Delete class at point.

Stores data in kill ring. Might be yanked back using `C-y'. 
(defalias 'py-kill-class #[nil "\301\302!\303@A\")\207" [erg py-mark-base "class" kill-region] 3 (#$ . 198099) "*"])
#@84 Delete def at point.

Stores data in kill ring. Might be yanked back using `C-y'. 
(defalias 'py-kill-def #[nil "\301\302!\303@A\")\207" [erg py-mark-base "def" kill-region] 3 (#$ . 198310) "*"])
#@87 Delete clause at point.

Stores data in kill ring. Might be yanked back using `C-y'. 
(defalias 'py-kill-clause #[nil "\301\302!\303@A\")\207" [erg py-mark-base "clause" kill-region] 3 (#$ . 198515) "*"])
#@72 Detect and warn about file of form "py11046IoE" in py-temp-directory. 
(defalias 'py-warn-tmp-files-left #[nil "\304\305	!\306\307\310#@Q!\205$\n\205$\311\312\305	!\306\307\313#@Q\")\207" [py-temp-directory py-separator-char erg1 py-verbose-p file-readable-p char-to-string directory-files nil "py[[:alnum:]]+$" message "py-warn-tmp-files-left: %s ?" "py[[:alnum:]]*$"] 8 (#$ . 198729)])
#@74 Goes to end of line after forward move.

Travels right-margin comments. 
(defalias 'py-forward-line #[(&optional arg) "\206\301\211y\210\302\210\303\302x\210\304 \210\303\302x)\207" [arg 1 nil " 	" py-beginning-of-comment] 3 (#$ . 199131) "p"])
#@112 Go to the beginning of current line's comment, if any.

From a programm use `py-beginning-of-comment' instead 
(defalias 'py-go-to-beginning-of-comment #[nil "\302 	\205\303 \205\304\305\")\207" [erg py-verbose-p py-beginning-of-comment interactive-p message "%s"] 3 (#$ . 199388) nil])
#@89 Go to the beginning of current line's comment, if any.

Returns position if succesful. 
(defalias 'py-beginning-of-comment #[nil "\214~\210\301 \3028\205\3038b*\207" [pps syntax-ppss 4 8] 2 (#$ . 199687)])
#@58 Returns a list, whose car is indentation, cdr position. 
(defalias 'py-clause-lookup-keyword #[(regexp arg &optional indent orig origline) "\206`	\206\f\306 \307\nW\203\310\202\311\307\nW\203#\312\202$\313\314#\2031#\202>\306 	W\203=\315 \202>\307$\316\317%\"\204P\316\320%\"\203U&\202l\316\321%\"\203b'\202l\316\322%\"\205l()\323*\324\211+,\324-\325!\204\307
W\203,\204\223\f \211+\203\324,*\203\252$\315 W\203\252\315 $\324*-\203\267\315 $W\202\274\315 $X\203z\326.!\204\312\315 $\326\327!\203\330 /\331\216\316%\317\"*\203\315 #\325!\204z\f \203z\323\211,\203z#\315 =\203\343\326\332!\203\343\202z\326\333!\203E\330 /\334\216\316\322%\"*\203E\315 #
T\325!\204z\f \203z\323\211,\203z#\315 =\203\"\326\335!\203\"\202z\326\336!\203\204\330 /\337\216\316\322%\"*\203\204\315 #
T\325!\204z\f \203z\323\211,\203z#\315 =\203a\326\335!\203a\202z\326\340!\203\307\330 /\341\216\316\321%\"*\203\307\315 #\325!\204z\f \203z\323\211,\203z
S\211\203z#\315 =\203\235\326\342!\203\235\202z\326)!\203\334\315 $X\203\334
S\202z\316\320%\"\203\361\3260!\203\361
S\202z\316\322%\"\203\326\320!\203\315 \210\202z\323-\202z+\203+\3261!\203$\315 2\\+B+\202+\315 +B++.\207" [orig origline arg stop function count py-count-lines 0 (eobp) (bobp) py-end-of-statement py-beginning-of-statement 1 current-indentation string-match "finally" "except" "elif" "else" t nil eval looking-at "\\_<finally\\>[: \n	]" match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) "try" "\\<else\\>[: \n	]" ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) "try\\|if" "\\_<else\\>[: \n	]" ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) "\\_<elif\\>[ \n	]" ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) "if" indent maxindent regexp py-try-re py-if-re py-minor-block-re complement-re first erg done strict py-block-or-clause-re save-match-data-internal py-block-re py-def-or-class-re py-indent-offset] 4 (#$ . 199904)])
#@52 If inside a comment or string, leave it backward. 
(defalias 'py-leave-comment-or-string-backward #[(&optional pos) "\301 \3028\205\3028Sb)\207" [pps syntax-ppss 8] 2 (#$ . 202103) nil])
#@144 Go to the beginning of a list.
Optional ARG indicates a start-position for `parse-partial-sexp'.
Return beginning position, nil if not inside.
(defalias 'py-beginning-of-list-pps #[(&optional iact last ppstart orig done) "\206`	\206\306\307\310\311\312$\206e\310\204b\210\311\313 A@\211\2038\n\nb\210\314
\f	%\202B
\203A\315\316\f\"\210\f+\207" [orig ppstart erg done last iact re-search-backward "^[a-zA-Z]" nil t 1 syntax-ppss py-beginning-of-list-pps message "%s"] 6 (#$ . 202302) "p"])
(byte-code "\300\301!\203\302\303\304\"\210\302\305\306\"\210\300\207" [featurep thing-at-point-utils defalias py-beginning-of-list #[(&optional iact orig limit done last) "\214\206`	\n\206\306\307\310\311\312$	\204\"\n\203\"\nd}\210\311b\210\313 \242\314 \242\315 \242\316\317\310\f
E\"\320\"@\211\203[Sb\210\321S\n	%\202m\203bb\210\203l\322\323\"\210.	\207" [orig done limit last pt br re-search-backward "^[a-zA-Z]" nil t 1 ar-in-parentized-p-atpt ar-in-braced-p-atpt ar-in-bracketed-p-atpt sort delq < py-beginning-of-list message "%s" bk erg iact] 8 "Go to beginning of any parentized, braced or bracketed expression in statement. " "p"] py-end-of-list #[(&optional iact orig limit done last) "\214\206`	\n\206\306\307\310\311\312$	\204\"\n\203\"\nd}\210\311b\210\313 \242\314 \242\315 \242\316\317\310\f
E\"\320\"@\211\203[Sb\210\321S\n	%\202s\205sb\210\322 \210`T\203r\323\324\"\210.	\207" [orig done limit last pt br re-search-backward "^[a-zA-Z]" nil t 1 ar-in-parentized-p-atpt ar-in-braced-p-atpt ar-in-bracketed-p-atpt sort delq < py-end-of-list match-paren message "%s" bk erg iact] 8 "Go to end of any parentized, braced or bracketed expression in statement. " "p"]] 3)
#@319 Goto beginning of line following end of block.

Returns position reached, if successful, nil otherwise.

"-lc" stands for "left-corner" - a complementary command travelling left, whilst `py-end-of-block' stops at right corner.

See also `py-down-block': down from current definition to next beginning of block below. 
(defalias 'py-down-block-lc #[nil "\302 \211\203m\204\303y\210\304 \210`	\203!\305 \203!\306\307\"\210)\207" [erg py-verbose-p py-end-of-block 1 beginning-of-line interactive-p message "%s"] 4 (#$ . 204092) nil])
#@323 Goto beginning of line following end of clause.

Returns position reached, if successful, nil otherwise.

"-lc" stands for "left-corner" - a complementary command travelling left, whilst `py-end-of-clause' stops at right corner.

See also `py-down-clause': down from current definition to next beginning of clause below. 
(defalias 'py-down-clause-lc #[nil "\302 \211\203m\204\303y\210\304 \210`	\203!\305 \203!\306\307\"\210)\207" [erg py-verbose-p py-end-of-clause 1 beginning-of-line interactive-p message "%s"] 4 (#$ . 204640) nil])
#@311 Goto beginning of line following end of def.

Returns position reached, if successful, nil otherwise.

"-lc" stands for "left-corner" - a complementary command travelling left, whilst `py-end-of-def' stops at right corner.

See also `py-down-def': down from current definition to next beginning of def below. 
(defalias 'py-down-def-lc #[nil "\302 \211\203m\204\303y\210\304 \210`	\203!\305 \203!\306\307\"\210)\207" [erg py-verbose-p py-end-of-def 1 beginning-of-line interactive-p message "%s"] 4 (#$ . 205194) nil])
#@319 Goto beginning of line following end of class.

Returns position reached, if successful, nil otherwise.

"-lc" stands for "left-corner" - a complementary command travelling left, whilst `py-end-of-class' stops at right corner.

See also `py-down-class': down from current definition to next beginning of class below. 
(defalias 'py-down-class-lc #[nil "\302 \211\203m\204\303y\210\304 \210`	\203!\305 \203!\306\307\"\210)\207" [erg py-verbose-p py-end-of-class 1 beginning-of-line interactive-p message "%s"] 4 (#$ . 205730) nil])
#@335 Goto beginning of line following end of statement.

Returns position reached, if successful, nil otherwise.

"-lc" stands for "left-corner" - a complementary command travelling left, whilst `py-end-of-statement' stops at right corner.

See also `py-down-statement': down from current definition to next beginning of statement below. 
(defalias 'py-down-statement-lc #[nil "\302 \211\203m\204\303y\210\304 \210`	\203!\305 \203!\306\307\"\210)\207" [erg py-verbose-p py-end-of-statement 1 beginning-of-line interactive-p message "%s"] 4 (#$ . 206278) nil])
#@113 Go to the beginning of next statement below in buffer.

Returns indentation if statement found, nil otherwise. 
(defalias 'py-down-statement #[nil "`\303m\203
\303\2023\304 \211\203-\305 \211W\203#	b\210\202-\304 \211\203-\306 \210	\2033i\n\203A\307 \203A\310\311	\"\210	*\207" [orig erg py-verbose-p nil py-end-of-statement py-beginning-of-statement-position py-beginning-of-statement interactive-p message "%s"] 4 (#$ . 206850) nil])
#@105 Go to the beginning of next block below in buffer.

Returns indentation if block found, nil otherwise. 
(defalias 'py-down-block #[nil "`\304m\203\304\211\2028\305\n\304\306#\203\307\310 8\204\311 \210\312\n!\203)\313 \2037\314 \2037\315\316	\"\210	*\207" [orig erg py-block-re py-verbose-p nil re-search-forward move 8 syntax-ppss back-to-indentation looking-at current-indentation interactive-p message "%s"] 4 (#$ . 207310) nil])
#@107 Go to the beginning of next clause below in buffer.

Returns indentation if clause found, nil otherwise. 
(defalias 'py-down-clause #[nil "`\304m\203
\304\202\305 \211\203\306\n!\203
\203(\307 \203(\310\311	\"\210	*\207" [orig erg py-clause-re py-verbose-p nil py-down-statement looking-at interactive-p message "%s"] 3 (#$ . 207765) nil])
#@125 Go to the beginning of next block-or-clause below in buffer.

Returns indentation if block-or-clause found, nil otherwise. 
(defalias 'py-down-block-or-clause #[nil "`\304m\203
\304\202\305 \211\203\306\n!\203
\203(\307 \203(\310\311	\"\210	*\207" [orig erg py-block-or-clause-re py-verbose-p nil py-down-statement looking-at interactive-p message "%s"] 3 (#$ . 208125) nil])
#@101 Go to the beginning of next def below in buffer.

Returns indentation if def found, nil otherwise. 
(defalias 'py-down-def #[nil "`\304m\203
\304\202\305 \211\203\306\n!\203
\203(\307 \203(\310\311	\"\210	*\207" [orig erg py-def-re py-verbose-p nil py-down-statement looking-at interactive-p message "%s"] 3 (#$ . 208521) nil])
#@105 Go to the beginning of next class below in buffer.

Returns indentation if class found, nil otherwise. 
(defalias 'py-down-class #[nil "`\304m\203
\304\202\305 \211\203\306\n!\203
\203(\307 \203(\310\311	\"\210	*\207" [orig erg py-class-re py-verbose-p nil py-down-statement looking-at interactive-p message "%s"] 3 (#$ . 208869) nil])
#@119 Go to the beginning of next def-or-class below in buffer.

Returns indentation if def-or-class found, nil otherwise. 
(defalias 'py-down-def-or-class #[nil "`\304m\203
\304\202\305 \211\203\306\n!\203
\203(\307 \203(\310\311	\"\210	*\207" [orig erg py-def-or-class-re py-verbose-p nil py-down-statement looking-at interactive-p message "%s"] 3 (#$ . 209225) nil])
#@227 Move forward to end of a nomenclature section or word.

With \[universal-argument] (programmatically, optional argument ARG), do it that many times.

A `nomenclature' is a fancy way of saying AWordWithMixedCaseNotUnderscores.
(defalias 'py-forward-into-nomenclature #[(&optional arg iact) "\204\306\307`\307\310V\203hm\204\227\310V\203\227\311\307w\310=\203,\312\307w\310=\204J\306\313\307wW\204D\314\307w\310=\203D\315\307w\310=\204S\202\306\313\307wW\204b\314\307w\310=\203b\315\307w\310=\204S\202o\204\227\310W\203\227\316\307x\310=\204}\317u\210\313\307x\310=\203\221\314\307x\310=\203\221\314\307x\210T\202h`\nW\203\266\320\321!\203\246\317u\210\322\323!\203\261`\202\307\307\202\307\n`W\203\305m\204\305`\202\307\307\f\203\331
\204\324\324 \203\331\325\326	\"\210	+\207" [arg erg orig case-fold-search py-report-position-p iact 1 nil 0 "[[:blank:][:punct:]\n
]" "_" "[:upper:]" "[[:lower:][:digit:]ÃŸ]" "[[:lower:][:digit:]]" "[[:blank:][:punct:]\n
\f_]" -1 looking-back "[[:upper:]]" looking-at "[[:alnum:]ÃŸ]" interactive-p message "%s"] 3 (#$ . 209609) "p"])
#@217 Move backward to beginning of a nomenclature section or word.

With optional ARG, move that many times.  If ARG is negative, move
forward.

A `nomenclature' is a fancy way of saying AWordWithMixedCaseNotUnderscores.
(defalias 'py-backward-into-nomenclature #[(&optional arg) "\206\301\302[\"\207" [arg 1 py-forward-into-nomenclature] 3 (#$ . 210738) "p"])
(defalias 'py-match-paren 'match-paren)
#@176 Go to the matching brace, bracket or parenthesis if on its counterpart.

Otherwise insert the character, the key is assigned to, here `%'.
With universal arg  insert a `%'. 
(defalias 'match-paren #[(&optional arg) "\303	\203\304	\247\203	\202\305!\202\200\n\204(\306\307!\203(\310\305!\210\311u\202\200\n\204;\306\312!\203;\305u\210\313\305!\202\200\306\314!\203F\315 \202\200\306\316!\203Q\317 \202\200\306\320!\203\\\321 \202\200\306\322!\203g\323 \202\200\306\324!\203r\325 \202\200\306\326!\203}\327 \202\200\304\305!)\207" [parse-sexp-ignore-comments arg match-paren-no-use-syntax-pps t self-insert-command 1 looking-at "\\s(" forward-list -1 "\\s)" backward-list "(" ar-parentized-end-atpt ")" ar-parentized-beginning-atpt "\\[" ar-bracketed-end-atpt "]" ar-bracketed-beginning-atpt "{" ar-braced-end-atpt "}" ar-braced-beginning-atpt] 2 (#$ . 211147) "P"])
#@116 Moves down until clause is closed, i.e. current indentation is reached.

Takes a list, INDENT and START position. 
(defalias 'py-travel-current-indent #[(indent) "\302`\211\203m\204\303 \203	\212\304 \210\305 )X\204\203$b\210)\207" [last indent nil py-end-of-statement py-beginning-of-statement current-indentation] 2 (#$ . 212046)])
#@42 Toggle py-execute-keep-temporary-file-p 
(defalias 'py-toggle-execute-keep-temporary-file-p #[nil "?	\205\302 \205\303\304\"\207" [py-execute-keep-temporary-file-p py-verbose-p interactive-p message "py-execute-keep-temporary-file-p: %s"] 3 (#$ . 212400) nil])
#@136 Watch output for Python prompt and exec next file waiting in queue.
This function is appropriate for `comint-output-filter-functions'.
(defalias 'py-comint-output-filter-function #[(string) "\304\230\204G\305Y\205:\306\307O\310\230\205:\307\211\204 \n\205:\311p!\210\307\312\313\217\210\nA\211\205:\314p!\315\n@\")\207" [string py-shell-input-lines py-file-queue pyproc ">>> " 5 -5 nil "\n>>> " pop-to-buffer (byte-code "\301@!\207" [py-file-queue delete-file] 2) ((error)) get-buffer-process py-execute-file] 4 (#$ . 212675)])
#@52 Defaults to "python", if guessing didn't succeed. 
(defalias 'py-guess-default-python #[nil "\206\n\304 \206\n\305\n\203	\202\306	!\307 \205+\203'\310\311	\"\202+\310\311\312\"*\207" [py-shell-name cmd py-edit-only-p erg py-choose-shell "python" executable-find interactive-p message "%s" "Could not detect Python on your system"] 3 (#$ . 213224) nil])
#@132 Return the file-path separator char from current machine.

When `py-separator-char' is customized, its taken.
Returns char found. 
(defalias 'py-separator-char #[nil "\303!\203\f\304!\202A\305\306	\"\2039\305\307	\"\2039\310	\311P!\312\313\314\n#\305\315\n\"\205A\n\305\315\n\"\316O\211\202A\310	\317\311Q!\211\312\313\314\n#)\207" [py-separator-char py-shell-name erg characterp char-to-string string-match "[Ii][Pp]ython" "epd\\|EPD" shell-command-to-string " -c \"import os; print(os.sep)\"" replace-regexp-in-string "\n" "" "^$" nil " -W ignore"] 4 (#$ . 213597)])
(byte-code "\204\300 \300\207" [py-separator-char] 1)
#@75 Return the name of the running Python process, `get-process' willsee it. 
(defalias 'py-process-name #[(&optional name dedicated nostars sepchar) "\206\306	!\n\203'\307\n\"\203#\n\307\310\311Q\n\"\210\312\224\313O\2024\n\2024\307\314P\"\2062\315\313O
\203A\316\f\317P!\202B\f\307\320\"\204T\307\321\"\203X\321\202Z\204p\307\322\"\204p\323\323Q,\207" [sepchar py-separator-char name py-shell-name thisname dedicated char-to-string string-match "\\(.+\\)" "\\(.+\\)$" 2 nil ".+$" 0 make-temp-name "-" "ipython" "IPython" "^*" "*" nname erg nostars] 5 (#$ . 214243)])
#@152 Either ipython0.10-completion-command-string or ipython0.11-completion-command-string.

ipython0.11-completion-command-string also covers version 0.12
(defvar ipython-completion-command-string nil (#$ . 214857))
#@66 The string send to ipython to query for all possible completions
(defvar ipython0\.10-completion-command-string "print(';'.join(__IP.Completer.all_completions('%s'))) #PYTHON-MODE SILENT\n" (#$ . 215075))
#@66 The string send to ipython to query for all possible completions
(defvar ipython0\.11-completion-command-string "print(';'.join(get_ipython().Completer.all_completions('%s'))) #PYTHON-MODE SILENT\n" (#$ . 215286))
(defalias 'py-dirstack-hook #[nil "\303\300!\210\304\303\301!\210\304\303\302!\210\305\306\307\310\304\305$\207" [shell-dirstack shell-last-dir shell-dirtrackp make-local-variable nil t add-hook comint-input-filter-functions shell-directory-tracker] 5])
#@54 Set and return `ipython-completion-command-string'. 
(defalias 'py-set-ipython-completion-command-string #[(&optional pyshellname) "\206	\306\307\"\205\310\311\312P!\313\314O!\211\205)\n\315W\203&\202'\f\211*\207" [pyshellname py-shell-name ipython-version ipython0\.10-completion-command-string ipython0\.11-completion-command-string ipython-completion-command-string string-match "ipython" string-to-number shell-command-to-string " -V" 2 -1 11] 5 (#$ . 215763) nil])
(defalias 'py-dedicated-shell 'py-shell-dedicated)
#@195 Start an interactive Python interpreter in another window.

With optional \[universal-argument] user is prompted by
`py-choose-shell' for command and options to pass to the Python
interpreter.

(defalias 'py-shell-dedicated #[(&optional argprompt) "\301\302\"\207" [argprompt py-shell t] 3 (#$ . 216305) "P"])
#@104 Return an appropriate name to display in modeline.
SEPCHAR is the file-path separator of your system. 
(defalias 'py-buffer-name-prepare #[(name &optional sepchar dedicated) "\206\306	!\307\211\211\310\311!
\"\203y$\2041\310\312\313\314!P
\"\2031\315\312\313\314!P\316
#\317 %\320\216\321
\"&*&\307'\211(\203f(@\211'\316\230\204]\f\306'\322H!P(A\211(\204I*)\204y
\310\323\324R
\"T\307O
\325\230\203\207\315\325\326
#\202\302
\327\230\203\225\315\327\330
#\202\302
\331\230\203\243\315\331\332
#\202\302\310\333
\"\203\262\315\333\334
#\202\302\310\335
\"\203\301\315\335\336
#\202\302
*\203\316\337\340P!\f\203\345\310\341\"\203\345\315\341\342\f\343Q#\202\371\f\203\364\342\f\343\342\260\202\371\342\342Q,\207" [sepchar py-separator-char suffix erg prefix name char-to-string nil string-match regexp-quote "^" expand-file-name "~" replace-regexp-in-string "" match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) split-string 0 "[^" "]+$" "ipython" "IPython" "jython" "Jython" "python" "Python" "python2" "Python2" "python3" "Python3" make-temp-name "-" "^*" "*" " " py-modeline-acronym-display-home-p save-match-data-internal liste ele #1=#:--cl-dolist-temp-- py-modeline-display-full-path-p dedicated] 7 (#$ . 216623)])
#@158 Delete numbering and star chars from string, return result.

Needed when file-path names are contructed from maybe numbered buffer names like "*Python*<2> "
(defalias 'py-delete-numbers-and-stars-from-string #[(string) "\301\302\303\301\304\303##\207" [string replace-regexp-in-string "<\\([0-9]+\\)>" "" "*"] 7 (#$ . 217958)])
(defalias 'py-shell-manage-windows #[(switch py-split-windows-on-execute-p py-switch-buffers-on-execute-p oldbuf py-buffer-name) "\306 \210\307\310!\210\311=\2043	\2033\300=\204\n\2033\312\313\"\204%\306 \210\314 \315W\203/\f \210\316!\207	\203h\311=\204C\300=\204h\314 \315W\203X\f \210\317!\210\307\310!\210\202\\\307\310!\210\320\310!\210\317
!\210\316
!\207\300=\204x\311=\204\n\203\316!\210db\207\311=\204\212\n?\205\220
q\210\321p!\207" [switch py-split-windows-on-execute-p py-switch-buffers-on-execute-p py-buffer-name py-split-windows-on-execute-function oldbuf delete-other-windows window-configuration-to-register 213465889 noswitch string-match "[Ii][Pp]ython" count-windows 2 pop-to-buffer display-buffer jump-to-register switch-to-buffer] 3])
(defalias 'py-report-executable #[(py-buffer-name) "\302\303\304\302\305\304\306\307\"\203\306\307\"T\310O\202##\227\306\311	\"\203,	\312\306\311	\"O	)\207" [py-buffer-name erg replace-regexp-in-string "<\\([0-9]+\\)>" "" "*" string-match " " nil "-" 0] 10])
#@125 Send all setup code for shell.
This function takes the list of setup code to send from the
`python-shell-setup-codes' list.
(defalias 'py-shell-send-setup-code #[(process) "\304\305\"\210	\306\211\205\"@\307\nJ\"\210\310\311!\210A\211\204
\306*\207" [process python-shell-setup-codes code #1=#:--cl-dolist-temp-- accept-process-output 1 nil python-shell-send-string-no-output sit-for 0.1] 4 (#$ . 219351)])
#@664 Start an interactive Python interpreter in another window.

Interactively, \[universal-argument] 4 prompts for a buffer.
\[universal-argument] 2 prompts for `py-python-command-args'.
If `default-directory' is a remote file name, it is also prompted
to change if called with a prefix arg.

Returns py-shell's buffer-name.
Optional string PYSHELLNAME overrides default `py-shell-name'.
Optional symbol SWITCH ('switch/'noswitch) precedes `py-switch-buffers-on-execute-p'
When SEPCHAR is given, `py-shell' must not detect the file-separator.
BUFFER allows specifying a name, the Python process is connected to
When DONE is `t', `py-shell-manage-windows' is omitted

(defalias 'py-shell #[(&optional argprompt dedicated pyshellname switch sepchar py-buffer-name done) "\204\"	\204\"\n\204\"\204\"\f\204\"
\204\"@\204\"\306 \203\204\f\206*\307A!BCpD\310\311!E\312E\205BEFPGQHBH
\206\240\205\240\313!\314=\203\202\315\316\317\320\n\206dI\f\"!\"\321J!\203}\322\323\324J\211\325\326\327&!J\211\202\240\313!\330=\205\240\331\332!\205\240\332\333\334\335\336B\337#\337P\"!\211C\n\206\270I\203\261I\340\230\203\266\341 \202\270I\325KL\340\230\204\312\322L!\202\322M\205\322\342\343!M
?\205\343\320\n\206\340I\f	#
\206\353\n\206\367
\205\367\344
!N\326O\345\346N
N\326C&q\210\347\350!\210\351\335\336\352\326PQRSTU\257\"\353#\354Q(\347\355!\210\356-\347\357!\210\325/\347\360!\210V0\326W\361\362\363\326\325$\210X\203\212\347\364!\210\3654\347\366!\210\3676\347\370!\210\3718\347\372!\210\373:\347\374!\210\375<\347\376!\210\377>\347\201Y!\210\201dY\201e \210\202\224\201fe\201g \"\210pZ\201hp!Odb\210\201iO!d\326\223\210\201jO!\210\201k\201l!\210\201m[\201n\201o
\"\203\344\310\201p!\203\336\310\201p!\201qP\202#\201r\202#\310\201s!\203\376\310\201s!\201t\344
!\201uR\202#	\203\201v
\201w\201n\201x
\"O\201uQ\202#\201v\344
!\201uQ\\\201y\325!\210\201z\201hp!\201{\"\210\325]\201|^!\210\201} \210\201~_!\210`\203[\201\201`!\210\306 \203na\203n\201\200
!\210\202\200@\204\200\201\201bcD
%\210
.
\207\201\202p!\203\222\201\203p!\207\201\202
!\205\233
\207" [argprompt dedicated pyshellname switch sepchar py-buffer-name interactive-p char-to-string getenv "PYTHONPATH" "PYTHONPATH=" prefix-numeric-value 4 read-buffer "Py-Shell buffer: " generate-new-buffer-name py-buffer-name-prepare file-remote-p expand-file-name read-file-name "Default directory: " t nil file-directory-p 2 fboundp split-string read-string "Py-Shell arguments: " mapconcat identity " " "" py-choose-shell error "Abort: `py-use-local-default' is set to `t' but `py-shell-local-path' is empty. Maybe call `py-toggle-local-default-use'" py-report-executable apply make-comint-in-buffer make-local-variable comint-prompt-regexp "\\(" delq "\\|" "\\)" comint-input-filter py-history-input-filter comint-use-prompt-regexp compilation-error-regexp-alist add-hook comint-preoutput-filter-functions python-preoutput-filter font-lock-defaults (python-font-lock-keywords nil nil nil nil (font-lock-syntactic-keywords . python-font-lock-syntactic-keywords)) comment-start "# " comment-start-skip "^[ 	]*#+ *" comment-column 40 comment-indent-function py-comment-indent-function indent-region-function py-indent-region done py-separator-char py-python-command-args args oldbuf path path-separator data-directory process-environment py-shell-name default-directory process-connection-type py-shell-local-path py-use-local-default executable proc py-shell-input-prompt-1-regexp py-shell-input-prompt-2-regexp ipython-de-input-prompt-regexp ipython-de-output-prompt-regexp py-pdbtrack-input-prompt py-pydbtrack-input-prompt python-compilation-regexp-alist completion-at-point-functions py-fontify-shell-buffer-p indent-line-function python-buffer comint-input-sender comint-input-ring-file-name py-pdbtrack-do-tracking-p python-mode-syntax-table py-shell-map py-shell-hook py-shell-switch-buffers-on-execute-p py-split-windows-on-execute-p py-switch-buffers-on-execute-p py-indent-line font-lock-fontify-buffer font-lock-unfontify-region line-beginning-position get-buffer-process process-mark py-shell-send-setup-code compilation-shell-minor-mode 1 py-shell-simple-send string-match "[iI][pP]ython[[:alnum:]]*$" "IPYTHONDIR" "/history" "~/.ipython/history" "PYTHONHISTORY" "/" "_history" "~/." 0 "-" comint-read-input-ring set-process-sentinel shell-write-history-on-exit set-syntax-table ansi-color-for-comint-mode-on use-local-map run-hooks pop-to-buffer py-shell-manage-windows comint-check-proc buffer-name] 11 (#$ . 219775) "P"])
(byte-code "\300\301\302\"\210\300\303\302\"\207" [defalias iyp ipython ipy] 3)
#@213 Start an Python interpreter.

Optional \[universal-argument] prompts for options to pass to the Python interpreter. See `py-python-command-args'.
   Optional DEDICATED SWITCH are provided for use from programs. 
(defalias 'python #[(&optional argprompt dedicated switch) "\303	\304\n$\207" [argprompt dedicated switch py-shell "python"] 5 (#$ . 224516) "P"])
(byte-code "\300\301\302\"\210\300\303\302\"\207" [defalias ipyhton ipython iypthon] 3)
#@215 Start an IPython interpreter.

Optional \[universal-argument] prompts for options to pass to the IPython interpreter. See `py-python-command-args'.
   Optional DEDICATED SWITCH are provided for use from programs. 
(defalias 'ipython #[(&optional argprompt dedicated switch) "\303	\304\n$\207" [argprompt dedicated switch py-shell "ipython"] 5 (#$ . 224971) "P"])
#@215 Start an Python3 interpreter.

Optional \[universal-argument] prompts for options to pass to the Python3 interpreter. See `py-python-command-args'.
   Optional DEDICATED SWITCH are provided for use from programs. 
(defalias 'python3 #[(&optional argprompt dedicated switch) "\303	\304\n$\207" [argprompt dedicated switch py-shell "python3"] 5 (#$ . 225342) "P"])
#@215 Start an Python2 interpreter.

Optional \[universal-argument] prompts for options to pass to the Python2 interpreter. See `py-python-command-args'.
   Optional DEDICATED SWITCH are provided for use from programs. 
(defalias 'python2 #[(&optional argprompt dedicated switch) "\303	\304\n$\207" [argprompt dedicated switch py-shell "python2"] 5 (#$ . 225713) "P"])
#@219 Start an Python2.7 interpreter.

Optional \[universal-argument] prompts for options to pass to the Python2.7 interpreter. See `py-python-command-args'.
   Optional DEDICATED SWITCH are provided for use from programs. 
(defalias 'python2\.7 #[(&optional argprompt dedicated switch) "\303	\304\n$\207" [argprompt dedicated switch py-shell "python2.7"] 5 (#$ . 226084) "P"])
#@213 Start an Jython interpreter.

Optional \[universal-argument] prompts for options to pass to the Jython interpreter. See `py-python-command-args'.
   Optional DEDICATED SWITCH are provided for use from programs. 
(defalias 'jython #[(&optional argprompt dedicated switch) "\303	\304\n$\207" [argprompt dedicated switch py-shell "jython"] 5 (#$ . 226464) "P"])
#@214 Start an BPython interpreter.

Optional \[universal-argument] prompts for options to pass to the Jython interpreter. See `py-python-command-args'.
   Optional DEDICATED SWITCH are provided for use from programs. 
(defalias 'bpython #[(&optional argprompt dedicated switch) "\303	\304\n$\207" [argprompt dedicated switch py-shell "bpython"] 5 (#$ . 226831) "P"])
#@219 Start an Python3.2 interpreter.

Optional \[universal-argument] prompts for options to pass to the Python3.2 interpreter. See `py-python-command-args'.
   Optional DEDICATED SWITCH are provided for use from programs. 
(defalias 'python3\.2 #[(&optional argprompt dedicated switch) "\303	\304\n$\207" [argprompt dedicated switch py-shell "python3.2"] 5 (#$ . 227201) "P"])
#@172 Start an unique Python interpreter in another window.

Optional \[universal-argument] prompts for options to pass to the Python interpreter. See `py-python-command-args'.
(defalias 'python-dedicated #[(&optional argprompt switch) "\302\303\304	$\207" [argprompt switch py-shell t "python"] 5 (#$ . 227581) "P"])
#@174 Start an unique IPython interpreter in another window.

Optional \[universal-argument] prompts for options to pass to the IPython interpreter. See `py-python-command-args'.
(defalias 'ipython-dedicated #[(&optional argprompt switch) "\302\303\304	$\207" [argprompt switch py-shell t "ipython"] 5 (#$ . 227901) "P"])
#@174 Start an unique Python3 interpreter in another window.

Optional \[universal-argument] prompts for options to pass to the Python3 interpreter. See `py-python-command-args'.
(defalias 'python3-dedicated #[(&optional argprompt switch) "\302\303\304	$\207" [argprompt switch py-shell t "python3"] 5 (#$ . 228225) "P"])
#@174 Start an unique Python2 interpreter in another window.

Optional \[universal-argument] prompts for options to pass to the Python2 interpreter. See `py-python-command-args'.
(defalias 'python2-dedicated #[(&optional argprompt switch) "\302\303\304	$\207" [argprompt switch py-shell t "python2"] 5 (#$ . 228549) "P"])
#@178 Start an unique Python2.7 interpreter in another window.

Optional \[universal-argument] prompts for options to pass to the Python2.7 interpreter. See `py-python-command-args'.
(defalias 'python2\.7-dedicated #[(&optional argprompt switch) "\302\303\304	$\207" [argprompt switch py-shell t "python2.7"] 5 (#$ . 228873) "P"])
#@172 Start an unique Jython interpreter in another window.

Optional \[universal-argument] prompts for options to pass to the Jython interpreter. See `py-python-command-args'.
(defalias 'jython-dedicated #[(&optional argprompt switch) "\302\303\304	$\207" [argprompt switch py-shell t "jython"] 5 (#$ . 229206) "P"])
#@178 Start an unique Python3.2 interpreter in another window.

Optional \[universal-argument] prompts for options to pass to the Python3.2 interpreter. See `py-python-command-args'.
(defalias 'python3\.2-dedicated #[(&optional argprompt switch) "\302\303\304	$\207" [argprompt switch py-shell t "python3.2"] 5 (#$ . 229526) "P"])
#@166 Switch to Python interpreter in another window.

Optional \[universal-argument] prompts for options to pass to the Python interpreter. See `py-python-command-args'.
(defalias 'python-switch #[(&optional argprompt dedicated) "\302	\303\304$\207" [argprompt dedicated py-shell "python" switch] 5 (#$ . 229859) "P"])
#@168 Switch to IPython interpreter in another window.

Optional \[universal-argument] prompts for options to pass to the IPython interpreter. See `py-python-command-args'.
(defalias 'ipython-switch #[(&optional argprompt dedicated) "\302	\303\304$\207" [argprompt dedicated py-shell "ipython" switch] 5 (#$ . 230181) "P"])
#@168 Switch to Python3 interpreter in another window.

Optional \[universal-argument] prompts for options to pass to the Python3 interpreter. See `py-python-command-args'.
(defalias 'python3-switch #[(&optional argprompt dedicated) "\302	\303\304$\207" [argprompt dedicated py-shell "python3" switch] 5 (#$ . 230507) "P"])
#@168 Switch to Python2 interpreter in another window.

Optional \[universal-argument] prompts for options to pass to the Python2 interpreter. See `py-python-command-args'.
(defalias 'python2-switch #[(&optional argprompt dedicated) "\302	\303\304$\207" [argprompt dedicated py-shell "python2" switch] 5 (#$ . 230833) "P"])
#@172 Switch to Python2.7 interpreter in another window.

Optional \[universal-argument] prompts for options to pass to the Python2.7 interpreter. See `py-python-command-args'.
(defalias 'python2\.7-switch #[(&optional argprompt dedicated) "\302	\303\304$\207" [argprompt dedicated py-shell "python2.7" switch] 5 (#$ . 231159) "P"])
#@166 Switch to Jython interpreter in another window.

Optional \[universal-argument] prompts for options to pass to the Jython interpreter. See `py-python-command-args'.
(defalias 'jython-switch #[(&optional argprompt dedicated) "\302	\303\304$\207" [argprompt dedicated py-shell "jython" switch] 5 (#$ . 231494) "P"])
#@172 Switch to Python3.2 interpreter in another window.

Optional \[universal-argument] prompts for options to pass to the Python3.2 interpreter. See `py-python-command-args'.
(defalias 'python3\.2-switch #[(&optional argprompt dedicated) "\302	\303\304$\207" [argprompt dedicated py-shell "python3.2" switch] 5 (#$ . 231816) "P"])
#@189 Open an Python interpreter in another window, but do not switch to it.

Optional \[universal-argument] prompts for options to pass to the Python interpreter. See `py-python-command-args'.
(defalias 'python-no-switch #[(&optional argprompt dedicated) "\302	\303\304$\207" [argprompt dedicated py-shell "python" noswitch] 5 (#$ . 232151) "P"])
#@191 Open an IPython interpreter in another window, but do not switch to it.

Optional \[universal-argument] prompts for options to pass to the IPython interpreter. See `py-python-command-args'.
(defalias 'ipython-no-switch #[(&optional argprompt dedicated) "\302	\303\304$\207" [argprompt dedicated py-shell "ipython" noswitch] 5 (#$ . 232501) "P"])
#@191 Open an Python3 interpreter in another window, but do not switch to it.

Optional \[universal-argument] prompts for options to pass to the Python3 interpreter. See `py-python-command-args'.
(defalias 'python3-no-switch #[(&optional argprompt dedicated) "\302	\303\304$\207" [argprompt dedicated py-shell "python3" noswitch] 5 (#$ . 232855) "P"])
#@191 Open an Python2 interpreter in another window, but do not switch to it.

Optional \[universal-argument] prompts for options to pass to the Python2 interpreter. See `py-python-command-args'.
(defalias 'python2-no-switch #[(&optional argprompt dedicated) "\302	\303\304$\207" [argprompt dedicated py-shell "python2" noswitch] 5 (#$ . 233209) "P"])
#@195 Open an Python2.7 interpreter in another window, but do not switch to it.

Optional \[universal-argument] prompts for options to pass to the Python2.7 interpreter. See `py-python-command-args'.
(defalias 'python2\.7-no-switch #[(&optional argprompt dedicated) "\302	\303\304$\207" [argprompt dedicated py-shell "python2.7" noswitch] 5 (#$ . 233563) "P"])
#@189 Open an Jython interpreter in another window, but do not switch to it.

Optional \[universal-argument] prompts for options to pass to the Jython interpreter. See `py-python-command-args'.
(defalias 'jython-no-switch #[(&optional argprompt dedicated) "\302	\303\304$\207" [argprompt dedicated py-shell "jython" noswitch] 5 (#$ . 233926) "P"])
#@195 Open an Python3.2 interpreter in another window, but do not switch to it.

Optional \[universal-argument] prompts for options to pass to the Python3.2 interpreter. See `py-python-command-args'.
(defalias 'python3\.2-no-switch #[(&optional argprompt dedicated) "\302	\303\304$\207" [argprompt dedicated py-shell "python3.2" noswitch] 5 (#$ . 234276) "P"])
(defalias 'python-dedicated-switch 'python-switch-dedicated)
#@176 Switch to an unique Python interpreter in another window.

Optional \[universal-argument] prompts for options to pass to the Python interpreter. See `py-python-command-args'.
(defalias 'python-switch-dedicated #[(&optional argprompt) "\301\302\303\304$\207" [argprompt py-shell t "python" switch] 5 (#$ . 234700) "P"])
(defalias 'ipython-dedicated-switch 'ipython-switch-dedicated)
#@178 Switch to an unique IPython interpreter in another window.

Optional \[universal-argument] prompts for options to pass to the IPython interpreter. See `py-python-command-args'.
(defalias 'ipython-switch-dedicated #[(&optional argprompt) "\301\302\303\304$\207" [argprompt py-shell t "ipython" switch] 5 (#$ . 235090) "P"])
(defalias 'python3-dedicated-switch 'python3-switch-dedicated)
#@178 Switch to an unique Python3 interpreter in another window.

Optional \[universal-argument] prompts for options to pass to the Python3 interpreter. See `py-python-command-args'.
(defalias 'python3-switch-dedicated #[(&optional argprompt) "\301\302\303\304$\207" [argprompt py-shell t "python3" switch] 5 (#$ . 235484) "P"])
(defalias 'python2-dedicated-switch 'python2-switch-dedicated)
#@178 Switch to an unique Python2 interpreter in another window.

Optional \[universal-argument] prompts for options to pass to the Python2 interpreter. See `py-python-command-args'.
(defalias 'python2-switch-dedicated #[(&optional argprompt) "\301\302\303\304$\207" [argprompt py-shell t "python2" switch] 5 (#$ . 235878) "P"])
(defalias 'python2\.7-dedicated-switch 'python2\.7-switch-dedicated)
#@182 Switch to an unique Python2.7 interpreter in another window.

Optional \[universal-argument] prompts for options to pass to the Python2.7 interpreter. See `py-python-command-args'.
(defalias 'python2\.7-switch-dedicated #[(&optional argprompt) "\301\302\303\304$\207" [argprompt py-shell t "python2.7" switch] 5 (#$ . 236278) "P"])
(defalias 'jython-dedicated-switch 'jython-switch-dedicated)
#@176 Switch to an unique Jython interpreter in another window.

Optional \[universal-argument] prompts for options to pass to the Jython interpreter. See `py-python-command-args'.
(defalias 'jython-switch-dedicated #[(&optional argprompt) "\301\302\303\304$\207" [argprompt py-shell t "jython" switch] 5 (#$ . 236679) "P"])
(defalias 'python3\.2-dedicated-switch 'python3\.2-switch-dedicated)
#@182 Switch to an unique Python3.2 interpreter in another window.

Optional \[universal-argument] prompts for options to pass to the Python3.2 interpreter. See `py-python-command-args'.
(defalias 'python3\.2-switch-dedicated #[(&optional argprompt) "\301\302\303\304$\207" [argprompt py-shell t "python3.2" switch] 5 (#$ . 237075) "P"])
#@144 Return the command appropriate to Python version.

Per default it's "(format "execfile(r'%s') # PYTHON-MODE\n" filename)" for Python 2 series.
(defalias 'py-which-execute-file-command #[(filename) "\304 \211\305W\203\306\307	\"\202\306\310	\211#\203&\311 \203&\312\313\314\n!\"\210\n*\207" [erg filename cmd py-verbose-p py-which-python 3 format "execfile(r'%s') # PYTHON-MODE\n" "exec(compile(open('%s').read(), '%s', 'exec')) # PYTHON-MODE\n" interactive-p message "%s" prin1-to-string] 5 (#$ . 237415) nil])
#@132 Send the region to a Python interpreter.

Ignores setting of `py-switch-buffers-on-execute-p', buffer with region stays current.
 
(defalias 'py-execute-region-no-switch #[(start end &optional shell dedicated) "\304	\n\305%\207" [start end py-shell-name dedicated py-execute-base noswitch] 6 (#$ . 237942) "r\nP"])
#@135 Send the region to a Python interpreter.

Ignores setting of `py-switch-buffers-on-execute-p', output-buffer will being switched to.

(defalias 'py-execute-region-switch #[(start end &optional shell dedicated) "\304	\n\305%\207" [start end py-shell-name dedicated py-execute-base switch] 6 (#$ . 238266) "r\nP"])
#@554 Send the region to a Python interpreter.

When called with \[univeral-argument], execution through `default-value' of `py-shell-name' is forced.
When called with \[univeral-argument] followed by a number different from 4 and 1, user is prompted to specify a shell. This might be the name of a system-wide shell or include the path to a virtual environment.

When called from a programm, it accepts a string specifying a shell which will be forced upon execute as argument.

Optional arguments DEDICATED (boolean) and SWITCH (symbols 'noswitch/'switch)

(defalias 'py-execute-region #[(start end &optional shell dedicated switch) "\203\f	\203\f\n\2025	\204\306!\307=\203\310\302!\2025\247\2034\306!\311=\2044\312\313\310\302!\"\2025\314\f

%)\207" [py-force-local-shell-p py-force-py-shell-name-p py-shell-name shell start end prefix-numeric-value 4 default-value 1 read-from-minibuffer "(path-to-)shell-name: " py-execute-base dedicated switch] 6 (#$ . 238588) "r\nP"])
#@91 Send the region to the systems default Python interpreter.
See also `py-execute-region'. 
(defalias 'py-execute-region-default #[(start end &optional dedicated) "\303	\304\305!\n$\207" [start end dedicated py-execute-base default-value py-shell-name] 5 (#$ . 239585) "r\nP"])
#@492 Get the region processed by an unique Python interpreter.

When called with \[univeral-argument], execution through `default-value' of `py-shell-name' is forced.
When called with \[univeral-argument] followed by a number different from 4 and 1, user is prompted to specify a shell. This might be the name of a system-wide shell or include the path to a virtual environment.

When called from a programm, it accepts a string specifying a shell which will be forced upon execute as argument. 
(defalias 'py-execute-region-dedicated #[(start end &optional shell) "\303!\304=\203\305\306!\202%\247\203$\303!\307=\204$\310\311\305\306!\"\202%\312	\n\313$)\207" [shell start end prefix-numeric-value 4 default-value py-shell-name 1 read-from-minibuffer "(path-to-)shell-name: " py-execute-base t] 5 (#$ . 239869) "r\nP"])
(defalias 'py-execute-region-dedicated-default 'py-execute-region-default-dedicated)
#@64 Send the region to an unique shell of systems default Python. 
(defalias 'py-execute-region-default-dedicated #[(start end) "\302	\303\304!\305$\207" [start end py-execute-base default-value py-shell-name t] 5 (#$ . 240788) "r"])
#@43 Adapt the variables used in the process. 
(defalias 'py-execute-base #[(start end &optional pyshellname dedicated switch nostars sepchar) "p	\206\306 \307\310\311\217\206\312\313!\206\312\314!\315\f\"@\206(\316A!@\317	@\"B\320\321\322@!\323\321\324\322@!P\325\321\326\323	###\323P!C\327D!@\321\322@!\323C#\330RE\331E!FG\203}\332\333\307G	H@B\334&!\202\225\332\317	!!\206\225\332\333\307G	H@B\334&!I\335I!J\336\337B\"\203\256\340\341E\211#\202\263\340\342E\"K\343\344!\205\275$$\334L\307MFq\210\345 \210
c\210\346ed\"\210\347\350I!@\"\210$\204\345\351 \210\336\352	\"\204\357\353 \210N\203<	O\354\230\203\355\202\356PP\212Fq\210\357edPQ$\210)\360Q!\204 \361\362!\2028pR\363Q!S\364Q!\210S\2057\364R!))\202\320Fq\210\365edE\307\334\307\366&\210\367\307!\210\370F!\210\371E!\203\306\336\372\373I!\"\203k\374T!\210\375IEKJ$MEpBR\376HUVB%\210\377p!\377J!\230\204\241W\203\241\361\201YJ\"\210\374\201Z!\210X\204\301\201[E!\210\201\\E!\203\301\370E!\210M\202\320\361\201]E\201^#.\207" [oldbuf pyshellname py-execute-directory start end strg py-choose-shell nil (byte-code "\300\301 !\207" [file-name-directory buffer-file-name] 2) ((error)) getenv "WORKON_HOME" "HOME" buffer-substring-no-properties char-to-string py-buffer-name-prepare make-temp-name replace-regexp-in-string regexp-quote "-" "^" "" ":" expand-file-name ".py" get-buffer-create get-buffer-process py-shell t process-buffer string-match "[pP]ython ?3" format "exec(compile(open('%s').read(), '%s', 'exec')) # PYTHON-MODE\n" "execfile(r'%s') # PYTHON-MODE\n" boundp wholebuf erase-buffer py-fix-start py-if-needed-insert-shell prin1-to-string py-insert-coding "[jJ]ython" py-insert-execute-directory "Jython" " -" " -c " shell-command-on-region get-buffer message "No output." py-postprocess-output-buffer pop-to-buffer write-region ask set-buffer-modified-p kill-buffer file-readable-p "ipython" process-name sit-for py-execute-file-base py-shell-manage-windows buffer-name sepchar py-separator-char py-buffer-name temp py-temp-directory file filebuf dedicated switch proc procbuf pec comint-scroll-to-bottom-on-output erg python-mode-v5-behavior-p py-which-bufname cmd py-output-buffer py-exception-buffer err-p py-ipython-execute-delay py-split-windows-on-execute-p py-switch-buffers-on-execute-p py-verbose-p py-execute-keep-temporary-file-p "Output buffer: %s" 0.1 delete-file buffer-live-p "%s not readable. %s" "Do you have write permissions?"] 11 (#$ . 241025)])
#@83 Send the argument STRING to a Python interpreter.

See also `py-execute-region'. 
(defalias 'py-execute-string #[(&optional string shell dedicated) "\206\304\305!	\206\306\307!\310\311!r\nq\210\312\216c\210\313ed	$-\207" [string shell #1=#:temp-buffer dedicated read-from-minibuffer "String: " default-value py-shell-name generate-new-buffer " *temp*" ((byte-code "\301!\203\n\302!\210\301\207" [#1# buffer-name kill-buffer] 2)) py-execute-region] 5 (#$ . 243586) nil])
#@91 Send the argument STRING to an unique Python interpreter.

See also `py-execute-region'. 
(defalias 'py-execute-string-dedicated #[(&optional string shell) "\206\303\304!	\206\305\306!\307\310!r\nq\210\311\216c\210\312ed	\313$-\207" [string shell #1=#:temp-buffer read-from-minibuffer "String: " default-value py-shell-name generate-new-buffer " *temp*" ((byte-code "\301!\203\n\302!\210\301\207" [#1# buffer-name kill-buffer] 2)) py-execute-region t] 5 (#$ . 244075) nil])
(defalias 'py-if-needed-insert-shell #[(&optional name sepchar) "\206\306 \206\307 \206	\n\206\310!\311\312\f\"\203/\f\311\312\f\"T\313O\211\314\fGSOeb\210\212\315 \210\316\317!)\203F`\320 T|\210\2022\316
!?\205\203\311\321\fP\322\"\203k\323\324\325\"\210\326p!\210\316\327!\205\203\330\331!\202\203\311\332\n!\f\"\203|\331\f\333Qc\202\203\312\f\333Rc*\207" [name py-shell-name sepchar py-separator-char erg py-shebang-regexp py-choose-shell-by-shebang py-choose-shell-by-import char-to-string string-match " " nil 0 beginning-of-line looking-at "\\s-*$" line-end-position "^" "ipython" shell-command "type ipython" t switch-to-buffer "[^/\n
]+" replace-match "#! " regexp-quote "\n\n" py-shebang-startstring] 5])
(defalias 'py-insert-execute-directory #[nil "eb\210\302\303\304#\203\305 \210\306	\307Qc\207eb\210\310y\210\305 \210\306	\307Qc\207" [py-encoding-string-re py-execute-directory re-search-forward nil move newline "import os; os.chdir(\"" "\")\n" 2] 4])
(defalias 'py-insert-coding #[nil "eb\210\303\304\305#?\205$eb\210\303	\304\305\306$\203 \307 \210\n\310Pc\207\n\310Pc\207" [py-encoding-string-re py-shebang-regexp py-encoding-string re-search-forward nil t 1 newline "\n"] 5])
#@85 Internal use by py-execute... functions.
Inserts an incentive true form "if 1:\n." 
(defalias 'py-if-needed-insert-if #[nil "\302\303!\302\304!U?\211\205\305c\210	S\211)\207" [needs-if py-line-number-offset py-point bol boi "if 1:\n"] 4 (#$ . 245793)])
#@79 Internal use by py-execute... functions.
Avoid empty lines at the beginning. 
(defalias 'py-fix-start #[(start end) "b\210\304!\212\305 \210\306\307!)\203\310 \311 T|\210\202\312 \210\313 \314=\204-\315\313 \n#\210\316\317\"	)\207" [start beg end py-line-number-offset copy-marker beginning-of-line looking-at "\\s-*$" line-beginning-position line-end-position back-to-indentation current-indentation 0 py-shift-left count-lines 1] 4 (#$ . 246056)])
#@89 Lookup if a `py-master-file' is specified.

See also doku of variable `py-master-file' 
(defalias 'py-fetch-py-master-file #[nil "\212\214~\210eb\210\302\303\304\305\306$\203\302\307\304\310\306$\203\311\312!*	\205+\313 \205+\314\315\"\207" [py-master-file py-verbose-p re-search-forward "^ *# Local Variables:" nil move 1 "^\\( *# py-master-file: *\\)\"\\([^ 	]+\\)\" *$" t match-string-no-properties 2 interactive-p message "%s"] 5 (#$ . 246523) nil])
#@845 Import the current buffer's file in a Python interpreter.

If the file has already been imported, then do reload instead to get
the latest version.

If the file's name does not end in ".py", then do execfile instead.

If the current buffer is not visiting a file, do `py-execute-buffer'
instead.

If the file local variable `py-master-file' is non-nil, import or
reload the named file instead of the buffer's file.  The file may be
saved based on the value of `py-execute-import-or-reload-save-p'.

See also `\[py-execute-region]'.

This may be preferable to `\[py-execute-buffer]' because:

 - Definitions stay in their module rather than appearing at top
   level, where they would clutter the global namespace and not affect
   uses of qualified names (MODULE.NAME).

 - The Python debugger gets line number information about the functions.
(defalias 'py-execute-import-or-reload #[(&optional argprompt shell dedicated) "\203\306!\307	!\206\310	!\211q\210*\206\311\f
#\312p!\203\203\313\314\315\217\206>\316\317\f
\206<\320\321!#!\322 ?\313\"\210\323\324\325\"\203z\326\306!!!\324\327\330!\"\203o\331\332!\211\211$\202v\331\333!\211\211$)\202~\334!#)\202\207\335!*\207" [py-master-file filename buffer shell argprompt dedicated expand-file-name get-file-buffer find-file-noselect py-choose-shell buffer-file-name nil (byte-code "\301\302!!\207" [shell get-process file-name-directory] 3) ((error)) get-buffer-process py-shell default-value py-shell-name save-some-buffers py-execute-file-base string-match "\\.py$" py-qualified-module-name "python2" file-name-nondirectory format "import sys\nif sys.modules.has_key('%s'):\n reload(%s)\nelse:\n import %s\n" "import sys,imp\nif'%s' in sys.modules:\n imp.reload(%s)\nelse:\n import %s\n" py-which-execute-file-command py-execute-buffer file proc py-ask-about-save m] 9 (#$ . 246992) "P"])
#@143 Find the qualified module name for filename FILE.

Basically, this goes down the directory tree as long as there are __init__.py files there.
(defalias 'py-qualified-module-name #[(file) "\302\211\303	!\304\305	!!\")\207" [rec file #[(d f) "\306!\211\307P\310\n!\203!\311!\f\306!\312!\313
Q\")\202\"
*\207" [d dir initpy d2 rec f file-name-directory "__init__.py" file-exists-p directory-file-name file-name-nondirectory "."] 6] file-name-directory file-name-sans-extension file-name-nondirectory] 6 (#$ . 248886)])
#@431 Send the contents of the buffer to a unique Python interpreter.

If the file local variable `py-master-file' is non-nil, execute the
named file instead of the buffer's file.

If a clipping restriction is in effect, only the accessible portion of the buffer is sent. A trailing newline will be supplied if needed.

With \[univeral-argument] user is prompted to specify another then default shell.
See also `\[py-execute-region]'. 
(defalias 'py-execute-buffer-dedicated #[(&optional shell) "\301\302\"\207" [shell py-execute-buffer-base t] 3 (#$ . 249419) "P"])
#@497 Send the contents of the buffer to a Python interpreter and switches to output.

If the file local variable `py-master-file' is non-nil, execute the
named file instead of the buffer's file.
If there is a *Python* process buffer, it is used.
If a clipping restriction is in effect, only the accessible portion of the buffer is sent. A trailing newline will be supplied if needed.

With \[univeral-argument] user is prompted to specify another then default shell.
See also `\[py-execute-region]'. 
(defalias 'py-execute-buffer-switch #[(&optional shell dedicated) "\302	\303#\207" [shell dedicated py-execute-buffer-base switch] 4 (#$ . 249988) "P"])
(defalias 'py-execute-buffer-switch-dedicated 'py-execute-buffer-dedicated-switch)
#@485 Send the contents of the buffer to an unique Python interpreter.

Ignores setting of `py-switch-buffers-on-execute-p'.
If the file local variable `py-master-file' is non-nil, execute the
named file instead of the buffer's file.

If a clipping restriction is in effect, only the accessible portion of the buffer is sent. A trailing newline will be supplied if needed.

With \[univeral-argument] user is prompted to specify another then default shell.
See also `\[py-execute-region]'. 
(defalias 'py-execute-buffer-dedicated-switch #[(&optional shell) "\301\302\303#\207" [shell py-execute-buffer-base t switch] 4 (#$ . 250728) "P"])
#@796 Send the contents of the buffer to a Python interpreter.

When called with \[univeral-argument], execution through `default-value' of `py-shell-name' is forced.
When called with \[univeral-argument] followed by a number different from 4 and 1, user is prompted to specify a shell. This might be the name of a system-wide shell or include the path to a virtual environment.

If the file local variable `py-master-file' is non-nil, execute the
named file instead of the buffer's file.

When called from a programm, it accepts a string specifying a shell which will be forced upon execute as argument.

When called from a programm, it accepts a string specifying a shell which will be forced upon execute as argument.

Optional arguments DEDICATED (boolean) and SWITCH (symbols 'noswitch/'switch) 
(defalias 'py-execute-buffer #[(&optional shell dedicated switch) "\212\306\206\307 \310\211\203$\311!\312\f!\206\313\f!\211q\210*ed\314\n	
%-\207" [py-master-file end beg wholebuf filename buffer t py-fetch-py-master-file nil expand-file-name get-file-buffer find-file-noselect py-execute-region shell dedicated switch] 7 (#$ . 251368) "P"])
#@26 Honor `py-master-file'. 
(defalias 'py-execute-buffer-base #[(&optional shell dedicated switch) "\212\206\306 \211\203\307!\310	!\206\311	!\211q\210*\312ed\f
%*\207" [py-master-file filename buffer shell dedicated switch py-fetch-py-master-file expand-file-name get-file-buffer find-file-noselect py-execute-region] 7 (#$ . 252533)])
#@501 Send the contents of the buffer to a Python interpreter but don't switch to output.

If the file local variable `py-master-file' is non-nil, execute the
named file instead of the buffer's file.
If there is a *Python* process buffer, it is used.
If a clipping restriction is in effect, only the accessible portion of the buffer is sent. A trailing newline will be supplied if needed.

With \[univeral-argument] user is prompted to specify another then default shell.
See also `\[py-execute-region]'. 
(defalias 'py-execute-buffer-no-switch #[(&optional shell dedicated) "\302	\303#\207" [shell dedicated py-execute-buffer-base noswitch] 4 (#$ . 252886) "P"])
#@74 Send the current defun (class or method) to the inferior Python process.
(defalias 'py-execute-defun #[nil "\212\300\301 \210`\302 \210`\")\207" [py-execute-region beginning-of-defun end-of-defun] 3 (#$ . 253551) nil])
#@86 Process "python filename".

Optional OUTPUT-BUFFER and ERROR-BUFFER might be given. 
(defalias 'py-process-file #[(filename &optional output-buffer error-buffer) "\306\211\206	\307\310!\311 \312!\204\313!q\210\314	\315\fQ
#\210\316 \205+\317!,\207" [output-buffer cmd coding-system-for-write coding-system-for-read filename error-buffer utf-8 make-temp-name "py-process-file-output" py-choose-shell buffer-live-p get-buffer-create shell-command " " interactive-p switch-to-buffer] 4 (#$ . 253776) "fDatei:"])
#@46 Execute the region in a Python interpreter. 
(defalias 'py-exec-execfile-region #[(start end &optional shell) "\305!\306=\203\307\310\311\301!\"\202	\312\n\"\313\f\314 #*\207" [shell py-shell-name start end strg prefix-numeric-value 4 read-from-minibuffer "Shell: " default-value buffer-substring-no-properties py-exec-execfile-base interactive-p] 4 (#$ . 254304) "r\nP"])
(defalias 'py-exec-execfile-base #[(strg shell iact) "\306\307 \310P!\311!	\312Q\313 \f\314\211\315\316!rq\210\317\216c\210c\210\f\2042\320 \321 \210\322\f!\210\323e`\"\324p!\210\325\n!\326\n!\210+\327\n
\330P$\210\330Pq\210 \203d\324p!\210\331\n!\203n\332\n!\210 \203x\333\334\"\210\330P.\207" [temp py-temp-directory file imports shell cmd make-temp-name buffer-name "-" expand-file-name ".py" py-find-imports nil generate-new-buffer " *temp*" ((byte-code "\301!\203\n\302!\210\301\207" [#1=#:temp-buffer buffer-name kill-buffer] 2)) py-choose-shell py-insert-coding py-if-needed-insert-shell buffer-substring-no-properties switch-to-buffer py-which-execute-file-command write-file py-exec-execfile "-output" file-readable-p delete-file message "Output goes to buffer: %s" header #1# strg iact] 7])
#@87 Process "python filename",
Optional OUTPUT-BUFFER and ERROR-BUFFER might be given.')

(defalias 'py-exec-execfile #[(filename cmd header &optional output-buffer error-buffer) "\306\211\307\n\310P!\260\311!q\210\fc\210
c\210\312!\210\2039\311!q\210\313 \210\314p!\210\315\316P#\202O\317\320!rq\210\321\216\315\316P#++\207" [coding-system-for-read coding-system-for-write filename exec-execfile header cmd utf-8 make-temp-name "-exec-execfile.py" get-buffer-create write-file erase-buffer switch-to-buffer shell-command "python " generate-new-buffer " *temp*" ((byte-code "\301!\203\n\302!\210\301\207" [#1=#:temp-buffer buffer-name kill-buffer] 2)) output-buffer error-buffer #1#] 5 (#$ . 255528) "fDatei:"])
#@599 Send statement at point to a Python interpreter.

When called with \[univeral-argument], execution through `default-value' of `py-shell-name' is forced.
See also `py-force-py-shell-name-p'.

When called with \[univeral-argument] followed by a number different from 4 and 1, user is prompted to specify a shell. This might be the name of a system-wide shell or include the path to a virtual environment.

When called from a programm, it accepts a string specifying a shell which will be forced upon execute as argument.

Optional arguments DEDICATED (boolean) and SWITCH (symbols 'noswitch/'switch)
(defalias 'py-execute-statement #[(&optional shell dedicated switch) "\212\305 \206\306 \307 \310	\n\f%+\207" [end beg shell dedicated switch py-beginning-of-statement-p py-beginning-of-statement py-end-of-statement py-execute-region] 6 (#$ . 256272) "P"])
#@595 Send block at point to a Python interpreter.

When called with \[univeral-argument], execution through `default-value' of `py-shell-name' is forced.
See also `py-force-py-shell-name-p'.

When called with \[univeral-argument] followed by a number different from 4 and 1, user is prompted to specify a shell. This might be the name of a system-wide shell or include the path to a virtual environment.

When called from a programm, it accepts a string specifying a shell which will be forced upon execute as argument.

Optional arguments DEDICATED (boolean) and SWITCH (symbols 'noswitch/'switch)
(defalias 'py-execute-block #[(&optional shell dedicated switch) "\212\305 \206\306 \307 \310	\n\f%+\207" [end beg shell dedicated switch py-beginning-of-block-p py-beginning-of-block py-end-of-block py-execute-region] 6 (#$ . 257140) "P"])
#@605 Send block-or-clause at point to a Python interpreter.

When called with \[univeral-argument], execution through `default-value' of `py-shell-name' is forced.
See also `py-force-py-shell-name-p'.

When called with \[univeral-argument] followed by a number different from 4 and 1, user is prompted to specify a shell. This might be the name of a system-wide shell or include the path to a virtual environment.

When called from a programm, it accepts a string specifying a shell which will be forced upon execute as argument.

Optional arguments DEDICATED (boolean) and SWITCH (symbols 'noswitch/'switch)
(defalias 'py-execute-block-or-clause #[(&optional shell dedicated switch) "\212\305 \206\306 \307 \310	\n\f%+\207" [end beg shell dedicated switch py-beginning-of-block-or-clause-p py-beginning-of-block-or-clause py-end-of-block-or-clause py-execute-region] 6 (#$ . 257988) "P"])
#@593 Send def at point to a Python interpreter.

When called with \[univeral-argument], execution through `default-value' of `py-shell-name' is forced.
See also `py-force-py-shell-name-p'.

When called with \[univeral-argument] followed by a number different from 4 and 1, user is prompted to specify a shell. This might be the name of a system-wide shell or include the path to a virtual environment.

When called from a programm, it accepts a string specifying a shell which will be forced upon execute as argument.

Optional arguments DEDICATED (boolean) and SWITCH (symbols 'noswitch/'switch)
(defalias 'py-execute-def #[(&optional shell dedicated switch) "\212\305 \206\306 \307 \310	\n\f%+\207" [end beg shell dedicated switch py-beginning-of-def-p py-beginning-of-def py-end-of-def py-execute-region] 6 (#$ . 258886) "P"])
#@595 Send class at point to a Python interpreter.

When called with \[univeral-argument], execution through `default-value' of `py-shell-name' is forced.
See also `py-force-py-shell-name-p'.

When called with \[univeral-argument] followed by a number different from 4 and 1, user is prompted to specify a shell. This might be the name of a system-wide shell or include the path to a virtual environment.

When called from a programm, it accepts a string specifying a shell which will be forced upon execute as argument.

Optional arguments DEDICATED (boolean) and SWITCH (symbols 'noswitch/'switch)
(defalias 'py-execute-class #[(&optional shell dedicated switch) "\212\305 \206\306 \307 \310	\n\f%+\207" [end beg shell dedicated switch py-beginning-of-class-p py-beginning-of-class py-end-of-class py-execute-region] 6 (#$ . 259724) "P"])
#@602 Send def-or-class at point to a Python interpreter.

When called with \[univeral-argument], execution through `default-value' of `py-shell-name' is forced.
See also `py-force-py-shell-name-p'.

When called with \[univeral-argument] followed by a number different from 4 and 1, user is prompted to specify a shell. This might be the name of a system-wide shell or include the path to a virtual environment.

When called from a programm, it accepts a string specifying a shell which will be forced upon execute as argument.

Optional arguments DEDICATED (boolean) and SWITCH (symbols 'noswitch/'switch)
(defalias 'py-execute-def-or-class #[(&optional shell dedicated switch) "\212\305 \206\306 \307 \310	\n\f%+\207" [end beg shell dedicated switch py-beginning-of-def-or-class-p py-beginning-of-def-or-class py-end-of-def-or-class py-execute-region] 6 (#$ . 260572) "P"])
#@600 Send expression at point to a Python interpreter.

When called with \[univeral-argument], execution through `default-value' of `py-shell-name' is forced.
See also `py-force-py-shell-name-p'.

When called with \[univeral-argument] followed by a number different from 4 and 1, user is prompted to specify a shell. This might be the name of a system-wide shell or include the path to a virtual environment.

When called from a programm, it accepts a string specifying a shell which will be forced upon execute as argument.

Optional arguments DEDICATED (boolean) and SWITCH (symbols 'noswitch/'switch)
(defalias 'py-execute-expression #[(&optional shell dedicated switch) "\212\305 \206\306 \307 \310	\n\f%+\207" [end beg shell dedicated switch py-beginning-of-expression-p py-beginning-of-expression py-end-of-expression py-execute-region] 6 (#$ . 261455) "P"])
#@608 Send partial-expression at point to a Python interpreter.

When called with \[univeral-argument], execution through `default-value' of `py-shell-name' is forced.
See also `py-force-py-shell-name-p'.

When called with \[univeral-argument] followed by a number different from 4 and 1, user is prompted to specify a shell. This might be the name of a system-wide shell or include the path to a virtual environment.

When called from a programm, it accepts a string specifying a shell which will be forced upon execute as argument.

Optional arguments DEDICATED (boolean) and SWITCH (symbols 'noswitch/'switch)
(defalias 'py-execute-partial-expression #[(&optional shell dedicated switch) "\212\305 \206\306 \307 \310	\n\f%+\207" [end beg shell dedicated switch py-beginning-of-partial-expression-p py-beginning-of-partial-expression py-end-of-partial-expression py-execute-region] 6 (#$ . 262328) "P"])
#@68 Send current line from beginning of indent to Python interpreter. 
(defalias 'py-execute-line #[nil "\212\301 \210`\302\303 \"*\207" [beg back-to-indentation py-execute-region line-end-position] 3 (#$ . 263240) nil])
#@60 When called interactively, user is prompted for filename. 
(defalias 'py-execute-file #[(&optional filename shell dedicated switch) "p\306	!\206\307\310\311\217\205\312 \206'\313\314!r\fq\210\315\216\316\n!\210\317 +\320
\"(\321\322\307
\2069(\227#!)
\203I\323\324p!!\202R\323\324\325(\325Q!!*\326\327(\"\203d\330\331\n\211#\202h\330\332\n\"+\333,\334\n!\203\275\335)\n+#-\npB.\336=\204\224\337=\204\237/\203\237\340*!\210db\210\202\264\341!\203\251\340!\2100\203\264\342\343*\"\210\344\345!\210-\202\301\342\346\347\".\207" [regbuf filename file shell #1=#:temp-buffer dedicated expand-file-name nil (byte-code "\300\301 !\207" [file-readable-p buffer-file-name] 2) ((error)) buffer-file-name generate-new-buffer " *temp*" ((byte-code "\301!\203\n\302!\210\301\207" [#1# buffer-name kill-buffer] 2)) insert-file-contents py-choose-shell py-process-name get-buffer-process py-shell buffer-name get-buffer "*" string-match "Python3" format "exec(compile(open('%s').read(), '%s', 'exec')) # PYTHON-MODE\n" "execfile(r'%s') # PYTHON-MODE\n" t file-readable-p py-execute-file-base switch noswitch pop-to-buffer buffer-live-p message "Output buffer: %s" sit-for 0.1 "File not readable: %s" "Do you have write permissions?" name proc procbuf pec comint-scroll-to-bottom-on-output erg py-exception-buffer py-switch-buffers-on-execute-p py-verbose-p] 5 (#$ . 263465) "fFile: "])
#@290 Send to Python interpreter process PROC, in Python version 2.. "execfile('FILENAME')".

Make that process's buffer visible and force display.  Also make
comint believe the user typed this string so that
`kill-output-from-shell' does The Right Thing.
Returns position where output starts. 
(defalias 'py-execute-file-base #[(proc filename &optional cmd procbuf) "\206\306	!\307\310\311\n\"\206\f\206\312\n!\313\2033\313\216\212q\210\314	!	\"\210*q\210\315	\"\210\316	!b\211-\207" [procbuf proc filename cmd py-exec-command erg process-buffer t format "## executing %s...\n" py-which-execute-file-command nil process-filter process-send-string process-mark msg comint-scroll-to-bottom-on-output py-verbose-p] 6 (#$ . 264895)])
#@119 Internal use only - when `py-up-exception' is called in
source-buffer, this will deliver the exception-buffer again. 
(defvar py-last-exeption-buffer nil (#$ . 265651))
#@110 Highlight exceptions found in BUF.
If an exception occurred return t, otherwise return nil.  BUF must exist.
(defalias 'py-postprocess-output-buffer #[(buf) "\306\211\211\211\212\fq\210eb\210\307
\306\310#\2033\311\312!\313\311\314!!\315\301!\316\317\320\224\320\225\"\321\322#\210\202)\203I\203I\323 \210\324\n#\210\310,\207" [err-p bol file line buf py-traceback-line-re nil re-search-forward t match-string 1 string-to-number 2 py-point overlay-put make-overlay 0 face highlight beep py-jump-to-exception py-jump-on-exception py-line-number-offset] 4 (#$ . 265827)])
#@42 Jump to the Python code in FILE at LINE.
(defalias 'py-jump-to-exception #[(file line py-line-number-offset) "\306\230\203	:\203	A\2024	\2024	:\203%	@\230\203%	A\2024\307\310\311\217\2064\312\313\314\307\315$!\f\\\316\n!\210
\317=\204F\317 \210eb\210\fSy\210\320\321\f#)\207" [file py-exception-buffer buffer py-line-number-offset line major-mode "<stdin>" nil (find-file-noselect file) ((error)) find-file read-file-name "Exception file: " t pop-to-buffer python-mode message "Jumping to exception in file %s on line %d"] 6 (#$ . 266423)])
#@182 Go to the next line down in the traceback.

With \[univeral-argument] (programmatically, optional argument
BOTTOM), jump to the bottom (innermost) exception in the exception
stack.
(defalias 'py-down-exception #[(&optional bottom) "\301\302\303!\304=\205\305\"\207" [bottom py-find-next-exception-prepare down prefix-numeric-value 4 "BOTTOM"] 4 (#$ . 266989) "P"])
#@178 Go to the previous line up in the traceback.

With \[universal-argument] (programmatically, optional argument TOP)
jump to the top (outermost) exception in the exception stack.
(defalias 'py-up-exception #[(&optional top) "\204p\302\303\304	!\305=\205\306\"\207" [py-last-exeption-buffer top py-find-next-exception-prepare up prefix-numeric-value 4 "TOP"] 4 (#$ . 267364) "P"])
#@63 Setup exception regexps depending from kind of Python shell. 
(defalias 'py-find-next-exception-prepare #[(direction start) "\306\307p!\310\311O!\211\203\307p!\202,\312\313	!!\203	\202,\n\203)\307\n!\202,\314\315!\211\2036\313!q\210\316p!\210\f\317=\203X
\320\230\203O\321\322\323\324$\202m\321\325\326\324$\202m
\327\230\203g\321\330\326\331$\202m\321\332\323\331$*\207" [name py-output-buffer py-last-exeption-buffer buffer direction start get-process buffer-name 1 -1 buffer-live-p get-buffer error "Don't see exeption buffer" switch-to-buffer up "TOP" py-find-next-exception bob re-search-forward "Top" bol re-search-backward "BOTTOM" eob "Bottom" eol] 6 (#$ . 267754)])
#@375 Find the next Python exception and jump to the code that caused it.
START is the buffer position in BUFFER from which to begin searching
for an exception.  SEARCHDIR is a function, either
`re-search-backward' or `re-search-forward' indicating the direction
to search.  ERRWHERE is used in an error message if the limit (top or
bottom) of the trackback stack is encountered.
(defalias 'py-find-next-exception #[(start buffer searchdir errwhere) "`\306 \307\211\211\310
!b\210#$\307\311#\205\352\312 %\313\216\306 *=\203B&\314\230\2033\315\2024\316y\210\317
'#&$\202\352\312 %\320\216\321\322\323\324!\"*\204\342p(\312 %\325\216\321\326\323\324!\"*\203t\323\327!`\330\323\331!!\202\234\212\330\323\316!!`\332\333\307\311\316$\205\232\312 %\334\216\321\335\323\316!\"*?\205\232\323\316!)\n\203\257\321\336\n\"\203\265\n\324\315O\202\265\337\340&\"\210\n\203\332	\203\332\n\341\230\203\321	\316=\203\321\337\340&\"\202\352\342\n	)#\202\352\337\340&\"\202\352\fb\210\337\340&\"-\207" [pos line file origline orig start py-count-lines nil py-point t match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) "Top" -1 1 py-find-next-exception ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) string-match "^IPython\\|^In \\[[0-9]+\\]: *\\|^>>>" match-string-no-properties 0 ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) "File" 2 string-to-number 3 re-search-backward "\\(^IPython\\|^In \\[[0-9]+\\]: *\\|^>>>\\|^[^	 >]+\\)>?[ 	]+in[ 	]+\\([^ 	\n]+\\)" ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) "<\\|^IPython\\|^In \\[[0-9]+\\]: *\\|^>>>" ".+.pyc" error "%s of traceback" "<stdin>" py-jump-to-exception searchdir py-traceback-line-re save-match-data-internal errwhere buffer py-last-exeption-buffer py-line-number-offset] 5 (#$ . 268458)])
#@54 Clear output buffer from py-shell-input prompt etc. 
(defalias 'py-output-buffer-filter #[(&optional beg end) "\206\304 \203\305 \202e	\203\306	!\202(\304 \203%\306\307 !\202(\306d!\211b\210\310\311\n\312\312\313\314\260\315\316\317$\203E\320\321!\210\202-b*\207" [beg end py-shell-input-prompt-1-regexp py-shell-input-prompt-2-regexp region-active-p region-beginning copy-marker region-end re-search-forward "\\(" "\\|" "^In \\[[0-9]+\\]: *" "\\)" nil move 1 replace-match ""] 9 (#$ . 270405) "*"])
#@45 Evaluate STRING in inferior Python process.
(defalias 'py-send-string #[(string &optional process) "\206\303 \304	\n\"\210\305\306\n\"\204\304	\307\"\210\305\310\n\"\205#\304	\307\")\207" [process proc string py-shell comint-send-string string-match "\n\\'" "\n" "\n[ 	].*\n?\\'"] 3 (#$ . 270930) "sPython command: "])
#@62 Activate or de arrow at beginning-of-line in current buffer.
(defalias 'py-pdbtrack-overlay-arrow #[(activation) "\203\304 \305	\306 p\223\210\307\211\207	\205\310\211\211\207" [activation overlay-arrow-position overlay-arrow-string py-pdbtrack-is-tracking-p make-marker "=>" line-beginning-position t nil] 4 (#$ . 271262)])
#@655 Show the file indicated by the pdb stack entry line, in a separate window.

Activity is disabled if the buffer-local variable
`py-pdbtrack-do-tracking-p' is nil.

We depend on the pdb input prompt matching `py-pdbtrack-input-prompt'
at the beginning of the line.

If the traceback target file path is invalid, we look for the most
recently visited python-mode buffer which either has the name of the
current function (or class) or which defines the function (or
class).  This is to provide for remote scripts, eg, Zope's 'Script
(Python)' - put a _copy_ of the script in a buffer named for the
script, and set to python-mode, and pdbtrack will find it.)
(defalias 'py-pdbtrack-track-stack-file #[(text) "p\306!\211\203\n\204\307\310!\202\205\311	!\f
Z]{\310\211\310\211\312\313P\"\204>\307\310!\202\203\314!\211;\203Q\315\316\"\202\203@\211A@)\317!\320!\210eb\210Sy\210\315\321#\210\307\322!\210\323\322\".*\207" [origbuf currproc py-pdbtrack-do-tracking-p procmark comint-last-input-end py-pdbtrack-track-range get-buffer-process py-pdbtrack-overlay-arrow nil process-mark string-match "$" py-pdbtrack-get-source-buffer message "pdbtrack: %s" buffer-file-name switch-to-buffer-other-window "pdbtrack: line %s, file %s" t pop-to-buffer block target target_fname target_lineno target_buffer py-pdbtrack-input-prompt x] 5 (#$ . 271604)])
(defalias 'py-pdbtrack-map-filename #[(filename) "\303	\304#\211\305=\204\306\n\307\211$\202)\207" [filename py-pdbtrack-filename-mapping replacement-val assoc-default #[(mapkey path) "\302\303\304!P	\"\207" [mapkey path string-match "^" regexp-quote] 4] nil replace-match t] 6])
#@363 Return line number and buffer of code indicated by block's traceback text.

We look first to visit the file indicated in the trace.

Failing that, we look for the most recently visited python-mode buffer
with the same name or having the named function.

If we're unable find the source code we return a string describing the
problem as best as we can determine.
(defalias 'py-pdbtrack-get-source-buffer #[(block) "\306	\"\204	\307\207\310\n	\"\311\310\f	\"!\310	\"\312\313!\203-
\314!D\202\201\313\315!!\203?
\314\315!!D\202\201\316
\"\211\203l\306\317\"\203e
\212q\210\320ee\306\321ed{\"]\")\\
D\202\201\322\234\323U\203{\324\325\"\202\201\324\326#,\207" [py-pdbtrack-stack-entry-regexp block py-pdbtrack-marker-regexp-file-group filename py-pdbtrack-marker-regexp-line-group lineno string-match "Traceback cue not found" match-string string-to-number nil file-exists-p find-file-noselect py-pdbtrack-map-filename py-pdbtrack-grub-for-buffer "/Script (Python)$" count-lines "^\\([^#]\\|#[^#]\\|#$\\)" 0 60 format "(Non-file source: '%s')" "Not found: %s(), %s" py-pdbtrack-marker-regexp-funcname-group funcname funcbuffer] 8 (#$ . 273295)])
#@183 Find most recent buffer itself named or having function funcname.

We walk the buffer-list history for python-mode buffers that are
named for funcname or define a function funcname.
(defalias 'py-pdbtrack-grub-for-buffer #[(funcname lineno) "\305 \306\211\n\203?\204?\n@\nA\212	q\210\307\230)\203\310\f\311	!\"\204:\310\312\f\313Q\212	q\210ed{)\"\203	\202+\207" [got buf buffers major-mode funcname buffer-list nil "python-mode" string-match buffer-name "^\\s-*\\(def\\|class\\)\\s-+" "\\s-*("] 4 (#$ . 274482)])
#@44 Set variable `py-pdbtrack-do-tracking-p'. 
(defalias 'py-pdbtrack-toggle-stack-tracking #[(arg) "\302p!\204\303\304p\"\210\203\305\306!\211!\203	?\202#\307V\310\311	\203-\312\202.\313\"\207" [arg py-pdbtrack-do-tracking-p get-buffer-process error "No process associated with buffer '%s'" zerop prefix-numeric-value 0 message "%sabled Python's pdbtrack" "En" "Dis"] 3 (#$ . 275019) "P"])
(defalias 'turn-on-pdbtrack #[nil "\300\301!\207" [py-pdbtrack-toggle-stack-tracking 1] 2 nil nil])
(defalias 'turn-off-pdbtrack #[nil "\300\301!\207" [py-pdbtrack-toggle-stack-tracking 0] 2 nil nil])
#@124 Lookup in current buffer for the doku for the symbol at point.

Useful for newly defined symbol, not known to python yet. 
(defalias 'py-fetch-docu #[nil "\305\306 !\307 \310\214~\210eb\210\311\312Q\310\313\314$\205N\314y\210\315\316!\205N\317\225b\210\320\317\224\311\321\310\313#\"\211\205N\322\323!q\210\324 \210\f\203L\325 \203L\326p!\210\nc,\207" [symb args erg py-def-or-class-re py-verbose-p prin1-to-string symbol-at-point py-expression nil re-search-forward " *" move 1 looking-at "[ 	]*\"\"\"\\|[ 	]*'''\\|[ 	]*'[^]+\\|[ 	]*\"[^\"]+" 0 buffer-substring-no-properties "\"\"\"\\|'''" get-buffer-create "*Python-Help*" erase-buffer interactive-p switch-to-buffer] 7 (#$ . 275629) nil])
#@52 Find top-level imports, updating `python-imports'.
(defalias 'py-find-imports #[nil "\302\212eb\210\303\304\302\305#\203\306\307\224\307\225\"\310Q\202)	\203*\311 \203*\312\313\"\210)\207" [imports py-verbose-p nil re-search-forward "^import *[A-Za-z_][A-Za-z_0-9].*\\|^from +[A-Za-z_][A-Za-z_0-9]+ +import .*" t buffer-substring-no-properties 0 ";" interactive-p message "%s"] 4 (#$ . 276339) nil])
#@33 Print help on symbol at point. 
(defalias 'py-eldoc-function #[nil "\306\307!\204\245\310`\311\"\312=\204*\310`\311\"\313=\204*\310`\311\"\314=\204*\310`\311\"\315=\203\245\316\317 !\320 \321\322 !\323\302J\"\324P\325 \212\326\327x\210\306\330!\205S\331\332\333\334!\")\335\305JP\336J\203k\305J\337\300J\340R\202s\305J\341\300J\342R\305J\343\300J\344R\345\346!.r.q\210\347\216\305Jc\210\350\304J!\210+\351\304J\352\"\210\353\304J!\205\242\354\304J!.\207\355 \207" [#1=#:--cl-sym-- #2=#:--cl-origfile-- #3=#:--cl-temp-- py-temp-directory #4=#:--cl-file-- #5=#:--cl-cmd-- looking-at " " get-char-property face font-lock-keyword-face py-builtins-face py-exception-name-face py-class-name-face prin1-to-string symbol-at-point buffer-file-name make-temp-name buffer-name expand-file-name ".py" py-find-imports "A-Za-z_0-9." nil "[A-Za-z_0-9.]+" string-match "\\." match-string-no-properties 0 "import pydoc\n" #6=#:--cl-no-quotes-- "try: pydoc.help(" ")\n" "try: pydoc.help('" "')\n" "except:\n    print 'No help available on:', \"" "\"" generate-new-buffer " *temp*" ((byte-code "\301!\203\n\302!\210\301\207" [#7=#:temp-buffer buffer-name kill-buffer] 2)) write-file py-process-file "*Python-Help*" file-readable-p delete-file delete-other-windows #7#] 4 (#$ . 276756) nil])
(defalias 'py-help-at-point 'py-describe-symbol)
#@121 Print help on symbol at point.

Optional \[universal-argument] used for debugging, will prevent deletion of temp file. 
(defalias 'py-describe-symbol #[(&optional arg) "`\306\307!\203\310\311!\204\312u\210\313\314 x\210`\313\315 w\210`\316	\n\"\317 \320\321 !\322
\"\"\323P#\324 $b\210\325$P\211$\326\327R$\330\331!%r%q\210\332\216$c\210\333#!\210+\334#\335\"\210\336#!\205z\337&!\340=?\205z\341#!.\207" [orig beg end sym origfile temp looking-back "(" looking-at "\\sw" -1 "a-zA-Z0-9_." line-beginning-position line-end-position buffer-substring-no-properties buffer-file-name make-temp-name buffer-name expand-file-name ".py" py-find-imports "import pydoc\n" "pydoc.help('" "')\n" generate-new-buffer " *temp*" ((byte-code "\301!\203\n\302!\210\301\207" [#1=#:temp-buffer buffer-name kill-buffer] 2)) write-file py-process-file "*Python-Help*" file-readable-p prefix-numeric-value 4 delete-file py-temp-directory file cmd #1# arg] 5 (#$ . 278111) "P"])
(defalias 'py-dump-help-string #[(str) "r\306\307!q\210p\310 \210	\311\211\312\211\312/\313 \210\314\315!\210+\21101\316 \311\211\211\211\317\311\211\21123456789:\320\321;5#\203\364\317\2244\317\2253;\322\224\322\225O9;\323\224\323\225O8\3248!7\325\326;54O!!\2109\327\232\203\226\3307!6\331\332\333\3347<\"\335#P2\202\3179\336\232\203\311\3377\340\"67:\236\203\275\341\3427J!\343\342\3447!!R\202\304\345\3427J!P2\202\317\346\3479\"\210\325\350\3519\327\232\203\335\352\202\336\35382$!\210\3256!\210\354 \21035\202B\325\326;5\311O!!\210.	\355 \3560!\210+\207" [default-directory #1=#:old-dir buffer-read-only buffer-file-name buffer-undo-list inhibit-modification-hooks get-buffer-create "*Help*" kill-all-local-variables nil t erase-buffer run-hooks temp-buffer-setup-hook buffer-local-variables 0 string-match "^%\\([vc]\\):\\(.+\\)\n" 1 2 intern princ substitute-command-keys "c" documentation "Key(s): " mapconcat key-description where-is-internal ", " "v" documentation-property variable-documentation "Local/Global values: " prin1-to-string " / " default-value "Value: " error "Error in py-dump-help-string, tag `%s'" format "\n-> %s:	%s	%s\n\n" "Command" "Variable" terpri help-print-return-message internal-temp-output-buffer-show inhibit-read-only #2=#:buf standard-output keys end mstart start funcdoc func funcname funckind locals str python-mode-map] 10])
(add-hook 'python-mode-hook #[nil "\304\302!\210\305\304\303!\210\306\211\207" [py-indent-tabs-mode indent-tabs-mode beginning-of-defun-function end-of-defun-function make-local-variable py-beginning-of-def-or-class py-end-of-def-or-class] 2])
#@39 Dump long form of `python-mode' docs.
(defalias 'py-describe-mode #[nil "\300\301!\207" [py-dump-help-string "Major mode for editing Python files.\nKnows about Python indentation, tokens, comments and continuation lines.\nParagraphs are separated by blank lines only.\n\nMajor sections below begin with the string `@'; specific function and\nvariable docs begin with `->'.\n\n@EXECUTING PYTHON CODE\n\n\\[py-execute-import-or-reload]	imports or reloads the file in the Python interpreter\n\\[py-execute-buffer]	sends the entire buffer to the Python interpreter\n\\[py-execute-region]	sends the current region\n\\[py-execute-def-or-class]	sends the current function or class definition\n\\[py-execute-string]	sends an arbitrary string\n\\[py-shell]	starts a Python interpreter window; this will be used by\n	subsequent Python execution commands\n%c:py-execute-import-or-reload\n%c:py-execute-buffer\n%c:py-execute-region\n%c:py-execute-def-or-class\n%c:py-execute-string\n%c:py-shell\n\n@VARIABLES\n\npy-install-directory	wherefrom `python-mode' looks for extensions\npy-indent-offset	indentation increment\npy-block-comment-prefix	comment string used by comment-region\n\npy-shell-name	shell command to invoke Python interpreter\npy-temp-directory	directory used for temp files (if needed)\n\npy-beep-if-tab-change	ring the bell if tab-width is changed\n%v:py-install-directory\n%v:py-indent-offset\n%v:py-block-comment-prefix\n%v:py-shell-name\n%v:py-temp-directory\n%v:py-beep-if-tab-change\n\n@KINDS OF LINES\n\nEach physical line in the file is either a `continuation line' (the\npreceding line ends with a backslash that's not part of a comment, or\nthe paren/bracket/brace nesting level at the start of the line is\nnon-zero, or both) or an `initial line' (everything else).\n\nAn initial line is in turn a `blank line' (contains nothing except\npossibly blanks or tabs), a `comment line' (leftmost non-blank\ncharacter is `#'), or a `code line' (everything else).\n\nComment Lines\n\nAlthough all comment lines are treated alike by Python, Python mode\nrecognizes two kinds that act differently with respect to indentation.\n\nAn `indenting comment line' is a comment line with a blank, tab or\nnothing after the initial `#'.  The indentation commands (see below)\ntreat these exactly as if they were code lines: a line following an\nindenting comment line will be indented like the comment line.  All\nother comment lines (those with a non-whitespace character immediately\nfollowing the initial `#') are `non-indenting comment lines', and\ntheir indentation is ignored by the indentation commands.\n\nIndenting comment lines are by far the usual case, and should be used\nwhenever possible.  Non-indenting comment lines are useful in cases\nlike these:\n\n	a = b # a very wordy single-line comment that ends up being\n	 #... continued onto another line\n\n	if a == b:\n##		print 'panic!' # old code we've `commented out'\n		return a\n\nSince the `#...' and `##' comment lines have a non-whitespace\ncharacter following the initial `#', Python mode ignores them when\ncomputing the proper indentation for the next line.\n\nContinuation Lines and Statements\n\nThe `python-mode' commands generally work on statements instead of on\nindividual lines, where a `statement' is a comment or blank line, or a\ncode line and all of its following continuation lines (if any)\nconsidered as a single logical unit.  The commands in this mode\ngenerally (when it makes sense) automatically move to the start of the\nstatement containing point, even if point happens to be in the middle\nof some continuation line.\n\n@INDENTATION\n\nPrimarily for entering new code:\n	\\[indent-for-tab-command]	 indent line appropriately\n	\\[py-newline-and-indent]	 insert newline, then indent\n	\\[py-electric-backspace]	 reduce indentation, or delete single character\n\nPrimarily for reindenting existing code:\n	\\[py-guess-indent-offset]	 guess py-indent-offset from file content; change locally\n	\\[universal-argument] \\[py-guess-indent-offset]	 ditto, but change globally\n\n	\\[py-indent-region]	 reindent region to match its context\n	\\[py-shift-left]	 shift line or region left by py-indent-offset\n	\\[py-shift-right]	 shift line or region right by py-indent-offset\n\nUnlike most programming languages, Python uses indentation, and only\nindentation, to specify block structure.  Hence the indentation supplied\nautomatically by `python-mode' is just an educated guess:  only you know\nthe block structure you intend, so only you can supply correct\nindentation.\n\nThe \\[indent-for-tab-command] and \\[py-newline-and-indent] keys try to suggest plausible indentation, based on\nthe indentation of preceding statements.  E.g., assuming\npy-indent-offset is 4, after you enter\n	if a > 0: \\[py-newline-and-indent]\nthe cursor will be moved to the position of the `_' (_ is not a\ncharacter in the file, it's just used here to indicate the location of\nthe cursor):\n	if a > 0:\n	 _\nIf you then enter `c = d' \\[py-newline-and-indent], the cursor will move\nto\n	if a > 0:\n	 c = d\n	 _\n`python-mode' cannot know whether that's what you intended, or whether\n	if a > 0:\n	 c = d\n	_\nwas your intent.  In general, `python-mode' either reproduces the\nindentation of the (closest code or indenting-comment) preceding\nstatement, or adds an extra py-indent-offset blanks if the preceding\nstatement has `:' as its last significant (non-whitespace and non-\ncomment) character.  If the suggested indentation is too much, use\n\\[py-electric-backspace] to reduce it.\n\nContinuation lines are given extra indentation.  If you don't like the\nsuggested indentation, change it to something you do like, and Python-\nmode will strive to indent later lines of the statement in the same way.\n\nIf a line is a continuation line by virtue of being in an unclosed\nparen/bracket/brace structure (`list', for short), the suggested\nindentation depends on whether the current line contains the first item\nin the list.  If it does, it's indented py-indent-offset columns beyond\nthe indentation of the line containing the open bracket.  If you don't\nlike that, change it by hand.  The remaining items in the list will mimic\nwhatever indentation you give to the first item.\n\nIf a line is a continuation line because the line preceding it ends with\na backslash, the third and following lines of the statement inherit their\nindentation from the line preceding them.  The indentation of the second\nline in the statement depends on the form of the first (base) line:  if\nthe base line is an assignment statement with anything more interesting\nthan the backslash following the leftmost assigning `=', the second line\nis indented two columns beyond that `='.  Else it's indented to two\ncolumns beyond the leftmost solid chunk of non-whitespace characters on\nthe base line.\n\nWarning:  indent-region should not normally be used!  It calls \\[indent-for-tab-command]\nrepeatedly, and as explained above, \\[indent-for-tab-command] can't guess the block\nstructure you intend.\n%c:indent-for-tab-command\n%c:py-newline-and-indent\n%c:py-electric-backspace\n\nThe next function may be handy when editing code you didn't write:\n%c:py-guess-indent-offset\n\nThe remaining `indent' functions apply to a region of Python code.  They\nassume the block structure (equals indentation, in Python) of the region\nis correct, and alter the indentation in various ways while preserving\nthe block structure:\n%c:py-indent-region\n%c:py-shift-left\n%c:py-shift-right\n\n@MARKING & MANIPULATING REGIONS OF CODE\n\n\\[py-mark-block]	 mark block of lines\n\\[py-mark-def-or-class]	 mark smallest enclosing def\n\\[universal-argument] \\[py-mark-def-or-class]	 mark smallest enclosing class\n\\[comment-region]	 comment out region of code\n\\[universal-argument] \\[comment-region]	 uncomment region of code\n%c:py-mark-block\n%c:py-mark-def-or-class\n%c:comment-region\n\n@MOVING POINT\n\n\\[py-previous-statement]	 move to statement preceding point\n\\[py-next-statement]	 move to statement following point\n\\[py-goto-block-up]	 move up to start of current block\n\\[py-beginning-of-def-or-class]	 move to start of def\n\\[universal-argument] \\[py-beginning-of-def-or-class]	 move to start of class\n\\[py-end-of-def-or-class]	 move to end of def\n\\[universal-argument] \\[py-end-of-def-or-class]	 move to end of class\n\nThe first two move to one statement beyond the statement that contains\npoint.  A numeric prefix argument tells them to move that many\nstatements instead.  Blank lines, comment lines, and continuation lines\ndo not count as `statements' for these commands.  So, e.g., you can go\nto the first code statement in a file by entering\n	\\[beginning-of-buffer]	 to move to the top of the file\n	\\[py-next-statement]	 to skip over initial comments and blank lines\nOr do `\\[py-previous-statement]' with a huge prefix argument.\n%c:py-previous-statement\n%c:py-next-statement\n%c:py-goto-block-up\n%c:py-beginning-of-def-or-class\n%c:py-end-of-def-or-class\n\n@LITTLE-KNOWN EMACS COMMANDS PARTICULARLY USEFUL IN PYTHON MODE\n\n`\\[indent-new-comment-line]' is handy for entering a multi-line comment.\n\n`\\[set-selective-display]' with a `small' prefix arg is ideally suited for viewing the\noverall class and def structure of a module.\n\n`\\[back-to-indentation]' moves point to a line's first non-blank character.\n\n`\\[indent-relative]' is handy for creating odd indentation.\n\n@OTHER EMACS HINTS\n\nIf you don't like the default value of a variable, change its value to\nwhatever you do like by putting a `setq' line in your .emacs file.\nE.g., to set the indentation increment to 4, put this line in your\n.emacs:\n	(setq py-indent-offset 4)\nTo see the value of a variable, do `\\[describe-variable]' and enter the variable\nname at the prompt.\n\nWhen entering a key sequence like `C-c C-n', it is not necessary to\nrelease the CONTROL key after doing the `C-c' part -- it suffices to\npress the CONTROL key, press and release `c' (while still holding down\nCONTROL), press and release `n' (while still holding down CONTROL), &\nthen release CONTROL.\n\nEntering Python mode calls with no arguments the value of the variable\n`python-mode-hook', if that value exists and is not nil; for backward\ncompatibility it also tries `py-mode-hook'; see the `Hooks' section of\nthe Elisp manual for details.\n\nObscure:  When python-mode is first loaded, it looks for all bindings\nto newline-and-indent in the global keymap, and shadows them with\nlocal bindings to py-newline-and-indent."] 2 (#$ . 280786) nil])
(byte-code "\300\301!\203\301\302\303\304\305\306\307&\210\300\207" [fboundp info-lookup-maybe-add-help :mode python-mode :regexp "[a-zA-Z0-9_]+" :doc-spec (("(python-lib)Module Index") ("(python-lib)Class-Exception-Object Index") ("(python-lib)Function-Method-Variable Index") ("(python-lib)Miscellaneous Index"))] 7)
#@64 Data from last `_emacs_out' line seen by the preoutput filter.
(defvar python-preoutput-result nil (#$ . 291725))
#@177 Send STRING to inferior Python (if any) and return result.

The result is what follows `_emacs_out' in the output.
This is a no-op if `python-check-comint-prompt' returns nil.
(defalias 'py-send-receive #[(string) "\303!\210\304 r\305	!q\210\306	!\205#\307\302!\210\310\311	\312\"\210\n\313\302!\210*\207" [string proc python-preoutput-result python-shell-send-string-no-output py-proc process-buffer python-check-comint-prompt make-local-variable nil accept-process-output 5 kill-local-variable] 3 (#$ . 291846)])
#@78 Find source of definition of function NAME.

Interactively, prompt for name.
(defalias 'py-find-function #[(name) "\204\305\306!\210\307\310\311	#!\312\n!@\211@\nA\204$\305\313	\"\210\314\315!!\210\f\250\2055eb\210\fSy,\207" [python-imports name loc file line error "Not called from buffer visiting Python file" py-send-receive format "emacs.location_of (%S, %s)" read-from-string "Don't know where `%s' is defined" pop-to-buffer find-file-noselect] 6 (#$ . 292371) (let ((symbol (let ((#1=#:table (syntax-table)) (#2=#:buffer (current-buffer))) (unwind-protect (progn (set-syntax-table py-dotted-expression-syntax-table) (current-word)) (save-current-buffer (set-buffer #2#) (set-syntax-table #1#))))) (enable-recursive-minibuffers t)) (list (read-string (if symbol (format "Find location of (default %s): " symbol) "Find location of: ") nil nil symbol)))])
#@75 Returns `python-imports'.

Imports done are displayed in message buffer. 
(defalias 'py-update-imports #[nil "\212p`\305\306\307\310\311\312 !@\313\314#\"\210\311!@\nq\210	b\210\315 \2031\316p!\210\f\2031\317\320\"\210,\207" [erg orig oldbuf python-imports py-verbose-p nil mapc py-execute-string split-string read-from-string py-find-imports "\n" t interactive-p switch-to-buffer message "%s"] 6 (#$ . 293248) nil])
#@271 Indent and move one line forward to next indentation.
Returns column of line reached.

If `py-kill-empty-line' is non-nil, delete an empty line.
When closing a form, use py-close-block et al, which will move and indent likewise.
With \[universal argument] just indent.

(defalias 'py-indent-forward-line #[(&optional arg) "`\306m\204N\307 \203\n\204\310y\210\202N\311 \210\312!\313=\204Nm\203,\314 \210\202N\310y\210\f\203N\212\315 \210\316\317!)\203N\316\320!\204Nm\204N\321 \322 |\210\323 \210\312!\313=\204_	`W\203ai
\203o\324 \203o\325\326\"\210*\207" [erg orig py-indent-comments arg py-kill-empty-line py-verbose-p nil py-in-comment-p 1 py-indent-line-outmost prefix-numeric-value 4 newline beginning-of-line looking-at "\\s-*$" "[ 	]*\n[[:alpha:]]" line-beginning-position line-end-position back-to-indentation interactive-p message "%s"] 3 (#$ . 293681) "*P"])
#@41 Dedent line and move one line forward. 
(defalias 'py-dedent-forward-line #[(&optional arg) "\301!\210\302y\210\303\210\304\303x\207" [arg py-dedent 1 nil " 	
\n\f"] 2 (#$ . 294580) "*p"])
#@244 Dedent line according to `py-indent-offset'.

With arg, do it that many times.
If point is between indent levels, dedent to next level.
Return indentation reached, if dedent done, nil otherwise.

Affected by `py-dedent-keep-relative-column'. 
(defalias 'py-dedent #[(&optional arg) "\306`!\307\n\310\fW\203D\311 \211\246
\245_\312 \210\313 \210\310W\2036j\210\202<
Zj\210+T\211\202*`	W\203Mi\203X	b\210\202_\307\210\314\307x\210\203n\315 \203n\316\317\"\210*\207" [erg orig arg i #1=#:--cl-dotimes-temp-- cui copy-marker nil 0 current-indentation beginning-of-line fixup-whitespace " 	
\n\f" interactive-p message "%s" py-indent-offset remain indent py-dedent-keep-relative-column py-verbose-p] 4 (#$ . 294778) "*p"])
#@37 Core function, internal used only. 
(defalias 'py-close-intern #[(regexp) "\303\304\305\217\306	`\"\210\307y\210\n\203\"\212\310 \210\311\312!)\204%\313 \210\202%\314 \210j\210)\207" [cui regexp py-close-provides-newline nil (byte-code "\301!@\207" [regexp py-go-to-keyword] 2) ((error)) py-end-base 1 beginning-of-line looking-at "\\s-*$" split-line fixup-whitespace] 3 (#$ . 295544)])
#@156 Set indent level to that of beginning of function definition.

If final line isn't empty and `py-close-block-provides-newline' non-nil, insert a newline. 
(defalias 'py-close-def #[nil "\303!\n\203\304 \203\305\306	\"\210	)\207" [py-def-re erg py-verbose-p py-close-intern interactive-p message "%s"] 3 (#$ . 295945) "*"])
#@153 Set indent level to that of beginning of class definition.

If final line isn't empty and `py-close-block-provides-newline' non-nil, insert a newline. 
(defalias 'py-close-class #[nil "\303!\n\203\304 \203\305\306	\"\210	)\207" [py-class-re erg py-verbose-p py-close-intern interactive-p message "%s"] 3 (#$ . 296281) "*"])
#@154 Set indent level to that of beginning of clause definition.

If final line isn't empty and `py-close-block-provides-newline' non-nil, insert a newline. 
(defalias 'py-close-clause #[nil "\303!\n\203\304 \203\305\306	\"\210	)\207" [py-clause-re erg py-verbose-p py-close-intern interactive-p message "%s"] 3 (#$ . 296618) "*"])
#@153 Set indent level to that of beginning of block definition.

If final line isn't empty and `py-close-block-provides-newline' non-nil, insert a newline. 
(defalias 'py-close-block #[nil "\303!\n\203\304 \203\305\306	\"\210	)\207" [py-block-re erg py-verbose-p py-close-intern interactive-p message "%s"] 3 (#$ . 296958) "*"])
#@96 Return class definition as string.

With interactive call, send it to the message buffer too. 
(defalias 'py-class-at-point #[nil "\212\304 \305 \247\205	\247\205	W\205\306	\"\203*\307 \203*\310\311\n\"\210\n,\207" [beg end res py-verbose-p py-beginning-of-class py-end-of-class buffer-substring-no-properties interactive-p message "%s"] 3 (#$ . 297294) nil])
#@85 Return line as string.
  With interactive call, send it to the message buffer too. 
(defalias 'py-line-at-point #[nil "\304 \305 \247\205	\247\205	W\205\306	\"\203)\307 \203)\310\311\n\"\210\n+\207" [beg end res py-verbose-p line-beginning-position line-end-position buffer-substring-no-properties interactive-p message "%s"] 3 (#$ . 297675) nil])
#@52 If looking at a python keyword. Returns t or nil. 
(defalias 'py-looking-at-keywords-p #[nil "\304\211\305!!A@@\306\304\211\307!!8@\310!\206\310	!\203*\311 \203*\312\313\n\"\210\n+\207" [kwds1 kwds3 res py-verbose-p eval (car font-lock-defaults) 3 (car font-lock-defaults) looking-at interactive-p message "looking-at keywords: %s"] 4 (#$ . 298044) nil])
#@32 py-match-paren-mode nil oder t
(defalias 'py-match-paren-mode #[(&optional arg) "\302!\303=\204\f	\204\304\211\207\305\211\207" [arg py-match-paren-mode prefix-numeric-value 4 t nil] 2 (#$ . 298414) "P"])
#@149 Goto to the opening or closing of block before or after point.

With arg, do it that many times.
 Closes unclosed block if jumping from beginning. 
(defalias 'py-match-paren #[nil "i\302 \303 \210	\302 W\203	b\202\304 \210`	=\205\305 *\207" [cid cuc current-indentation py-beginning-of-block-or-clause back-to-indentation py-end-of-block] 2 (#$ . 298632) nil])
#@110 Regexp indicating which chars shall be stripped before STRING - which is defined by `string-chars-preserve'.
(custom-declare-variable 'strip-chars-before '"[ 	
\n]*" '(#$ . 299008) :type 'string :group 'convenience)
#@109 Regexp indicating which chars shall be stripped after STRING - which is defined by `string-chars-preserve'.
(custom-declare-variable 'strip-chars-after '"[ 	
\n]*\\'" '(#$ . 299231) :type 'string :group 'convenience)
#@112 Chars preserved of STRING.
`strip-chars-after' and
`strip-chars-before' indicate what class of chars to strip.
(custom-declare-variable 'string-chars-preserve '"\\(.*?\\)" '(#$ . 299455) :type 'string :group 'convenience)
#@228 Return a copy of STR, CHARS removed.
`CHARS-BEFORE' and `CHARS-AFTER' default is "[ 	
]*",
i.e. spaces, tabs, carriage returns, newlines and newpages.
`CHARS-PRESERVE' must be a parentized expression,
it defaults to "\(.*?\)"
(defalias 'string-strip #[(str &optional chars-before chars-after chars-preserve) "\206	\n\206\n\f\206

\306\307\310
\311\312\260\"\210\313\314\"+\207" [chars-before strip-chars-before chars-after strip-chars-after chars-preserve string-chars-preserve string-match "\\`[" "]*" "[" "]*\\'" match-string 1 s-c-p s-c-a s-c-b str] 8 (#$ . 299684)])
(defalias 'druck 'py-printform-insert)
#@107 Inserts a print statement out of current `(car kill-ring)' by default, inserts ARG instead if delivered. 
(defalias 'py-printform-insert #[(&optional arg) "\305\206	@!\306=\204\307=\205\310\n\311\nR\211c*\207" [arg kill-ring name major-mode form string-strip python-mode inferior-python-mode "print \"" ": %s \" % "] 5 (#$ . 300324) "*"])
#@35 Launch PyDOC on the Word at Point
(defalias 'py-documentation #[(w) "\302\303	\304R\305\"\210\306\305\307\310#\207" [py-shell-name w shell-command " -c \"from pydoc import help;help('" "')\"" "*PYDOCS*" view-buffer-other-window t kill-buffer-and-window] 5 (#$ . 300680) (list (let* ((word (thing-at-point 'word)) (input (read-string (format "pydoc entry%s: " (if (not word) #1="" (format " (default %s)" word)))))) (if (string= input #1#) (if (not word) (error "No pydoc args given") word) input)))])
#@49 Put "eval(...)" forms around strings at point. 
(defalias 'eva #[nil "\303\304w\210\305 \211@A\211b\210\306c\210	b\210\307c+\207" [bounds beg end " 	
\n\f" nil ar-bounds-of-word-atpt ")" "eval("] 3 (#$ . 301188) "*"])
#@58 Kill previous "pdb.set_trace()" and insert it at point. 
(defalias 'pst-here #[nil "\301`!\302\303!\210\304\305!\210\212\306 \210\307\310!)\203\311 \312 |\210b\210\303c)\207" [orig copy-marker search-backward "pdb.set_trace()" replace-match "" beginning-of-line looking-at "\\s-*$" line-beginning-position line-end-position] 2 (#$ . 301416) "*"])
#@55 Transforms the item on current in a print statement. 
(defalias 'py-line-to-printform-python2 #[(&optional arg) "\303\304!	\305=\204	\306=\205\307\310R\311 \312 |\210\nc\210*\313y\210\314 \207" [name major-mode form thing-at-point word python-mode inferior-python-mode "print \"" ": %s \" % " line-beginning-position line-end-position 1 back-to-indentation] 4 (#$ . 301773) "*"])
#@59 Regexp for Python classes for use with the Imenu package.
(defvar py-imenu-class-regexp "\\(^[ 	]*\\(class[ 	]+[a-zA-Z0-9_]+\\)\\([ 	]*\\((\\([a-zA-Z0-9_,. 	\n]\\)*)\\)?\\)[ 	]*:\\)" (#$ . 302167))
#@69 Regexp for Python methods/functions for use with the Imenu package.
(defvar py-imenu-method-regexp "\\(^[ 	]*\\(def[ 	]+\\([a-zA-Z0-9_]+\\)[ 	]*(\\([^:#]*\\))\\)[ 	]*:\\)" (#$ . 302371))
#@230 Indices into groups of the Python regexp for use with Imenu.

Using these values will result in smaller Imenu lists, as arguments to
functions are not listed.

See the variable `py-imenu-show-method-args-p' for more
information.
(defvar py-imenu-method-no-arg-parens '(2 8) (#$ . 302565))
#@223 Indices into groups of the Python regexp for use with imenu.
Using these values will result in large Imenu lists, as arguments to
functions are listed.

See the variable `py-imenu-show-method-args-p' for more
information.
(defvar py-imenu-method-arg-parens '(2 7) (#$ . 302861))
#@233 Generic Python expression which may be used directly with Imenu.
Used by setting the variable `imenu-generic-expression' to this value.
Also, see the function \[py-imenu-create-index] for a better
alternative for finding the index.
(defvar py-imenu-generic-expression (byte-code "\303	Q\nB\207" [py-imenu-class-regexp py-imenu-method-regexp py-imenu-method-no-arg-parens "\\|"] 3) (#$ . 303147))
(defvar py-imenu-generic-regexp nil)
(defvar py-imenu-generic-parens nil)
#@386 For development only. Good old renamed `py-imenu-create-index'-function hangs with medium size files already. Working `py-imenu-create-index-new' is active by default.

Switch between classic index machine `py-imenu-create-index'-function and new `py-imenu-create-index-new'.

The former may provide a more detailed report, thus delivering two different index-machines is considered. 
(defalias 'py-switch-imenu-index-function #[nil "\303=\203#	\304=\203\305\202\304\n\205\"\306 \205'\307\310\311	!\"\207\312\313\314\"\207" [major-mode imenu-create-index-function py-verbose-p python-mode py-imenu-create-index-new py-imenu-create-index interactive-p message "imenu-create-index-function: %s" prin1-to-string error "%s" "Only available in buffers set to python-mode"] 4 (#$ . 303625) nil])
#@200 Python interface function for the Imenu package.
Finds all Python classes and functions/methods. Calls function
\[py-imenu-create-index-engine].  See that function for the details
of how this works.
(defalias 'py-imenu-create-index-function #[nil "@\n\203\202\f\feb\210\306\307!\207" [py-imenu-generic-expression py-imenu-generic-regexp py-imenu-show-method-args-p py-imenu-method-arg-parens py-imenu-method-no-arg-parens py-imenu-generic-parens py-imenu-create-index-engine nil] 2 (#$ . 304432)])
#@1195 Function for finding Imenu definitions in Python.

Finds all definitions (classes, methods, or functions) in a Python
file for the Imenu package.

Returns a possibly nested alist of the form

        (INDEX-NAME . INDEX-POSITION)

The second element of the alist may be an alist, producing a nested
list as in

        (INDEX-NAME . INDEX-ALIST)

This function should not be called directly, as it calls itself
recursively and requires some setup.  Rather this is the engine for
the function \[py-imenu-create-index-function].

It works recursively by looking for all definitions at the current
indention level.  When it finds one, it adds it to the alist.  If it
finds a definition at a greater indentation level, it removes the
previous definition from the alist. In its place it adds all
definitions found at the next indentation level.  When it finds a
definition that is less indented then the current level, it returns
the alist it has created thus far.

The optional argument START-INDENT indicates the starting indentation
at which to continue looking for Python classes, methods, or
functions.  If this is not supplied, the function uses the indentation
of the first definition found.
(defalias 'py-imenu-create-index-engine #[(&optional start-indent) "\306\211\211\211\211\211\211@\211A@)\307d\310#\203\324\212\224\2034\2025\n\311\224\225\")\312 \313\216\314 \210*\315 \210\316 )\224\206Z\n\224\204c
\204l\317 \204\277
U\203\204\fBB\202\277
W\203\265\320e\321#\210\322
!\211\203\277\211A@BBB)\202\277\306\320e\310#\210\203%\307d\321#\211\204*\237.	\207" [py-imenu-generic-parens x def-paren class-paren def-pos cur-indent nil re-search-forward t buffer-substring-no-properties match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) py-beginning-of-def-or-class beginning-of-line current-indentation py-in-literal re-search-backward move py-imenu-create-index-engine prev-name def-name looking-p sub-method-alist index-alist py-imenu-generic-regexp cur-paren save-match-data-internal start-indent save-elmt] 10 (#$ . 304945)])
(defalias 'py-imenu-create-index-new-intern #[(&optional thisend) "\306\224\307\310!\311	P\206\312 \313\216\314 *\315\316\317\206\"\320\321$\203i\322\323 8\204i\306\224\307\310!\311	P\206F\312 \324\216\314 *\307\321!\325\230\203]\326\312 \327\216\314 *!\210\202e\330	PB
B,\202\n\203\202
\237\nB
B\n
BB\211\202\211
B\211-\207" [pos name classname thisend save-match-data-internal sublist 0 match-string-no-properties 2 "class " match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) py-end-of-def-or-class-position nil re-search-forward "^[ 	]*\\(?:\\(def\\|class\\)\\)[ 	]+\\(?:\\(\\sw+\\)\\)" t 1 8 syntax-ppss ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) "class" py-imenu-create-index-new-intern ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) " " end index-alist] 5])
#@44 `imenu-create-index-function' for Python. 
(defalias 'py-imenu-create-index-new #[(&optional beg end) "\306\300!\210\307`	\206\fe\n\206d\310\211\211\211\211 	b\210\311\312\n\313\314$\203\353\315\316 8\204\353\317 !\320\216\321\314!\322\230*\203\324\323\224\"\321\324!#\325#P\317 !\326\216\327 *\310\311\312
\206d\n\313\314$\203\262\315\316 8\204\262\323\224\"\321\324!#\325#P
\206\214\317 !\330\216\327 *\321\314!\322\230\203\244\331\317 !\332\216\327 *!\210\202\256\333#P\"B\fB,\202]\203\313\f\237\"B\fB\fBB\202$\fB\202$\323\224\321\324!#\"#\"BB*\202$eb\210\311\334\n\313#\203\315\316 8\204\356\314\224\321\314!#\"#\"BB*\202\356\237\203(\335\237BB b\210.\207" [imenu-max-items beg end classname sublist thisend make-local-variable 99 nil re-search-forward "^[ 	]*\\(def\\|class\\)[ 	]+\\(\\sw+\\)" t 1 8 syntax-ppss match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) match-string-no-properties "class" 0 2 "class " ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) py-end-of-def-or-class-position ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) py-imenu-create-index-new-intern ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) " " "^\\(\\sw+\\)[ 	]*=" "Module variables" vars index-alist orig save-match-data-internal pos name] 8 (#$ . 308071)])
#@157 Return a list of completions of the string SYMBOL from Python process.
The list is sorted.
Uses `python-imports' to load modules against which to complete.
(defalias 'python-symbol-completions #[(symbol) ";\205\302\303\304\217\305\306	!\307\")\207" [symbol completions nil (byte-code "\302\303\304\305\306!	#!!@\207" [symbol python-imports read-from-string python-send-receive format "emacs.complete(%S,%s)" substring-no-properties] 6) ((error)) sort delete-dups string<] 3 (#$ . 309579)])
#@41 Keymap used in *Python Output* buffers.
(defvar py-mode-output-map nil (#$ . 310080))
(byte-code "\204\304 \305\306\307#\210\305\310\311#\210\312\313\314\315!\"\210\316	!\305\n\317\320#\210\305\n\321\322#\210\305\n\323\324#\210\305\n\325\326#\210\305\n\327\326#\210\n)\304\207" [py-mode-output-map comint-mode-map map py-shell-map make-sparse-keymap define-key [button2] py-mouseto-exception "" py-goto-exception mapc #[(key) "\302	\303#\207" [py-mode-output-map key define-key #[nil "\300 \207" [beep] 1 nil nil]] 4] where-is-internal self-insert-command copy-keymap "
" comint-send-input "-" py-up-exception "=" py-down-exception "	" py-shell-complete [(meta tab)]] 4)
#@165 Select Python executable according to version desplayed in path, current buffer-file is selected from.

Returns versioned string, nil if nothing appropriate found 
(defalias 'py-choose-shell-by-path #[(&optional file-separator-char) "\305 \206	\306	!\307\304J\2036\303J\2036\310\303J\311\303JQ\304J\"\2036\304J\310\303J\311\303JQ\304J\"T\312\225SO\313 \203A\314\315\302J\"\210\302J+\207" [file-separator-char py-separator-char #1=#:--cl-erg-- #2=#:--cl-file-separator-char-- #3=#:--cl-path-- buffer-file-name char-to-string nil string-match "[iI]?[pP]ython[0-9.]+" 0 interactive-p message "%s"] 5 (#$ . 310771) nil])
#@114 Choose shell by looking at #! on the first line.

Returns the specified Python resp. Jython shell command name. 
(defalias 'py-choose-shell-by-shebang #[nil "\306\211\212eb\210\307\n!\2031\310\311\312!\313\"\211\306\211\2030\f@\314\315\"\203)\fA\211\204*)
\203@\316 \203@\317\320	\"\210	*\207" [erg res py-shebang-regexp ele #1=#:--cl-dolist-temp-- py-verbose-p nil looking-at split-string match-string-no-properties 0 "[#! 	]" string-match "[bijp]+ython" interactive-p message "%s"] 4 (#$ . 311405) nil])
#@216 Choose CPython or Jython mode based imports.

If a file imports any packages in `py-jython-packages', within
`py-import-check-point-max' characters from the start of the file,
return `jython', otherwise return nil.
(defalias 'py-choose-shell-by-import #[nil "\303\212eb\210\204 \304\305	\306#\203 \307\310!\n\235\205\311\211\203\n))\207" [mode py-import-check-point-max py-jython-packages nil search-forward-regexp "^\\(\\(from\\)\\|\\(import\\)\\) \\([^ 	\n.]+\\)" t match-string 4 jython] 5 (#$ . 311935)])
(defalias 'py-version 'py-which-python)
#@62 Returns version of Python of current environment, a number. 
(defalias 'py-which-python #[nil "\304 \305\306P!\307\310	\"\203\311\312	\"\202$\307\313	\"\205$	\314	GSO\315 \203?	\203:\203?\316\317	\"\210\202?\316\317\320\"\210\321\n!+\207" [cmd erg version py-verbose-p py-choose-shell shell-command-to-string " --version" string-match "\\(on top of Python \\)\\([0-9]\\.[0-9]+\\)" match-string-no-properties 2 "\\([0-9]\\.[0-9]+\\)" 7 interactive-p message "%s" "Could not detect Python on your system" string-to-number] 3 (#$ . 312499) nil])
#@47 Returns path of current Python installation. 
(defalias 'py-python-current-environment #[nil "\304 \305\306P!\211\307\310	\"\311O\312 \203+\n\203&\203+\313\314\n\"\210\202+\313\314\315\"\210\n+\207" [cmd denv erg py-verbose-p py-choose-shell shell-command-to-string "type " string-match "/" nil interactive-p message "%s" "Could not detect Python on your system"] 5 (#$ . 313061) nil])
(byte-code "\300\301\302\"\210\300\303\302\"\207" [defalias python-toggle-shells py-switch-shell py-toggle-shell] 3)
#@709 Toggles between the interpreter customized in `py-shell-toggle-1' resp. `py-shell-toggle-2'. Was hard-coded CPython and Jython in earlier versions, now starts with Python2 and Python3 by default.

ARG might be a python-version string to set to.

\[universal-argument] `py-toggle-shell' prompts to specify a reachable Python command.
\[universal-argument] followed by numerical arg 2 or 3, `py-toggle-shell' opens a respective Python shell.
\[universal-argument] followed by numerical arg 5 opens a Jython shell.

Should you need more shells to select, extend this command by adding inside the first cond:

                    ((eq NUMBER (prefix-numeric-value arg))
                     "MY-PATH-TO-SHELL")

(defalias 'py-switch-shell #[(&optional arg) "\306!\307=\203\f\310\202C\306!\311=\203\312\202C\306!\313=\203+\314\315\316	\"\317\211#\202C\306!\320=\2037\321\202C\322	\n\"\203B\202C\n\323\211\324\230\204R
\325\230\203`
\325\211$%\325&\202\265\322\312
\"\203y
\326
!$\327%\326
!&\202\265\322\321
\"\203\222
\326
!$\330%\326
!&\202\265\322\331
\"\203\252
\326
!$\327%$&\202\265

$
%
&\332	!\211\203\327\333 \210\334 \203\314\335\336%\f#\210\337\340$\"\211'\202\335\341\342	\343Q!*\207" [arg py-shell-name py-shell-toggle-1 py-shell-toggle-2 erg name prefix-numeric-value 2 "python2" 3 "python3" 4 string-strip read-from-minibuffer "Python Shell: " "\" " 5 "jython" string-match nil "ipython" "IPython" py-buffer-name-prepare "CPython" "Jython" "python" executable-find force-mode-line-update interactive-p message "Using the %s shell, %s" format "*%s Output*" error "Could not detect " " on your sys\ntem" py-which-bufname msg mode-name py-output-buffer] 5 (#$ . 313580) "P"])
(defalias 'py-which-shell 'py-choose-shell)
#@506 Return an appropriate executable as a string.

Returns nil, if no executable found.

This does the following:
 - look for an interpreter with `py-choose-shell-by-shebang'
 - examine imports using `py-choose-shell-by-import'
 - look if Path/To/File indicates a Python version
 - if not successful, return default value of `py-shell-name'

When interactivly called, messages the shell name, Emacs would in the given circtumstances.

With \[universal-argument] 4 is called `py-switch-shell' see docu there.

(defalias 'py-choose-shell #[(&optional arg pyshell dedicated) "\306!\307=\203\f\310\311!\207	\203\n\202R\203*\f\312\230\204$\313\f!\202R\314\315!\202R\316p!\2038\317\320p!!\202R\321 \206R\322 \206R\323 \206R\n\203O\n\202R\324\302!\203\\
\202_\325
!\211\203s\326 \203}\314\327\"\210\202}\326 \203}\314\327\330\"\210
*\207" [arg py-force-py-shell-name-p py-shell-name py-use-local-default py-shell-local-path erg prefix-numeric-value 4 py-switch-shell (4) "" expand-file-name message "Abort: `py-use-local-default' is set to `t' but `py-shell-local-path' is empty. Maybe call `py-toggle-local-default-use'" comint-check-proc process-name get-buffer-process py-choose-shell-by-shebang py-choose-shell-by-import py-choose-shell-by-path default-value executable-find interactive-p "%s" "Could not detect Python on your system. Maybe set `py-edit-only-p'?" py-edit-only-p cmd] 4 (#$ . 315369) "P"])
(defalias 'toggle-py-smart-indentation 'py-toggle-smart-indentation)
#@103 If `py-smart-indentation' should be on or off.

Returns value of `py-smart-indentation' switched to. 
(defalias 'py-toggle-smart-indentation #[(&optional arg) "\206
	\203\f\304\202
\305\306W\203\307\202\310\311\302!\203-\312 \203-\313\314	\"\210	)\207" [arg py-smart-indentation py-indent-offset py-verbose-p -1 1 0 t nil default-value interactive-p message "py-smart-indentation: %s"] 3 (#$ . 316874) nil])
#@85 Make sure, `py-smart-indentation' is on.

Returns value of `py-smart-indentation'. 
(defalias 'py-smart-indentation-on #[(&optional arg) "\206\302\303!\210)\304 \203\305\306	\"\210	\207" [arg py-smart-indentation 1 toggle-py-smart-indentation interactive-p message "py-smart-indentation: %s"] 3 (#$ . 317304) "p"])
#@86 Make sure, `py-smart-indentation' is off.

Returns value of `py-smart-indentation'. 
(defalias 'py-smart-indentation-off #[(&optional arg) "\203	[\202\n\302\303!\210)\304 \203\305\306	\"\210	\207" [arg py-smart-indentation -1 toggle-py-smart-indentation interactive-p message "py-smart-indentation: %s"] 3 (#$ . 317632) "p"])
(defalias 'toggle-py-split-windows-on-execute 'py-toggle-split-windows-on-execute)
#@123 If `py-split-windows-on-execute-p' should be on or off.

  Returns value of `py-split-windows-on-execute-p' switched to. 
(defalias 'py-toggle-split-windows-on-execute #[(&optional arg) "\206
	\203\f\302\202
\303\304W\203\305\202\306\307 \203%\310\311	\"\210	)\207" [arg py-split-windows-on-execute-p -1 1 0 t nil interactive-p message "py-split-windows-on-execute-p: %s"] 3 (#$ . 318056) nil])
#@103 Make sure, `py-split-windows-on-execute-p' is on.

Returns value of `py-split-windows-on-execute-p'. 
(defalias 'py-split-windows-on-execute-on #[(&optional arg) "\206\302\303!\210)\304 \203\305\306	\"\210	\207" [arg py-split-windows-on-execute-p 1 toggle-py-split-windows-on-execute interactive-p message "py-split-windows-on-execute-p: %s"] 3 (#$ . 318471) "p"])
#@104 Make sure, `py-split-windows-on-execute-p' is off.

Returns value of `py-split-windows-on-execute-p'. 
(defalias 'py-split-windows-on-execute-off #[nil "\301\302!\210\303 \203\304\305\"\210\207" [py-split-windows-on-execute-p toggle-py-split-windows-on-execute -1 interactive-p message "py-split-windows-on-execute-p: %s"] 3 (#$ . 318850) nil])
#@90 Remove entries with SUFFIX from `flymake-allowed-file-name-masks'.

Default is "\.py\'" 
(defalias 'clear-flymake-allowed-file-name-masks #[(&optional suffix) "\306!\307=\203\310\311\312\"\202\203\202\312	\313	\313\211\203=
@\314\f@\"\2046\315\302\f\316#\210
A\211\204%*\n\203O\317 \203O\320\321	\"\210	+\207" [suffix flymake-allowed-file-name-masks newlist erg ele #1=#:--cl-dolist-temp-- prefix-numeric-value 4 read-from-minibuffer "Suffix: " "\\\\.py\\\\'" nil string-match add-to-list t interactive-p message "%s" py-verbose-p] 5 (#$ . 319205) "P"])
(defalias 'py-toggle-flymake-intern #[(name command) "\306\307\"\204\310!\204	\203\311\312\211#\210\313\314!\315\n\316!\"\317\320\321\322\323Q!@\"\210
\f*CD\207" [name py-verbose-p temp-file buffer-file-name local-file command string-match "pyflakespep8" executable-find message "Don't see %s. Use `easy_install' %s? " flymake-init-create-temp-buffer-copy flymake-create-temp-inplace file-relative-name file-name-directory add-to-list flymake-allowed-file-name-masks read-from-string "(\"\\.py\\'\" flymake-" ")"] 6])
#@34 Toggle `pylint' `flymake-mode'. 
(defalias 'pylint-flymake-mode #[nil "\203\300 \207\301\302\211\"\210\300 \207" [flymake-mode py-toggle-flymake-intern "pylint"] 3 (#$ . 320323) nil])
#@36 Toggle `pyflakes' `flymake-mode'. 
(defalias 'pyflakes-flymake-mode #[nil "\203\300 \207\301\302\211\"\210\300 \207" [flymake-mode py-toggle-flymake-intern "pyflakes"] 3 (#$ . 320516) nil])
#@37 Toggle `pychecker' `flymake-mode'. 
(defalias 'pychecker-flymake-mode #[nil "\203\300 \207\301\302\211\"\210\300 \207" [flymake-mode py-toggle-flymake-intern "pychecker"] 3 (#$ . 320715) nil])
#@32 Toggle `pep8' `flymake-mode'. 
(defalias 'pep8-flymake-mode #[nil "\203\300 \207\301\302\211\"\210\300 \207" [flymake-mode py-toggle-flymake-intern "pep8"] 3 (#$ . 320917) nil])
#@114 Toggle `pyflakespep8' `flymake-mode'.

Joint call to pyflakes and pep8 as proposed by

Keegan Carruthers-Smith


(defalias 'pyflakespep8-flymake-mode #[nil "\203\300 \207\301\302\211\"\210\300 \207" [flymake-mode py-toggle-flymake-intern "pyflakespep8"] 3 (#$ . 321105) nil])
(defalias 'toggle-py-shell-switch-buffers-on-execute 'py-toggle-shell-switch-buffers-on-execute)
#@125 If `py-switch-buffers-on-execute-p' should be on or off.

  Returns value of `py-switch-buffers-on-execute-p' switched to. 
(defalias 'py-toggle-shell-switch-buffers-on-execute #[(&optional arg) "\206
	\203\f\302\202
\303\304W\203\305\202\306\307 \203%\310\311	\"\210	)\207" [arg py-switch-buffers-on-execute-p -1 1 0 t nil interactive-p message "py-shell-switch-buffers-on-execute: %s"] 3 (#$ . 321488) nil])
#@105 Make sure, `py-switch-buffers-on-execute-p' is on.

Returns value of `py-switch-buffers-on-execute-p'. 
(defalias 'py-shell-switch-buffers-on-execute-on #[(&optional arg) "\206\302\303!\210)\304 \203\305\306	\"\210	\207" [arg py-switch-buffers-on-execute-p 1 toggle-py-shell-switch-buffers-on-execute interactive-p message "py-shell-switch-buffers-on-execute: %s"] 3 (#$ . 321918) "p"])
#@106 Make sure, `py-switch-buffers-on-execute-p' is off.

Returns value of `py-switch-buffers-on-execute-p'. 
(defalias 'py-shell-switch-buffers-on-execute-off #[nil "\301\302!\210\303 \203\304\305\"\210\207" [py-switch-buffers-on-execute-p toggle-py-shell-switch-buffers-on-execute -1 interactive-p message "py-shell-switch-buffers-on-execute: %s"] 3 (#$ . 322319) nil])
(defvar inferior-python-mode-map (byte-code "\301 \302\303\304#\210\302\305\306#\210)\207" [map make-sparse-keymap define-key "\f" py-load-file "" python-check] 4))
#@78 Make sure DIRECTORY ends with a file-path separator char.

Returns DIRECTORY
(defalias 'py-normalize-directory #[(directory &optional file-separator-char) "\206\305	!\306\307P\n\"\203\n\202\n\310\230?\205\nP\211\204,\f\203,\311\312!\210*\207" [file-separator-char py-separator-char directory erg py-verbose-p char-to-string string-match "$" "" message "Warning: directory is empty"] 4 (#$ . 322868)])
#@79 Do some sanity check for `py-install-directory'.

Returns `t' if successful. 
(defalias 'py-install-directory-check #[nil "\302\300!\205;\205\303GW\304 \203\305\306	\"\210	)\207" [py-install-directory erg boundp 1 interactive-p message "py-install-directory-check: %s"] 3 (#$ . 323291) nil])
#@96 Takes value of user directory aka $HOME
if `(locate-library "python-mode")' is not succesful. 
(defalias 'py-guess-py-install-directory #[nil "\303\304\305!!\211\203\n\203!\306 \203!\307\310\"\210\202!\311\312!	)\207" [erg py-install-directory py-verbose-p file-name-directory locate-library "python-mode" interactive-p message "Setting py-install-directory to: %s" expand-file-name "~/"] 4 (#$ . 323598) nil])
#@51 Include needed subdirs of python-mode directory. 
(defalias 'py-set-load-path #[nil "\304\305	!\"\211\306\230\2046;\2036\307\310\311!\"\210\307\310\311!\312P\"\210\307\310\311!\313P\"\210\307\310\311!\314P\"\202L\n\203I\315 \211\205E\307\310\")\206L\316\317!)\207" [py-install-directory py-separator-char py-guess-py-install-directory-p guessed-py-install-directory py-normalize-directory char-to-string "" add-to-list load-path expand-file-name "completion" "test" "tools" py-guess-py-install-directory error "Please set `py-install-directory', see INSTALL"] 5 (#$ . 324025) nil])
#@149 How to decide whether to pair opening brackets or quotes.

Set this to 'always to always pair, or 'help-balance to be more
criterious when pairing.
(defvar autopair-pair-criteria 'help-balance (#$ . 324629))
#@150 How to decide whether to skip closing brackets or quotes.

Set this to 'always to always skip, or 'help-balance to be more
criterious when skipping.
(defvar autopair-skip-criteria 'help-balance (#$ . 324844))
#@75 A dinamic keymap for autopair set mostly from the current
  syntax table.
(defvar autopair-emulation-alist nil (#$ . 325059))
(byte-code "\301V\204\302\303!\210\304\305!\210\303\207" [emacs-major-version 23 (lambda (#1=#:def-tmp-var) (defvar autopair-dont-activate #1# "Control activation of `autopair-global-mode'.\n\nSet this to a non-nil value to skip activation of `autopair-mode'\nin certain contexts.  If however the value satisfies `functionp'\nand is a function of no arguments, the function is called and it is\nthe return value that decides.")) nil make-variable-buffer-local autopair-dont-activate] 2)
#@943 Extra pairs for which to use pairing.

It's a Common-lisp-style even-numbered property list, each pair
of elements being of the form (TYPE , PAIRS). PAIRS is a mixed
list whose elements are cons cells, which look like cells look
like (OPENING . CLOSING). Autopair pairs these like
parenthesis.

TYPE can be one of:

:string : whereby PAIRS will be considered only when inside a
          string literal

:comment : whereby PAIRS will be considered only when inside a comment

:code : whereby PAIRS will be considered only when outisde a
        string and a comment.

:everywhere : whereby PAIRS will be considered in all situations

In Emacs-lisp, this might be useful

(add-hook 'emacs-lisp-mode-hook
          #'(lambda ()
              (setq autopair-extra-pairs `(:comment ((?`. ?'))))))

Note that this does *not* work for single characters,
e.x. characters you want to behave as quotes.  See the
docs/source comments for more details.
(defvar autopair-extra-pairs nil (#$ . 325682))
(make-variable-buffer-local 'autopair-extra-pairs)
#@792 Characters for which to skip any pairing behaviour.

This variable overrides `autopair-pair-criteria' and
`autopair-extra-pairs'. It does not
  (currently) affect the skipping behaviour.

It's a Common-lisp-style even-numbered property list, each pair
of elements being of the form (TYPE , CHARS). CHARS is a list of
characters and TYPE can be one of:

:string : whereby characters in CHARS will not be autopaired when
          inside a string literal

:comment : whereby characters in CHARS will not be autopaired when
          inside a comment

:never : whereby characters in CHARS won't even have their
         bindings replaced by autopair's. This particular option
         should be used for troubleshooting and requires
         `autopair-mode' to be restarted to have any effect.
(defvar autopair-dont-pair '(:string (39) :comment (39)) (#$ . 326730))
(make-variable-buffer-local 'autopair-dont-pair)
#@421 Autopair action decided on by last interactive autopair command, or nil.

When autopair decides on an action this is a list whose first
three elements are (ACTION PAIR POS-BEFORE).

ACTION is one of `opening', `insert-quote', `skip-quote',
`backspace', `newline' or `paired-delimiter'. PAIR is the pair of
the `autopair-inserted' character, if applicable. POS-BEFORE is
value of point before action command took place .
(defvar autopair-action nil (#$ . 327649))
#@358 Autowrap action decided on by autopair, if any.

When autopair decides on an action this is a list whose first
three elements are (ACTION PAIR POS-BEFORE REGION-BEFORE).

ACTION can only be `wrap' currently. PAIR and POS-BEFORE
delimiter are as in `autopair-action'. REGION-BEFORE is a cons
cell with the bounds of the region before the command takes
place
(defvar autopair-wrap-action nil (#$ . 328119))
#@506 Autopair handlers to run *instead* of the default handler.

Each element is a function taking three arguments (ACTION, PAIR
and POS-BEFORE), which are the three elements of the
`autopair-action' variable, which see.

If non-nil, these functions are called *instead* of the single
function `autopair-default-handle-action', so use this variable
to specify special behaviour. To also run the default behaviour,
be sure to include `autopair-default-handle-action' in the
list, or call it from your handlers.
(defvar autopair-handle-action-fns nil (#$ . 328531))
(make-variable-buffer-local 'autopair-handle-action-fns)
#@538 Autopair wrap handlers to run *instead* of the default handler.

Each element is a function taking four arguments (ACTION, PAIR,
POS-BEFORE and REGION-BEFORE), which are the three elements of the
`autopair-wrap-action' variable, which see.

If non-nil, these functions are called *instead* of the single
function `autopair-default-handle-wrap-action', so use this
variable to specify special behaviour. To also run the default
behaviour, be sure to include `autopair-default-handle-wrap-action' in
the list, or call it in your handlers.
(defvar autopair-handle-wrap-action-fns nil (#$ . 329154))
(make-variable-buffer-local 'autopair-handle-wrap-action-fns)
#@125 Delimiter inserted by last interactive autopair command.

This is calculated with `autopair-calculate-inserted', which see.
(defvar autopair-inserted nil (#$ . 329819))
#@113 Attempts to guess the delimiter the current command is inserting.

For now, simply returns `last-command-event'
(defalias 'autopair-calculate-inserted #[nil "\207" [last-command-event] 1 (#$ . 329995)])
(defvar autopair-mode-major-mode nil)
(make-variable-buffer-local 'autopair-mode-major-mode)
#@281 Non-nil if Autopair-Global mode is enabled.
See the command `autopair-global-mode' for a description of this minor mode.
Setting this variable directly does not take effect;
either customize it (see the info node `Easy Customization')
or call the function `autopair-global-mode'.
(custom-declare-variable 'autopair-global-mode 'nil '(#$ . 330299) :set 'custom-set-minor-mode :initialize 'custom-initialize-default :group 'autopair :type 'boolean)
#@323 Toggle Autopair mode in all buffers.
With prefix ARG, enable Autopair-Global mode if ARG is positive;
otherwise, disable it.  If called from Lisp, enable the mode if
ARG is omitted or nil.

Autopair mode is enabled in all buffers where
`autopair-on' would do it.
See `autopair-mode' for more information on Autopair mode.
(defalias 'autopair-global-mode #[(&optional arg) "\306 	\307=\203\n?\202\310	!\311V\211\203/\312\313\314\"\210\312\315\314\"\210\312\316\317\"\210\312\320\321\"\210\202C\322\313\314\"\210\322\315\314\"\210\322\316\317\"\210\322\320\321\"\210\323 \324\211\203m\f@rq\210\n\203]\325 \210\202e
\203e\305\326!\210)\fA\211\204L*\327\330\n\203x\331\202y\332\"\210\333\334!\203\236\335\302!\210\306 \203\221\306 \232\203\236\336\337\n\203\233\340\202\234\341\"\210)\342 \210\n\207" [#1=#:last-message arg autopair-global-mode buf #2=#:--cl-dolist-temp-- autopair-mode current-message toggle prefix-numeric-value 0 add-hook after-change-major-mode-hook autopair-global-mode-enable-in-buffers change-major-mode-after-body-hook find-file-hook autopair-global-mode-check-buffers change-major-mode-hook autopair-global-mode-cmhh remove-hook buffer-list nil autopair-on -1 run-hooks autopair-global-mode-hook autopair-global-mode-on-hook autopair-global-mode-off-hook called-interactively-p any customize-mark-as-set message "Autopair-Global mode %sabled" "en" "dis" force-mode-line-update] 4 (#$ . 330753) (list (or current-prefix-arg 'toggle))])
(byte-code "\301\302\303\304\300!\205\n\303\211%\207" [autopair-global-mode-map add-minor-mode autopair-global-mode nil boundp] 6)
(defvar autopair-global-mode-buffers nil)
(defalias 'autopair-global-mode-enable-in-buffers #[nil "\306\211\2059\n@\307	!\2031r	q\210\f=\2040
\203+\305\310!\210\311 \210\f\2020\311 \210\f)\nA\211\204\306*\207" [autopair-global-mode-buffers buf #1=#:--cl-dolist-temp-- autopair-mode-major-mode major-mode autopair-mode nil buffer-live-p -1 autopair-on] 3])
(put 'autopair-global-mode-enable-in-buffers 'definition-name 'autopair-global-mode)
(defalias 'autopair-global-mode-check-buffers #[nil "\301 \210\302\303\304\305\"\207" [autopair-global-mode-buffers autopair-global-mode-enable-in-buffers nil remove-hook post-command-hook autopair-global-mode-check-buffers] 3])
(put 'autopair-global-mode-check-buffers 'definition-name 'autopair-global-mode)
(defalias 'autopair-global-mode-cmhh #[nil "\300\301p\"\210\302\303\304\"\207" [add-to-list autopair-global-mode-buffers add-hook post-command-hook autopair-global-mode-check-buffers] 3])
(put 'autopair-global-mode-cmhh 'definition-name 'autopair-global-mode)
(defalias 'autopair-on #[nil "\206\303 \204\304\305\306 \"\206	\307=\206\310\302!\205\n?\205%\311\312!\207" [buffer-read-only major-mode autopair-dont-activate minibufferp string-match "^ \\*" buffer-name sldb-mode boundp autopair-mode 1] 3])
#@95 Non-nil if Autopair mode is enabled.
Use the command `autopair-mode' to change this variable.
(defvar autopair-mode nil (#$ . 333657))
(make-variable-buffer-local 'autopair-mode)
#@40 Automagically pair braces and quotes. 
(defalias 'autopair-mode #[(&optional arg) "\306 	\307=\203\n?\202\310	!\311V\211\203(\312 \313\314\315#\210\313\316\315#\210\313\317\315#\210\313\320\315#\210\313\321\315#\210\313\322\323#\210\313\324\323#\210\325\311\f
W\203\267\f\326?\327\"\235\204\260\330 \fH\211@\205g\331@!A@\205q@ABA\332=\203\216\313\333\f!\334#\210\313\333B!\335#\210\202\257A\336=\203\240\313\333\f!\337#\210\202\257A\340=\203\257\313\333\f!\341#\210+\fT\211\202J*\342\343C\"\344D\211E\203E@\211D\344B\211F\203\367F@B\313\333B@!\345#\210\313\333BA!\346#\210FA\211F\204\325*EA\211E\204\306*\347\350!\210\351BC(\352\353\354\"\210)\344\211GH\352\355\350\356#\210\352\357\360\344\361$\210\202;\362\353\363\"\210\344(\362\355\350\"\210\362\357\360\361#\210\364\365\n\203E\366\202F\367\"\210\370\371!\203g\306 \203Z\306 \232\203g\372\373\n\203d\374\202e\375\"\210)\376 \210\n\207" [#1=#:last-message arg autopair-mode map char #2=#:--cl-dotimes-temp-- current-message toggle prefix-numeric-value 0 make-sparse-keymap define-key [remap delete-backward-char] autopair-backspace [remap backward-delete-char-untabify] [backspace] [backspace] "" [return] autopair-newline "
" 256 getf :never syntax-table syntax-class 4 string autopair-insert-opening autopair-skip-close-maybe 7 autopair-insert-or-skip-quote 8 autopair-insert-or-skip-paired-delimiter remove-if-not listp nil autopair-extra-insert-opening autopair-extra-skip-close-maybe make-local-variable autopair-emulation-alist t add-hook python-mode-hook #[nil "\301\302D\211\207" [autopair-handle-action-fns autopair-default-handle-action autopair-python-triple-quote-action] 2] emulation-mode-map-alists append post-command-hook autopair-post-command-handler local remove-hook #[nil "\301\302D\211\207" [autopair-handle-action-fns autopair-default-handle-action autopair-python-triple-quote-action] 2] run-hooks autopair-mode-hook autopair-mode-on-hook autopair-mode-off-hook called-interactively-p any message "Autopair mode %sabled" "en" "dis" force-mode-line-update autopair-dont-pair syntax-entry class pair autopair-extra-pairs pairs-list #3=#:--cl-dolist-temp-- #4=#:--cl-dolist-temp-- autopair-action autopair-wrap-action] 6 (#$ . 333842) (list (or current-prefix-arg 'toggle))])
(byte-code "\301\302\303\304\300!\205\n\305\211%\207" [autopair-mode-map add-minor-mode autopair-mode " pair" boundp nil] 6)
#@484 Calculate syntax info relevant to autopair.

A list of four elements is returned:

- SYNTAX-INFO is either the result `syntax-ppss' or the result of
  calling `parse-partial-sexp' with the appropriate
  bounds (previously calculated with `syntax-ppss'.

- WHERE-SYM can be one of the symbols :string, :comment or :code.

- QUICK-SYNTAX-INFO is always the result returned by `syntax-ppss'.

- BOUNDS are the boudaries of the current string or comment if
  we're currently inside one.
(defalias 'autopair-syntax-ppss #[nil "\302 \3038\3048\203\305	T`\"\306	\307\310\311\217BF\2025\3128\2031\305\3038T`\"\313E\2025\314E*\207" [quick-syntax-info string-or-comment-start syntax-ppss 8 3 parse-partial-sexp :string nil (scan-sexps string-or-comment-start 1) ((error)) 4 :comment :code] 7 (#$ . 336307)])
(defalias 'autopair-find-pair #[(delim &optional closing) "\205L\250\205L\304 H\305	!\306=\203	A\202K\305	!\307=\204+\305	!\310=\203/\202K\n\204@\305	!\311=\203@	A\202K\205K\312\313\314\315\"\")\207" [delim syntax-entry closing autopair-extra-pairs syntax-table syntax-class 4 7 8 5 some #[(pair-list) "\301\302\"\207" [pair-list some #[(pair) "A	=\203\n@\207@	=\205A\207" [pair delim] 2]] 3] remove-if-not listp] 5])
(defalias 'autopair-calculate-wrap-action #[nil "\205R	\205R`\306 V\203\307 \210\212\310 \311 B`\312\n@!\312\nA!\313=\203>\f@
@=\205Q\314\f8\314
8=\205Q\315\211A@)\206N\316!\nF-\207" [transient-mark-mode mark-active region-before point-before start-syntax end-syntax mark exchange-point-and-mark region-beginning region-end syntax-ppss help-balance 3 wrap autopair-find-pair autopair-autowrap autopair-action x autopair-inserted] 5])
(defalias 'autopair-original-binding #[(fallback-keys) "\302\303!!\206\302\304 !\206\302	!\207" [autopair-inserted fallback-keys key-binding vector this-single-command-keys] 3])
(defalias 'autopair-fallback #[(&optional fallback-keys) "\306\211\307\n!)\307\n!
\203\310 \311\312!\203*\313\314\315!\"\203*\306
??\316\f!-\207" [autopair-emulation-alist cua--keymap-alist fallback-keys beyond-cua beyond-autopair autopair-autowrap nil autopair-original-binding autopair-calculate-wrap-action featurep paredit string-match "paredit" symbol-name call-interactively autopair-wrap-action this-original-command autopair-action blink-matching-paren cua-delete-selection] 5])
#@187 If non-nil autopair attempts to wrap the selected region.

This is also done in an optimistic "try-to-balance" fashion.
Set this to to 'help-balance to be more criterious when wrapping.
(defvar autopair-autowrap 'help-balance (#$ . 338720))
#@172 If non-nil also skip over whitespace when skipping closing delimiters.

If set to 'chomp, this will be most useful in lisp-like languages where you want
lots of )))))....
(defvar autopair-skip-whitespace nil (#$ . 338968))
#@49 If non-nil autopair blinks matching delimiters.
(defvar autopair-blink (byte-code "\301\300!\203\207\302\207" [blink-matching-paren boundp t] 2) (#$ . 339197))
#@39 Autopair's blink-the-delimiter delay.
(defvar autopair-blink-delay 0.1 (#$ . 339366))
(defalias 'autopair-document-bindings #[(&optional fallback-keys) "\304\305=\205\306\307\310 !\206\307\n!\211\205\311\312\"*\313Q\207" [this-command autopair-emulation-alist fallback-keys command "Works by scheduling possible autopair behaviour, then calls\noriginal command as if autopair didn't exist" describe-key nil key-binding this-single-command-keys format ", which in this case is `%s'" "."] 5])
(defalias 'autopair-escaped-p #[(syntax-info) "\3018\207" [syntax-info 5] 2])
(defalias 'autopair-exception-p #[(where-sym exception-where-sym blacklist &optional fn) "\305=\204\f	=\205 \n\203\306\307\f\"\"\202\307\f\"\235\207" [exception-where-sym where-sym autopair-inserted fn blacklist :everywhere mapcar getf] 6])
#@448 Try to uplist as much as possible, moving point.

Return nil if something prevented uplisting.

Otherwise return a cons of char positions of the starting
delimiter and end delimiters of the last list we just came out
of. If we aren't inside any lists return a cons of current point.

If inside nested lists of mixed parethesis types, finding a
matching parenthesis of a mixed-type is considered OK (non-nil is
returned) and uplisting stops there.
(defalias 'autopair-up-list #[(syntax-info &optional closing) "\300\301\302\217\207" [nil (byte-code "@``B\211\303V\203\"\304\305\306\217\203\"\307`\310\211#b\210\nS\211\202	*\207" [syntax-info retval howmany 0 err (byte-code "\301`d[\"\210\302!\207" [err scan-sexps error] 3) ((error (byte-code "\205\305!\n\211AA)A@`B	?\206#	\n\211AA)A@f=)\207" [closing opening err x retval autopair-find-pair] 3))) scan-lists 1] 5) ((error))] 3 (#$ . 340206)])
(defalias 'autopair-insert-or-skip-quote #[nil "\306 \307 \211@	\211A@)	\211AA)@\f\310=\205&
\211AA)A@\311\n!\211\204a`f=\203a\203K\312=\204X=\204X\f\313=\203a\314\315\316\217\203a\317`E\202\223\204\223\312=\204\223\320	!\204\223\321\322\323\217\204\223\320\212db\210\307 )!\204\223\324\325\326\"\204\223\327`E\330 .\207" [autopair-inserted syntax-triplet syntax-info x where-sym orig-info autopair-calculate-inserted autopair-syntax-ppss :string autopair-escaped-p t :comment nil (byte-code "\301`T\302\"f=\207" [autopair-inserted scan-sexps -1] 4) ((error)) skip-quote autopair-in-unterminated-string-p err (byte-code "\212\300 \210)\301\207" [up-list nil] 1) ((error (byte-code "\302\212\211AA)A@b\210\303 )!\207" [err x autopair-in-unterminated-string-p autopair-syntax-ppss] 3))) some #[(sym) "\303	\n#\207" [where-sym sym autopair-dont-pair autopair-exception-p] 4] (:comment :string) insert-quote autopair-fallback inside-string escaped-p autopair-action] 4 nil nil])
(put 'autopair-insert-or-skip-quote 'function-documentation '(concat "Insert or possibly skip over a quoting character.\n\n" (autopair-document-bindings)))
(defalias 'autopair-in-unterminated-string-p #[(autopair-triplet) "	\211AA)@\211AA)A@=\205\303\304\305\217\207" [autopair-inserted autopair-triplet x nil (byte-code "\302\303\211AA)@8\304\"\210\305\207" [autopair-triplet x scan-sexps 8 1 nil] 4) ((error t))] 4])
(defalias 'autopair-insert-opening #[nil "\302 \303 \203\304\305!`E\306 \207" [autopair-inserted autopair-action autopair-calculate-inserted autopair-pair-p opening autopair-find-pair autopair-fallback] 3 nil nil])
(put 'autopair-insert-opening 'function-documentation '(concat "Insert opening delimiter and possibly automatically close it.\n\n" (autopair-document-bindings)))
(defalias 'autopair-skip-close-maybe #[nil "\302 \303 \203\304\305!`E\306 \207" [autopair-inserted autopair-action autopair-calculate-inserted autopair-skip-p closing autopair-find-pair autopair-fallback] 3 nil nil])
(put 'autopair-skip-close-maybe 'function-documentation '(concat "Insert or possibly skip over a closing delimiter.\n\n" (autopair-document-bindings)))
(defalias 'autopair-backspace #[nil "\302 `Sf\203\303\304`Sf\305\"`E\306\307!\207" [autopair-inserted autopair-action autopair-calculate-inserted backspace autopair-find-pair closing autopair-fallback ""] 4 nil nil])
(put 'autopair-backspace 'function-documentation '(concat "Possibly delete a pair of paired delimiters.\n\n" (autopair-document-bindings (kbd "DEL"))))
(defalias 'autopair-newline #[nil "\303 \304`Sf!\211\203 	z\305=\203 \306f	=\203 \307	`E\310\311!)\207" [autopair-inserted pair autopair-action autopair-calculate-inserted autopair-find-pair 41 nil newline autopair-fallback "
"] 4 nil nil])
(put 'autopair-newline 'function-documentation '(concat "Do a smart newline when right between parenthesis.\n\nIn other words, insert an extra newline along with the one inserted normally\nby this command. Then place point after the first, indented.\n\n" (autopair-document-bindings (kbd "RET"))))
(defalias 'autopair-skip-p #[nil "\306 \211@`\307=\2032\212\310	\f\"\211\205.
@
A=\206.\n
AW\206.
@f\311\f!=*\202B\312=\203A\212\313\314\315\217)\202B\316+\207" [syntax-triplet syntax-info orig-point autopair-skip-criteria autopair-inserted pos-pair autopair-syntax-ppss help-balance autopair-up-list autopair-find-pair need-opening err (byte-code "\300 \210\301\207" [backward-list t] 1) ((error)) t] 4])
(defalias 'autopair-pair-p #[nil "\306 \211@\211A@)`\307\310\311\"?\205I
\312=\203;\313	!?\205I\212\314	!d\315!\316\317\320\217,\202I
\321=\203E\322\202I\313	!?,\207" [syntax-triplet syntax-info x where-sym orig-point autopair-pair-criteria autopair-syntax-ppss some #[(sym) "\303	\n#\207" [where-sym sym autopair-dont-pair autopair-exception-p] 4] (:string :comment :code :everywhere) help-balance autopair-escaped-p autopair-up-list autopair-find-pair err (byte-code "`=\204`\301 \210\202\302\207" [prev-point forward-sexp t] 2) ((error (byte-code "\303\304\211A@)\"\204\305\207\300\306\307\217\203)\n\211AA)@f=?\206*\n`f=?\207\310\207" [err x expected-closing string-match "prematurely" t (byte-code "\301`\302\303#f=\301`\302\211#b\210\207" [autopair-inserted scan-lists -1 0] 5) ((error t)) nil] 4))) always t autopair-inserted expected-closing prev-point pos-pair] 5])
#@87 Performs pairing and wrapping based on `autopair-action' and
`autopair-wrap-action'. 
(defalias 'autopair-post-command-handler #[nil "\203'\306\307\310\311\n	$+\204'\f\203 \312\313\314\217\210\202%\310\315\"\210\307
\205Q\306
\307\310\311\n	$+?\205Q\203I\312\316\317\217\210\202N\310\320
\"\210\307\211\207" [autopair-wrap-action cl-rest cl-seq cl-pred autopair-handle-wrap-action-fns autopair-action null nil apply some err (mapc #[(fn) "\302	\"\207" [fn autopair-wrap-action apply] 3] autopair-handle-wrap-action-fns) ((error (byte-code "\300\301!\210\302\303!\207" [message "[autopair] error running custom `autopair-handle-wrap-action-fns', switching autopair off" autopair-mode -1] 2))) autopair-default-handle-wrap-action (mapc #[(fn) "	@	\211A@)	\211AA)@#\207" [fn autopair-action x] 5] autopair-handle-action-fns) ((error (byte-code "\300\301!\210\302\303!\207" [message "[autopair] error running custom `autopair-handle-action-fns', switching autopair off" autopair-mode -1] 2))) autopair-default-handle-action autopair-handle-action-fns] 5 (#$ . 345581)])
(defalias 'autopair-blink-matching-open #[nil "\305	\306 +\207" [autopair-blink autopair-blink-delay blink-matching-delay show-paren-mode blink-matching-paren nil blink-matching-open] 3])
(defalias 'autopair-blink #[(&optional pos) "\205	\203\212	b\210\303\n!)\207\303\n!\207" [autopair-blink pos autopair-blink-delay sit-for] 2])
(defalias 'autopair-default-handle-action #[(action pair pos-before) "\300\301\302\217\207" [err (byte-code "\306=\203	`Sf=\204	c\210\307 \210\310u\207\311=\203&	c\210\307 \210\310u\207\312=\203:	`f=\203:\313\314!\210\315 \207\316=\203|\317\203L\212\320\321w)\f`\n\\f=\203x\322\314!\210\323\n!\204e\307`\n\\!\210\324=\203r\313\n!\210\202u\nu\210\321u\210\315 )\207\325=\203\215	`f=\203\215\313\314!\207\326=\205\274	`f=\205\274\212\327 \210)\330 \210\331\305!\203\254
\204\267\331\332!\205\274\205\274\333 \210\334 \207" [action pair skipped autopair-skip-whitespace autopair-inserted global-hl-line-mode opening autopair-blink -1 insert-quote skip-quote delete-char 1 autopair-blink-matching-open closing 0 " \n	" nil backward-delete-char zerop chomp backspace newline newline-and-indent indent-according-to-mode boundp hl-line-mode hl-line-unhighlight hl-line-highlight] 3) ((error (message "[autopair] Ignored error in `autopair-default-handle-action'")))] 3])
#@60 Default handler for the wrapping action in `autopair-wrap'
(defalias 'autopair-default-handle-wrap-action #[(action pair pos-before region-before) "\300\301\302\217\207" [err (byte-code "\306=\205_\307\n@\310=\203\"ATb\210\fc\210\311 \210@Tb\210\202[\n@\312=\203;\313\314!\210\fc\210ATb\210
c\210\202[\n@\315=\203PATb\210\fc\210\311 \210\202[\313\314!\210Ab\210
c\210\307\211)\207" [action delete-active-region autopair-action region-before pair autopair-inserted wrap nil opening autopair-blink closing delete-backward-char 1 insert-quote] 2) ((error (message "[autopair] Ignored error in `autopair-default-handle-wrap-action'")))] 3 (#$ . 348017)])
(defalias 'autopair-python-triple-quote-action #[(action pair pos-before) "\302=\203!`\303Y\203!`\303Z`{\304\303	\"\230\203!\212\304\305	\"c)\207\306=\203L`\305Y\203L`d\305ZX\203L`\305Z`\305\\{\304\307	\"\230\203L`\305Z`\305\\|\207\310=\203j`d\305ZX\203j``\305\\{\304\305	\"\230\203j\305u\207\311\207" [action pair insert-quote 3 make-string 2 backspace 4 skip-quote t] 4])
#@107 Pair or skip latex's "paired delimiter" syntax in math mode. Added AucText support, thanks Massimo Lauria
(defalias 'autopair-latex-mode-paired-delimiter-action #[(action pair pos-before) "\303=\205_`Sf	=\205_\304\n\305\"\306=\204+\304\nS\305\"\307=\204+\307\304\nS\305\"\235\203Z\310f	=\203Z\310f	=\203H`Tf	=\203H\311\312!\210\310u\207\nSf	=\203V	c\210\313u\207\311\312!\207	c\210\313u\207" [action pair pos-before paired-delimiter get-text-property face tex-math font-latex-math-face nil delete-char 1 -1] 4 (#$ . 349077)])
(defalias 'autopair-extra-insert-opening #[nil "\302 \303 \203\304\305!`E\306 \207" [autopair-inserted autopair-action autopair-calculate-inserted autopair-extra-pair-p opening autopair-find-pair autopair-fallback] 3 nil nil])
(put 'autopair-extra-insert-opening 'function-documentation '(concat "Insert (an extra) opening delimiter and possibly automatically close it.\n\n" (autopair-document-bindings)))
(defalias 'autopair-extra-skip-close-maybe #[nil "\302 \303 \203
\304`E\305 \207" [autopair-inserted autopair-action autopair-calculate-inserted autopair-extra-skip-p closing autopair-fallback] 3 nil nil])
(put 'autopair-extra-skip-close-maybe 'function-documentation '(concat "Insert or possibly skip over a (and extra) closing delimiter.\n\n" (autopair-document-bindings)))
(defalias 'autopair-extra-pair-p #[nil "\304 \211@\211A@)\305\306\307\"+\207" [syntax-triplet syntax-info x where-sym autopair-syntax-ppss some #[(sym) "\303	\n\304$\207" [where-sym sym autopair-extra-pairs autopair-exception-p car] 5] (:everywhere :comment :string :code)] 4])
(defalias 'autopair-extra-skip-p #[nil "\306 \211@\211A@)``f
=\205.\307\310\311\"\205.\212\312\313\314\217\210\315\316\317\320
!\"\f\321#),\207" [syntax-triplet syntax-info x where-sym orig-point autopair-inserted autopair-syntax-ppss some #[(sym) "\303	\n\304$\207" [where-sym sym autopair-extra-pairs autopair-exception-p cdr] 5] (:comment :string :code :everywhere) err (byte-code "\300d!\207" [backward-sexp] 2) ((error (byte-code "\211AA)@b\207" [err x] 2))) search-forward make-string 1 autopair-find-pair noerror] 6])
#@46  insert or skip a character paired delimiter
(defalias 'autopair-insert-or-skip-paired-delimiter #[nil "\302 \303`E\304 \207" [autopair-inserted autopair-action autopair-calculate-inserted paired-delimiter autopair-fallback] 3 (#$ . 351230) nil])
(byte-code "\300\301\302\303#\210\300\304\305\306#\210\300\307\305\306#\210\300\310\305\306#\210\300\311\305\306#\210\300\312\305\306#\210\300\313\305\314#\210\300\315\305\306#\207" [put autopair-insert-or-skip-paired-delimiter function-documentation (concat "Insert or possibly skip over a character with a syntax-class of \"paired delimiter\"." (autopair-document-bindings)) autopair-insert-opening delete-selection t autopair-skip-close-maybe autopair-insert-or-skip-quote autopair-extra-insert-opening autopair-extra-skip-close-maybe autopair-backspace supersede autopair-newline] 4)
(defalias 'autopair-should-autowrap #[nil "\303!\n\205\304=?\205\305\306\303!\"\205\307 )\207" [this-command name autopair-mode symbol-name autopair-backspace string-match "^autopair" autopair-calculate-wrap-action] 4])
(byte-code "\303\304\305\306\307$\210\310\304\307\"\210\303\311\312\306\307$\210\310\311\307\"\210\313 \314\315\316#\210\314\317\320#\210\314\321\322#\210\314\323\324#\210\314\325\326#\210\314\327\330#\210\314\331\332#\210\314\333\334#\210\314\335\336#\210\314\337\340#\210\314\341\342#\210\314\343\344#\210\314\345\346#\210\314\347\350#\210\314\351\350#\210\314\352\353#\210\314\354\355#\210\314\356\357#\210\314\360\355#\210\314\361\357#\210\314\362\363#\210\314\364\365#\210\314\366\367#\210\314\370\371#\210\314\372\373#\210\314\374\375#\210\314\376\377#\210\314\201@\201A#\210\314\201B\201C#\210\314\201D\201E#\210\314\201F\201G#\210\314\201H\201I#\210\314\201J\201K#\210\314\201L\201M#\210\314\201N\201O#\210\314\201P\201Q#\210\314\201R\201S#\210\314\201T\201U#\210\314\201V\201W#\210\314\201X\201Y#\210\314\201Z\201[#\210\314\201\\\201]#\210\314\201^\201_#\210\314\201`\201a#\210	\203v\314\201b	#\210\202\200\314\201c\201d#\210\201e\307!\210\201f\201g\201h\201i$\210\201j\307!\210\201f\201g\201k\201l$\210\201m\307!\210\201f\201g\201n\201o$\210\201p\307!\210\201f\201g\201q\201r$\210)\307\207" [map py-complete-function python-mode-map ad-add-advice cua--pre-command-handler-1 (autopair-override nil t (advice lambda nil "Don't actually do anything if autopair is about to autowrap. " (unless (autopair-should-autowrap) ad-do-it))) around nil ad-activate delete-selection-pre-hook (autopair-override nil t (advice lambda nil "Don't actually do anything if autopair is about to autowrap. " (unless (autopair-should-autowrap) ad-do-it))) make-sparse-keymap define-key [(:)] py-electric-colon [(\#)] py-electric-comment [(delete)] py-electric-delete [(backspace)] py-electric-backspace [(control backspace)] py-hungry-delete-backwards [(control c) (delete)] py-hungry-delete-forward [(control c) (control a)] py-mark-statement [(control c) (control p)] py-beginning-of-statement [(control c) (control n)] py-end-of-statement [(control c) (control u)] py-beginning-of-block [(control c) (control q)] py-end-of-block [(control meta a)] py-beginning-of-def-or-class [(control meta e)] py-end-of-def-or-class [(control j)] py-newline-and-indent "
" [(super backspace)] py-dedent [(control c) (control l)] py-shift-left [(control c) (control r)] py-shift-right [(control c) (<)] [(control c) (>)] [(control c) (tab)] py-indent-region [(control c) (:)] py-guess-indent-offset [(control c) (control c)] py-execute-buffer [(control c) (control m)] py-execute-import-or-reload [(control c) (control s)] py-execute-string [(control c) (|)] py-execute-region [(control meta x)] py-execute-def-or-class [(control c) (!)] py-shell [(control c) (control t)] py-toggle-shell [(control meta h)] py-mark-def-or-class [(control c) (control k)] py-mark-block-or-clause [(control c) (\.)] py-expression [(control c) (control d)] py-pdbtrack-toggle-stack-tracking [(control c) (control f)] py-sort-imports [(control c) (\#)] py-comment-region [(control c) (\?)] py-describe-mode [(control c) (control e)] py-describe-symbol [(control c) (-)] py-up-exception [(control c) (=)] py-down-exception [(control x) (n) (d)] py-narrow-to-defun [(control c) (control b)] py-submit-bug-report [(control c) (control v)] py-version [(control c) (control w)] py-pychecker-run "	" py-indent-line [(meta tab)] [(meta tab)] py-shell-complete (lambda (#1=#:def-tmp-var) (defvar py-menu #1# #2="Python Tools")) easy-menu-do-define py-menu #2# ("PyTools" :help "Python mode tools" ["Customize Python mode" (customize-group 'python-mode) :help "Open the customization buffer for Python mode"] "-" ["pychecker-run" py-pychecker-run :help "`py-pychecker-run'\nRun pychecker"] ("Pylint ... " :help "Extendet report options\ncall `easy_install pylint' if not available" ["pylint-run" py-pylint-run :help "`pylint-run'\nPylint will display a number of messages as it analyzes the code,\nas well as some statistics about the number of warnings and\nerrors found in different files - unless called with arg \"--errors-only\". The messages are classified\nunder various categories such as errors and warnings\n\nPylint checks length of lines of code, if variable names are\nwell-formed according to your coding standard, if declared\ninterfaces are truly implemented, and much more. Additionally, it\nis possible to write plugins.\n\ncall `easy_install pylint' if not available\n"] ["pylint-help" pylint-help :help "`pylint-help'\nList extendet report options\n"] ["pylint-flymake-mode" pylint-flymake-mode :help "`pylint-flymake-mode'\nToggle flymake-mode running `pylint'\n"]) ("pep8 ... " :help "Check formatting\ncall `easy_install pep8' if not available" ["pep8-run" py-pep8-run :help "`py-pep8-run'\nCheck formatting (default on the file currently visited)\ncall `easy_install pep8' if not available\n"] ["pep8-help" py-pep8-help :help "`py-pep8-help'\nDisplay help for pep8 format checker)\n"] ["pep8-flymake-mode" pep8-flymake-mode :help "`pep8-flymake-mode'\nToggle flymake-mode running `pep8'\n"]) ("Pyflakes ... " :help "Non intrusive code\n             checker call `easy_install pyflakes' if\n             not available" ["pyflakes-run" py-pyflakes-run :help "`py-pyflakes-run' Run pyflakes call\n              `easy_install pyflakes' if not\n              available"] ["pyflakes-help" py-pyflakes-help :help "`py-pyflakes-help' Display help for\n              Pyflakes "] ["pyflakes-flymake-mode" pyflakes-flymake-mode :help "`pyflakes-flymake-mode'\nToggle flymake-mode running `pyflakes' "]) ("Pyflakes-pep8 ... " :help "Non intrusive code checker running `pyflakes' and `pep8'\ncall `easy_install pyflakes' and `easy_install pep8' if basics not available" ["pyflakespep8-run" py-pyflakespep8-run :help "`py-pyflakespep8-run' Run `pyflakespep8'\ncall `easy_install pyflakes' if not available"] ["pyflakespep8-help" py-pyflakespep8-help :help "`py-pyflakespep8-help' Display help for\n              Pyflakespep8 "] ["pyflakespep8-flymake-mode" pyflakespep8-flymake-mode :help "`pyflakespep8-flymake-mode'\nToggle flymake-mode running `pyflakespep8' "]) "-" ("Abbrevs" :help "see also `py-add-abbrev'" :filter (lambda (&rest junk) (abbrev-table-menu python-mode-abbrev-table))) ["add-abbrev" py-add-abbrev :help "Defines python-mode specific abbrev for last expressions before point.\nArgument is how many `py-partial-expression's form the expansion; or zero means the region is the expansion. "] ("Skeletons" :help "See also templates in YASnippet" ["if" py-if :help "Inserts if-statement"] ["py-else" py-else :help "Inserts else-statement"] ["py-while" py-while :help "Inserts while-statement"] ["py-for" py-for :help "Inserts for-statement"] ["py-try/finally" py-try/finally :help "Inserts py-try/finally-statement"] ["py-try/except" py-try/except :help "Inserts py-try/except-statement"]) "-" ["Import/reload file" py-execute-import-or-reload :help "`py-execute-import-or-reload'\nLoad into inferior Python session"] ["Debugger" pdb :help "`pdb'\nRun pdb under GUD"] "-" ["Toggle autopair-mode" autopair-mode :help "When `py-prepare-autopair-mode-p' is `t', this toggles `autopair-mode' "] ["Toggle py-smart-indentation" toggle-py-smart-indentation :help "See also `py-smart-indentation-on', `-off' "] ["Toggle indent-tabs-mode" py-toggle-indent-tabs-mode :help "See also `py-indent-tabs-mode-on', `-off' "] ["Help on symbol" py-describe-symbol :help "`py-describe-symbol'\nUse pydoc on symbol at point"] ["Complete symbol" py-shell-complete :help "`py-shell-complete'\nComplete (qualified) symbol before point"] ["Find function" py-find-function :help "`py-find-function'\nTry to find source definition of function at point"] ["Update imports" py-update-imports :help "`py-update-imports'\nUpdate list of top-level imports for completion"] "-") (lambda (#1#) (defvar py-menu #1# #3="Execute Python")) #3# ("PyExec" :help "Python-specific features" ["Execute statement" py-execute-statement :help "`py-execute-statement'\n       Send statement at point to Python interpreter. "] ["Execute block" py-execute-block :help "`py-execute-block'\n       Send block at point to Python interpreter. "] ["Execute block-or-clause" py-execute-block-or-clause :help "`py-execute-block-or-clause'\n       Send block-or-clause at point to Python interpreter. "] ["Execute def" py-execute-def :help "`py-execute-def'\n       Send def at point to Python interpreter. "] ["Execute class" py-execute-class :help "`py-execute-class'\n       Send class at point to Python interpreter. "] ["Execute region" py-execute-region :help "`py-execute-region'\n       Send region at point to Python interpreter. "] ["Execute buffer" py-execute-buffer :help "`py-execute-buffer'\n       Send buffer at point to Python interpreter. "] ["Execute file" py-execute-file :help "`py-execute-file'\n       Send file at point to Python interpreter. "] ["Execute line" py-execute-line :help "`py-execute-line'\n       Send current line from beginning of indent to Python interpreter. "] ["Execute expression" py-execute-expression :help "`py-execute-expression'\n       Send expression at point to Python interpreter. "] ["Execute partial-expression" py-execute-partial-expression :help "`py-execute-partial-expression'\n       Send partial-expression at point to Python interpreter. "] ["Execute line" py-execute-line :help "`py-execute-line'\n       Send line at point to Python interpreter. "] ("Execute statement ... " :help "Execute statement functions" ["py-execute-statement-python" py-execute-statement-python :help "Execute statement through a Python interpreter.\n        With \\[universal-argument] use an unique Python interpreter. "] ["py-execute-statement-ipython" py-execute-statement-ipython :help "Execute statement through an IPython interpreter.\n        With \\[universal-argument] use an unique IPython interpreter. "] ["py-execute-statement-python3" py-execute-statement-python3 :help "Execute statement through a Python3 interpreter.\n        With \\[universal-argument] use an unique Python3 interpreter. "] ["py-execute-statement-python2" py-execute-statement-python2 :help "Execute statement through a Python2 interpreter.\n        With \\[universal-argument] use an unique Python2 interpreter. "] ["py-execute-statement-python2.7" py-execute-statement-python2\.7 :help "Execute statement through a Python2.7 interpreter.\n        With \\[universal-argument] use an unique Python2.7 interpreter. "] ["py-execute-statement-jython" py-execute-statement-jython :help "Execute statement through a Jython interpreter.\n        With \\[universal-argument] use an unique Jython interpreter. "] ["py-execute-statement-python3.2" py-execute-statement-python3\.2 :help "Execute statement through a Python3.2 interpreter.\n        With \\[universal-argument] use an unique Python3.2 interpreter. "] ["py-execute-statement-python-dedicated" py-execute-statement-python-dedicated :help "Execute statement through a unique Python interpreter.\nOptional \\[universal-argument] forces switch to output buffer, ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-statement-ipython-dedicated" py-execute-statement-ipython-dedicated :help "Execute statement through a unique IPython interpreter.\nOptional \\[universal-argument] forces switch to output buffer, ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-statement-python3-dedicated" py-execute-statement-python3-dedicated :help "Execute statement through a unique Python3 interpreter.\nOptional \\[universal-argument] forces switch to output buffer, ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-statement-python2-dedicated" py-execute-statement-python2-dedicated :help "Execute statement through a unique Python2 interpreter.\nOptional \\[universal-argument] forces switch to output buffer, ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-statement-python2.7-dedicated" py-execute-statement-python2\.7-dedicated :help "Execute statement through a unique Python2.7 interpreter.\nOptional \\[universal-argument] forces switch to output buffer, ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-statement-jython-dedicated" py-execute-statement-jython-dedicated :help "Execute statement through a unique Jython interpreter.\nOptional \\[universal-argument] forces switch to output buffer, ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-statement-python3.2-dedicated" py-execute-statement-python3\.2-dedicated :help "Execute statement through a unique Python3.2 interpreter.\nOptional \\[universal-argument] forces switch to output buffer, ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-statement-python-switch" py-execute-statement-python-switch :help "Execute statement through a Python interpreter.\nWith \\[universal-argument] use an unique Python interpreter. "] ["py-execute-statement-ipython-switch" py-execute-statement-ipython-switch :help "Execute statement through an IPython interpreter.\nWith \\[universal-argument] use an unique IPython interpreter. "] ["py-execute-statement-python3-switch" py-execute-statement-python3-switch :help "Execute statement through a Python3 interpreter.\nWith \\[universal-argument] use an unique Python3 interpreter. "] ["py-execute-statement-python2-switch" py-execute-statement-python2-switch :help "Execute statement through a Python2 interpreter.\nWith \\[universal-argument] use an unique Python2 interpreter. "] ["py-execute-statement-python2.7-switch" py-execute-statement-python2\.7-switch :help "Execute statement through a Python2.7 interpreter.\nWith \\[universal-argument] use an unique Python2.7 interpreter. "] ["py-execute-statement-jython-switch" py-execute-statement-jython-switch :help "Execute statement through a Jython interpreter.\nWith \\[universal-argument] use an unique Jython interpreter. "] ["py-execute-statement-python3.2-switch" py-execute-statement-python3\.2-switch :help "Execute statement through a Python3.2 interpreter.\nWith \\[universal-argument] use an unique Python3.2 interpreter. "] ["py-execute-statement-python-dedicated-switch" py-execute-statement-python-dedicated-switch :help "Execute statement through a unique Python interpreter.\nSwitch to output buffer; ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-statement-ipython-dedicated-switch" py-execute-statement-ipython-dedicated-switch :help "Execute statement through a uniquen IPython interpreter.\nSwitch to output buffer; ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-statement-python3-dedicated-switch" py-execute-statement-python3-dedicated-switch :help "Execute statement through a unique Python3 interpreter.\nSwitch to output buffer; ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-statement-python2-dedicated-switch" py-execute-statement-python2-dedicated-switch :help "Execute statement through a unique Python2 interpreter.\nSwitch to output buffer; ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-statement-python2.7-dedicated-switch" py-execute-statement-python2\.7-dedicated-switch :help "Execute statement through a unique Python2.7 interpreter.\nSwitch to output buffer; ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-statement-jython-dedicated-switch" py-execute-statement-jython-dedicated-switch :help "Execute statement through a unique Jython interpreter.\nSwitch to output buffer; ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-statement-python3.2-dedicated-switch" py-execute-statement-python3\.2-dedicated-switch :help "Execute statement through a unique Python3.2 interpreter.\nSwitch to output buffer; ignores `py-switch-buffers-on-execute-p'. "]) ("Execute block ... " :help "Execute block functions" ["py-execute-block-python" py-execute-block-python :help "Execute block through a Python interpreter.\n        With \\[universal-argument] use an unique Python interpreter. "] ["py-execute-block-ipython" py-execute-block-ipython :help "Execute block through an IPython interpreter.\n        With \\[universal-argument] use an unique IPython interpreter. "] ["py-execute-block-python3" py-execute-block-python3 :help "Execute block through a Python3 interpreter.\n        With \\[universal-argument] use an unique Python3 interpreter. "] ["py-execute-block-python2" py-execute-block-python2 :help "Execute block through a Python2 interpreter.\n        With \\[universal-argument] use an unique Python2 interpreter. "] ["py-execute-block-python2.7" py-execute-block-python2\.7 :help "Execute block through a Python2.7 interpreter.\n        With \\[universal-argument] use an unique Python2.7 interpreter. "] ["py-execute-block-jython" py-execute-block-jython :help "Execute block through a Jython interpreter.\n        With \\[universal-argument] use an unique Jython interpreter. "] ["py-execute-block-python3.2" py-execute-block-python3\.2 :help "Execute block through a Python3.2 interpreter.\n        With \\[universal-argument] use an unique Python3.2 interpreter. "] ["py-execute-block-python-dedicated" py-execute-block-python-dedicated :help "Execute block through a unique Python interpreter.\nOptional \\[universal-argument] forces switch to output buffer, ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-block-ipython-dedicated" py-execute-block-ipython-dedicated :help "Execute block through a unique IPython interpreter.\nOptional \\[universal-argument] forces switch to output buffer, ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-block-python3-dedicated" py-execute-block-python3-dedicated :help "Execute block through a unique Python3 interpreter.\nOptional \\[universal-argument] forces switch to output buffer, ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-block-python2-dedicated" py-execute-block-python2-dedicated :help "Execute block through a unique Python2 interpreter.\nOptional \\[universal-argument] forces switch to output buffer, ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-block-python2.7-dedicated" py-execute-block-python2\.7-dedicated :help "Execute block through a unique Python2.7 interpreter.\nOptional \\[universal-argument] forces switch to output buffer, ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-block-jython-dedicated" py-execute-block-jython-dedicated :help "Execute block through a unique Jython interpreter.\nOptional \\[universal-argument] forces switch to output buffer, ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-block-python3.2-dedicated" py-execute-block-python3\.2-dedicated :help "Execute block through a unique Python3.2 interpreter.\nOptional \\[universal-argument] forces switch to output buffer, ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-block-python-switch" py-execute-block-python-switch :help "Execute block through a Python interpreter.\nWith \\[universal-argument] use an unique Python interpreter. "] ["py-execute-block-ipython-switch" py-execute-block-ipython-switch :help "Execute block through an IPython interpreter.\nWith \\[universal-argument] use an unique IPython interpreter. "] ["py-execute-block-python3-switch" py-execute-block-python3-switch :help "Execute block through a Python3 interpreter.\nWith \\[universal-argument] use an unique Python3 interpreter. "] ["py-execute-block-python2-switch" py-execute-block-python2-switch :help "Execute block through a Python2 interpreter.\nWith \\[universal-argument] use an unique Python2 interpreter. "] ["py-execute-block-python2.7-switch" py-execute-block-python2\.7-switch :help "Execute block through a Python2.7 interpreter.\nWith \\[universal-argument] use an unique Python2.7 interpreter. "] ["py-execute-block-jython-switch" py-execute-block-jython-switch :help "Execute block through a Jython interpreter.\nWith \\[universal-argument] use an unique Jython interpreter. "] ["py-execute-block-python3.2-switch" py-execute-block-python3\.2-switch :help "Execute block through a Python3.2 interpreter.\nWith \\[universal-argument] use an unique Python3.2 interpreter. "] ["py-execute-block-python-dedicated-switch" py-execute-block-python-dedicated-switch :help "Execute block through a unique Python interpreter.\nSwitch to output buffer; ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-block-ipython-dedicated-switch" py-execute-block-ipython-dedicated-switch :help "Execute block through a uniquen IPython interpreter.\nSwitch to output buffer; ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-block-python3-dedicated-switch" py-execute-block-python3-dedicated-switch :help "Execute block through a unique Python3 interpreter.\nSwitch to output buffer; ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-block-python2-dedicated-switch" py-execute-block-python2-dedicated-switch :help "Execute block through a unique Python2 interpreter.\nSwitch to output buffer; ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-block-python2.7-dedicated-switch" py-execute-block-python2\.7-dedicated-switch :help "Execute block through a unique Python2.7 interpreter.\nSwitch to output buffer; ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-block-jython-dedicated-switch" py-execute-block-jython-dedicated-switch :help "Execute block through a unique Jython interpreter.\nSwitch to output buffer; ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-block-python3.2-dedicated-switch" py-execute-block-python3\.2-dedicated-switch :help "Execute block through a unique Python3.2 interpreter.\nSwitch to output buffer; ignores `py-switch-buffers-on-execute-p'. "]) ("Execute block-or-clause ... " :help "Execute block-or-clause functions" ["py-execute-block-or-clause-python" py-execute-block-or-clause-python :help "Execute block-or-clause through a Python interpreter.\n        With \\[universal-argument] use an unique Python interpreter. "] ["py-execute-block-or-clause-ipython" py-execute-block-or-clause-ipython :help "Execute block-or-clause through an IPython interpreter.\n        With \\[universal-argument] use an unique IPython interpreter. "] ["py-execute-block-or-clause-python3" py-execute-block-or-clause-python3 :help "Execute block-or-clause through a Python3 interpreter.\n        With \\[universal-argument] use an unique Python3 interpreter. "] ["py-execute-block-or-clause-python2" py-execute-block-or-clause-python2 :help "Execute block-or-clause through a Python2 interpreter.\n        With \\[universal-argument] use an unique Python2 interpreter. "] ["py-execute-block-or-clause-python2.7" py-execute-block-or-clause-python2\.7 :help "Execute block-or-clause through a Python2.7 interpreter.\n        With \\[universal-argument] use an unique Python2.7 interpreter. "] ["py-execute-block-or-clause-jython" py-execute-block-or-clause-jython :help "Execute block-or-clause through a Jython interpreter.\n        With \\[universal-argument] use an unique Jython interpreter. "] ["py-execute-block-or-clause-python3.2" py-execute-block-or-clause-python3\.2 :help "Execute block-or-clause through a Python3.2 interpreter.\n        With \\[universal-argument] use an unique Python3.2 interpreter. "] ["py-execute-block-or-clause-python-dedicated" py-execute-block-or-clause-python-dedicated :help "Execute block-or-clause through a unique Python interpreter.\nOptional \\[universal-argument] forces switch to output buffer, ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-block-or-clause-ipython-dedicated" py-execute-block-or-clause-ipython-dedicated :help "Execute block-or-clause through a unique IPython interpreter.\nOptional \\[universal-argument] forces switch to output buffer, ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-block-or-clause-python3-dedicated" py-execute-block-or-clause-python3-dedicated :help "Execute block-or-clause through a unique Python3 interpreter.\nOptional \\[universal-argument] forces switch to output buffer, ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-block-or-clause-python2-dedicated" py-execute-block-or-clause-python2-dedicated :help "Execute block-or-clause through a unique Python2 interpreter.\nOptional \\[universal-argument] forces switch to output buffer, ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-block-or-clause-python2.7-dedicated" py-execute-block-or-clause-python2\.7-dedicated :help "Execute block-or-clause through a unique Python2.7 interpreter.\nOptional \\[universal-argument] forces switch to output buffer, ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-block-or-clause-jython-dedicated" py-execute-block-or-clause-jython-dedicated :help "Execute block-or-clause through a unique Jython interpreter.\nOptional \\[universal-argument] forces switch to output buffer, ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-block-or-clause-python3.2-dedicated" py-execute-block-or-clause-python3\.2-dedicated :help "Execute block-or-clause through a unique Python3.2 interpreter.\nOptional \\[universal-argument] forces switch to output buffer, ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-block-or-clause-python-switch" py-execute-block-or-clause-python-switch :help "Execute block-or-clause through a Python interpreter.\nWith \\[universal-argument] use an unique Python interpreter. "] ["py-execute-block-or-clause-ipython-switch" py-execute-block-or-clause-ipython-switch :help "Execute block-or-clause through an IPython interpreter.\nWith \\[universal-argument] use an unique IPython interpreter. "] ["py-execute-block-or-clause-python3-switch" py-execute-block-or-clause-python3-switch :help "Execute block-or-clause through a Python3 interpreter.\nWith \\[universal-argument] use an unique Python3 interpreter. "] ["py-execute-block-or-clause-python2-switch" py-execute-block-or-clause-python2-switch :help "Execute block-or-clause through a Python2 interpreter.\nWith \\[universal-argument] use an unique Python2 interpreter. "] ["py-execute-block-or-clause-python2.7-switch" py-execute-block-or-clause-python2\.7-switch :help "Execute block-or-clause through a Python2.7 interpreter.\nWith \\[universal-argument] use an unique Python2.7 interpreter. "] ["py-execute-block-or-clause-jython-switch" py-execute-block-or-clause-jython-switch :help "Execute block-or-clause through a Jython interpreter.\nWith \\[universal-argument] use an unique Jython interpreter. "] ["py-execute-block-or-clause-python3.2-switch" py-execute-block-or-clause-python3\.2-switch :help "Execute block-or-clause through a Python3.2 interpreter.\nWith \\[universal-argument] use an unique Python3.2 interpreter. "] ["py-execute-block-or-clause-python-dedicated-switch" py-execute-block-or-clause-python-dedicated-switch :help "Execute block-or-clause through a unique Python interpreter.\nSwitch to output buffer; ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-block-or-clause-ipython-dedicated-switch" py-execute-block-or-clause-ipython-dedicated-switch :help "Execute block-or-clause through a uniquen IPython interpreter.\nSwitch to output buffer; ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-block-or-clause-python3-dedicated-switch" py-execute-block-or-clause-python3-dedicated-switch :help "Execute block-or-clause through a unique Python3 interpreter.\nSwitch to output buffer; ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-block-or-clause-python2-dedicated-switch" py-execute-block-or-clause-python2-dedicated-switch :help "Execute block-or-clause through a unique Python2 interpreter.\nSwitch to output buffer; ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-block-or-clause-python2.7-dedicated-switch" py-execute-block-or-clause-python2\.7-dedicated-switch :help "Execute block-or-clause through a unique Python2.7 interpreter.\nSwitch to output buffer; ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-block-or-clause-jython-dedicated-switch" py-execute-block-or-clause-jython-dedicated-switch :help "Execute block-or-clause through a unique Jython interpreter.\nSwitch to output buffer; ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-block-or-clause-python3.2-dedicated-switch" py-execute-block-or-clause-python3\.2-dedicated-switch :help "Execute block-or-clause through a unique Python3.2 interpreter.\nSwitch to output buffer; ignores `py-switch-buffers-on-execute-p'. "]) ("Execute def ... " :help "Execute def functions" ["py-execute-def-python" py-execute-def-python :help "Execute def through a Python interpreter.\n        With \\[universal-argument] use an unique Python interpreter. "] ["py-execute-def-ipython" py-execute-def-ipython :help "Execute def through an IPython interpreter.\n        With \\[universal-argument] use an unique IPython interpreter. "] ["py-execute-def-python3" py-execute-def-python3 :help "Execute def through a Python3 interpreter.\n        With \\[universal-argument] use an unique Python3 interpreter. "] ["py-execute-def-python2" py-execute-def-python2 :help "Execute def through a Python2 interpreter.\n        With \\[universal-argument] use an unique Python2 interpreter. "] ["py-execute-def-python2.7" py-execute-def-python2\.7 :help "Execute def through a Python2.7 interpreter.\n        With \\[universal-argument] use an unique Python2.7 interpreter. "] ["py-execute-def-jython" py-execute-def-jython :help "Execute def through a Jython interpreter.\n        With \\[universal-argument] use an unique Jython interpreter. "] ["py-execute-def-python3.2" py-execute-def-python3\.2 :help "Execute def through a Python3.2 interpreter.\n        With \\[universal-argument] use an unique Python3.2 interpreter. "] ["py-execute-def-python-dedicated" py-execute-def-python-dedicated :help "Execute def through a unique Python interpreter.\nOptional \\[universal-argument] forces switch to output buffer, ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-def-ipython-dedicated" py-execute-def-ipython-dedicated :help "Execute def through a unique IPython interpreter.\nOptional \\[universal-argument] forces switch to output buffer, ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-def-python3-dedicated" py-execute-def-python3-dedicated :help "Execute def through a unique Python3 interpreter.\nOptional \\[universal-argument] forces switch to output buffer, ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-def-python2-dedicated" py-execute-def-python2-dedicated :help "Execute def through a unique Python2 interpreter.\nOptional \\[universal-argument] forces switch to output buffer, ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-def-python2.7-dedicated" py-execute-def-python2\.7-dedicated :help "Execute def through a unique Python2.7 interpreter.\nOptional \\[universal-argument] forces switch to output buffer, ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-def-jython-dedicated" py-execute-def-jython-dedicated :help "Execute def through a unique Jython interpreter.\nOptional \\[universal-argument] forces switch to output buffer, ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-def-python3.2-dedicated" py-execute-def-python3\.2-dedicated :help "Execute def through a unique Python3.2 interpreter.\nOptional \\[universal-argument] forces switch to output buffer, ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-def-python-switch" py-execute-def-python-switch :help "Execute def through a Python interpreter.\nWith \\[universal-argument] use an unique Python interpreter. "] ["py-execute-def-ipython-switch" py-execute-def-ipython-switch :help "Execute def through an IPython interpreter.\nWith \\[universal-argument] use an unique IPython interpreter. "] ["py-execute-def-python3-switch" py-execute-def-python3-switch :help "Execute def through a Python3 interpreter.\nWith \\[universal-argument] use an unique Python3 interpreter. "] ["py-execute-def-python2-switch" py-execute-def-python2-switch :help "Execute def through a Python2 interpreter.\nWith \\[universal-argument] use an unique Python2 interpreter. "] ["py-execute-def-python2.7-switch" py-execute-def-python2\.7-switch :help "Execute def through a Python2.7 interpreter.\nWith \\[universal-argument] use an unique Python2.7 interpreter. "] ["py-execute-def-jython-switch" py-execute-def-jython-switch :help "Execute def through a Jython interpreter.\nWith \\[universal-argument] use an unique Jython interpreter. "] ["py-execute-def-python3.2-switch" py-execute-def-python3\.2-switch :help "Execute def through a Python3.2 interpreter.\nWith \\[universal-argument] use an unique Python3.2 interpreter. "] ["py-execute-def-python-dedicated-switch" py-execute-def-python-dedicated-switch :help "Execute def through a unique Python interpreter.\nSwitch to output buffer; ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-def-ipython-dedicated-switch" py-execute-def-ipython-dedicated-switch :help "Execute def through a uniquen IPython interpreter.\nSwitch to output buffer; ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-def-python3-dedicated-switch" py-execute-def-python3-dedicated-switch :help "Execute def through a unique Python3 interpreter.\nSwitch to output buffer; ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-def-python2-dedicated-switch" py-execute-def-python2-dedicated-switch :help "Execute def through a unique Python2 interpreter.\nSwitch to output buffer; ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-def-python2.7-dedicated-switch" py-execute-def-python2\.7-dedicated-switch :help "Execute def through a unique Python2.7 interpreter.\nSwitch to output buffer; ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-def-jython-dedicated-switch" py-execute-def-jython-dedicated-switch :help "Execute def through a unique Jython interpreter.\nSwitch to output buffer; ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-def-python3.2-dedicated-switch" py-execute-def-python3\.2-dedicated-switch :help "Execute def through a unique Python3.2 interpreter.\nSwitch to output buffer; ignores `py-switch-buffers-on-execute-p'. "]) ("Execute class ... " :help "Execute class functions" ["py-execute-class-python" py-execute-class-python :help "Execute class through a Python interpreter.\n        With \\[universal-argument] use an unique Python interpreter. "] ["py-execute-class-ipython" py-execute-class-ipython :help "Execute class through an IPython interpreter.\n        With \\[universal-argument] use an unique IPython interpreter. "] ["py-execute-class-python3" py-execute-class-python3 :help "Execute class through a Python3 interpreter.\n        With \\[universal-argument] use an unique Python3 interpreter. "] ["py-execute-class-python2" py-execute-class-python2 :help "Execute class through a Python2 interpreter.\n        With \\[universal-argument] use an unique Python2 interpreter. "] ["py-execute-class-python2.7" py-execute-class-python2\.7 :help "Execute class through a Python2.7 interpreter.\n        With \\[universal-argument] use an unique Python2.7 interpreter. "] ["py-execute-class-jython" py-execute-class-jython :help "Execute class through a Jython interpreter.\n        With \\[universal-argument] use an unique Jython interpreter. "] ["py-execute-class-python3.2" py-execute-class-python3\.2 :help "Execute class through a Python3.2 interpreter.\n        With \\[universal-argument] use an unique Python3.2 interpreter. "] ["py-execute-class-python-dedicated" py-execute-class-python-dedicated :help "Execute class through a unique Python interpreter.\nOptional \\[universal-argument] forces switch to output buffer, ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-class-ipython-dedicated" py-execute-class-ipython-dedicated :help "Execute class through a unique IPython interpreter.\nOptional \\[universal-argument] forces switch to output buffer, ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-class-python3-dedicated" py-execute-class-python3-dedicated :help "Execute class through a unique Python3 interpreter.\nOptional \\[universal-argument] forces switch to output buffer, ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-class-python2-dedicated" py-execute-class-python2-dedicated :help "Execute class through a unique Python2 interpreter.\nOptional \\[universal-argument] forces switch to output buffer, ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-class-python2.7-dedicated" py-execute-class-python2\.7-dedicated :help "Execute class through a unique Python2.7 interpreter.\nOptional \\[universal-argument] forces switch to output buffer, ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-class-jython-dedicated" py-execute-class-jython-dedicated :help "Execute class through a unique Jython interpreter.\nOptional \\[universal-argument] forces switch to output buffer, ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-class-python3.2-dedicated" py-execute-class-python3\.2-dedicated :help "Execute class through a unique Python3.2 interpreter.\nOptional \\[universal-argument] forces switch to output buffer, ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-class-python-switch" py-execute-class-python-switch :help "Execute class through a Python interpreter.\nWith \\[universal-argument] use an unique Python interpreter. "] ["py-execute-class-ipython-switch" py-execute-class-ipython-switch :help "Execute class through an IPython interpreter.\nWith \\[universal-argument] use an unique IPython interpreter. "] ["py-execute-class-python3-switch" py-execute-class-python3-switch :help "Execute class through a Python3 interpreter.\nWith \\[universal-argument] use an unique Python3 interpreter. "] ["py-execute-class-python2-switch" py-execute-class-python2-switch :help "Execute class through a Python2 interpreter.\nWith \\[universal-argument] use an unique Python2 interpreter. "] ["py-execute-class-python2.7-switch" py-execute-class-python2\.7-switch :help "Execute class through a Python2.7 interpreter.\nWith \\[universal-argument] use an unique Python2.7 interpreter. "] ["py-execute-class-jython-switch" py-execute-class-jython-switch :help "Execute class through a Jython interpreter.\nWith \\[universal-argument] use an unique Jython interpreter. "] ["py-execute-class-python3.2-switch" py-execute-class-python3\.2-switch :help "Execute class through a Python3.2 interpreter.\nWith \\[universal-argument] use an unique Python3.2 interpreter. "] ["py-execute-class-python-dedicated-switch" py-execute-class-python-dedicated-switch :help "Execute class through a unique Python interpreter.\nSwitch to output buffer; ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-class-ipython-dedicated-switch" py-execute-class-ipython-dedicated-switch :help "Execute class through a uniquen IPython interpreter.\nSwitch to output buffer; ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-class-python3-dedicated-switch" py-execute-class-python3-dedicated-switch :help "Execute class through a unique Python3 interpreter.\nSwitch to output buffer; ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-class-python2-dedicated-switch" py-execute-class-python2-dedicated-switch :help "Execute class through a unique Python2 interpreter.\nSwitch to output buffer; ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-class-python2.7-dedicated-switch" py-execute-class-python2\.7-dedicated-switch :help "Execute class through a unique Python2.7 interpreter.\nSwitch to output buffer; ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-class-jython-dedicated-switch" py-execute-class-jython-dedicated-switch :help "Execute class through a unique Jython interpreter.\nSwitch to output buffer; ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-class-python3.2-dedicated-switch" py-execute-class-python3\.2-dedicated-switch :help "Execute class through a unique Python3.2 interpreter.\nSwitch to output buffer; ignores `py-switch-buffers-on-execute-p'. "]) ("Execute region ... " :help "Execute region functions" ["py-execute-region-python" py-execute-region-python :help "Execute region through a Python interpreter.\n        With \\[universal-argument] use an unique Python interpreter. "] ["py-execute-region-ipython" py-execute-region-ipython :help "Execute region through an IPython interpreter.\n        With \\[universal-argument] use an unique IPython interpreter. "] ["py-execute-region-python3" py-execute-region-python3 :help "Execute region through a Python3 interpreter.\n        With \\[universal-argument] use an unique Python3 interpreter. "] ["py-execute-region-python2" py-execute-region-python2 :help "Execute region through a Python2 interpreter.\n        With \\[universal-argument] use an unique Python2 interpreter. "] ["py-execute-region-python2.7" py-execute-region-python2\.7 :help "Execute region through a Python2.7 interpreter.\n        With \\[universal-argument] use an unique Python2.7 interpreter. "] ["py-execute-region-jython" py-execute-region-jython :help "Execute region through a Jython interpreter.\n        With \\[universal-argument] use an unique Jython interpreter. "] ["py-execute-region-python3.2" py-execute-region-python3\.2 :help "Execute region through a Python3.2 interpreter.\n        With \\[universal-argument] use an unique Python3.2 interpreter. "] ["py-execute-region-python-dedicated" py-execute-region-python-dedicated :help "Execute region through a unique Python interpreter.\nOptional \\[universal-argument] forces switch to output buffer, ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-region-ipython-dedicated" py-execute-region-ipython-dedicated :help "Execute region through a unique IPython interpreter.\nOptional \\[universal-argument] forces switch to output buffer, ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-region-python3-dedicated" py-execute-region-python3-dedicated :help "Execute region through a unique Python3 interpreter.\nOptional \\[universal-argument] forces switch to output buffer, ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-region-python2-dedicated" py-execute-region-python2-dedicated :help "Execute region through a unique Python2 interpreter.\nOptional \\[universal-argument] forces switch to output buffer, ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-region-python2.7-dedicated" py-execute-region-python2\.7-dedicated :help "Execute region through a unique Python2.7 interpreter.\nOptional \\[universal-argument] forces switch to output buffer, ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-region-jython-dedicated" py-execute-region-jython-dedicated :help "Execute region through a unique Jython interpreter.\nOptional \\[universal-argument] forces switch to output buffer, ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-region-python3.2-dedicated" py-execute-region-python3\.2-dedicated :help "Execute region through a unique Python3.2 interpreter.\nOptional \\[universal-argument] forces switch to output buffer, ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-region-python-switch" py-execute-region-python-switch :help "Execute region through a Python interpreter.\nWith \\[universal-argument] use an unique Python interpreter. "] ["py-execute-region-ipython-switch" py-execute-region-ipython-switch :help "Execute region through an IPython interpreter.\nWith \\[universal-argument] use an unique IPython interpreter. "] ["py-execute-region-python3-switch" py-execute-region-python3-switch :help "Execute region through a Python3 interpreter.\nWith \\[universal-argument] use an unique Python3 interpreter. "] ["py-execute-region-python2-switch" py-execute-region-python2-switch :help "Execute region through a Python2 interpreter.\nWith \\[universal-argument] use an unique Python2 interpreter. "] ["py-execute-region-python2.7-switch" py-execute-region-python2\.7-switch :help "Execute region through a Python2.7 interpreter.\nWith \\[universal-argument] use an unique Python2.7 interpreter. "] ["py-execute-region-jython-switch" py-execute-region-jython-switch :help "Execute region through a Jython interpreter.\nWith \\[universal-argument] use an unique Jython interpreter. "] ["py-execute-region-python3.2-switch" py-execute-region-python3\.2-switch :help "Execute region through a Python3.2 interpreter.\nWith \\[universal-argument] use an unique Python3.2 interpreter. "] ["py-execute-region-python-dedicated-switch" py-execute-region-python-dedicated-switch :help "Execute region through a unique Python interpreter.\nSwitch to output buffer; ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-region-ipython-dedicated-switch" py-execute-region-ipython-dedicated-switch :help "Execute region through a uniquen IPython interpreter.\nSwitch to output buffer; ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-region-python3-dedicated-switch" py-execute-region-python3-dedicated-switch :help "Execute region through a unique Python3 interpreter.\nSwitch to output buffer; ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-region-python2-dedicated-switch" py-execute-region-python2-dedicated-switch :help "Execute region through a unique Python2 interpreter.\nSwitch to output buffer; ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-region-python2.7-dedicated-switch" py-execute-region-python2\.7-dedicated-switch :help "Execute region through a unique Python2.7 interpreter.\nSwitch to output buffer; ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-region-jython-dedicated-switch" py-execute-region-jython-dedicated-switch :help "Execute region through a unique Jython interpreter.\nSwitch to output buffer; ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-region-python3.2-dedicated-switch" py-execute-region-python3\.2-dedicated-switch :help "Execute region through a unique Python3.2 interpreter.\nSwitch to output buffer; ignores `py-switch-buffers-on-execute-p'. "]) ("Execute buffer ... " :help "Execute buffer functions" ["py-execute-buffer-python" py-execute-buffer-python :help "Execute buffer through a Python interpreter.\n        With \\[universal-argument] use an unique Python interpreter. "] ["py-execute-buffer-ipython" py-execute-buffer-ipython :help "Execute buffer through an IPython interpreter.\n        With \\[universal-argument] use an unique IPython interpreter. "] ["py-execute-buffer-python3" py-execute-buffer-python3 :help "Execute buffer through a Python3 interpreter.\n        With \\[universal-argument] use an unique Python3 interpreter. "] ["py-execute-buffer-python2" py-execute-buffer-python2 :help "Execute buffer through a Python2 interpreter.\n        With \\[universal-argument] use an unique Python2 interpreter. "] ["py-execute-buffer-python2.7" py-execute-buffer-python2\.7 :help "Execute buffer through a Python2.7 interpreter.\n        With \\[universal-argument] use an unique Python2.7 interpreter. "] ["py-execute-buffer-jython" py-execute-buffer-jython :help "Execute buffer through a Jython interpreter.\n        With \\[universal-argument] use an unique Jython interpreter. "] ["py-execute-buffer-python3.2" py-execute-buffer-python3\.2 :help "Execute buffer through a Python3.2 interpreter.\n        With \\[universal-argument] use an unique Python3.2 interpreter. "] ["py-execute-buffer-python-dedicated" py-execute-buffer-python-dedicated :help "Execute buffer through a unique Python interpreter.\nOptional \\[universal-argument] forces switch to output buffer, ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-buffer-ipython-dedicated" py-execute-buffer-ipython-dedicated :help "Execute buffer through a unique IPython interpreter.\nOptional \\[universal-argument] forces switch to output buffer, ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-buffer-python3-dedicated" py-execute-buffer-python3-dedicated :help "Execute buffer through a unique Python3 interpreter.\nOptional \\[universal-argument] forces switch to output buffer, ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-buffer-python2-dedicated" py-execute-buffer-python2-dedicated :help "Execute buffer through a unique Python2 interpreter.\nOptional \\[universal-argument] forces switch to output buffer, ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-buffer-python2.7-dedicated" py-execute-buffer-python2\.7-dedicated :help "Execute buffer through a unique Python2.7 interpreter.\nOptional \\[universal-argument] forces switch to output buffer, ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-buffer-jython-dedicated" py-execute-buffer-jython-dedicated :help "Execute buffer through a unique Jython interpreter.\nOptional \\[universal-argument] forces switch to output buffer, ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-buffer-python3.2-dedicated" py-execute-buffer-python3\.2-dedicated :help "Execute buffer through a unique Python3.2 interpreter.\nOptional \\[universal-argument] forces switch to output buffer, ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-buffer-python-switch" py-execute-buffer-python-switch :help "Execute buffer through a Python interpreter.\nWith \\[universal-argument] use an unique Python interpreter. "] ["py-execute-buffer-ipython-switch" py-execute-buffer-ipython-switch :help "Execute buffer through an IPython interpreter.\nWith \\[universal-argument] use an unique IPython interpreter. "] ["py-execute-buffer-python3-switch" py-execute-buffer-python3-switch :help "Execute buffer through a Python3 interpreter.\nWith \\[universal-argument] use an unique Python3 interpreter. "] ["py-execute-buffer-python2-switch" py-execute-buffer-python2-switch :help "Execute buffer through a Python2 interpreter.\nWith \\[universal-argument] use an unique Python2 interpreter. "] ["py-execute-buffer-python2.7-switch" py-execute-buffer-python2\.7-switch :help "Execute buffer through a Python2.7 interpreter.\nWith \\[universal-argument] use an unique Python2.7 interpreter. "] ["py-execute-buffer-jython-switch" py-execute-buffer-jython-switch :help "Execute buffer through a Jython interpreter.\nWith \\[universal-argument] use an unique Jython interpreter. "] ["py-execute-buffer-python3.2-switch" py-execute-buffer-python3\.2-switch :help "Execute buffer through a Python3.2 interpreter.\nWith \\[universal-argument] use an unique Python3.2 interpreter. "] ["py-execute-buffer-python-dedicated-switch" py-execute-buffer-python-dedicated-switch :help "Execute buffer through a unique Python interpreter.\nSwitch to output buffer; ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-buffer-ipython-dedicated-switch" py-execute-buffer-ipython-dedicated-switch :help "Execute buffer through a uniquen IPython interpreter.\nSwitch to output buffer; ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-buffer-python3-dedicated-switch" py-execute-buffer-python3-dedicated-switch :help "Execute buffer through a unique Python3 interpreter.\nSwitch to output buffer; ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-buffer-python2-dedicated-switch" py-execute-buffer-python2-dedicated-switch :help "Execute buffer through a unique Python2 interpreter.\nSwitch to output buffer; ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-buffer-python2.7-dedicated-switch" py-execute-buffer-python2\.7-dedicated-switch :help "Execute buffer through a unique Python2.7 interpreter.\nSwitch to output buffer; ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-buffer-jython-dedicated-switch" py-execute-buffer-jython-dedicated-switch :help "Execute buffer through a unique Jython interpreter.\nSwitch to output buffer; ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-buffer-python3.2-dedicated-switch" py-execute-buffer-python3\.2-dedicated-switch :help "Execute buffer through a unique Python3.2 interpreter.\nSwitch to output buffer; ignores `py-switch-buffers-on-execute-p'. "]) ("Execute expression ... " :help "Execute expression functions" ["py-execute-expression-python" py-execute-expression-python :help "Execute expression through a Python interpreter.\n        With \\[universal-argument] use an unique Python interpreter. "] ["py-execute-expression-ipython" py-execute-expression-ipython :help "Execute expression through an IPython interpreter.\n        With \\[universal-argument] use an unique IPython interpreter. "] ["py-execute-expression-python3" py-execute-expression-python3 :help "Execute expression through a Python3 interpreter.\n        With \\[universal-argument] use an unique Python3 interpreter. "] ["py-execute-expression-python2" py-execute-expression-python2 :help "Execute expression through a Python2 interpreter.\n        With \\[universal-argument] use an unique Python2 interpreter. "] ["py-execute-expression-python2.7" py-execute-expression-python2\.7 :help "Execute expression through a Python2.7 interpreter.\n        With \\[universal-argument] use an unique Python2.7 interpreter. "] ["py-execute-expression-jython" py-execute-expression-jython :help "Execute expression through a Jython interpreter.\n        With \\[universal-argument] use an unique Jython interpreter. "] ["py-execute-expression-python3.2" py-execute-expression-python3\.2 :help "Execute expression through a Python3.2 interpreter.\n        With \\[universal-argument] use an unique Python3.2 interpreter. "] ["py-execute-expression-python-dedicated" py-execute-expression-python-dedicated :help "Execute expression through a unique Python interpreter.\nOptional \\[universal-argument] forces switch to output buffer, ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-expression-ipython-dedicated" py-execute-expression-ipython-dedicated :help "Execute expression through a unique IPython interpreter.\nOptional \\[universal-argument] forces switch to output buffer, ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-expression-python3-dedicated" py-execute-expression-python3-dedicated :help "Execute expression through a unique Python3 interpreter.\nOptional \\[universal-argument] forces switch to output buffer, ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-expression-python2-dedicated" py-execute-expression-python2-dedicated :help "Execute expression through a unique Python2 interpreter.\nOptional \\[universal-argument] forces switch to output buffer, ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-expression-python2.7-dedicated" py-execute-expression-python2\.7-dedicated :help "Execute expression through a unique Python2.7 interpreter.\nOptional \\[universal-argument] forces switch to output buffer, ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-expression-jython-dedicated" py-execute-expression-jython-dedicated :help "Execute expression through a unique Jython interpreter.\nOptional \\[universal-argument] forces switch to output buffer, ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-expression-python3.2-dedicated" py-execute-expression-python3\.2-dedicated :help "Execute expression through a unique Python3.2 interpreter.\nOptional \\[universal-argument] forces switch to output buffer, ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-expression-python-switch" py-execute-expression-python-switch :help "Execute expression through a Python interpreter.\nWith \\[universal-argument] use an unique Python interpreter. "] ["py-execute-expression-ipython-switch" py-execute-expression-ipython-switch :help "Execute expression through an IPython interpreter.\nWith \\[universal-argument] use an unique IPython interpreter. "] ["py-execute-expression-python3-switch" py-execute-expression-python3-switch :help "Execute expression through a Python3 interpreter.\nWith \\[universal-argument] use an unique Python3 interpreter. "] ["py-execute-expression-python2-switch" py-execute-expression-python2-switch :help "Execute expression through a Python2 interpreter.\nWith \\[universal-argument] use an unique Python2 interpreter. "] ["py-execute-expression-python2.7-switch" py-execute-expression-python2\.7-switch :help "Execute expression through a Python2.7 interpreter.\nWith \\[universal-argument] use an unique Python2.7 interpreter. "] ["py-execute-expression-jython-switch" py-execute-expression-jython-switch :help "Execute expression through a Jython interpreter.\nWith \\[universal-argument] use an unique Jython interpreter. "] ["py-execute-expression-python3.2-switch" py-execute-expression-python3\.2-switch :help "Execute expression through a Python3.2 interpreter.\nWith \\[universal-argument] use an unique Python3.2 interpreter. "] ["py-execute-expression-python-dedicated-switch" py-execute-expression-python-dedicated-switch :help "Execute expression through a unique Python interpreter.\nSwitch to output buffer; ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-expression-ipython-dedicated-switch" py-execute-expression-ipython-dedicated-switch :help "Execute expression through a uniquen IPython interpreter.\nSwitch to output buffer; ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-expression-python3-dedicated-switch" py-execute-expression-python3-dedicated-switch :help "Execute expression through a unique Python3 interpreter.\nSwitch to output buffer; ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-expression-python2-dedicated-switch" py-execute-expression-python2-dedicated-switch :help "Execute expression through a unique Python2 interpreter.\nSwitch to output buffer; ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-expression-python2.7-dedicated-switch" py-execute-expression-python2\.7-dedicated-switch :help "Execute expression through a unique Python2.7 interpreter.\nSwitch to output buffer; ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-expression-jython-dedicated-switch" py-execute-expression-jython-dedicated-switch :help "Execute expression through a unique Jython interpreter.\nSwitch to output buffer; ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-expression-python3.2-dedicated-switch" py-execute-expression-python3\.2-dedicated-switch :help "Execute expression through a unique Python3.2 interpreter.\nSwitch to output buffer; ignores `py-switch-buffers-on-execute-p'. "]) ("Execute partial-expression ... " :help "Execute partial-expression functions" ["py-execute-partial-expression-python" py-execute-partial-expression-python :help "Execute minor-expression through a Python interpreter.\n        With \\[universal-argument] use an unique Python interpreter. "] ["py-execute-minor-expression-ipython" py-execute-minor-expression-ipython :help "Execute minor-expression through an IPython interpreter.\n        With \\[universal-argument] use an unique IPython interpreter. "] ["py-execute-minor-expression-python3" py-execute-minor-expression-python3 :help "Execute minor-expression through a Python3 interpreter.\n        With \\[universal-argument] use an unique Python3 interpreter. "] ["py-execute-minor-expression-python2" py-execute-minor-expression-python2 :help "Execute minor-expression through a Python2 interpreter.\n        With \\[universal-argument] use an unique Python2 interpreter. "] ["py-execute-minor-expression-python2.7" py-execute-minor-expression-python2\.7 :help "Execute minor-expression through a Python2.7 interpreter.\n        With \\[universal-argument] use an unique Python2.7 interpreter. "] ["py-execute-minor-expression-jython" py-execute-minor-expression-jython :help "Execute minor-expression through a Jython interpreter.\n        With \\[universal-argument] use an unique Jython interpreter. "] ["py-execute-minor-expression-python3.2" py-execute-minor-expression-python3\.2 :help "Execute minor-expression through a Python3.2 interpreter.\n        With \\[universal-argument] use an unique Python3.2 interpreter. "] ["py-execute-minor-expression-python-dedicated" py-execute-minor-expression-python-dedicated :help "Execute minor-expression through a unique Python interpreter.\nOptional \\[universal-argument] forces switch to output buffer, ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-minor-expression-ipython-dedicated" py-execute-minor-expression-ipython-dedicated :help "Execute minor-expression through a unique IPython interpreter.\nOptional \\[universal-argument] forces switch to output buffer, ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-minor-expression-python3-dedicated" py-execute-minor-expression-python3-dedicated :help "Execute minor-expression through a unique Python3 interpreter.\nOptional \\[universal-argument] forces switch to output buffer, ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-minor-expression-python2-dedicated" py-execute-minor-expression-python2-dedicated :help "Execute minor-expression through a unique Python2 interpreter.\nOptional \\[universal-argument] forces switch to output buffer, ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-minor-expression-python2.7-dedicated" py-execute-minor-expression-python2\.7-dedicated :help "Execute minor-expression through a unique Python2.7 interpreter.\nOptional \\[universal-argument] forces switch to output buffer, ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-minor-expression-jython-dedicated" py-execute-minor-expression-jython-dedicated :help "Execute minor-expression through a unique Jython interpreter.\nOptional \\[universal-argument] forces switch to output buffer, ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-minor-expression-python3.2-dedicated" py-execute-minor-expression-python3\.2-dedicated :help "Execute minor-expression through a unique Python3.2 interpreter.\nOptional \\[universal-argument] forces switch to output buffer, ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-minor-expression-python-switch" py-execute-minor-expression-python-switch :help "Execute minor-expression through a Python interpreter.\nWith \\[universal-argument] use an unique Python interpreter. "] ["py-execute-minor-expression-ipython-switch" py-execute-minor-expression-ipython-switch :help "Execute minor-expression through an IPython interpreter.\nWith \\[universal-argument] use an unique IPython interpreter. "] ["py-execute-minor-expression-python3-switch" py-execute-minor-expression-python3-switch :help "Execute minor-expression through a Python3 interpreter.\nWith \\[universal-argument] use an unique Python3 interpreter. "] ["py-execute-minor-expression-python2-switch" py-execute-minor-expression-python2-switch :help "Execute minor-expression through a Python2 interpreter.\nWith \\[universal-argument] use an unique Python2 interpreter. "] ["py-execute-minor-expression-python2.7-switch" py-execute-minor-expression-python2\.7-switch :help "Execute minor-expression through a Python2.7 interpreter.\nWith \\[universal-argument] use an unique Python2.7 interpreter. "] ["py-execute-minor-expression-jython-switch" py-execute-minor-expression-jython-switch :help "Execute minor-expression through a Jython interpreter.\nWith \\[universal-argument] use an unique Jython interpreter. "] ["py-execute-minor-expression-python3.2-switch" py-execute-minor-expression-python3\.2-switch :help "Execute minor-expression through a Python3.2 interpreter.\nWith \\[universal-argument] use an unique Python3.2 interpreter. "] ["py-execute-minor-expression-python-dedicated-switch" py-execute-minor-expression-python-dedicated-switch :help "Execute minor-expression through a unique Python interpreter.\nSwitch to output buffer; ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-minor-expression-ipython-dedicated-switch" py-execute-minor-expression-ipython-dedicated-switch :help "Execute minor-expression through a uniquen IPython interpreter.\nSwitch to output buffer; ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-minor-expression-python3-dedicated-switch" py-execute-minor-expression-python3-dedicated-switch :help "Execute minor-expression through a unique Python3 interpreter.\nSwitch to output buffer; ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-minor-expression-python2-dedicated-switch" py-execute-minor-expression-python2-dedicated-switch :help "Execute minor-expression through a unique Python2 interpreter.\nSwitch to output buffer; ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-minor-expression-python2.7-dedicated-switch" py-execute-minor-expression-python2\.7-dedicated-switch :help "Execute minor-expression through a unique Python2.7 interpreter.\nSwitch to output buffer; ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-minor-expression-jython-dedicated-switch" py-execute-minor-expression-jython-dedicated-switch :help "Execute minor-expression through a unique Jython interpreter.\nSwitch to output buffer; ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-minor-expression-python3.2-dedicated-switch" py-execute-minor-expression-python3\.2-dedicated-switch :help "Execute minor-expression through a unique Python3.2 interpreter.\nSwitch to output buffer; ignores `py-switch-buffers-on-execute-p'. "]) ("Execute line ... " :help "Execute line functions" ["py-execute-line-python" py-execute-line-python :help "Execute line through a Python interpreter.\n        With \\[universal-argument] use an unique Python interpreter. "] ["py-execute-line-ipython" py-execute-line-ipython :help "Execute line through an IPython interpreter.\n        With \\[universal-argument] use an unique IPython interpreter. "] ["py-execute-line-python3" py-execute-line-python3 :help "Execute line through a Python3 interpreter.\n        With \\[universal-argument] use an unique Python3 interpreter. "] ["py-execute-line-python2" py-execute-line-python2 :help "Execute line through a Python2 interpreter.\n        With \\[universal-argument] use an unique Python2 interpreter. "] ["py-execute-line-python2.7" py-execute-line-python2\.7 :help "Execute line through a Python2.7 interpreter.\n        With \\[universal-argument] use an unique Python2.7 interpreter. "] ["py-execute-line-jython" py-execute-line-jython :help "Execute line through a Jython interpreter.\n        With \\[universal-argument] use an unique Jython interpreter. "] ["py-execute-line-python3.2" py-execute-line-python3\.2 :help "Execute line through a Python3.2 interpreter.\n        With \\[universal-argument] use an unique Python3.2 interpreter. "] ["py-execute-line-python-dedicated" py-execute-line-python-dedicated :help "Execute line through a unique Python interpreter.\nOptional \\[universal-argument] forces switch to output buffer, ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-line-ipython-dedicated" py-execute-line-ipython-dedicated :help "Execute line through a unique IPython interpreter.\nOptional \\[universal-argument] forces switch to output buffer, ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-line-python3-dedicated" py-execute-line-python3-dedicated :help "Execute line through a unique Python3 interpreter.\nOptional \\[universal-argument] forces switch to output buffer, ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-line-python2-dedicated" py-execute-line-python2-dedicated :help "Execute line through a unique Python2 interpreter.\nOptional \\[universal-argument] forces switch to output buffer, ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-line-python2.7-dedicated" py-execute-line-python2\.7-dedicated :help "Execute line through a unique Python2.7 interpreter.\nOptional \\[universal-argument] forces switch to output buffer, ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-line-jython-dedicated" py-execute-line-jython-dedicated :help "Execute line through a unique Jython interpreter.\nOptional \\[universal-argument] forces switch to output buffer, ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-line-python3.2-dedicated" py-execute-line-python3\.2-dedicated :help "Execute line through a unique Python3.2 interpreter.\nOptional \\[universal-argument] forces switch to output buffer, ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-line-python-switch" py-execute-line-python-switch :help "Execute line through a Python interpreter.\nWith \\[universal-argument] use an unique Python interpreter. "] ["py-execute-line-ipython-switch" py-execute-line-ipython-switch :help "Execute line through an IPython interpreter.\nWith \\[universal-argument] use an unique IPython interpreter. "] ["py-execute-line-python3-switch" py-execute-line-python3-switch :help "Execute line through a Python3 interpreter.\nWith \\[universal-argument] use an unique Python3 interpreter. "] ["py-execute-line-python2-switch" py-execute-line-python2-switch :help "Execute line through a Python2 interpreter.\nWith \\[universal-argument] use an unique Python2 interpreter. "] ["py-execute-line-python2.7-switch" py-execute-line-python2\.7-switch :help "Execute line through a Python2.7 interpreter.\nWith \\[universal-argument] use an unique Python2.7 interpreter. "] ["py-execute-line-jython-switch" py-execute-line-jython-switch :help "Execute line through a Jython interpreter.\nWith \\[universal-argument] use an unique Jython interpreter. "] ["py-execute-line-python3.2-switch" py-execute-line-python3\.2-switch :help "Execute line through a Python3.2 interpreter.\nWith \\[universal-argument] use an unique Python3.2 interpreter. "] ["py-execute-line-python-dedicated-switch" py-execute-line-python-dedicated-switch :help "Execute line through a unique Python interpreter.\nSwitch to output buffer; ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-line-ipython-dedicated-switch" py-execute-line-ipython-dedicated-switch :help "Execute line through a uniquen IPython interpreter.\nSwitch to output buffer; ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-line-python3-dedicated-switch" py-execute-line-python3-dedicated-switch :help "Execute line through a unique Python3 interpreter.\nSwitch to output buffer; ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-line-python2-dedicated-switch" py-execute-line-python2-dedicated-switch :help "Execute line through a unique Python2 interpreter.\nSwitch to output buffer; ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-line-python2.7-dedicated-switch" py-execute-line-python2\.7-dedicated-switch :help "Execute line through a unique Python2.7 interpreter.\nSwitch to output buffer; ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-line-jython-dedicated-switch" py-execute-line-jython-dedicated-switch :help "Execute line through a unique Jython interpreter.\nSwitch to output buffer; ignores `py-switch-buffers-on-execute-p'. "] ["py-execute-line-python3.2-dedicated-switch" py-execute-line-python3\.2-dedicated-switch :help "Execute line through a unique Python3.2 interpreter.\nSwitch to output buffer; ignores `py-switch-buffers-on-execute-p'. "])) (lambda (#1#) (defvar py-menu #1# #4="Python Mode Commands")) #4# ("PyEdit" :help "Python-specific features" ["Copy block" py-copy-block :help "`py-copy-block'\nCopy innermost compound statement at point"] ["Copy clause" py-copy-clause :help "`py-copy-clause'\nCopy clause at point"] ["Copy def-or-class" py-copy-def-or-class :help "`py-copy-def-or-class'\nCopy innermost definition at point"] ["Copy def" py-copy-def :help "`py-copy-def'\nCopy method/function definition at point"] ["Copy class" py-copy-class :help "`py-copy-class'\nCopy class definition at point"] ["Copy statement" py-copy-statement :help "`py-copy-statement'\nCopy statement at point"] ["Copy expression" py-copy-expression :help "`py-copy-expression'\nCopy expression at point"] ["Copy partial expression" py-copy-partial-expression :help "`py-copy-partial-expression'\n\".\" operators delimit a partial-expression expression on it's level"] "-" ["Beginning of block" py-beginning-of-block :help "`py-beginning-of-block'\nGo to start of innermost compound statement at point"] ["End of block" py-end-of-block :help "`py-end-of-block'\nGo to end of innermost compound statement at point"] ["Beginning of Def-or-Class" py-beginning-of-def-or-class :help "`py-beginning-of-def-or-class'\nGo to start of innermost definition at point"] ["End of Def-or-Class" py-end-of-def-or-class :help "`py-end-of-def-or-class'\nGo to end of innermost function definition at point"] ["Beginning of class" py-beginning-of-class :help "`py-beginning-of-class'\nGo to start of class definition "] ["End of class" py-end-of-class :help "`py-end-of-class'\nGo to end of class definition "] ["Beginning of statement" py-beginning-of-statement :help "`py-beginning-of-statement'\nGo to start of a Python statement"] ["End of statement" py-end-of-statement :help "`py-end-of-statement'\nGo to end of a Python statement"] ["Beginning of expression" py-beginning-of-expression :help "Go to the beginning of a compound python expression.\n\nA a compound python expression might be concatenated by \".\" operator, thus composed by minor python expressions.\n\nExpression here is conceived as the syntactical component of a statement in Python. See http://docs.python.org/reference\nOperators however are left aside resp. limit py-expression designed for edit-purposes."] ["End of expression" py-end-of-expression :help "`py-end-of-expression'\nGo to the end of a compound python expression.\n\nA a compound python expression might be concatenated by \".\" operator, thus composed by minor python expressions.\n\nExpression here is conceived as the syntactical component of a statement in Python. See http://docs.python.org/reference\nOperators however are left aside resp. limit py-expression designed for edit-purposes."] ["Beginning of minor expression" py-beginning-of-partial-expression :help "`py-beginning-of-partial-expression'\nGo to start of an minor expression\n\nExpression here is conceived as the syntactical component of a statement in Python. See http://docs.python.org/reference\nOperators however are left aside resp. limit py-expression designed for edit-purposes."] ["End of partial-expression" py-end-of-partial-expression :help "`py-end-of-partial-expression'\nGo to end of an partial-expression\n\nExpression here is conceived as the syntactical component of a statement in Python. See http://docs.python.org/reference\nOperators however are left aside resp. limit py-expression designed for edit-purposes."] ["Backward into nomenclature" py-backward-into-nomenclature :help " `py-backward-into-nomenclature'\nGo backward into nomenclature\n\nA nomenclature is a fancy way of saying AWordWithMixedCaseNotUnderscores. "] ["Forward into nomenclature" py-forward-into-nomenclature :help " `py-forward-into-nomenclature'\nGo forward into nomenclature\n\nA nomenclature is a fancy way of saying AWordWithMixedCaseNotUnderscores. "] "-" ["Down statement lc" py-down-statement-lc :help "`py-down-statement-lc'\nGoto beginning of line following end of statement.\n\nReturns position reached, if successful, nil otherwise.\n\n\"-lc\" stands for \"left-corner\" - a complementary command travelling left, whilst `py-end-of-statement' stops at right corner.\n\nSee also `py-down-statement': down from current definition to next beginning of statement below. "] ["Down block lc" py-down-block-lc :help "`py-down-block-lc'\nGoto beginning of line following end of block.\n\nReturns position reached, if successful, nil otherwise.\n\n\"-lc\" stands for \"left-corner\" - a complementary command travelling left, whilst `py-end-of-block' stops at right corner.\n\nSee also `py-down-block': down from current definition to next beginning of block below. "] ["Down def lc" py-down-def-lc :help "`py-down-def-lc'\nGoto beginning of line following end of def.\n\nReturns position reached, if successful, nil otherwise.\n\n\"-lc\" stands for \"left-corner\" - a complementary command travelling left, whilst `py-end-of-def' stops at right corner.\n\nSee also `py-down-def': down from current definition to next beginning of def below.\n "] ["Down statement" py-down-statement :help "`py-down-statement'\n\nGo to the beginning of next statement below in buffer.\n\nReturns indentation if statement found, nil otherwise. "] ["Down block" py-down-block :help "`py-down-block'\n\nGo to the beginning of next block below in buffer.\n\nReturns indentation if block found, nil otherwise. "] ["Down def" py-down-def :help "`py-down-def'\n\nGo to the beginning of next function definition below in buffer.\n\nReturns indentation if found, nil otherwise. "]) (lambda (#1#) (defvar py-menu #1# #5="Python Shells")) #5# ("PyShell" :help "Python Shells" ["Default interpreter" py-shell :help "`py-shell'\nSwitch to `inferior' Python in separate buffer"] ["Enforce py-shell-name" force-py-shell-name-p-on :help "Enforce customized default `py-shell-name' should upon execution. "] ["Don't enforce default interpreter" force-py-shell-name-p-off :help "Make execute commands guess interpreter from environment"] ["Enforce local Python shell " py-force-local-shell-on :help "Locally indicated Python being enforced upon sessions execute commands. "] ["Remove local Python shell enforcement, restore default" py-force-local-shell-off :help "Restore `py-shell-name' default value and `behaviour'. "] "-" ["python" python :help "`python'\nStart an Python interpreter.\n\nOptional C-u prompts for options to pass to the Python interpreter. See `py-python-command-args'."] ["ipython" ipython :help "`ipython'\nStart an IPython interpreter.\n\nOptional C-u prompts for options to pass to the IPython interpreter. See `py-python-command-args'."] ["python3" python3 :help "`python3'\nStart an Python3 interpreter.\n\nOptional C-u prompts for options to pass to the Python3 interpreter. See `py-python-command-args'."] ["python2" python2 :help "`python2'\nStart an Python2 interpreter.\n\nOptional C-u prompts for options to pass to the Python2 interpreter. See `py-python-command-args'."] ["python2.7" python2\.7 :help "`python2.7'\nStart an Python2.7 interpreter.\n\nOptional C-u prompts for options to pass to the Python2.7 interpreter. See `py-python-command-args'."] ["jython" jython :help "`jython'\nStart an Jython interpreter.\n\nOptional C-u prompts for options to pass to the Jython interpreter. See `py-python-command-args'."] ["python3.2" python3\.2 :help "`python3.2'\nStart an Python3.2 interpreter.\n\nOptional C-u prompts for options to pass to the Python3.2 interpreter. See `py-python-command-args'."] "-" ["python-dedicated" python-dedicated :help "`python-dedicated'\nStart an unique Python interpreter in another window.\n\nOptional C-u prompts for options to pass to the Python interpreter. See `py-python-command-args'."] ["ipython-dedicated" ipython-dedicated :help "`ipython-dedicated'\nStart an unique IPython interpreter in another window.\n\nOptional C-u prompts for options to pass to the IPython interpreter. See `py-python-command-args'."] ["python3-dedicated" python3-dedicated :help "`python3-dedicated'\nStart an unique Python3 interpreter in another window.\n\nOptional C-u prompts for options to pass to the Python3 interpreter. See `py-python-command-args'."] ["python2-dedicated" python2-dedicated :help "`python2-dedicated'\nStart an unique Python2 interpreter in another window.\n\nOptional C-u prompts for options to pass to the Python2 interpreter. See `py-python-command-args'."] ["python2.7-dedicated" python2\.7-dedicated :help "`python2'.7-dedicated\nStart an unique Python2.7 interpreter in another window.\n\nOptional C-u prompts for options to pass to the Python2.7 interpreter. See `py-python-command-args'."] ["jython-dedicated" jython-dedicated :help "`jython-dedicated'\nStart an unique Jython interpreter in another window.\n\nOptional C-u prompts for options to pass to the Jython interpreter. See `py-python-command-args'."] ["python3.2-dedicated" python3\.2-dedicated :help "`python3.2-dedicated'\nStart an unique Python3.2 interpreter in another window.\n\nOptional C-u prompts for options to pass to the Python3.2 interpreter. See `py-python-command-args'."] "-" ["Toggle split-windows-on-execute" py-toggle-split-windows-on-execute :help "Switch boolean `py-split-windows-on-execute-p'."] ["Switch split-windows-on-execute ON" py-split-windows-on-execute-on :help "Switch `py-split-windows-on-execute-p' ON. "] ["Switch split-windows-on-execute OFF" py-split-windows-on-execute-off :help "Switch `py-split-windows-on-execute-p' OFF. "] ["Toggle shell-switch-buffers-on-execute" py-toggle-shell-switch-buffers-on-execute :help "Switch boolean `py-switch-buffers-on-execute-p'."] ["Switch shell-switch-buffers-on-execute ON" py-shell-switch-buffers-on-execute-on :help "Switch `py-switch-buffers-on-execute-p' ON. "] ["Switch shell-switch-buffers-on-execute OFF" py-shell-switch-buffers-on-execute-off :help "Switch `py-switch-buffers-on-execute-p' OFF. "])] 5)
#@548 Jumps to `python-mode-abbrev-table' in a buffer containing lists of abbrev definitions.
You can edit them and type \<edit-abbrevs-map>\[edit-abbrevs-redefine] to redefine abbrevs
according to your editing.
Buffer contains a header line for each abbrev table,
 which is the abbrev table name in parentheses.
This is followed by one line per abbrev in that table:
NAME   USECOUNT   EXPANSION   HOOK
where NAME and EXPANSION are strings with quotes,
USECOUNT is an integer, and HOOK is any valid function
or may be omitted (it is usually omitted).  
(defalias 'py-edit-abbrevs #[nil "\212\302!\303 \210\304q\210\305p!\210eb\210\306\307\310\311	\"P!*\207" [local-abbrev-table mat abbrev-table-name prepare-abbrev-list-buffer "*Abbrevs*" switch-to-buffer search-forward "(" format "%s"] 5 (#$ . 432878) nil])
(defalias 'py-add-abbrev-propose #[(table type arg &optional dont-ask) "\212`\306\211\307U\203\310`\311 \"\2027\307W\2032\312 \210\313\314!\203,\315\307!\227	PS\202\310`\n\"\f\203?	\202O\316\317\203I\320\202J\321
#	\"\322\307G\306$\210\203x\323\"\203x\324\317\325\323\"#!\205\200\326\227#,\207" [exp proposal orig arg dont-ask type nil 0 buffer-substring-no-properties mark py-beginning-of-partial-expression looking-at "[[:alpha:]]" match-string-no-properties read-string format "%s abbrev for \"%s\": " "Undefine %s abbrev: " set-text-properties abbrev-expansion y-or-n-p "%s expands to \"%s\"; redefine? " define-abbrev name table] 7])
#@421 Defines python-mode specific abbrev for last expressions before point.
Argument is how many `py-partial-expression's form the expansion; or zero means the region is the expansion.

Reads the abbreviation in the minibuffer; with numeric arg it displays a proposal for an abbrev.
Proposal is composed from the initial character(s) of the
expansion.

Don't use this function in a Lisp program; use `define-abbrev' instead.
(defalias 'py-add-abbrev #[(arg) "\212\304\203\n	\202\n\206\305\306!\307#)\207" [only-global-abbrevs global-abbrev-table local-abbrev-table arg py-add-abbrev-propose error "No per-mode abbrev table" "Mode"] 4 (#$ . 434378) "p"])
(byte-code "\305\306\307\"\210\305\310\311\"\210\305\312\313\"\210\314\315\316\"\210\305\315\317\"\210\305\320\321\322\323$\210\305\310\324\"\210\305\315\325\"\210\2033\305\315\326\"\210\327	!\203A\305\315\330\"\210\202F\331\332\333\"\210\334\335\336\n\203Q\337\202R\340\341\342\343\344\"\345#P\322\346\347\322\257\"\210\350\315\351N\204s\352\315\351\353\354!#\210\355\356!\204\352\356\357\336#\210\322\207" [py-warn-tmp-files-left-p abbrev-file-name py-hide-show-hide-docstrings py-hide-show-keywords imenu-generic-expression add-hook kill-emacs-hook py-kill-emacs-hook comint-output-filter-functions py-pdbtrack-track-stack-file inferior-python-mode-hook py-send-shell-setup-code remove-hook python-mode-hook python-setup-brm #[nil "\2056o\2034\212\214~\210m\204-\302 \211A@\206\303	8)\204'\304 \305=\203-\306y\210\202\f\307 \210\310 *\207\310 \207" [py-smart-indentation erg syntax-ppss 8 current-indentation 0 1 back-to-indentation py-guess-indent-offset] 3] which-func-functions python-which-func nil t py-comint-output-filter-function #[nil "\304\302!\210\305\304\303!\210\306\211\207" [py-indent-tabs-mode indent-tabs-mode beginning-of-defun-function end-of-defun-function make-local-variable py-beginning-of-def-or-class py-end-of-def-or-class] 2] py-warn-tmp-files-left file-readable-p (lambda nil (load abbrev-file-name nil t)) message "Warning: %s" "no abbrev-file found, customize `abbrev-file-name' in order to make mode-specific abbrevs work. " add-to-list hs-special-modes-alist python-mode "^\\s-*\"\"\"\\|" "" mapconcat identity mapcar #[(x) "\301\302Q\207" [x "^\\s-*" "\\_>"] 3] "\\|" "#" #[(arg) "\300 \210\301\302x\207" [py-down-block-lc " 	\n" nil] 2] py-imenu-generic-regexp variable-documentation put purecopy "Hook run when entering python-mode-modeline-display mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" boundp python-mode-map definition-name] 9)
(defvar python-mode-map (make-sparse-keymap))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\305\306!\204\302\306\307\310#\210\300\207" [python-mode-map variable-documentation put purecopy "Keymap for `python-mode'." boundp python-mode-syntax-table definition-name python-mode] 5)
(defvar python-mode-syntax-table (make-syntax-table))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\302\305\306\307#\207" [python-mode-syntax-table variable-documentation put purecopy "Syntax table for `python-mode'." python-mode-abbrev-table definition-name python-mode] 5)
(defvar python-mode-abbrev-table (progn (define-abbrev-table 'python-mode-abbrev-table nil) python-mode-abbrev-table))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\302\305\306\307#\210\302\305\310\305#\207" [python-mode-abbrev-table variable-documentation put purecopy "Abbrev table for `python-mode'." python-mode derived-mode-parent nil custom-mode-group] 5)
#@806 Major mode for editing Python files.

To submit a problem report, enter `\[py-submit-bug-report]' from a
`python-mode' buffer.  Do `\[py-describe-mode]' for detailed
documentation.  To see what version of `python-mode' you are running,
enter `\[py-version]'.

This mode knows about Python indentation, tokens, comments and
continuation lines.  Paragraphs are separated by blank lines only.

COMMANDS

VARIABLES

py-indent-offset		indentation increment
py-block-comment-prefix		comment string used by `comment-region'
py-shell-name		shell command to invoke Python interpreter
py-temp-directory		directory used for temp files (if needed)
py-beep-if-tab-change		ring the bell if `tab-width' is changed

\{python-mode-map}

This mode runs the hook `python-mode-hook', as the final step
during initialization.
(defalias 'python-mode #[nil "\306\300!\210\307\310 \210\311\n\312\f!\210\313
!\210@A\306\314!\210\315\316\317\320B\"\321#\260\f\306\322!\210\323\306\324!\210\307\306\325!\210\307\306\326!\210\327\306\330!\210\331\306\332!\210\333\306\334!\210\335\306\336!\210\337\306\340!\210\341 \306\342!\210\343\"\306\344!\210\345$\306\346!\210\347&\306\350!\210\351(\306\352!\210\353*\306\354!\210\355,\306\356!\210\357.\306\360!\210C0\306\361!\210\306\362!\210D2\306\363!\210\3643\306\365!\210\3665E\203\306\367\370\371\"\210F\203\337\372\373!\203\337\351\374\375\217\203\337\376G\373\377!\210H\203\353\201MH!\210I\203\370\201N\201O!\210J\203&\201P\201Q!\210\201R\201S !\204pK\212\201T \210Kq\210*\201U\201Q!\210L\2033\201V\201O!\210\201W \203E\201X\201Y\201Z\"\210)\201[\370!\207" [delay-mode-hooks major-mode python-mode-modeline-display mode-name python-mode-map python-mode-syntax-table make-local-variable t kill-all-local-variables python-mode use-local-map set-syntax-table outline-regexp mapconcat identity mapcar #[(x) "\301\302Q\207" [x "^\\s-*" "\\_>"] 3] "\\|" font-lock-defaults (python-font-lock-keywords nil nil nil nil (font-lock-syntactic-keywords . python-font-lock-syntactic-keywords)) parse-sexp-lookup-properties parse-sexp-ignore-comments comment-start "# " comment-start-skip "^[ 	]*#+ *" comment-column 40 comment-indent-function py-comment-indent-function indent-region-function py-indent-region indent-line-function py-indent-line hs-hide-comments-when-hiding-all py-hide-comments-when-hiding-all outline-heading-end-regexp ":\\s-*\n" outline-level python-outline-level open-paren-in-column-0-is-defun-start nil add-log-current-defun-function py-current-defun paragraph-start "\\s-*$" fill-paragraph-function py-fill-paragraph require-final-newline python-saved-check-command tab-width eldoc-documentation-function py-eldoc-function skeleton-further-elements ((< '(backward-delete-char-untabify (min py-indent-offset (current-column)))) (^ '(- (1+ (current-indentation))))) add-hook python-mode-hook #[nil "\301\302D\211\207" [autopair-handle-action-fns autopair-default-handle-action autopair-python-triple-quote-action] 2] fboundp imenu-add-to-menubar (byte-code "\300\301!\207" [require imenu] 2) ((error)) py-imenu-create-index-new "PyIndex" python-mode-abbrev-table local-abbrev-table py-outline-mode-keywords mode-require-final-newline py-indent-offset py-prepare-autopair-mode-p py-imenu-create-index-p imenu-create-index-function py-menu py-hide-show-minor-mode-p py-start-run-py-shell oldbuf py-outline-minor-mode-p easy-menu-add hs-minor-mode 1 window-configuration-to-register 213465879 get-process py-process-name py-shell jump-to-register outline-minor-mode interactive-p message "python-mode loaded from: %s" "python-mode.el" run-mode-hooks] 5 (#$ . 437975) nil])
(byte-code "\300\301\302\303\304$\210\305\301\304\"\210\306\307\310\"\210\306\311\312\"\210\313\314N\204$\315\313\314\316\317!#\210\320\321!\2040\315\321\322\323#\210\304\207" [ad-add-advice pdb (gud-query-cmdline nil t (advice lambda nil "Provide a better default command line when called interactively." (interactive (list (gud-query-cmdline pdb-path (file-name-nondirectory buffer-file-name)))))) before nil ad-activate defalias py-hungry-delete-forward c-hungry-delete-forward py-hungry-delete-backwards c-hungry-delete-backwards python2-mode-hook variable-documentation put purecopy "Hook run when entering Python2 mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" boundp python2-mode-map definition-name python2-mode] 5)
(defvar python2-mode-map (make-sparse-keymap))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\305\306!\204\302\306\307\310#\210\300\207" [python2-mode-map variable-documentation put purecopy "Keymap for `python2-mode'." boundp python2-mode-syntax-table definition-name python2-mode] 5)
(defvar python2-mode-syntax-table (make-syntax-table))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\302\305\306\307#\207" [python2-mode-syntax-table variable-documentation put purecopy "Syntax table for `python2-mode'." python2-mode-abbrev-table definition-name python2-mode] 5)
(defvar python2-mode-abbrev-table (progn (define-abbrev-table 'python2-mode-abbrev-table nil) python2-mode-abbrev-table))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\302\305\306\307#\210\302\305\310\311#\207" [python2-mode-abbrev-table variable-documentation put purecopy "Abbrev table for `python2-mode'." python2-mode derived-mode-parent python-mode custom-mode-group Python] 5)
#@232 Edit and run code used by Python version 2 series. 

In addition to any hooks its parent mode `python-mode' might have run,
this mode runs the hook `python2-mode-hook', as the final step
during initialization.

\{python2-mode-map}
(defalias 'python2-mode #[nil "\306\300!\210\307\310 \210\311\312\310\313N\203\314\311\313\310\313N#\210\315!\204'\316\317 \"\210\320\f!\211\2036
\321 =\203<\322\f\323 \"\210)\324!\325\"\204V!\"=\204V\326!\325\"C#\210\327!\210\330\f!\210!\"\306\331!\210\332\306\333!\210\334\335\336!\210)\337\340!\207" [delay-mode-hooks major-mode mode-name python2-mode-map python2-mode-syntax-table parent make-local-variable t python-mode python2-mode "Python2" mode-class put keymap-parent set-keymap-parent current-local-map char-table-parent standard-syntax-table set-char-table-parent syntax-table abbrev-table-get :parents abbrev-table-put use-local-map set-syntax-table py-exec-command (format "execfile(r'%s') # PYTHON-MODE\n" filename) py-exec-string-command (format "exec(r'%s') # PYTHON-MODE\n" string) py-toggle-shell "python2" run-mode-hooks python2-mode-hook python2-mode-abbrev-table local-abbrev-table] 6 (#$ . 443446) nil])
(byte-code "\300\301N\204\302\300\301\303\304!#\210\305\306!\204\302\306\307\310#\210\300\207" [python3-mode-hook variable-documentation put purecopy "Hook run when entering Python3 mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" boundp python3-mode-map definition-name python3-mode] 5)
(defvar python3-mode-map (make-sparse-keymap))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\305\306!\204\302\306\307\310#\210\300\207" [python3-mode-map variable-documentation put purecopy "Keymap for `python3-mode'." boundp python3-mode-syntax-table definition-name python3-mode] 5)
(defvar python3-mode-syntax-table (make-syntax-table))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\302\305\306\307#\207" [python3-mode-syntax-table variable-documentation put purecopy "Syntax table for `python3-mode'." python3-mode-abbrev-table definition-name python3-mode] 5)
(defvar python3-mode-abbrev-table (progn (define-abbrev-table 'python3-mode-abbrev-table nil) python3-mode-abbrev-table))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\302\305\306\307#\210\302\305\310\311#\207" [python3-mode-abbrev-table variable-documentation put purecopy "Abbrev table for `python3-mode'." python3-mode derived-mode-parent python-mode custom-mode-group Python] 5)
#@232 Edit and run code used by Python version 3 series. 

In addition to any hooks its parent mode `python-mode' might have run,
this mode runs the hook `python3-mode-hook', as the final step
during initialization.

\{python3-mode-map}
(defalias 'python3-mode #[nil "\306\300!\210\307\310 \210\311\312\310\313N\203\314\311\313\310\313N#\210\315!\204'\316\317 \"\210\320\f!\211\2036
\321 =\203<\322\f\323 \"\210)\324!\325\"\204V!\"=\204V\326!\325\"C#\210\327!\210\330\f!\210!\"\306\331!\210\332\306\333!\210\334\335\336!\210)\337\340!\207" [delay-mode-hooks major-mode mode-name python3-mode-map python3-mode-syntax-table parent make-local-variable t python-mode python3-mode "Python3" mode-class put keymap-parent set-keymap-parent current-local-map char-table-parent standard-syntax-table set-char-table-parent syntax-table abbrev-table-get :parents abbrev-table-put use-local-map set-syntax-table py-exec-command (format "exec(compile(open('%s').read(), '%s', 'exec')) # PYTHON-MODE\n" file file) py-exec-string-command (format "exec(r'(%s)') # PYTHON-MODE\n" string) py-toggle-shell "python3" run-mode-hooks python3-mode-hook python3-mode-abbrev-table local-abbrev-table] 6 (#$ . 445987) nil])
#@62 Returns beginning position of function or class definition. 
(defalias 'py-def-or-class-beginning-position #[nil "`\303 \210``\n\203\304 \203\305\306\"\210	b\210*\207" [pos here py-verbose-p py-beginning-of-def-or-class interactive-p message "%s"] 4 (#$ . 447210) nil])
#@56 Returns end position of function or class definition. 
(defalias 'py-def-or-class-end-position #[nil "`\303 \210``\n\203\304 \203\305\306\"\210	b\210*\207" [pos here py-verbose-p py-end-of-def-or-class interactive-p message "%s"] 4 (#$ . 447493) nil])
#@43 Returns beginning position of statement. 
(defalias 'py-statement-beginning-position #[nil "`\303 \210``\n\203\304 \203\305\306\"\210	b\210*\207" [pos here py-verbose-p py-beginning-of-statement interactive-p message "%s"] 4 (#$ . 447758) nil])
#@37 Returns end position of statement. 
(defalias 'py-statement-end-position #[nil "\302\212\303 )	\203\304 \203\305\306\"\210)\207" [erg py-verbose-p nil py-end-of-statement interactive-p message "%s"] 3 (#$ . 448016) nil])
#@46 Returns beginning position of code in line. 
(defalias 'py-current-indentation #[nil "`\303 \210``\n\203\304 \203\305\306\"\210	b\210*\207" [pos here py-verbose-p back-to-indentation interactive-p message "%s"] 4 (#$ . 448251) nil])
(byte-code "\300\301\302\303#\210\304\305N\204\306\304\305\307\310!#\210\311\312!\204 \306\312\313\302#\210\303\207" [make-obsolete jpython-mode jython-mode nil jython-mode-hook variable-documentation put purecopy "Hook run when entering Jython mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" boundp jython-mode-map definition-name] 5)
(defvar jython-mode-map (make-sparse-keymap))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\305\306!\204\302\306\307\310#\210\300\207" [jython-mode-map variable-documentation put purecopy "Keymap for `jython-mode'." boundp jython-mode-syntax-table definition-name jython-mode] 5)
(defvar jython-mode-syntax-table (make-syntax-table))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\302\305\306\307#\207" [jython-mode-syntax-table variable-documentation put purecopy "Syntax table for `jython-mode'." jython-mode-abbrev-table definition-name jython-mode] 5)
(defvar jython-mode-abbrev-table (progn (define-abbrev-table 'jython-mode-abbrev-table nil) jython-mode-abbrev-table))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\302\305\306\307#\210\302\305\310\307#\207" [jython-mode-abbrev-table variable-documentation put purecopy "Abbrev table for `jython-mode'." jython-mode derived-mode-parent python-mode custom-mode-group] 5)
#@176 Major mode for editing Jython files.
Like `python-mode', but sets up parameters for Jython subprocesses.
Runs `jython-mode-hook' after `python-mode-hook'.

\{jython-mode-map}
(defalias 'jython-mode #[nil "\306\300!\210\307\310 \210\311\312\310\313N\203\314\311\313\310\313N#\210\315!\204'\316\317 \"\210\320\f!\211\2036
\321 =\203<\322\f\323 \"\210)\324\325\"\204V=\204V\326\325C#\210\327!\210\330\f!\210\331\332!\210)\333\334!\207" [delay-mode-hooks major-mode mode-name jython-mode-map jython-mode-syntax-table parent make-local-variable t python-mode jython-mode "Jython" mode-class put keymap-parent set-keymap-parent current-local-map char-table-parent standard-syntax-table set-char-table-parent syntax-table abbrev-table-get :parents abbrev-table-put use-local-map set-syntax-table py-toggle-shell "jython" run-mode-hooks jython-mode-hook jython-mode-abbrev-table local-abbrev-table] 6 (#$ . 449874) nil])
(byte-code "\303\304@	\"\204@	BA\211\204)\305\306\n\"\204)\305\307\n\"\204)\310\nB\304\207" [modes interpreter-mode-alist auto-mode-alist (("jython" . jython-mode) ("python" . python-mode) ("python3" . python-mode)) assoc rassq python-mode jython-mode ("\\.py$" . python-mode)] 4)
#@87 Delete files in `py-file-queue'.
These are Python temporary files awaiting execution.
(defalias 'py-kill-emacs-hook #[nil "\301\302\"\207" [py-file-queue mapc #[(filename) "\300\301\302\217\207" [nil (delete-file filename) ((error))] 3]] 3 (#$ . 451115)])
(byte-code "\301\302\303\"\210\301\304\305\"\210\306\236\204\307B\301\207" [minor-mode-alist add-hook kill-emacs-hook py-kill-emacs-hook comint-output-filter-functions py-pdbtrack-track-stack-file py-pdbtrack-is-tracking-p (py-pdbtrack-is-tracking-p py-pdbtrack-minor-mode-string)] 3)
#@158 Returns versions number of a Python EXECUTABLE, string.

If no EXECUTABLE given, `py-shell-name' is used.
Interactively output of `--version' is displayed. 
(defalias 'py-python-version #[(&optional executable verbose) "\206	\305\306\307P!!\310 \203\311\312\n\"\210\204%\313\n!\211A@)\n*\207" [executable py-shell-name erg verbose x string-strip shell-command-to-string " --version" interactive-p message "%s" split-string] 5 (#$ . 451669) nil])
#@62 Echo the current version of `python-mode' in the minibuffer.
(defalias 'py-version #[nil "\302\303\"\210\304\301!\205\305\211\207" [py-version zmacs-region-stays message "Using `python-mode' version %s" boundp t] 3 (#$ . 452133) nil])
(defalias 'py-install-search-local #[nil "\301\302\303\304Q!!\210\305\207" [default-directory split-string shell-command-to-string "find " " -maxdepth 9 -type f -name \"*python\"" nil] 5 nil nil])
#@211 Builds Python-shell commands from executable found in LOCAL.

If LOCAL is empty, shell-command `find' searches beneath current directory.
Eval resulting buffer to install it, see customizable `py-extensions'. 
(defalias 'py-install-local-shells #[(&optional local path-prefix) "\203\n\306!\202\307\310	\"\311\312\n\"\203\312\202\313\314\315\316\n\317Q!!\320\211(\320\211)*\320\211+,\321-!q\210\322 \210\323p!\210\f\320.\211/\203/@.\324).\311\325.\"T\320O0.\326\311\325.\"TO1\3141\327!\"\3202\2113\203\2333@\2112\324\230\204\222)2\326\330OP)3A\2113\204}*`,4c\210`+,b\210\331\332+\313\330$\203\315\333)\334.\335 5\336\216\311\325.\"*T\320OQ\313\"\210,b\210\337\340+\313\330$\203\361\3330\341\230\203\347\342\202\353\3430!\313\"\210\202\321,b\210\337\344+\313\330$\203\333.\313\"\210db\210/A\211/\204M*\345 \210\3466\312-Q!\205(\3476\312-Q!.	\207" [local default-directory local-dir path-separator shells erg expand-file-name read-from-minibuffer "Virtualenv directory: " string-match "/" t split-string shell-command-to-string "find " " -maxdepth 9 -type f -executable -name \"*python\"" nil get-buffer-create erase-buffer switch-to-buffer "" "/[^/]+$" 0 regexp-quote 1 re-search-forward "\\<NAME\\>" replace-match "-" match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) search-forward "DOCNAME" "ipython" "IPython" capitalize "FULLNAME" emacs-lisp-mode file-readable-p find-file newshell prefix akt end orig py-extensions elt #1=#:--cl-dolist-temp-- curexe aktpath prf #2=#:--cl-dolist-temp-- py-shell-template save-match-data-internal py-install-directory] 8 (#$ . 452577) nil])
(defvar python-which-shell nil)
(defvar python-which-args python-python-command-args)
(defvar python-which-bufname "Python")
(byte-code "\301\302!\210\301\303!\210\301\304!\210\305\236\204\306B\301\207" [minor-mode-alist make-variable-buffer-local python-which-shell python-which-args python-which-bufname python-pdbtrack-is-tracking-p (python-pdbtrack-is-tracking-p python-pdbtrack-minor-mode-string)] 2)
#@98 Queue of Python temp files awaiting execution.
Currently-active file is at the head of the list.
(defvar python-file-queue nil (#$ . 454695))
(defvar python-pdbtrack-is-tracking-p nil)
#@63 Regular expression pdbtrack uses to find a stack trace entry.
(defconst python-pdbtrack-stack-entry-regexp "^> \\(.*\\)(\\([0-9]+\\))\\([?a-zA-Z0-9_<>]+\\)()" (#$ . 454886))
#@61 Regular expression pdbtrack uses to recognize a pdb prompt.
(defconst python-pdbtrack-input-prompt "\n[(<]*[Ii]?[Pp]db[>)]+ " (#$ . 455066))
#@72 Max number of characters from end of buffer to search for stack entry.
(defconst python-pdbtrack-track-range 10000 (#$ . 455213))
#@55 `compilation-error-regexp-alist' for inferior Python.
(defconst python-compilation-regexp-alist (byte-code "\300\301B\302\303B\304\305BE\207" ["^[	 ]+File \"\\([^\"<]+\\)\", line \\([[:digit:]]+\\)" (1 2) " in file \\(.+\\) on line \\([[:digit:]]+\\)" (1 2) "^> \\([^\"(<]+\\)(\\([[:digit:]]+\\))[^(]+()" (1 2)] 4) (#$ . 455349))
(defvar inferior-python-mode-syntax-table (byte-code "\302!\303\304\305	#\210	)\207" [py-mode-syntax-table st make-syntax-table modify-syntax-entry 39 "."] 4))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\305\306!\204\302\306\307\310#\210\300\207" [inferior-python-mode-hook variable-documentation put purecopy "Hook run when entering Inferior Python mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" boundp inferior-python-mode-map definition-name inferior-python-mode] 5)
(defvar inferior-python-mode-map (make-sparse-keymap))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\305\306!\204\302\306\307\310#\210\300\207" [inferior-python-mode-map variable-documentation put purecopy "Keymap for `inferior-python-mode'." boundp inferior-python-mode-syntax-table definition-name inferior-python-mode] 5)
(defvar inferior-python-mode-syntax-table (make-syntax-table))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\302\305\306\307#\207" [inferior-python-mode-syntax-table variable-documentation put purecopy "Syntax table for `inferior-python-mode'." inferior-python-mode-abbrev-table definition-name inferior-python-mode] 5)
(defvar inferior-python-mode-abbrev-table (progn (define-abbrev-table 'inferior-python-mode-abbrev-table nil) inferior-python-mode-abbrev-table))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\302\305\306\307#\210\302\305\310\311#\207" [inferior-python-mode-abbrev-table variable-documentation put purecopy "Abbrev table for `inferior-python-mode'." inferior-python-mode derived-mode-parent comint-mode custom-mode-group python-mode] 5)
#@669 Major mode for interacting with an inferior Python process.
A Python process can be started with \[py-shell].

Hooks `comint-mode-hook' and `inferior-python-mode-hook' are run in
that order.

You can send text to the inferior Python process from other buffers
containing Python source.
 * \[python-switch-to-python] switches the current buffer to the Python
    process buffer.
 * \[python-send-region] sends the current region to the Python process.
 * \[python-send-region-and-go] switches to the Python process buffer
    after sending the text.
For running multiple processes in multiple buffers, see `run-python' and
`python-buffer'.

\{inferior-python-mode-map}
(defalias 'inferior-python-mode #[nil "\306\300!\210\307\310 \210\311\312\310\313N\203\314\311\313\310\313N#\210\315!\204'\316\317 \"\210\320\f!\211\2036
\321 =\203<\322\f\323 \"\210)\324\325\"\204V=\204V\326\325C#\210\327!\210\330\f!\210\331)\332\333!\207" [delay-mode-hooks major-mode mode-name inferior-python-mode-map inferior-python-mode-syntax-table parent make-local-variable t comint-mode inferior-python-mode "Inferior Python" mode-class put keymap-parent set-keymap-parent current-local-map char-table-parent standard-syntax-table set-char-table-parent syntax-table abbrev-table-get :parents abbrev-table-put use-local-map set-syntax-table (":%s") run-mode-hooks inferior-python-mode-hook inferior-python-mode-abbrev-table local-abbrev-table mode-line-process] 6 (#$ . 457364) nil])
(defvar python-preoutput-leftover nil)
(defvar python-preoutput-skip-next-prompt nil)
#@49 Send the region to the inferior Python process.
(defalias 'py-send-region #[(start end) "\306\307!\310\311	\"\203\312\313\"\202\312\314\"\315!\212b\210\316 \317U)\204;\212\fb\210\f\320\317!\321\223\210)\322\323\321\321\324%\210\322
\325\324%\210\326\n!\210r\327\330 !q\210\331\f\",\207" [f py-shell-name command start orig-start end make-temp-file "py" string-match "^ipython" format "execfile %S" "emacs.eexecfile(%S)" copy-marker current-indentation 0 line-beginning-position nil write-region "if True:\n" nomsg t python-send-command process-buffer py-proc compilation-fake-loc] 6 (#$ . 458947) "r"])
#@57 Send the current buffer to the inferior Python process.
(defalias 'py-send-buffer #[nil "\300ed\"\207" [py-send-region] 3 (#$ . 459572) nil])
#@118 Switch to the Python process buffer, maybe starting new process.

With prefix arg, position cursor at end of buffer.
(defalias 'py-switch-to-python #[(eob-p) "\301\302\303 !\304\"\210\205\305 \210db\207" [eob-p pop-to-buffer process-buffer py-proc t push-mark] 3 (#$ . 459721) "P"])
#@85 Send the region to the inferior Python process.

Then switch to the process buffer.
(defalias 'py-send-region-and-go #[(start end) "\302	\"\210\303\304!\207" [start end py-send-region py-switch-to-python t] 3 (#$ . 460013) "r"])
#@123 Caches (directory . file) pair used in the last `py-load-file' command.
Used for determining the default in the next one.
(defvar python-prev-dir/file nil (#$ . 460250))
#@288 Load a Python file FILE-NAME into the inferior Python process.

If the file has extension `.py' import or reload it as a module.
Treating it as a module keeps the global namespace clean, provides
function location information for debugging, and supports users of
module-qualified names.
(defalias 'py-load-file #[(file-name) "\303!\210\304!\305!Br\306\307 !q\210\310\311\312\"\203,\313\305!!\314\315\n\304!#)\2020\314\316\"!\210\317\320\")\207" [file-name python-prev-dir/file module comint-check-source file-name-directory file-name-nondirectory process-buffer py-proc python-send-command string-match "\\.py\\'" file-name-sans-extension format "emacs.eimport(%S,%S)" "execfile(%S)" message "%s loaded"] 6 (#$ . 460427) (comint-get-source "Load Python file: " python-prev-dir/file python-source-modes t)])
(add-hook 'comint-output-filter-functions 'python-pdbtrack-track-stack-file)
#@136 Watch output for Python prompt and exec next file waiting in queue.
This function is appropriate for `comint-output-filter-functions'.
(defalias 'python-comint-output-filter-function #[(string) "\304	\"\205!\n\205!\305\306\307\217\210\nA\211\205!\310p!\311\n@\")\207" [python--prompt-regexp string python-file-queue pyproc string-match nil (byte-code "\301@!\207" [python-file-queue delete-file] 2) ((error)) get-buffer-process python-execute-file] 4 (#$ . 461330)])
#@70 Activate or deactivate arrow at beginning-of-line in current buffer.
(defalias 'python-pdbtrack-overlay-arrow #[(activation) "\203\304 \305\306	\212\307 \210`)p\223\207\310\211\211\207" [activation overlay-arrow-position overlay-arrow-string python-pdbtrack-is-tracking-p make-marker "=>" t beginning-of-line nil] 4 (#$ . 461811)])
#@697 Show the file indicated by the pdb stack entry line, in a separate window.

Activity is disabled if the buffer-local variable
`python-pdbtrack-do-tracking-p' is nil.

We depend on the pdb input prompt being a match for
`python-pdbtrack-input-prompt'.

If the traceback target file path is invalid, we look for the
most recently visited python-mode buffer which either has the
name of the current function or class, or which defines the
function or class.  This is to provide for scripts not in the
local filesytem (e.g., Zope's 'Script (Python)', but it's not
Zope specific).  If you put a copy of the script in a buffer
named for the script and activate python-mode, then pdbtrack will
find it.
(defalias 'python-pdbtrack-track-stack-file #[(text) "p\306!\211\203\n\204\307\310!\202\214\311	!\f
Z]{\310\211\310\211\312\313P\"\204>\307\310!\202\212\314!\211;\203U\307\310!\210\315\316\"\202\212@\211A@)\317!\320!\210eb\210Sy\210\315\321#\210\307\322!\210\323\322\"\210b.*\207" [origbuf currproc python-pdbtrack-do-tracking-p procmark comint-last-input-end python-pdbtrack-track-range get-buffer-process python-pdbtrack-overlay-arrow nil process-mark string-match "$" python-pdbtrack-get-source-buffer message "pdbtrack: %s" buffer-file-name switch-to-buffer-other-window "pdbtrack: line %s, file %s" t pop-to-buffer block target target_fname target_lineno target_buffer python-pdbtrack-input-prompt x] 5 (#$ . 462158)])
#@335 Return line number and buffer of code indicated by block's traceback text.

We look first to visit the file indicated in the trace.

Failing that, we look for the most recently visited python-mode buffer
with the same name or having the named function.

If we're unable find the source code we return a string describing the
problem.
(defalias 'python-pdbtrack-get-source-buffer #[(block) "\306	\"\204	\307\207\310\311	\"\312\310\313	\"!\310\314	\"\315\316\n!\203*\317\n!D\202q\320\f\"\211\203]\306\321\n\"\203Wr
q\210ed\232\203I\322\202T\323ee\306\324ed{\"]\")\\
D\202q\n\322\234\325U\203l\326\327\n\"\202q\326\330\f\n#,\207" [python-pdbtrack-stack-entry-regexp block filename lineno funcname funcbuffer string-match "Traceback cue not found" match-string 1 string-to-number 2 3 nil file-exists-p find-file-noselect python-pdbtrack-grub-for-buffer "/Script (Python)$" 0 count-lines "^\\([^#]\\|#[^#]\\|#$\\)" 60 format "(Non-file source: '%s')" "Not found: %s(), %s"] 8 (#$ . 463645)])
#@74 Find recent python-mode buffer named, or having function named funcname.
(defalias 'python-pdbtrack-grub-for-buffer #[(funcname lineno) "\305 \306\211\n\203?\204?\n@\nAr	q\210\307\230)\203\310\f\311	!\"\204:\310\312\f\313Qr	q\210ed{)\"\203	\202+\207" [got buf buffers major-mode funcname buffer-list nil "python-mode" string-match buffer-name "^\\s-*\\(def\\|class\\)\\s-+" "\\s-*("] 4 (#$ . 464659)])
#@227 Send to Python interpreter process PROC "execfile('FILENAME')".
Make that process's buffer visible and force display.  Also make
comint believe the user typed this string so that
`kill-output-from-shell' does The Right Thing.
(defalias 'python-execute-file #[(proc filename) "p\306!\307\310	\"\307\311	\"\312\216r\fq\210db\210\313!`\314\223\210\315!\"\210*\316\n\",\207" [proc filename cmd msg procbuf curbuf process-buffer format "## working on region in file %s...\n" "execfile(r'%s') # PYTHON-MODE\n" ((set-buffer curbuf)) process-mark nil process-filter process-send-string] 6 (#$ . 465086)])
(defalias 'py-find-global-imports #[nil "\212\302\211eb\210\303\304\302\305#eb\210\303\306\302\305#\203&\307\310\224\310\225{C\"\202+\207" [imports first-class-or-def nil re-search-forward "^ *\\(def\\|class\\) " t "^\\(import \\|from \\([A-Za-z_][A-Za-z_0-9]*\\) import \\).*" append 0] 4])
(byte-code "\300\301\302\"\210\300\303\304\"\207" [defalias py-shell-redirect-send-command-to-process comint-redirect-send-command-to-process py-shell-dynamic-simple-complete comint-dynamic-simple-complete] 3)
#@69 String of top-level import statements updated by `py-find-imports'.
(defvar python-imports "None" (#$ . 466210))
(make-variable-buffer-local 'python-imports)
(defalias 'py-shell-simple-send #[(proc string) "\302	\"\207" [proc string comint-simple-send] 3])
#@90 Send to Python interpreter process PROC "exec STRING in {}".
and return collected output
(defalias 'py-shell-execute-string-now #[(string &optional shell buffer) "\206	\306\307\211	#\310\n!\311\312\313\314\315\f\316\"\317#\"\320\321!\307\216\307\322\323\217-\207" [buffer shell procbuf proc string cmd py-shell nil get-buffer-process format "exec '''%s''' in {}" mapconcat identity split-string "\n" "\\n" get-buffer-create " *pyshellcomplete-output*" (byte-code "rq\210ed|\210)r	q\210\305\n\306\307%\210\f\204!\310\311\"\210\202)rq\210ed{)\207" [outbuf procbuf cmd proc comint-redirect-completed comint-redirect-send-command-to-process nil t accept-process-output 1] 6) ((quit (byte-code "rq\210\304	\n\"\210\204\305	\306\"\210\202	)\307\310\311\"\207" [procbuf proc comint-ptyp comint-redirect-completed interrupt-process accept-process-output 1 signal quit nil] 3))) outbuf] 7 (#$ . 466474)])
(defalias 'py-dot-word-before-point #[nil "\212\300\301x\210`)`{\207" ["a-zA-Z0-9_." nil] 2])
#@64 An alternative completion, similar the way python.el does it. 
(defalias 'py-completion-at-point #[nil "\303\304x\205`\303\304w\210`\205\305\306	\"!\211\203'	|\210\n@c\202)\307 +\207" [start end completion "[[:alnum:]_]" nil py-symbol-completions buffer-substring-no-properties tab-to-tab-stop] 5 (#$ . 467490) "*"])
(defalias 'py-script-complete #[nil "`\212\302\303\304\305#\205\f\306\224)\205	\307\310!E*\207" [start end re-search-backward "\\(?:\\`\\|[^[:alnum:]._]\\)\\([[:alnum:]._]+\\)\\=" nil t 1 completion-table-dynamic py-symbol-completions] 5 nil "*"])
#@157 Return a list of completions of the string SYMBOL from Python process.
The list is sorted.
Uses `python-imports' to load modules against which to complete.
(defalias 'py-symbol-completions #[(symbol) ";\205\302\303\304\217\305\306	!\307\")\207" [symbol completions nil (byte-code "\302\303\304\305\306!	#!!@\207" [symbol python-imports read-from-string python-send-receive format "emacs.complete(%S,%s)" substring-no-properties] 6) ((error)) sort delete-dups string<] 3 (#$ . 468081)])
#@60 Complete word before point, if any. Otherwise insert TAB. 
(defalias 'py-python-script-complete #[(&optional shell imports beg end word) "\306\211`\206\f\206\307 
\206\212\310\306x\210`)-\206#`-.\206/\311
-\"./\2068\312 /.\313\230\203K\314\315\316\"\210\317 \202\354\320\321!!\2110\204_\320\322\306\211#!0\3230!\203\351\324\325.\"\203\263\212\326 1\327\216eb\210\330\331\332\333.\"\334Q\306\335\333$\210*/\203\253\324\336\332\333.\"\337Q/\"\204\262/\340\332\333.\"\337QP/\202\262\332\341.\"/)\3420/.#\210`\n=\203\345\343 \204\341\344\345\346!!\203\341\346q\210\347p!\210\350 \210\351.!\210\202\345\352\306!\210\306\202\354\353\354!.\207" [py-split-windows-on-execute-p py-switch-buffers-on-execute-p orig shell py-local-versioned-command beg nil py-choose-shell "a-zA-Z0-9_." buffer-substring-no-properties py-find-imports "" message "%s" "Nothing to complete. " tab-to-tab-stop get-buffer-process py-buffer-name-prepare py-shell processp string-match "^\\(^[a-zA-Z0-9_]+\\)\\.\\([a-zA-Z0-9_]+\\)$" match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) re-search-forward "^[ 	]*" match-string-no-properties 1 "[ 	]*=[ 	]*[^ \n
\f	]+" t "import " ";" "import" 0 python-shell-completion--do-completion-at-point window-full-height-p buffer-live-p get-buffer "*Python Completions*" switch-to-buffer delete-other-windows search-forward dabbrev-expand error "No completion process at proc" end word imports proc save-match-data-internal] 6 (#$ . 468578) nil])
(defalias 'py-python2-shell-complete #[(&optional shell) "\306\211\n\206	`\212\307\306x\210`)`\310
\"\211\311\230\203/\312\313\314\"\210\315 \210\202Q\316\n!\211\204A\316\317\306\211\n#!\312\313\320!\"\210\321\306#\210.\306\207" [py-split-windows-on-execute-p py-switch-buffers-on-execute-p shell py-local-versioned-command orig beg nil "a-zA-Z0-9_." buffer-substring-no-properties "" message "%s" "Nothing to complete. " tab-to-tab-stop get-buffer-process py-shell processp python-shell-completion--do-completion-at-point end word proc] 6 nil nil])
#@60 Complete word before point, if any. Otherwise insert TAB. 
(defalias 'py-python3-shell-complete #[(&optional shell) "\206	`\212\306\307x\210`)`\310\f\"\211\311\230\203'\312\313\314\"\210\315 \2020\316\317p!\307
#\210\307-\207" [shell py-local-versioned-command orig beg end word "a-zA-Z0-9_." nil buffer-substring-no-properties "" message "%s" "Nothing to complete. " tab-to-tab-stop python-shell-completion--do-completion-at-point get-buffer-process] 5 (#$ . 470715) nil])
#@60 Complete word before point, if any. Otherwise insert TAB. 
(defalias 'py-shell-complete #[(&optional shell) "\306=\204\f\307=\203]\310	\206\311\312p!!\313\314	\"\203$\315 \202[`\212\316\310x\210`)`\317\f
\"\211\320\230\203A\321 \202Z\313\322	\"\203S\323\324p!\320#\202Z\325\f
	$,*\207	\206c\326 \310\211\324	!\206y\324\327\310\211	\330\310%!\212\316\310x\210`)`\317\f
\"\331 \320\230\203\233\321 \202\325\313\314	\"\203\247\315 \202\325\313\322	\"\203\273\323\317\f
\"#\202\325\203\314\332	\f
%\202\325\325\f
	%.\207" [major-mode shell py-fontify-shell-buffer-p orig beg end comint-mode inferior-python-mode nil py-report-executable buffer-name string-match "[iI][pP]ython" ipython-complete "a-zA-Z0-9_." buffer-substring-no-properties "" tab-to-tab-stop "[pP]ython3[^[:alpha:]]*$" python-shell-completion--do-completion-at-point get-buffer-process py-shell-complete-intern py-choose-shell py-shell noswitch py-find-imports py-python-script-complete word py-split-windows-on-execute-p py-switch-buffers-on-execute-p proc imports] 8 (#$ . 471206) nil])
(defalias 'py-shell-complete-intern #[(word &optional beg end shell imports) "\306	\203\307\310	\311P\n\"\"\202\"\307\310\311\n\"\312p!\205 p#\306=\204.\313\230\2034\314\315!\202o\316\f\313#\306\317\320\321\322\211\"\203L\321\322\323#\202P\321\322\"!\324\"
@\n\230\203c\325 \210\202m|\210
@c\210*`)\207" [result imports word shell comint-prompt-regexp completions nil py-shell-execute-string-now format "\ndef print_completions(namespace, text, prefix=''):\n   for name in namespace:\n       if name.startswith(text):\n           print(prefix + name)\n\ndef complete(text):\n    import __builtin__\n    import __main__\n    if '.' in text:\n        terms = text.split('.')\n        try:\n            if hasattr(__main__, terms[0]):\n                obj = getattr(__main__, terms[0])\n            else:\n                obj = getattr(__builtin__, terms[0])\n            for term in terms[1:-1]:\n                obj = getattr(obj, term)\n            print_completions(dir(obj), terms[-1], text[:text.rfind('.') + 1])\n        except AttributeError:\n            pass\n    else:\n        import keyword\n        print_completions(keyword.kwlist, text)\n        print_completions(dir(__builtin__), text)\n        print_completions(dir(__main__), text)\ncomplete('%s')" comint-check-proc "" message "Can't complete" replace-regexp-in-string sort delete-dups split-string "\n" t string< tab-to-tab-stop comint-completion-addsuffix beg end] 7])
#@156 Complete the python symbol before point.

If no completion available, insert a TAB.
Returns the completed symbol, a string, if successful, nil otherwise. 
(defalias 'ipython-complete #[(&optional done completion-command-string beg end word) "\306\211\n\206\212\307\310 x\210`)\206`\f\206\311\n\"\3125\3136\314 7\30689\203R\315\316!\205?\317\320\321\316!!!?\205\321\322\306\2116\323\306\316&!\2027\203}8\204}6\3207@!\230\203t\3247@!\203t7@87A\2117\204W8\211:\206\233\321\322\306\211\325\3266\"\203\2266\202\227\313\323\306%!;\327\330<\"<\331<\332\"<=\206\266\333\320;!!>\306\211?@\306\211AB
\334\230\203\317\335 \202\225\336;\337>
\"\"\210\340;\341\"\210\342B\343\344\345B\"O5\"\211@C\306\211DEC:\203C@\211D\306DEBECA\211C\202\371E\237+A\346
A\"\211?\347=\203+\335 \202\225?\204<\350\351
\"\210\352 \210\306\202\225
?\230\204O\n|\210?c\210\306\202\225F\203X\350\353!\210GHr\354\355!q\210p\356 \210HG\306\211IJ\347\211K\347LM\357 \210\360\361!\210+\211NO\362\363
A\"!\210\364N!\210+\306.\207" [py-split-windows-on-execute-p py-switch-buffers-on-execute-p beg end word pattern nil "a-z0-9A-Z_." point-at-bol buffer-substring-no-properties ";" "ipython" process-list buffer-live-p "*IPython-Complete*" comint-check-proc process-name get-buffer-process py-shell noswitch processp string-match "[iI][pP]ython[^[:alpha:]]*$" delq py-comint-output-filter-function append (ansi-color-filter-apply (lambda (string) (setq ugly-return (concat ugly-return string)) (delete-region comint-last-output-start (process-mark (get-buffer-process (current-buffer)))))) py-set-ipython-completion-command-string "" tab-to-tab-stop process-send-string format accept-process-output 5 split-string 0 position 10 try-completion t message "Can't find completion for \"%s\"" ding "Making completion list..." get-buffer-create "*Python Completions*" kill-all-local-variables erase-buffer run-hooks temp-buffer-setup-hook display-completion-list all-completions internal-temp-output-buffer-show sep pyshellname processlist done ipython-complete-use-separate-shell-p process python-process comint-output-filter-functions completion-command-string ccs completion completions completion-table ugly-return #1=#:--cl-var-- str #2=#:--cl-var-- py-verbose-p default-directory #3=#:old-dir buffer-read-only buffer-file-name buffer-undo-list inhibit-modification-hooks inhibit-read-only #4=#:buf standard-output] 9 (#$ . 473796) "*"])
#@288 Complete the python symbol before point.

If no completion available, insert a TAB.
Returns the completed symbol, a string, if successful, nil otherwise.

Bug: if no IPython-shell is running, fails first time due to header returned, which messes up the result. Please repeat once then. 
(defalias 'ipython-complete-py-shell-name #[(&optional done) "\306\211\212\307\310 x\210`)`\311\n\"\312\313p!\206,\313\314 !\206,\313\314\306\211\315\316\306%!/\317\3200\"0\3210\322\"0\306\21112\306\21134\f\323\230\203T\324 \210\202\325/\326\327\330/!\227!\f\"\"\210\331/!\210\3324\333\334\3354\"O
\"\21125\306\211675:\203\2335@\2116\306D7B75A\2115\202\2017\237+3\336\f3\"\2111\337=\2041\204\276\340\341\f\"\210\342 \210\202\f1\230\204\320\n|\2101c\210\202\340\343!\21089r\344\345!q\210p\346 \21098\306\211:;\337\211<\337=>\347 \210\350\351!\210+\211?@\352\353\f3\"!\210\354?!\210+\340\355\356\"\2101.
\207" [py-split-windows-on-execute-p py-switch-buffers-on-execute-p beg end pattern sep nil "a-z0-9A-Z_." point-at-bol buffer-substring-no-properties ";" get-buffer-process py-shell "ipython" noswitch delq py-comint-output-filter-function append (ansi-color-filter-apply (lambda (string) (setq ugly-return (concat ugly-return string)) (delete-region comint-last-output-start (process-mark (get-buffer-process (current-buffer)))))) "" tab-to-tab-stop process-send-string format py-set-ipython-completion-command-string process-name accept-process-output split-string 0 position 10 try-completion t message "Can't find completion for \"%s\"" ding "Making completion list..." get-buffer-create "*Python Completions*" kill-all-local-variables erase-buffer run-hooks temp-buffer-setup-hook display-completion-list all-completions internal-temp-output-buffer-show "Making completion list...%s" "done" py-process comint-output-filter-functions completion completions completion-table ugly-return #1=#:--cl-var-- str #2=#:--cl-var-- default-directory #3=#:old-dir buffer-read-only buffer-file-name buffer-undo-list inhibit-modification-hooks inhibit-read-only #4=#:buf standard-output] 8 (#$ . 476310) "*"])
#@71 *Run pep8, check formatting (default on the file currently visited).

(defalias 'py-pep8-run #[(command) "\302?\303\"\210\304\305!\205\305	!\207" [py-ask-about-save command save-some-buffers nil fboundp compilation-start] 3 (#$ . -478474) (let ((default (if (buffer-file-name) (format "%s %s %s" py-pep8-command (mapconcat 'identity py-pep8-command-args " ") (buffer-file-name)) (format "%s %s" py-pep8-command (mapconcat 'identity py-pep8-command-args " ")))) (last (if py-pep8-history (progn (let* ((lastcmd (car py-pep8-history)) (cmd (cdr (reverse (split-string lastcmd)))) (newcmd (reverse (cons (buffer-file-name) cmd)))) (mapconcat 'identity newcmd " ")))))) (list (if (fboundp 'read-shell-command) (read-shell-command "Run pep8 like this: " (if last last default) 'py-pep8-history) (read-string "Run pep8 like this: " (if last last default) 'py-pep8-history))))])
#@43 Display pep8 command line help messages. 
(defalias 'py-pep8-help #[nil "\300\301!q\210\302 \210\303\304\301\"\207" [get-buffer-create "*pep8-Help*" erase-buffer shell-command "pep8 --help"] 3 (#$ . 479355) nil])
(defalias 'pylint 'py-pylint-run)
#@162 *Run pylint (default on the file currently visited).

For help see M-x pylint-help resp. M-x pylint-long-help.
Home-page: http://www.logilab.org/project/pylint 
(defalias 'py-pylint-run #[(command) "\302?\303\"\210\304\305!\205\305	!\207" [py-ask-about-save command save-some-buffers nil fboundp compilation-start] 3 (#$ . -479609) (let ((default (if (buffer-file-name) (format "%s %s %s" py-pylint-command (mapconcat 'identity py-pylint-command-args " ") (buffer-file-name)) (format "%s %s" py-pylint-command (mapconcat 'identity py-pylint-command-args " ")))) (last (if py-pylint-history (progn (let* ((lastcmd (car py-pylint-history)) (cmd (cdr (reverse (split-string lastcmd)))) (newcmd (reverse (cons (buffer-file-name) cmd)))) (mapconcat 'identity newcmd " ")))))) (list (if (fboundp 'read-shell-command) (read-shell-command "Run pylint like this: " (if last last default) 'py-pylint-history) (read-string "Run pylint like this: " (if last last default) 'py-pylint-history))))])
(defalias 'pylint-help 'py-pylint-help)
#@101 Display Pylint command line help messages.

Let's have this until more Emacs-like help is prepared 
(defalias 'py-pylint-help #[nil "\300\301!q\210\302 \210\303\304\301\"\207" [get-buffer-create "*Pylint-Help*" erase-buffer shell-command "pylint --long-help"] 3 (#$ . 480644) nil])
(defalias 'pylint-doku 'py-pylint-doku)
#@68 Display Pylint Documentation.

Calls `pylint --full-documentation'
(defalias 'py-pylint-doku #[nil "\300\301!q\210\302 \210\303\304\301\"\207" [get-buffer-create "*Pylint-Documentation*" erase-buffer shell-command "pylint --full-documentation"] 3 (#$ . 480972) nil])
(defalias 'pyflakes 'py-pyflakes-run)
#@170 *Run pyflakes (default on the file currently visited).

For help see M-x pyflakes-help resp. M-x pyflakes-long-help.
Home-page: http://www.logilab.org/project/pyflakes 
(defalias 'py-pyflakes-run #[(command) "\302?\303\"\210\304\305!\205\305	!\207" [py-ask-about-save command save-some-buffers nil fboundp compilation-start] 3 (#$ . -481284) (let ((default (if (buffer-file-name) (format "%s %s %s" py-pyflakes-command (mapconcat 'identity py-pyflakes-command-args " ") (buffer-file-name)) (format "%s %s" py-pyflakes-command (mapconcat 'identity py-pyflakes-command-args " ")))) (last (if py-pyflakes-history (progn (let* ((lastcmd (car py-pyflakes-history)) (cmd (cdr (reverse (split-string lastcmd)))) (newcmd (reverse (cons (buffer-file-name) cmd)))) (mapconcat 'identity newcmd " ")))))) (list (if (fboundp 'read-shell-command) (read-shell-command "Run pyflakes like this: " (if last last default) 'py-pyflakes-history) (read-string "Run pyflakes like this: " (if last last default) 'py-pyflakes-history))))])
(defalias 'pyflakes-help 'py-pyflakes-help)
#@103 Display Pyflakes command line help messages.

Let's have this until more Emacs-like help is prepared 
(defalias 'py-pyflakes-help #[nil "\306\211\223\210\306\307\nBr\310\311!q\210p\312 \210\f\306\211\313\211\313\314 \210\315\316!\210+\211rq\210\317c)\320!\210+\321	!\210*\207" [help-window-point-marker help-window temp-buffer-show-hook default-directory #1=#:old-dir buffer-read-only nil #[nil "\301 \211\207" [help-window selected-window] 2] get-buffer-create "*Pyflakes-Help*" kill-all-local-variables t erase-buffer run-hooks temp-buffer-setup-hook "       pyflakes [file-or-directory ...]\n\n       Pyflakes is a simple program which checks Python\n       source files for errors. It is similar to\n       PyChecker in scope, but differs in that it does\n       not execute the modules to check them. This is\n       both safer and faster, although it does not\n       perform as many checks. Unlike PyLint, Pyflakes\n       checks only for logical errors in programs; it\n       does not perform any checks on style.\n\n       All commandline arguments are checked, which\n       have to be either regular files or directories.\n       If a directory is given, every .py file within\n       will be checked.\n\n       When no commandline arguments are given, data\n       will be read from standard input.\n\n       The exit status is 0 when no warnings or errors\n       are found. When errors are found the exit status\n       is 2. When warnings (but no errors) are found\n       the exit status is 1.\n\nExtracted from http://manpages.ubuntu.com/manpages/natty/man1/pyflakes.1.html\n" internal-temp-output-buffer-show help-window-setup buffer-file-name buffer-undo-list inhibit-modification-hooks inhibit-read-only #2=#:buf standard-output] 4 (#$ . 482353) nil])
(defalias 'pyflakespep8 'py-pyflakespep8-run)
#@79 *Run pyflakespep8, check formatting (default on the file currently visited).

(defalias 'py-pyflakespep8-run #[(command) "\302?\303\"\210\304\305!\205\305	!\207" [py-ask-about-save command save-some-buffers nil fboundp compilation-start] 3 (#$ . -484202) (let ((default (if (buffer-file-name) (format "%s %s %s" py-pyflakespep8-command (mapconcat 'identity py-pyflakespep8-command-args " ") (buffer-file-name)) (format "%s %s" py-pyflakespep8-command (mapconcat 'identity py-pyflakespep8-command-args " ")))) (last (if py-pyflakespep8-history (progn (let* ((lastcmd (car py-pyflakespep8-history)) (cmd (cdr (reverse (split-string lastcmd)))) (newcmd (reverse (cons (buffer-file-name) cmd)))) (mapconcat 'identity newcmd " ")))))) (list (if (fboundp 'read-shell-command) (read-shell-command "Run pyflakespep8 like this: " (if last last default) 'py-pyflakespep8-history) (read-string "Run pyflakespep8 like this: " (if last last default) 'py-pyflakespep8-history))))])
#@51 Display pyflakespep8 command line help messages. 
(defalias 'py-pyflakespep8-help #[nil "\300\301!q\210\302 \210\303\304\301\"\207" [get-buffer-create "*pyflakespep8-Help*" erase-buffer shell-command "pyflakespep8 --help"] 3 (#$ . 485179) nil])
#@57 *Run pychecker (default on the file currently visited).
(defalias 'py-pychecker-run #[(command) "\302?\303\"\210\304\305!\205\305	!\207" [py-ask-about-save command save-some-buffers nil fboundp compilation-start] 3 (#$ . -485430) (let ((default (if (buffer-file-name) (format "%s %s %s" py-pychecker-command (mapconcat 'identity py-pychecker-command-args " ") (buffer-file-name)) (format "%s %s" py-pychecker-command (mapconcat 'identity py-pychecker-command-args " ")))) (last (if py-pychecker-history (progn (let* ((lastcmd (car py-pychecker-history)) (cmd (cdr (reverse (split-string lastcmd)))) (newcmd (reverse (cons (buffer-file-name) cmd)))) (mapconcat 'identity newcmd " ")))))) (list (if (fboundp 'read-shell-command) (read-shell-command "Run pychecker like this: " (if last last default) 'py-pychecker-history) (read-string "Run pychecker like this: " (if last last default) 'py-pychecker-history))))])
(put 'py-else 'no-self-insert t)
#@524 Auxiliary skeleton.

This is a skeleton command (see `skeleton-insert').
Normally the skeleton text is inserted at point, with nothing "inside".
If there is a highlighted region, the skeleton text is wrapped
around the region text.

A prefix argument ARG says to wrap the skeleton around the next ARG words.
A prefix argument of -1 says to wrap around region, even if not highlighted.
A prefix argument of zero says to wrap around zero words---that is, nothing.
This is a way of overriding the use of a highlighted region.
(defalias 'py-else #[(&optional str arg) "\302\303	#\207" [str arg skeleton-proxy-new (nil (unless (eq 121 (read-char "Add `else' clause? (y for yes or RET for no) ")) (signal 'quit t)) < "else:" n)] 4 (#$ . 486386) "*P\nP"])
(put 'py-if 'no-self-insert t)
#@518 If condition 

This is a skeleton command (see `skeleton-insert').
Normally the skeleton text is inserted at point, with nothing "inside".
If there is a highlighted region, the skeleton text is wrapped
around the region text.

A prefix argument ARG says to wrap the skeleton around the next ARG words.
A prefix argument of -1 says to wrap around region, even if not highlighted.
A prefix argument of zero says to wrap around zero words---that is, nothing.
This is a way of overriding the use of a highlighted region.
(defalias 'py-if #[(&optional str arg) "\302\303	#\207" [str arg skeleton-proxy-new ("if " "if " str ":" n _ n ("other condition, %s: " < "elif " str ":" n > _ n nil) '(py-else) | ^)] 4 (#$ . 487174) "*P\nP"])
(put 'py-else 'no-self-insert t)
#@524 Auxiliary skeleton.

This is a skeleton command (see `skeleton-insert').
Normally the skeleton text is inserted at point, with nothing "inside".
If there is a highlighted region, the skeleton text is wrapped
around the region text.

A prefix argument ARG says to wrap the skeleton around the next ARG words.
A prefix argument of -1 says to wrap around region, even if not highlighted.
A prefix argument of zero says to wrap around zero words---that is, nothing.
This is a way of overriding the use of a highlighted region.
(defalias 'py-else #[(&optional str arg) "\302\303	#\207" [str arg skeleton-proxy-new (nil (unless (eq 121 (read-char "Add `else' clause? (y for yes or RET for no) ")) (signal 'quit t)) "else:" n > _ n)] 4 (#$ . 487942) "*P\nP"])
(put 'py-while 'no-self-insert t)
#@516 Condition: 

This is a skeleton command (see `skeleton-insert').
Normally the skeleton text is inserted at point, with nothing "inside".
If there is a highlighted region, the skeleton text is wrapped
around the region text.

A prefix argument ARG says to wrap the skeleton around the next ARG words.
A prefix argument of -1 says to wrap around region, even if not highlighted.
A prefix argument of zero says to wrap around zero words---that is, nothing.
This is a way of overriding the use of a highlighted region.
(defalias 'py-while #[(&optional str arg) "\302\303	#\207" [str arg skeleton-proxy-new ("while " "while " str ":" n > -1 _ n '(py-else) | ^)] 4 (#$ . 488737) "*P\nP"])
(put 'py-for 'no-self-insert t)
#@517 Target, %s: 

This is a skeleton command (see `skeleton-insert').
Normally the skeleton text is inserted at point, with nothing "inside".
If there is a highlighted region, the skeleton text is wrapped
around the region text.

A prefix argument ARG says to wrap the skeleton around the next ARG words.
A prefix argument of -1 says to wrap around region, even if not highlighted.
A prefix argument of zero says to wrap around zero words---that is, nothing.
This is a way of overriding the use of a highlighted region.
(defalias 'py-for #[(&optional str arg) "\302\303	#\207" [str arg skeleton-proxy-new ("for " "for " str " in " (skeleton-read "Expression, %s: ") ":" n > -1 _ n '(py-else) | ^)] 4 (#$ . 489460) "*P\nP"])
(put 'py-try/except 'no-self-insert t)
#@528 Py-try/except skeleton 

This is a skeleton command (see `skeleton-insert').
Normally the skeleton text is inserted at point, with nothing "inside".
If there is a highlighted region, the skeleton text is wrapped
around the region text.

A prefix argument ARG says to wrap the skeleton around the next ARG words.
A prefix argument of -1 says to wrap around region, even if not highlighted.
A prefix argument of zero says to wrap around zero words---that is, nothing.
This is a way of overriding the use of a highlighted region.
(defalias 'py-try/except #[(&optional str arg) "\302\303	#\207" [str arg skeleton-proxy-new ("try:" "try:" n > -1 _ n ("Exception, %s: " < "except " str '(python-target) ":" n > _ n nil) < "except:" n > _ n '(py-else) | ^)] 4 (#$ . 490227) "*P\nP"])
(put 'py-target 'no-self-insert t)
#@524 Auxiliary skeleton.

This is a skeleton command (see `skeleton-insert').
Normally the skeleton text is inserted at point, with nothing "inside".
If there is a highlighted region, the skeleton text is wrapped
around the region text.

A prefix argument ARG says to wrap the skeleton around the next ARG words.
A prefix argument of -1 says to wrap around region, even if not highlighted.
A prefix argument of zero says to wrap around zero words---that is, nothing.
This is a way of overriding the use of a highlighted region.
(defalias 'py-target #[(&optional str arg) "\302\303	#\207" [str arg skeleton-proxy-new ("Target, %s: " ", " str | -2)] 4 (#$ . 491047) "*P\nP"])
(put 'py-try/finally 'no-self-insert t)
#@529 Py-try/finally skeleton 

This is a skeleton command (see `skeleton-insert').
Normally the skeleton text is inserted at point, with nothing "inside".
If there is a highlighted region, the skeleton text is wrapped
around the region text.

A prefix argument ARG says to wrap the skeleton around the next ARG words.
A prefix argument of -1 says to wrap around region, even if not highlighted.
A prefix argument of zero says to wrap around zero words---that is, nothing.
This is a way of overriding the use of a highlighted region.
(defalias 'py-try/finally #[(&optional str arg) "\302\303	#\207" [str arg skeleton-proxy-new ("try:" n > -1 _ n < "finally:" n > _ n)] 4 (#$ . 491764) "*P\nP"])
(put 'py-def 'no-self-insert t)
#@511 Name: 

This is a skeleton command (see `skeleton-insert').
Normally the skeleton text is inserted at point, with nothing "inside".
If there is a highlighted region, the skeleton text is wrapped
around the region text.

A prefix argument ARG says to wrap the skeleton around the next ARG words.
A prefix argument of -1 says to wrap around region, even if not highlighted.
A prefix argument of zero says to wrap around zero words---that is, nothing.
This is a way of overriding the use of a highlighted region.
(defalias 'py-def #[(&optional str arg) "\302\303	#\207" [str arg skeleton-proxy-new ("def " str " (" ("Parameter, %s: " (unless (equal 40 (char-before)) ", ") str) "):" n "\"\"\"" - "\"\"\"" n > _ n)] 4 (#$ . 492493) "*P\nP"])
(put 'py-class 'no-self-insert t)
#@511 Name: 

This is a skeleton command (see `skeleton-insert').
Normally the skeleton text is inserted at point, with nothing "inside".
If there is a highlighted region, the skeleton text is wrapped
around the region text.

A prefix argument ARG says to wrap the skeleton around the next ARG words.
A prefix argument of -1 says to wrap around region, even if not highlighted.
A prefix argument of zero says to wrap around zero words---that is, nothing.
This is a way of overriding the use of a highlighted region.
(defalias 'py-class #[(&optional str arg) "\302\303	#\207" [str arg skeleton-proxy-new ("class " str " (" ("Inheritance, %s: " (unless (equal 40 (char-before)) ", ") str) & ")" | -2 ":" n "\"\"\"" - "\"\"\"" n > _ n)] 4 (#$ . 493273) "*P\nP"])
(defvar virtualenv-workon-home nil)
(byte-code "\301\302!\203
\301\302!\202\303\301\207" [virtualenv-workon-home getenv "WORKON_HOME" "~/.virtualenvs"] 2)
(defvar virtualenv-name nil)
(byte-code "\301\211\207" [virtualenv-name nil] 2)
#@150 Apply to each element of SEQUENCE the PREDICATE, if FUNCTION
  returns non-nil append the element to the return value of
  virtualenv-filter: a list
(defalias 'virtualenv-filter #[(predicate sequence) "\305	\305\211\203@\f\n!\203\nBA\211\204\n*\237)\207" [retlist sequence element #1=#:--cl-dolist-temp-- predicate nil] 3 (#$ . 494276)])
#@141 Append DIR to a path-like varibale VAR, for example:
 (virtualenv-append-path /usr/bin:/bin /home/test/bin) -> /home/test/bin:/usr/bin:/bin
(defalias 'virtualenv-append-path #[(dir var) "\303!	\nQ\207" [dir path-separator var expand-file-name] 3 (#$ . 494636)])
#@50 Add the specified path element to the Emacs PATH
(defalias 'virtualenv-add-to-path #[(dir) "\301\302\303\304\302!\"\"\207" [dir setenv "PATH" virtualenv-append-path getenv] 6 (#$ . 494905)])
#@40 barfs the current activated virtualenv
(defalias 'virtualenv-current #[nil "\301!\207" [virtualenv-name message] 2 (#$ . 495103) nil])
#@40 Activate the virtualenv located in DIR
(defalias 'virtualenv-activate #[(dir) "\203\305 \210\306\307!\n\310\311\f\"\210\312\f\313P!\210\314\302\f\313P\"\210\f\315\316\317Q!\207" [virtualenv-name virtualenv-old-path exec-path virtualenv-old-exec-path dir virtualenv-deactivate getenv "PATH" setenv "VIRTUAL_ENV" virtualenv-add-to-path "bin" add-to-list message "Virtualenv '" "' activated."] 4 (#$ . 495245) "DVirtualenv Directory: "])
#@43 Deactivate the current virtual enviroment
(defalias 'virtualenv-deactivate #[nil "\304\305\"\210	\306\307\310Q!\210\311\211\207" [virtualenv-old-path virtualenv-old-exec-path exec-path virtualenv-name setenv "PATH" message "Virtualenv '" "' deactivated." nil] 4 (#$ . 495693) nil])
#@38 Check if a directory is a virtualenv
(defalias 'virtualenvp #[(dir) "\301\302P!\207" [dir file-exists-p "/bin/activate"] 3 (#$ . 495985)])
#@52 return available completions for virtualenv-workon
(defalias 'virtualenv-workon-complete #[nil "\302\303\"\304\305\306\307\306\310	\"\"\")\207" [virtualenv-workon-home filelist directory-files t mapcar file-name-nondirectory virtualenv-filter virtualenvp file-directory-p] 7 (#$ . 496131)])
#@58 Issue a virtualenvwrapper-like virtualenv-workon command
(defalias 'virtualenv-workon #[(name) "\301\302\303!\304Q!\207" [name virtualenv-activate getenv "WORKON_HOME" "/"] 4 (#$ . 496430) (list (completing-read "Virtualenv: " (virtualenv-workon-complete)))])
(defalias 'py-toggle-local-default-use #[nil "?\301 \203
\302\303\"\210\207" [py-use-local-default interactive-p message "py-use-local-default set to %s"] 3 nil nil])
#@36 Used by python-extended-executes .
(defalias 'py-execute-prepare #[(form &optional shell dedicated switch) "\212\306\307\310Q! \206\306\307P! \206\311 \306\312P! \313\n	\f
%+\207" [form end beg shell dedicated switch intern-soft "py-beginning-of-" "-p" push-mark "py-end-of-" py-execute-base] 6 (#$ . 496869)])
#@49 Send statement at point to Python interpreter. 
(defalias 'py-execute-statement-python #[nil "\300\301\302\303\211$\207" [py-execute-prepare "statement" "python" nil] 5 (#$ . 497196) nil])
#@123 Send statement at point to Python interpreter.

Switch to output buffer. Ignores `py-shell-switch-buffers-on-execute-p'. 
(defalias 'py-execute-statement-python-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "statement" "python" nil switch] 5 (#$ . 497392) nil])
#@118 Send statement at point to Python interpreter.

Keep current buffer. Ignores `py-shell-switch-buffers-on-execute-p' 
(defalias 'py-execute-statement-python-noswitch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "statement" "python" nil noswitch] 5 (#$ . 497676) nil])
#@56 Send statement at point to Python unique interpreter. 
(defalias 'py-execute-statement-python-dedicated #[nil "\300\301\302\303\304$\207" [py-execute-prepare "statement" "python" t nil] 5 (#$ . 497958) nil])
#@77 Send statement at point to Python unique interpreter and switch to result. 
(defalias 'py-execute-statement-python-dedicated-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "statement" "python" t switch] 5 (#$ . 498172) nil])
#@50 Send statement at point to IPython interpreter. 
(defalias 'py-execute-statement-ipython #[nil "\300\301\302\303\211$\207" [py-execute-prepare "statement" "ipython" nil] 5 (#$ . 498417) nil])
#@124 Send statement at point to IPython interpreter.

Switch to output buffer. Ignores `py-shell-switch-buffers-on-execute-p'. 
(defalias 'py-execute-statement-ipython-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "statement" "ipython" nil switch] 5 (#$ . 498616) nil])
#@119 Send statement at point to IPython interpreter.

Keep current buffer. Ignores `py-shell-switch-buffers-on-execute-p' 
(defalias 'py-execute-statement-ipython-noswitch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "statement" "ipython" nil noswitch] 5 (#$ . 498903) nil])
#@57 Send statement at point to IPython unique interpreter. 
(defalias 'py-execute-statement-ipython-dedicated #[nil "\300\301\302\303\304$\207" [py-execute-prepare "statement" "ipython" t nil] 5 (#$ . 499188) nil])
#@78 Send statement at point to IPython unique interpreter and switch to result. 
(defalias 'py-execute-statement-ipython-dedicated-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "statement" "ipython" t switch] 5 (#$ . 499405) nil])
#@50 Send statement at point to Python3 interpreter. 
(defalias 'py-execute-statement-python3 #[nil "\300\301\302\303\211$\207" [py-execute-prepare "statement" "python3" nil] 5 (#$ . 499653) nil])
#@124 Send statement at point to Python3 interpreter.

Switch to output buffer. Ignores `py-shell-switch-buffers-on-execute-p'. 
(defalias 'py-execute-statement-python3-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "statement" "python3" nil switch] 5 (#$ . 499852) nil])
#@119 Send statement at point to Python3 interpreter.

Keep current buffer. Ignores `py-shell-switch-buffers-on-execute-p' 
(defalias 'py-execute-statement-python3-noswitch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "statement" "python3" nil noswitch] 5 (#$ . 500139) nil])
#@57 Send statement at point to Python3 unique interpreter. 
(defalias 'py-execute-statement-python3-dedicated #[nil "\300\301\302\303\304$\207" [py-execute-prepare "statement" "python3" t nil] 5 (#$ . 500424) nil])
#@78 Send statement at point to Python3 unique interpreter and switch to result. 
(defalias 'py-execute-statement-python3-dedicated-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "statement" "python3" t switch] 5 (#$ . 500641) nil])
#@50 Send statement at point to Python2 interpreter. 
(defalias 'py-execute-statement-python2 #[nil "\300\301\302\303\211$\207" [py-execute-prepare "statement" "python2" nil] 5 (#$ . 500889) nil])
#@124 Send statement at point to Python2 interpreter.

Switch to output buffer. Ignores `py-shell-switch-buffers-on-execute-p'. 
(defalias 'py-execute-statement-python2-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "statement" "python2" nil switch] 5 (#$ . 501088) nil])
#@119 Send statement at point to Python2 interpreter.

Keep current buffer. Ignores `py-shell-switch-buffers-on-execute-p' 
(defalias 'py-execute-statement-python2-noswitch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "statement" "python2" nil noswitch] 5 (#$ . 501375) nil])
#@57 Send statement at point to Python2 unique interpreter. 
(defalias 'py-execute-statement-python2-dedicated #[nil "\300\301\302\303\304$\207" [py-execute-prepare "statement" "python2" t nil] 5 (#$ . 501660) nil])
#@78 Send statement at point to Python2 unique interpreter and switch to result. 
(defalias 'py-execute-statement-python2-dedicated-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "statement" "python2" t switch] 5 (#$ . 501877) nil])
#@52 Send statement at point to Python2.7 interpreter. 
(defalias 'py-execute-statement-python2\.7 #[nil "\300\301\302\303\211$\207" [py-execute-prepare "statement" "python2.7" nil] 5 (#$ . 502125) nil])
#@126 Send statement at point to Python2.7 interpreter.

Switch to output buffer. Ignores `py-shell-switch-buffers-on-execute-p'. 
(defalias 'py-execute-statement-python2\.7-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "statement" "python2.7" nil switch] 5 (#$ . 502331) nil])
#@121 Send statement at point to Python2.7 interpreter.

Keep current buffer. Ignores `py-shell-switch-buffers-on-execute-p' 
(defalias 'py-execute-statement-python2\.7-noswitch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "statement" "python2.7" nil noswitch] 5 (#$ . 502625) nil])
#@59 Send statement at point to Python2.7 unique interpreter. 
(defalias 'py-execute-statement-python2\.7-dedicated #[nil "\300\301\302\303\304$\207" [py-execute-prepare "statement" "python2.7" t nil] 5 (#$ . 502917) nil])
#@80 Send statement at point to Python2.7 unique interpreter and switch to result. 
(defalias 'py-execute-statement-python2\.7-dedicated-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "statement" "python2.7" t switch] 5 (#$ . 503141) nil])
#@49 Send statement at point to Jython interpreter. 
(defalias 'py-execute-statement-jython #[nil "\300\301\302\303\211$\207" [py-execute-prepare "statement" "jython" nil] 5 (#$ . 503396) nil])
#@123 Send statement at point to Jython interpreter.

Switch to output buffer. Ignores `py-shell-switch-buffers-on-execute-p'. 
(defalias 'py-execute-statement-jython-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "statement" "jython" nil switch] 5 (#$ . 503592) nil])
#@118 Send statement at point to Jython interpreter.

Keep current buffer. Ignores `py-shell-switch-buffers-on-execute-p' 
(defalias 'py-execute-statement-jython-noswitch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "statement" "jython" nil noswitch] 5 (#$ . 503876) nil])
#@56 Send statement at point to Jython unique interpreter. 
(defalias 'py-execute-statement-jython-dedicated #[nil "\300\301\302\303\304$\207" [py-execute-prepare "statement" "jython" t nil] 5 (#$ . 504158) nil])
#@77 Send statement at point to Jython unique interpreter and switch to result. 
(defalias 'py-execute-statement-jython-dedicated-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "statement" "jython" t switch] 5 (#$ . 504372) nil])
#@52 Send statement at point to Python3.2 interpreter. 
(defalias 'py-execute-statement-python3\.2 #[nil "\300\301\302\303\211$\207" [py-execute-prepare "statement" "python3.2" nil] 5 (#$ . 504617) nil])
#@126 Send statement at point to Python3.2 interpreter.

Switch to output buffer. Ignores `py-shell-switch-buffers-on-execute-p'. 
(defalias 'py-execute-statement-python3\.2-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "statement" "python3.2" nil switch] 5 (#$ . 504823) nil])
#@121 Send statement at point to Python3.2 interpreter.

Keep current buffer. Ignores `py-shell-switch-buffers-on-execute-p' 
(defalias 'py-execute-statement-python3\.2-noswitch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "statement" "python3.2" nil noswitch] 5 (#$ . 505117) nil])
#@59 Send statement at point to Python3.2 unique interpreter. 
(defalias 'py-execute-statement-python3\.2-dedicated #[nil "\300\301\302\303\304$\207" [py-execute-prepare "statement" "python3.2" t nil] 5 (#$ . 505409) nil])
#@80 Send statement at point to Python3.2 unique interpreter and switch to result. 
(defalias 'py-execute-statement-python3\.2-dedicated-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "statement" "python3.2" t switch] 5 (#$ . 505633) nil])
#@45 Send block at point to Python interpreter. 
(defalias 'py-execute-block-python #[nil "\300\301\302\303\211$\207" [py-execute-prepare "block" "python" nil] 5 (#$ . 505888) nil])
#@119 Send block at point to Python interpreter.

Switch to output buffer. Ignores `py-shell-switch-buffers-on-execute-p'. 
(defalias 'py-execute-block-python-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "block" "python" nil switch] 5 (#$ . 506072) nil])
#@114 Send block at point to Python interpreter.

Keep current buffer. Ignores `py-shell-switch-buffers-on-execute-p' 
(defalias 'py-execute-block-python-noswitch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "block" "python" nil noswitch] 5 (#$ . 506344) nil])
#@52 Send block at point to Python unique interpreter. 
(defalias 'py-execute-block-python-dedicated #[nil "\300\301\302\303\304$\207" [py-execute-prepare "block" "python" t nil] 5 (#$ . 506614) nil])
#@73 Send block at point to Python unique interpreter and switch to result. 
(defalias 'py-execute-block-python-dedicated-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "block" "python" t switch] 5 (#$ . 506816) nil])
#@46 Send block at point to IPython interpreter. 
(defalias 'py-execute-block-ipython #[nil "\300\301\302\303\211$\207" [py-execute-prepare "block" "ipython" nil] 5 (#$ . 507049) nil])
#@120 Send block at point to IPython interpreter.

Switch to output buffer. Ignores `py-shell-switch-buffers-on-execute-p'. 
(defalias 'py-execute-block-ipython-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "block" "ipython" nil switch] 5 (#$ . 507236) nil])
#@115 Send block at point to IPython interpreter.

Keep current buffer. Ignores `py-shell-switch-buffers-on-execute-p' 
(defalias 'py-execute-block-ipython-noswitch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "block" "ipython" nil noswitch] 5 (#$ . 507511) nil])
#@53 Send block at point to IPython unique interpreter. 
(defalias 'py-execute-block-ipython-dedicated #[nil "\300\301\302\303\304$\207" [py-execute-prepare "block" "ipython" t nil] 5 (#$ . 507784) nil])
#@74 Send block at point to IPython unique interpreter and switch to result. 
(defalias 'py-execute-block-ipython-dedicated-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "block" "ipython" t switch] 5 (#$ . 507989) nil])
#@46 Send block at point to Python3 interpreter. 
(defalias 'py-execute-block-python3 #[nil "\300\301\302\303\211$\207" [py-execute-prepare "block" "python3" nil] 5 (#$ . 508225) nil])
#@120 Send block at point to Python3 interpreter.

Switch to output buffer. Ignores `py-shell-switch-buffers-on-execute-p'. 
(defalias 'py-execute-block-python3-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "block" "python3" nil switch] 5 (#$ . 508412) nil])
#@115 Send block at point to Python3 interpreter.

Keep current buffer. Ignores `py-shell-switch-buffers-on-execute-p' 
(defalias 'py-execute-block-python3-noswitch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "block" "python3" nil noswitch] 5 (#$ . 508687) nil])
#@53 Send block at point to Python3 unique interpreter. 
(defalias 'py-execute-block-python3-dedicated #[nil "\300\301\302\303\304$\207" [py-execute-prepare "block" "python3" t nil] 5 (#$ . 508960) nil])
#@74 Send block at point to Python3 unique interpreter and switch to result. 
(defalias 'py-execute-block-python3-dedicated-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "block" "python3" t switch] 5 (#$ . 509165) nil])
#@46 Send block at point to Python2 interpreter. 
(defalias 'py-execute-block-python2 #[nil "\300\301\302\303\211$\207" [py-execute-prepare "block" "python2" nil] 5 (#$ . 509401) nil])
#@120 Send block at point to Python2 interpreter.

Switch to output buffer. Ignores `py-shell-switch-buffers-on-execute-p'. 
(defalias 'py-execute-block-python2-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "block" "python2" nil switch] 5 (#$ . 509588) nil])
#@115 Send block at point to Python2 interpreter.

Keep current buffer. Ignores `py-shell-switch-buffers-on-execute-p' 
(defalias 'py-execute-block-python2-noswitch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "block" "python2" nil noswitch] 5 (#$ . 509863) nil])
#@53 Send block at point to Python2 unique interpreter. 
(defalias 'py-execute-block-python2-dedicated #[nil "\300\301\302\303\304$\207" [py-execute-prepare "block" "python2" t nil] 5 (#$ . 510136) nil])
#@74 Send block at point to Python2 unique interpreter and switch to result. 
(defalias 'py-execute-block-python2-dedicated-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "block" "python2" t switch] 5 (#$ . 510341) nil])
#@48 Send block at point to Python2.7 interpreter. 
(defalias 'py-execute-block-python2\.7 #[nil "\300\301\302\303\211$\207" [py-execute-prepare "block" "python2.7" nil] 5 (#$ . 510577) nil])
#@122 Send block at point to Python2.7 interpreter.

Switch to output buffer. Ignores `py-shell-switch-buffers-on-execute-p'. 
(defalias 'py-execute-block-python2\.7-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "block" "python2.7" nil switch] 5 (#$ . 510771) nil])
#@117 Send block at point to Python2.7 interpreter.

Keep current buffer. Ignores `py-shell-switch-buffers-on-execute-p' 
(defalias 'py-execute-block-python2\.7-noswitch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "block" "python2.7" nil noswitch] 5 (#$ . 511053) nil])
#@55 Send block at point to Python2.7 unique interpreter. 
(defalias 'py-execute-block-python2\.7-dedicated #[nil "\300\301\302\303\304$\207" [py-execute-prepare "block" "python2.7" t nil] 5 (#$ . 511333) nil])
#@76 Send block at point to Python2.7 unique interpreter and switch to result. 
(defalias 'py-execute-block-python2\.7-dedicated-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "block" "python2.7" t switch] 5 (#$ . 511545) nil])
#@45 Send block at point to Jython interpreter. 
(defalias 'py-execute-block-jython #[nil "\300\301\302\303\211$\207" [py-execute-prepare "block" "jython" nil] 5 (#$ . 511788) nil])
#@119 Send block at point to Jython interpreter.

Switch to output buffer. Ignores `py-shell-switch-buffers-on-execute-p'. 
(defalias 'py-execute-block-jython-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "block" "jython" nil switch] 5 (#$ . 511972) nil])
#@114 Send block at point to Jython interpreter.

Keep current buffer. Ignores `py-shell-switch-buffers-on-execute-p' 
(defalias 'py-execute-block-jython-noswitch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "block" "jython" nil noswitch] 5 (#$ . 512244) nil])
#@52 Send block at point to Jython unique interpreter. 
(defalias 'py-execute-block-jython-dedicated #[nil "\300\301\302\303\304$\207" [py-execute-prepare "block" "jython" t nil] 5 (#$ . 512514) nil])
#@73 Send block at point to Jython unique interpreter and switch to result. 
(defalias 'py-execute-block-jython-dedicated-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "block" "jython" t switch] 5 (#$ . 512716) nil])
#@48 Send block at point to Python3.2 interpreter. 
(defalias 'py-execute-block-python3\.2 #[nil "\300\301\302\303\211$\207" [py-execute-prepare "block" "python3.2" nil] 5 (#$ . 512949) nil])
#@122 Send block at point to Python3.2 interpreter.

Switch to output buffer. Ignores `py-shell-switch-buffers-on-execute-p'. 
(defalias 'py-execute-block-python3\.2-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "block" "python3.2" nil switch] 5 (#$ . 513143) nil])
#@117 Send block at point to Python3.2 interpreter.

Keep current buffer. Ignores `py-shell-switch-buffers-on-execute-p' 
(defalias 'py-execute-block-python3\.2-noswitch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "block" "python3.2" nil noswitch] 5 (#$ . 513425) nil])
#@55 Send block at point to Python3.2 unique interpreter. 
(defalias 'py-execute-block-python3\.2-dedicated #[nil "\300\301\302\303\304$\207" [py-execute-prepare "block" "python3.2" t nil] 5 (#$ . 513705) nil])
#@76 Send block at point to Python3.2 unique interpreter and switch to result. 
(defalias 'py-execute-block-python3\.2-dedicated-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "block" "python3.2" t switch] 5 (#$ . 513917) nil])
#@46 Send clause at point to Python interpreter. 
(defalias 'py-execute-clause-python #[nil "\300\301\302\303\211$\207" [py-execute-prepare "clause" "python" nil] 5 (#$ . 514160) nil])
#@120 Send clause at point to Python interpreter.

Switch to output buffer. Ignores `py-shell-switch-buffers-on-execute-p'. 
(defalias 'py-execute-clause-python-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "clause" "python" nil switch] 5 (#$ . 514347) nil])
#@115 Send clause at point to Python interpreter.

Keep current buffer. Ignores `py-shell-switch-buffers-on-execute-p' 
(defalias 'py-execute-clause-python-noswitch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "clause" "python" nil noswitch] 5 (#$ . 514622) nil])
#@53 Send clause at point to Python unique interpreter. 
(defalias 'py-execute-clause-python-dedicated #[nil "\300\301\302\303\304$\207" [py-execute-prepare "clause" "python" t nil] 5 (#$ . 514895) nil])
#@74 Send clause at point to Python unique interpreter and switch to result. 
(defalias 'py-execute-clause-python-dedicated-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "clause" "python" t switch] 5 (#$ . 515100) nil])
#@47 Send clause at point to IPython interpreter. 
(defalias 'py-execute-clause-ipython #[nil "\300\301\302\303\211$\207" [py-execute-prepare "clause" "ipython" nil] 5 (#$ . 515336) nil])
#@121 Send clause at point to IPython interpreter.

Switch to output buffer. Ignores `py-shell-switch-buffers-on-execute-p'. 
(defalias 'py-execute-clause-ipython-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "clause" "ipython" nil switch] 5 (#$ . 515526) nil])
#@116 Send clause at point to IPython interpreter.

Keep current buffer. Ignores `py-shell-switch-buffers-on-execute-p' 
(defalias 'py-execute-clause-ipython-noswitch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "clause" "ipython" nil noswitch] 5 (#$ . 515804) nil])
#@54 Send clause at point to IPython unique interpreter. 
(defalias 'py-execute-clause-ipython-dedicated #[nil "\300\301\302\303\304$\207" [py-execute-prepare "clause" "ipython" t nil] 5 (#$ . 516080) nil])
#@75 Send clause at point to IPython unique interpreter and switch to result. 
(defalias 'py-execute-clause-ipython-dedicated-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "clause" "ipython" t switch] 5 (#$ . 516288) nil])
#@47 Send clause at point to Python3 interpreter. 
(defalias 'py-execute-clause-python3 #[nil "\300\301\302\303\211$\207" [py-execute-prepare "clause" "python3" nil] 5 (#$ . 516527) nil])
#@121 Send clause at point to Python3 interpreter.

Switch to output buffer. Ignores `py-shell-switch-buffers-on-execute-p'. 
(defalias 'py-execute-clause-python3-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "clause" "python3" nil switch] 5 (#$ . 516717) nil])
#@116 Send clause at point to Python3 interpreter.

Keep current buffer. Ignores `py-shell-switch-buffers-on-execute-p' 
(defalias 'py-execute-clause-python3-noswitch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "clause" "python3" nil noswitch] 5 (#$ . 516995) nil])
#@54 Send clause at point to Python3 unique interpreter. 
(defalias 'py-execute-clause-python3-dedicated #[nil "\300\301\302\303\304$\207" [py-execute-prepare "clause" "python3" t nil] 5 (#$ . 517271) nil])
#@75 Send clause at point to Python3 unique interpreter and switch to result. 
(defalias 'py-execute-clause-python3-dedicated-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "clause" "python3" t switch] 5 (#$ . 517479) nil])
#@47 Send clause at point to Python2 interpreter. 
(defalias 'py-execute-clause-python2 #[nil "\300\301\302\303\211$\207" [py-execute-prepare "clause" "python2" nil] 5 (#$ . 517718) nil])
#@121 Send clause at point to Python2 interpreter.

Switch to output buffer. Ignores `py-shell-switch-buffers-on-execute-p'. 
(defalias 'py-execute-clause-python2-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "clause" "python2" nil switch] 5 (#$ . 517908) nil])
#@116 Send clause at point to Python2 interpreter.

Keep current buffer. Ignores `py-shell-switch-buffers-on-execute-p' 
(defalias 'py-execute-clause-python2-noswitch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "clause" "python2" nil noswitch] 5 (#$ . 518186) nil])
#@54 Send clause at point to Python2 unique interpreter. 
(defalias 'py-execute-clause-python2-dedicated #[nil "\300\301\302\303\304$\207" [py-execute-prepare "clause" "python2" t nil] 5 (#$ . 518462) nil])
#@75 Send clause at point to Python2 unique interpreter and switch to result. 
(defalias 'py-execute-clause-python2-dedicated-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "clause" "python2" t switch] 5 (#$ . 518670) nil])
#@49 Send clause at point to Python2.7 interpreter. 
(defalias 'py-execute-clause-python2\.7 #[nil "\300\301\302\303\211$\207" [py-execute-prepare "clause" "python2.7" nil] 5 (#$ . 518909) nil])
#@123 Send clause at point to Python2.7 interpreter.

Switch to output buffer. Ignores `py-shell-switch-buffers-on-execute-p'. 
(defalias 'py-execute-clause-python2\.7-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "clause" "python2.7" nil switch] 5 (#$ . 519106) nil])
#@118 Send clause at point to Python2.7 interpreter.

Keep current buffer. Ignores `py-shell-switch-buffers-on-execute-p' 
(defalias 'py-execute-clause-python2\.7-noswitch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "clause" "python2.7" nil noswitch] 5 (#$ . 519391) nil])
#@56 Send clause at point to Python2.7 unique interpreter. 
(defalias 'py-execute-clause-python2\.7-dedicated #[nil "\300\301\302\303\304$\207" [py-execute-prepare "clause" "python2.7" t nil] 5 (#$ . 519674) nil])
#@77 Send clause at point to Python2.7 unique interpreter and switch to result. 
(defalias 'py-execute-clause-python2\.7-dedicated-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "clause" "python2.7" t switch] 5 (#$ . 519889) nil])
#@46 Send clause at point to Jython interpreter. 
(defalias 'py-execute-clause-jython #[nil "\300\301\302\303\211$\207" [py-execute-prepare "clause" "jython" nil] 5 (#$ . 520135) nil])
#@120 Send clause at point to Jython interpreter.

Switch to output buffer. Ignores `py-shell-switch-buffers-on-execute-p'. 
(defalias 'py-execute-clause-jython-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "clause" "jython" nil switch] 5 (#$ . 520322) nil])
#@115 Send clause at point to Jython interpreter.

Keep current buffer. Ignores `py-shell-switch-buffers-on-execute-p' 
(defalias 'py-execute-clause-jython-noswitch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "clause" "jython" nil noswitch] 5 (#$ . 520597) nil])
#@53 Send clause at point to Jython unique interpreter. 
(defalias 'py-execute-clause-jython-dedicated #[nil "\300\301\302\303\304$\207" [py-execute-prepare "clause" "jython" t nil] 5 (#$ . 520870) nil])
#@74 Send clause at point to Jython unique interpreter and switch to result. 
(defalias 'py-execute-clause-jython-dedicated-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "clause" "jython" t switch] 5 (#$ . 521075) nil])
#@49 Send clause at point to Python3.2 interpreter. 
(defalias 'py-execute-clause-python3\.2 #[nil "\300\301\302\303\211$\207" [py-execute-prepare "clause" "python3.2" nil] 5 (#$ . 521311) nil])
#@123 Send clause at point to Python3.2 interpreter.

Switch to output buffer. Ignores `py-shell-switch-buffers-on-execute-p'. 
(defalias 'py-execute-clause-python3\.2-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "clause" "python3.2" nil switch] 5 (#$ . 521508) nil])
#@118 Send clause at point to Python3.2 interpreter.

Keep current buffer. Ignores `py-shell-switch-buffers-on-execute-p' 
(defalias 'py-execute-clause-python3\.2-noswitch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "clause" "python3.2" nil noswitch] 5 (#$ . 521793) nil])
#@56 Send clause at point to Python3.2 unique interpreter. 
(defalias 'py-execute-clause-python3\.2-dedicated #[nil "\300\301\302\303\304$\207" [py-execute-prepare "clause" "python3.2" t nil] 5 (#$ . 522076) nil])
#@77 Send clause at point to Python3.2 unique interpreter and switch to result. 
(defalias 'py-execute-clause-python3\.2-dedicated-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "clause" "python3.2" t switch] 5 (#$ . 522291) nil])
#@55 Send block-or-clause at point to Python interpreter. 
(defalias 'py-execute-block-or-clause-python #[nil "\300\301\302\303\211$\207" [py-execute-prepare "block-or-clause" "python" nil] 5 (#$ . 522537) nil])
#@129 Send block-or-clause at point to Python interpreter.

Switch to output buffer. Ignores `py-shell-switch-buffers-on-execute-p'. 
(defalias 'py-execute-block-or-clause-python-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "block-or-clause" "python" nil switch] 5 (#$ . 522751) nil])
#@124 Send block-or-clause at point to Python interpreter.

Keep current buffer. Ignores `py-shell-switch-buffers-on-execute-p' 
(defalias 'py-execute-block-or-clause-python-noswitch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "block-or-clause" "python" nil noswitch] 5 (#$ . 523053) nil])
#@62 Send block-or-clause at point to Python unique interpreter. 
(defalias 'py-execute-block-or-clause-python-dedicated #[nil "\300\301\302\303\304$\207" [py-execute-prepare "block-or-clause" "python" t nil] 5 (#$ . 523353) nil])
#@83 Send block-or-clause at point to Python unique interpreter and switch to result. 
(defalias 'py-execute-block-or-clause-python-dedicated-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "block-or-clause" "python" t switch] 5 (#$ . 523585) nil])
#@56 Send block-or-clause at point to IPython interpreter. 
(defalias 'py-execute-block-or-clause-ipython #[nil "\300\301\302\303\211$\207" [py-execute-prepare "block-or-clause" "ipython" nil] 5 (#$ . 523848) nil])
#@130 Send block-or-clause at point to IPython interpreter.

Switch to output buffer. Ignores `py-shell-switch-buffers-on-execute-p'. 
(defalias 'py-execute-block-or-clause-ipython-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "block-or-clause" "ipython" nil switch] 5 (#$ . 524065) nil])
#@125 Send block-or-clause at point to IPython interpreter.

Keep current buffer. Ignores `py-shell-switch-buffers-on-execute-p' 
(defalias 'py-execute-block-or-clause-ipython-noswitch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "block-or-clause" "ipython" nil noswitch] 5 (#$ . 524370) nil])
#@63 Send block-or-clause at point to IPython unique interpreter. 
(defalias 'py-execute-block-or-clause-ipython-dedicated #[nil "\300\301\302\303\304$\207" [py-execute-prepare "block-or-clause" "ipython" t nil] 5 (#$ . 524673) nil])
#@84 Send block-or-clause at point to IPython unique interpreter and switch to result. 
(defalias 'py-execute-block-or-clause-ipython-dedicated-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "block-or-clause" "ipython" t switch] 5 (#$ . 524908) nil])
#@56 Send block-or-clause at point to Python3 interpreter. 
(defalias 'py-execute-block-or-clause-python3 #[nil "\300\301\302\303\211$\207" [py-execute-prepare "block-or-clause" "python3" nil] 5 (#$ . 525174) nil])
#@130 Send block-or-clause at point to Python3 interpreter.

Switch to output buffer. Ignores `py-shell-switch-buffers-on-execute-p'. 
(defalias 'py-execute-block-or-clause-python3-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "block-or-clause" "python3" nil switch] 5 (#$ . 525391) nil])
#@125 Send block-or-clause at point to Python3 interpreter.

Keep current buffer. Ignores `py-shell-switch-buffers-on-execute-p' 
(defalias 'py-execute-block-or-clause-python3-noswitch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "block-or-clause" "python3" nil noswitch] 5 (#$ . 525696) nil])
#@63 Send block-or-clause at point to Python3 unique interpreter. 
(defalias 'py-execute-block-or-clause-python3-dedicated #[nil "\300\301\302\303\304$\207" [py-execute-prepare "block-or-clause" "python3" t nil] 5 (#$ . 525999) nil])
#@84 Send block-or-clause at point to Python3 unique interpreter and switch to result. 
(defalias 'py-execute-block-or-clause-python3-dedicated-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "block-or-clause" "python3" t switch] 5 (#$ . 526234) nil])
#@56 Send block-or-clause at point to Python2 interpreter. 
(defalias 'py-execute-block-or-clause-python2 #[nil "\300\301\302\303\211$\207" [py-execute-prepare "block-or-clause" "python2" nil] 5 (#$ . 526500) nil])
#@130 Send block-or-clause at point to Python2 interpreter.

Switch to output buffer. Ignores `py-shell-switch-buffers-on-execute-p'. 
(defalias 'py-execute-block-or-clause-python2-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "block-or-clause" "python2" nil switch] 5 (#$ . 526717) nil])
#@125 Send block-or-clause at point to Python2 interpreter.

Keep current buffer. Ignores `py-shell-switch-buffers-on-execute-p' 
(defalias 'py-execute-block-or-clause-python2-noswitch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "block-or-clause" "python2" nil noswitch] 5 (#$ . 527022) nil])
#@63 Send block-or-clause at point to Python2 unique interpreter. 
(defalias 'py-execute-block-or-clause-python2-dedicated #[nil "\300\301\302\303\304$\207" [py-execute-prepare "block-or-clause" "python2" t nil] 5 (#$ . 527325) nil])
#@84 Send block-or-clause at point to Python2 unique interpreter and switch to result. 
(defalias 'py-execute-block-or-clause-python2-dedicated-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "block-or-clause" "python2" t switch] 5 (#$ . 527560) nil])
#@58 Send block-or-clause at point to Python2.7 interpreter. 
(defalias 'py-execute-block-or-clause-python2\.7 #[nil "\300\301\302\303\211$\207" [py-execute-prepare "block-or-clause" "python2.7" nil] 5 (#$ . 527826) nil])
#@132 Send block-or-clause at point to Python2.7 interpreter.

Switch to output buffer. Ignores `py-shell-switch-buffers-on-execute-p'. 
(defalias 'py-execute-block-or-clause-python2\.7-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "block-or-clause" "python2.7" nil switch] 5 (#$ . 528050) nil])
#@127 Send block-or-clause at point to Python2.7 interpreter.

Keep current buffer. Ignores `py-shell-switch-buffers-on-execute-p' 
(defalias 'py-execute-block-or-clause-python2\.7-noswitch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "block-or-clause" "python2.7" nil noswitch] 5 (#$ . 528362) nil])
#@65 Send block-or-clause at point to Python2.7 unique interpreter. 
(defalias 'py-execute-block-or-clause-python2\.7-dedicated #[nil "\300\301\302\303\304$\207" [py-execute-prepare "block-or-clause" "python2.7" t nil] 5 (#$ . 528672) nil])
#@86 Send block-or-clause at point to Python2.7 unique interpreter and switch to result. 
(defalias 'py-execute-block-or-clause-python2\.7-dedicated-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "block-or-clause" "python2.7" t switch] 5 (#$ . 528914) nil])
#@55 Send block-or-clause at point to Jython interpreter. 
(defalias 'py-execute-block-or-clause-jython #[nil "\300\301\302\303\211$\207" [py-execute-prepare "block-or-clause" "jython" nil] 5 (#$ . 529187) nil])
#@129 Send block-or-clause at point to Jython interpreter.

Switch to output buffer. Ignores `py-shell-switch-buffers-on-execute-p'. 
(defalias 'py-execute-block-or-clause-jython-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "block-or-clause" "jython" nil switch] 5 (#$ . 529401) nil])
#@124 Send block-or-clause at point to Jython interpreter.

Keep current buffer. Ignores `py-shell-switch-buffers-on-execute-p' 
(defalias 'py-execute-block-or-clause-jython-noswitch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "block-or-clause" "jython" nil noswitch] 5 (#$ . 529703) nil])
#@62 Send block-or-clause at point to Jython unique interpreter. 
(defalias 'py-execute-block-or-clause-jython-dedicated #[nil "\300\301\302\303\304$\207" [py-execute-prepare "block-or-clause" "jython" t nil] 5 (#$ . 530003) nil])
#@83 Send block-or-clause at point to Jython unique interpreter and switch to result. 
(defalias 'py-execute-block-or-clause-jython-dedicated-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "block-or-clause" "jython" t switch] 5 (#$ . 530235) nil])
#@58 Send block-or-clause at point to Python3.2 interpreter. 
(defalias 'py-execute-block-or-clause-python3\.2 #[nil "\300\301\302\303\211$\207" [py-execute-prepare "block-or-clause" "python3.2" nil] 5 (#$ . 530498) nil])
#@132 Send block-or-clause at point to Python3.2 interpreter.

Switch to output buffer. Ignores `py-shell-switch-buffers-on-execute-p'. 
(defalias 'py-execute-block-or-clause-python3\.2-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "block-or-clause" "python3.2" nil switch] 5 (#$ . 530722) nil])
#@127 Send block-or-clause at point to Python3.2 interpreter.

Keep current buffer. Ignores `py-shell-switch-buffers-on-execute-p' 
(defalias 'py-execute-block-or-clause-python3\.2-noswitch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "block-or-clause" "python3.2" nil noswitch] 5 (#$ . 531034) nil])
#@65 Send block-or-clause at point to Python3.2 unique interpreter. 
(defalias 'py-execute-block-or-clause-python3\.2-dedicated #[nil "\300\301\302\303\304$\207" [py-execute-prepare "block-or-clause" "python3.2" t nil] 5 (#$ . 531344) nil])
#@86 Send block-or-clause at point to Python3.2 unique interpreter and switch to result. 
(defalias 'py-execute-block-or-clause-python3\.2-dedicated-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "block-or-clause" "python3.2" t switch] 5 (#$ . 531586) nil])
#@43 Send def at point to Python interpreter. 
(defalias 'py-execute-def-python #[nil "\300\301\302\303\211$\207" [py-execute-prepare "def" "python" nil] 5 (#$ . 531859) nil])
#@117 Send def at point to Python interpreter.

Switch to output buffer. Ignores `py-shell-switch-buffers-on-execute-p'. 
(defalias 'py-execute-def-python-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "def" "python" nil switch] 5 (#$ . 532037) nil])
#@112 Send def at point to Python interpreter.

Keep current buffer. Ignores `py-shell-switch-buffers-on-execute-p' 
(defalias 'py-execute-def-python-noswitch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "def" "python" nil noswitch] 5 (#$ . 532303) nil])
#@50 Send def at point to Python unique interpreter. 
(defalias 'py-execute-def-python-dedicated #[nil "\300\301\302\303\304$\207" [py-execute-prepare "def" "python" t nil] 5 (#$ . 532567) nil])
#@71 Send def at point to Python unique interpreter and switch to result. 
(defalias 'py-execute-def-python-dedicated-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "def" "python" t switch] 5 (#$ . 532763) nil])
#@44 Send def at point to IPython interpreter. 
(defalias 'py-execute-def-ipython #[nil "\300\301\302\303\211$\207" [py-execute-prepare "def" "ipython" nil] 5 (#$ . 532990) nil])
#@118 Send def at point to IPython interpreter.

Switch to output buffer. Ignores `py-shell-switch-buffers-on-execute-p'. 
(defalias 'py-execute-def-ipython-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "def" "ipython" nil switch] 5 (#$ . 533171) nil])
#@113 Send def at point to IPython interpreter.

Keep current buffer. Ignores `py-shell-switch-buffers-on-execute-p' 
(defalias 'py-execute-def-ipython-noswitch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "def" "ipython" nil noswitch] 5 (#$ . 533440) nil])
#@51 Send def at point to IPython unique interpreter. 
(defalias 'py-execute-def-ipython-dedicated #[nil "\300\301\302\303\304$\207" [py-execute-prepare "def" "ipython" t nil] 5 (#$ . 533707) nil])
#@72 Send def at point to IPython unique interpreter and switch to result. 
(defalias 'py-execute-def-ipython-dedicated-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "def" "ipython" t switch] 5 (#$ . 533906) nil])
#@44 Send def at point to Python3 interpreter. 
(defalias 'py-execute-def-python3 #[nil "\300\301\302\303\211$\207" [py-execute-prepare "def" "python3" nil] 5 (#$ . 534136) nil])
#@118 Send def at point to Python3 interpreter.

Switch to output buffer. Ignores `py-shell-switch-buffers-on-execute-p'. 
(defalias 'py-execute-def-python3-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "def" "python3" nil switch] 5 (#$ . 534317) nil])
#@113 Send def at point to Python3 interpreter.

Keep current buffer. Ignores `py-shell-switch-buffers-on-execute-p' 
(defalias 'py-execute-def-python3-noswitch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "def" "python3" nil noswitch] 5 (#$ . 534586) nil])
#@51 Send def at point to Python3 unique interpreter. 
(defalias 'py-execute-def-python3-dedicated #[nil "\300\301\302\303\304$\207" [py-execute-prepare "def" "python3" t nil] 5 (#$ . 534853) nil])
#@72 Send def at point to Python3 unique interpreter and switch to result. 
(defalias 'py-execute-def-python3-dedicated-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "def" "python3" t switch] 5 (#$ . 535052) nil])
#@44 Send def at point to Python2 interpreter. 
(defalias 'py-execute-def-python2 #[nil "\300\301\302\303\211$\207" [py-execute-prepare "def" "python2" nil] 5 (#$ . 535282) nil])
#@118 Send def at point to Python2 interpreter.

Switch to output buffer. Ignores `py-shell-switch-buffers-on-execute-p'. 
(defalias 'py-execute-def-python2-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "def" "python2" nil switch] 5 (#$ . 535463) nil])
#@113 Send def at point to Python2 interpreter.

Keep current buffer. Ignores `py-shell-switch-buffers-on-execute-p' 
(defalias 'py-execute-def-python2-noswitch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "def" "python2" nil noswitch] 5 (#$ . 535732) nil])
#@51 Send def at point to Python2 unique interpreter. 
(defalias 'py-execute-def-python2-dedicated #[nil "\300\301\302\303\304$\207" [py-execute-prepare "def" "python2" t nil] 5 (#$ . 535999) nil])
#@72 Send def at point to Python2 unique interpreter and switch to result. 
(defalias 'py-execute-def-python2-dedicated-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "def" "python2" t switch] 5 (#$ . 536198) nil])
#@46 Send def at point to Python2.7 interpreter. 
(defalias 'py-execute-def-python2\.7 #[nil "\300\301\302\303\211$\207" [py-execute-prepare "def" "python2.7" nil] 5 (#$ . 536428) nil])
#@120 Send def at point to Python2.7 interpreter.

Switch to output buffer. Ignores `py-shell-switch-buffers-on-execute-p'. 
(defalias 'py-execute-def-python2\.7-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "def" "python2.7" nil switch] 5 (#$ . 536616) nil])
#@115 Send def at point to Python2.7 interpreter.

Keep current buffer. Ignores `py-shell-switch-buffers-on-execute-p' 
(defalias 'py-execute-def-python2\.7-noswitch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "def" "python2.7" nil noswitch] 5 (#$ . 536892) nil])
#@53 Send def at point to Python2.7 unique interpreter. 
(defalias 'py-execute-def-python2\.7-dedicated #[nil "\300\301\302\303\304$\207" [py-execute-prepare "def" "python2.7" t nil] 5 (#$ . 537166) nil])
#@74 Send def at point to Python2.7 unique interpreter and switch to result. 
(defalias 'py-execute-def-python2\.7-dedicated-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "def" "python2.7" t switch] 5 (#$ . 537372) nil])
#@43 Send def at point to Jython interpreter. 
(defalias 'py-execute-def-jython #[nil "\300\301\302\303\211$\207" [py-execute-prepare "def" "jython" nil] 5 (#$ . 537609) nil])
#@117 Send def at point to Jython interpreter.

Switch to output buffer. Ignores `py-shell-switch-buffers-on-execute-p'. 
(defalias 'py-execute-def-jython-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "def" "jython" nil switch] 5 (#$ . 537787) nil])
#@112 Send def at point to Jython interpreter.

Keep current buffer. Ignores `py-shell-switch-buffers-on-execute-p' 
(defalias 'py-execute-def-jython-noswitch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "def" "jython" nil noswitch] 5 (#$ . 538053) nil])
#@50 Send def at point to Jython unique interpreter. 
(defalias 'py-execute-def-jython-dedicated #[nil "\300\301\302\303\304$\207" [py-execute-prepare "def" "jython" t nil] 5 (#$ . 538317) nil])
#@71 Send def at point to Jython unique interpreter and switch to result. 
(defalias 'py-execute-def-jython-dedicated-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "def" "jython" t switch] 5 (#$ . 538513) nil])
#@46 Send def at point to Python3.2 interpreter. 
(defalias 'py-execute-def-python3\.2 #[nil "\300\301\302\303\211$\207" [py-execute-prepare "def" "python3.2" nil] 5 (#$ . 538740) nil])
#@120 Send def at point to Python3.2 interpreter.

Switch to output buffer. Ignores `py-shell-switch-buffers-on-execute-p'. 
(defalias 'py-execute-def-python3\.2-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "def" "python3.2" nil switch] 5 (#$ . 538928) nil])
#@115 Send def at point to Python3.2 interpreter.

Keep current buffer. Ignores `py-shell-switch-buffers-on-execute-p' 
(defalias 'py-execute-def-python3\.2-noswitch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "def" "python3.2" nil noswitch] 5 (#$ . 539204) nil])
#@53 Send def at point to Python3.2 unique interpreter. 
(defalias 'py-execute-def-python3\.2-dedicated #[nil "\300\301\302\303\304$\207" [py-execute-prepare "def" "python3.2" t nil] 5 (#$ . 539478) nil])
#@74 Send def at point to Python3.2 unique interpreter and switch to result. 
(defalias 'py-execute-def-python3\.2-dedicated-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "def" "python3.2" t switch] 5 (#$ . 539684) nil])
#@45 Send class at point to Python interpreter. 
(defalias 'py-execute-class-python #[nil "\300\301\302\303\211$\207" [py-execute-prepare "class" "python" nil] 5 (#$ . 539921) nil])
#@119 Send class at point to Python interpreter.

Switch to output buffer. Ignores `py-shell-switch-buffers-on-execute-p'. 
(defalias 'py-execute-class-python-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "class" "python" nil switch] 5 (#$ . 540105) nil])
#@114 Send class at point to Python interpreter.

Keep current buffer. Ignores `py-shell-switch-buffers-on-execute-p' 
(defalias 'py-execute-class-python-noswitch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "class" "python" nil noswitch] 5 (#$ . 540377) nil])
#@52 Send class at point to Python unique interpreter. 
(defalias 'py-execute-class-python-dedicated #[nil "\300\301\302\303\304$\207" [py-execute-prepare "class" "python" t nil] 5 (#$ . 540647) nil])
#@73 Send class at point to Python unique interpreter and switch to result. 
(defalias 'py-execute-class-python-dedicated-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "class" "python" t switch] 5 (#$ . 540849) nil])
#@46 Send class at point to IPython interpreter. 
(defalias 'py-execute-class-ipython #[nil "\300\301\302\303\211$\207" [py-execute-prepare "class" "ipython" nil] 5 (#$ . 541082) nil])
#@120 Send class at point to IPython interpreter.

Switch to output buffer. Ignores `py-shell-switch-buffers-on-execute-p'. 
(defalias 'py-execute-class-ipython-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "class" "ipython" nil switch] 5 (#$ . 541269) nil])
#@115 Send class at point to IPython interpreter.

Keep current buffer. Ignores `py-shell-switch-buffers-on-execute-p' 
(defalias 'py-execute-class-ipython-noswitch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "class" "ipython" nil noswitch] 5 (#$ . 541544) nil])
#@53 Send class at point to IPython unique interpreter. 
(defalias 'py-execute-class-ipython-dedicated #[nil "\300\301\302\303\304$\207" [py-execute-prepare "class" "ipython" t nil] 5 (#$ . 541817) nil])
#@74 Send class at point to IPython unique interpreter and switch to result. 
(defalias 'py-execute-class-ipython-dedicated-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "class" "ipython" t switch] 5 (#$ . 542022) nil])
#@46 Send class at point to Python3 interpreter. 
(defalias 'py-execute-class-python3 #[nil "\300\301\302\303\211$\207" [py-execute-prepare "class" "python3" nil] 5 (#$ . 542258) nil])
#@120 Send class at point to Python3 interpreter.

Switch to output buffer. Ignores `py-shell-switch-buffers-on-execute-p'. 
(defalias 'py-execute-class-python3-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "class" "python3" nil switch] 5 (#$ . 542445) nil])
#@115 Send class at point to Python3 interpreter.

Keep current buffer. Ignores `py-shell-switch-buffers-on-execute-p' 
(defalias 'py-execute-class-python3-noswitch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "class" "python3" nil noswitch] 5 (#$ . 542720) nil])
#@53 Send class at point to Python3 unique interpreter. 
(defalias 'py-execute-class-python3-dedicated #[nil "\300\301\302\303\304$\207" [py-execute-prepare "class" "python3" t nil] 5 (#$ . 542993) nil])
#@74 Send class at point to Python3 unique interpreter and switch to result. 
(defalias 'py-execute-class-python3-dedicated-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "class" "python3" t switch] 5 (#$ . 543198) nil])
#@46 Send class at point to Python2 interpreter. 
(defalias 'py-execute-class-python2 #[nil "\300\301\302\303\211$\207" [py-execute-prepare "class" "python2" nil] 5 (#$ . 543434) nil])
#@120 Send class at point to Python2 interpreter.

Switch to output buffer. Ignores `py-shell-switch-buffers-on-execute-p'. 
(defalias 'py-execute-class-python2-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "class" "python2" nil switch] 5 (#$ . 543621) nil])
#@115 Send class at point to Python2 interpreter.

Keep current buffer. Ignores `py-shell-switch-buffers-on-execute-p' 
(defalias 'py-execute-class-python2-noswitch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "class" "python2" nil noswitch] 5 (#$ . 543896) nil])
#@53 Send class at point to Python2 unique interpreter. 
(defalias 'py-execute-class-python2-dedicated #[nil "\300\301\302\303\304$\207" [py-execute-prepare "class" "python2" t nil] 5 (#$ . 544169) nil])
#@74 Send class at point to Python2 unique interpreter and switch to result. 
(defalias 'py-execute-class-python2-dedicated-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "class" "python2" t switch] 5 (#$ . 544374) nil])
#@48 Send class at point to Python2.7 interpreter. 
(defalias 'py-execute-class-python2\.7 #[nil "\300\301\302\303\211$\207" [py-execute-prepare "class" "python2.7" nil] 5 (#$ . 544610) nil])
#@122 Send class at point to Python2.7 interpreter.

Switch to output buffer. Ignores `py-shell-switch-buffers-on-execute-p'. 
(defalias 'py-execute-class-python2\.7-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "class" "python2.7" nil switch] 5 (#$ . 544804) nil])
#@117 Send class at point to Python2.7 interpreter.

Keep current buffer. Ignores `py-shell-switch-buffers-on-execute-p' 
(defalias 'py-execute-class-python2\.7-noswitch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "class" "python2.7" nil noswitch] 5 (#$ . 545086) nil])
#@55 Send class at point to Python2.7 unique interpreter. 
(defalias 'py-execute-class-python2\.7-dedicated #[nil "\300\301\302\303\304$\207" [py-execute-prepare "class" "python2.7" t nil] 5 (#$ . 545366) nil])
#@76 Send class at point to Python2.7 unique interpreter and switch to result. 
(defalias 'py-execute-class-python2\.7-dedicated-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "class" "python2.7" t switch] 5 (#$ . 545578) nil])
#@45 Send class at point to Jython interpreter. 
(defalias 'py-execute-class-jython #[nil "\300\301\302\303\211$\207" [py-execute-prepare "class" "jython" nil] 5 (#$ . 545821) nil])
#@119 Send class at point to Jython interpreter.

Switch to output buffer. Ignores `py-shell-switch-buffers-on-execute-p'. 
(defalias 'py-execute-class-jython-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "class" "jython" nil switch] 5 (#$ . 546005) nil])
#@114 Send class at point to Jython interpreter.

Keep current buffer. Ignores `py-shell-switch-buffers-on-execute-p' 
(defalias 'py-execute-class-jython-noswitch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "class" "jython" nil noswitch] 5 (#$ . 546277) nil])
#@52 Send class at point to Jython unique interpreter. 
(defalias 'py-execute-class-jython-dedicated #[nil "\300\301\302\303\304$\207" [py-execute-prepare "class" "jython" t nil] 5 (#$ . 546547) nil])
#@73 Send class at point to Jython unique interpreter and switch to result. 
(defalias 'py-execute-class-jython-dedicated-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "class" "jython" t switch] 5 (#$ . 546749) nil])
#@48 Send class at point to Python3.2 interpreter. 
(defalias 'py-execute-class-python3\.2 #[nil "\300\301\302\303\211$\207" [py-execute-prepare "class" "python3.2" nil] 5 (#$ . 546982) nil])
#@122 Send class at point to Python3.2 interpreter.

Switch to output buffer. Ignores `py-shell-switch-buffers-on-execute-p'. 
(defalias 'py-execute-class-python3\.2-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "class" "python3.2" nil switch] 5 (#$ . 547176) nil])
#@117 Send class at point to Python3.2 interpreter.

Keep current buffer. Ignores `py-shell-switch-buffers-on-execute-p' 
(defalias 'py-execute-class-python3\.2-noswitch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "class" "python3.2" nil noswitch] 5 (#$ . 547458) nil])
#@55 Send class at point to Python3.2 unique interpreter. 
(defalias 'py-execute-class-python3\.2-dedicated #[nil "\300\301\302\303\304$\207" [py-execute-prepare "class" "python3.2" t nil] 5 (#$ . 547738) nil])
#@76 Send class at point to Python3.2 unique interpreter and switch to result. 
(defalias 'py-execute-class-python3\.2-dedicated-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "class" "python3.2" t switch] 5 (#$ . 547950) nil])
#@46 Send region at point to Python interpreter. 
(defalias 'py-execute-region-python #[(beg end) "\302	\303\304\211%\207" [beg end py-execute-base "python" nil] 6 (#$ . 548193) "r"])
#@120 Send region at point to Python interpreter.

Switch to output buffer. Ignores `py-shell-switch-buffers-on-execute-p'. 
(defalias 'py-execute-region-python-switch #[(beg end) "\302	\303\304\305%\207" [beg end py-execute-base "python" nil switch] 6 (#$ . 548380) "r"])
#@115 Send region at point to Python interpreter.

Keep current buffer. Ignores `py-shell-switch-buffers-on-execute-p' 
(defalias 'py-execute-region-python-noswitch #[(beg end) "\302	\303\304\305%\207" [beg end py-execute-base "python" nil noswitch] 6 (#$ . 548655) "r"])
#@53 Send region at point to Python unique interpreter. 
(defalias 'py-execute-region-python-dedicated #[(beg end) "\302	\303\304\305%\207" [beg end py-execute-base "python" t nil] 6 (#$ . 548928) "r"])
#@74 Send region at point to Python unique interpreter and switch to result. 
(defalias 'py-execute-region-python-dedicated-switch #[(beg end) "\302	\303\304\305%\207" [beg end py-execute-base "python" t switch] 6 (#$ . 549133) "r"])
#@47 Send region at point to IPython interpreter. 
(defalias 'py-execute-region-ipython #[(beg end) "\302	\303\304\211%\207" [beg end py-execute-base "ipython" nil] 6 (#$ . 549369) "r"])
#@121 Send region at point to IPython interpreter.

Switch to output buffer. Ignores `py-shell-switch-buffers-on-execute-p'. 
(defalias 'py-execute-region-ipython-switch #[(beg end) "\302	\303\304\305%\207" [beg end py-execute-base "ipython" nil switch] 6 (#$ . 549559) "r"])
#@116 Send region at point to IPython interpreter.

Keep current buffer. Ignores `py-shell-switch-buffers-on-execute-p' 
(defalias 'py-execute-region-ipython-noswitch #[(beg end) "\302	\303\304\305%\207" [beg end py-execute-base "ipython" nil noswitch] 6 (#$ . 549837) "r"])
#@54 Send region at point to IPython unique interpreter. 
(defalias 'py-execute-region-ipython-dedicated #[(beg end) "\302	\303\304\305%\207" [beg end py-execute-base "ipython" t nil] 6 (#$ . 550113) "r"])
#@75 Send region at point to IPython unique interpreter and switch to result. 
(defalias 'py-execute-region-ipython-dedicated-switch #[(beg end) "\302	\303\304\305%\207" [beg end py-execute-base "ipython" t switch] 6 (#$ . 550321) "r"])
#@47 Send region at point to Python3 interpreter. 
(defalias 'py-execute-region-python3 #[(beg end) "\302	\303\304\211%\207" [beg end py-execute-base "python3" nil] 6 (#$ . 550560) "r"])
#@121 Send region at point to Python3 interpreter.

Switch to output buffer. Ignores `py-shell-switch-buffers-on-execute-p'. 
(defalias 'py-execute-region-python3-switch #[(beg end) "\302	\303\304\305%\207" [beg end py-execute-base "python3" nil switch] 6 (#$ . 550750) "r"])
#@116 Send region at point to Python3 interpreter.

Keep current buffer. Ignores `py-shell-switch-buffers-on-execute-p' 
(defalias 'py-execute-region-python3-noswitch #[(beg end) "\302	\303\304\305%\207" [beg end py-execute-base "python3" nil noswitch] 6 (#$ . 551028) "r"])
#@54 Send region at point to Python3 unique interpreter. 
(defalias 'py-execute-region-python3-dedicated #[(beg end) "\302	\303\304\305%\207" [beg end py-execute-base "python3" t nil] 6 (#$ . 551304) "r"])
#@75 Send region at point to Python3 unique interpreter and switch to result. 
(defalias 'py-execute-region-python3-dedicated-switch #[(beg end) "\302	\303\304\305%\207" [beg end py-execute-base "python3" t switch] 6 (#$ . 551512) "r"])
#@47 Send region at point to Python2 interpreter. 
(defalias 'py-execute-region-python2 #[(beg end) "\302	\303\304\211%\207" [beg end py-execute-base "python2" nil] 6 (#$ . 551751) "r"])
#@121 Send region at point to Python2 interpreter.

Switch to output buffer. Ignores `py-shell-switch-buffers-on-execute-p'. 
(defalias 'py-execute-region-python2-switch #[(beg end) "\302	\303\304\305%\207" [beg end py-execute-base "python2" nil switch] 6 (#$ . 551941) "r"])
#@116 Send region at point to Python2 interpreter.

Keep current buffer. Ignores `py-shell-switch-buffers-on-execute-p' 
(defalias 'py-execute-region-python2-noswitch #[(beg end) "\302	\303\304\305%\207" [beg end py-execute-base "python2" nil noswitch] 6 (#$ . 552219) "r"])
#@54 Send region at point to Python2 unique interpreter. 
(defalias 'py-execute-region-python2-dedicated #[(beg end) "\302	\303\304\305%\207" [beg end py-execute-base "python2" t nil] 6 (#$ . 552495) "r"])
#@75 Send region at point to Python2 unique interpreter and switch to result. 
(defalias 'py-execute-region-python2-dedicated-switch #[(beg end) "\302	\303\304\305%\207" [beg end py-execute-base "python2" t switch] 6 (#$ . 552703) "r"])
#@49 Send region at point to Python2.7 interpreter. 
(defalias 'py-execute-region-python2\.7 #[(beg end) "\302	\303\304\211%\207" [beg end py-execute-base "python2.7" nil] 6 (#$ . 552942) "r"])
#@123 Send region at point to Python2.7 interpreter.

Switch to output buffer. Ignores `py-shell-switch-buffers-on-execute-p'. 
(defalias 'py-execute-region-python2\.7-switch #[(beg end) "\302	\303\304\305%\207" [beg end py-execute-base "python2.7" nil switch] 6 (#$ . 553139) "r"])
#@118 Send region at point to Python2.7 interpreter.

Keep current buffer. Ignores `py-shell-switch-buffers-on-execute-p' 
(defalias 'py-execute-region-python2\.7-noswitch #[(beg end) "\302	\303\304\305%\207" [beg end py-execute-base "python2.7" nil noswitch] 6 (#$ . 553424) "r"])
#@56 Send region at point to Python2.7 unique interpreter. 
(defalias 'py-execute-region-python2\.7-dedicated #[(beg end) "\302	\303\304\305%\207" [beg end py-execute-base "python2.7" t nil] 6 (#$ . 553707) "r"])
#@77 Send region at point to Python2.7 unique interpreter and switch to result. 
(defalias 'py-execute-region-python2\.7-dedicated-switch #[(beg end) "\302	\303\304\305%\207" [beg end py-execute-base "python2.7" t switch] 6 (#$ . 553922) "r"])
#@46 Send region at point to Jython interpreter. 
(defalias 'py-execute-region-jython #[(beg end) "\302	\303\304\211%\207" [beg end py-execute-base "jython" nil] 6 (#$ . 554168) "r"])
#@120 Send region at point to Jython interpreter.

Switch to output buffer. Ignores `py-shell-switch-buffers-on-execute-p'. 
(defalias 'py-execute-region-jython-switch #[(beg end) "\302	\303\304\305%\207" [beg end py-execute-base "jython" nil switch] 6 (#$ . 554355) "r"])
#@115 Send region at point to Jython interpreter.

Keep current buffer. Ignores `py-shell-switch-buffers-on-execute-p' 
(defalias 'py-execute-region-jython-noswitch #[(beg end) "\302	\303\304\305%\207" [beg end py-execute-base "jython" nil noswitch] 6 (#$ . 554630) "r"])
#@53 Send region at point to Jython unique interpreter. 
(defalias 'py-execute-region-jython-dedicated #[(beg end) "\302	\303\304\305%\207" [beg end py-execute-base "jython" t nil] 6 (#$ . 554903) "r"])
#@74 Send region at point to Jython unique interpreter and switch to result. 
(defalias 'py-execute-region-jython-dedicated-switch #[(beg end) "\302	\303\304\305%\207" [beg end py-execute-base "jython" t switch] 6 (#$ . 555108) "r"])
#@49 Send region at point to Python3.2 interpreter. 
(defalias 'py-execute-region-python3\.2 #[(beg end) "\302	\303\304\211%\207" [beg end py-execute-base "python3.2" nil] 6 (#$ . 555344) "r"])
#@123 Send region at point to Python3.2 interpreter.

Switch to output buffer. Ignores `py-shell-switch-buffers-on-execute-p'. 
(defalias 'py-execute-region-python3\.2-switch #[(beg end) "\302	\303\304\305%\207" [beg end py-execute-base "python3.2" nil switch] 6 (#$ . 555541) "r"])
#@118 Send region at point to Python3.2 interpreter.

Keep current buffer. Ignores `py-shell-switch-buffers-on-execute-p' 
(defalias 'py-execute-region-python3\.2-noswitch #[(beg end) "\302	\303\304\305%\207" [beg end py-execute-base "python3.2" nil noswitch] 6 (#$ . 555826) "r"])
#@56 Send region at point to Python3.2 unique interpreter. 
(defalias 'py-execute-region-python3\.2-dedicated #[(beg end) "\302	\303\304\305%\207" [beg end py-execute-base "python3.2" t nil] 6 (#$ . 556109) "r"])
#@77 Send region at point to Python3.2 unique interpreter and switch to result. 
(defalias 'py-execute-region-python3\.2-dedicated-switch #[(beg end) "\302	\303\304\305%\207" [beg end py-execute-base "python3.2" t switch] 6 (#$ . 556324) "r"])
#@46 Send buffer at point to Python interpreter. 
(defalias 'py-execute-buffer-python #[nil "\212\306\206\307 \310\211\203$\311!\312\f!\206\313\f!\211q\210*ed\314\n	\315\310\211%-\207" [py-master-file end beg wholebuf filename buffer t py-fetch-py-master-file nil expand-file-name get-file-buffer find-file-noselect py-execute-region "python"] 7 (#$ . 556570) nil])
#@120 Send buffer at point to Python interpreter.

Switch to output buffer. Ignores `py-shell-switch-buffers-on-execute-p'. 
(defalias 'py-execute-buffer-python-switch #[nil "\212\306\206\307 \310\211\203$\311!\312\f!\206\313\f!\211q\210*ed\314\n	\315\310\316%-\207" [py-master-file end beg wholebuf filename buffer t py-fetch-py-master-file nil expand-file-name get-file-buffer find-file-noselect py-execute-region "python" switch] 7 (#$ . 556954) nil])
#@115 Send buffer at point to Python interpreter.

Keep current buffer. Ignores `py-shell-switch-buffers-on-execute-p' 
(defalias 'py-execute-buffer-python-noswitch #[nil "\212\306\206\307 \310\211\203$\311!\312\f!\206\313\f!\211q\210*ed\314\n	\315\310\316%-\207" [py-master-file end beg wholebuf filename buffer t py-fetch-py-master-file nil expand-file-name get-file-buffer find-file-noselect py-execute-region "python" noswitch] 7 (#$ . 557426) nil])
#@53 Send buffer at point to Python unique interpreter. 
(defalias 'py-execute-buffer-python-dedicated #[nil "\212\306\206\307 \310\211\203$\311!\312\f!\206\313\f!\211q\210*ed\314\n	\315\306\310%-\207" [py-master-file end beg wholebuf filename buffer t py-fetch-py-master-file nil expand-file-name get-file-buffer find-file-noselect py-execute-region "python"] 7 (#$ . 557896) nil])
#@74 Send buffer at point to Python unique interpreter and switch to result. 
(defalias 'py-execute-buffer-python-dedicated-switch #[nil "\212\306\206\307 \310\211\203$\311!\312\f!\206\313\f!\211q\210*ed\314\n	\315\306\316%-\207" [py-master-file end beg wholebuf filename buffer t py-fetch-py-master-file nil expand-file-name get-file-buffer find-file-noselect py-execute-region "python" switch] 7 (#$ . 558296) nil])
#@47 Send buffer at point to IPython interpreter. 
(defalias 'py-execute-buffer-ipython #[nil "\212\306\206\307 \310\211\203$\311!\312\f!\206\313\f!\211q\210*ed\314\n	\315\310\211%-\207" [py-master-file end beg wholebuf filename buffer t py-fetch-py-master-file nil expand-file-name get-file-buffer find-file-noselect py-execute-region "ipython"] 7 (#$ . 558731) nil])
#@121 Send buffer at point to IPython interpreter.

Switch to output buffer. Ignores `py-shell-switch-buffers-on-execute-p'. 
(defalias 'py-execute-buffer-ipython-switch #[nil "\212\306\206\307 \310\211\203$\311!\312\f!\206\313\f!\211q\210*ed\314\n	\315\310\316%-\207" [py-master-file end beg wholebuf filename buffer t py-fetch-py-master-file nil expand-file-name get-file-buffer find-file-noselect py-execute-region "ipython" switch] 7 (#$ . 559118) nil])
#@116 Send buffer at point to IPython interpreter.

Keep current buffer. Ignores `py-shell-switch-buffers-on-execute-p' 
(defalias 'py-execute-buffer-ipython-noswitch #[nil "\212\306\206\307 \310\211\203$\311!\312\f!\206\313\f!\211q\210*ed\314\n	\315\310\316%-\207" [py-master-file end beg wholebuf filename buffer t py-fetch-py-master-file nil expand-file-name get-file-buffer find-file-noselect py-execute-region "ipython" noswitch] 7 (#$ . 559593) nil])
#@54 Send buffer at point to IPython unique interpreter. 
(defalias 'py-execute-buffer-ipython-dedicated #[nil "\212\306\206\307 \310\211\203$\311!\312\f!\206\313\f!\211q\210*ed\314\n	\315\306\310%-\207" [py-master-file end beg wholebuf filename buffer t py-fetch-py-master-file nil expand-file-name get-file-buffer find-file-noselect py-execute-region "ipython"] 7 (#$ . 560066) nil])
#@75 Send buffer at point to IPython unique interpreter and switch to result. 
(defalias 'py-execute-buffer-ipython-dedicated-switch #[nil "\212\306\206\307 \310\211\203$\311!\312\f!\206\313\f!\211q\210*ed\314\n	\315\306\316%-\207" [py-master-file end beg wholebuf filename buffer t py-fetch-py-master-file nil expand-file-name get-file-buffer find-file-noselect py-execute-region "ipython" switch] 7 (#$ . 560469) nil])
#@47 Send buffer at point to Python3 interpreter. 
(defalias 'py-execute-buffer-python3 #[nil "\212\306\206\307 \310\211\203$\311!\312\f!\206\313\f!\211q\210*ed\314\n	\315\310\211%-\207" [py-master-file end beg wholebuf filename buffer t py-fetch-py-master-file nil expand-file-name get-file-buffer find-file-noselect py-execute-region "python3"] 7 (#$ . 560907) nil])
#@121 Send buffer at point to Python3 interpreter.

Switch to output buffer. Ignores `py-shell-switch-buffers-on-execute-p'. 
(defalias 'py-execute-buffer-python3-switch #[nil "\212\306\206\307 \310\211\203$\311!\312\f!\206\313\f!\211q\210*ed\314\n	\315\310\316%-\207" [py-master-file end beg wholebuf filename buffer t py-fetch-py-master-file nil expand-file-name get-file-buffer find-file-noselect py-execute-region "python3" switch] 7 (#$ . 561294) nil])
#@116 Send buffer at point to Python3 interpreter.

Keep current buffer. Ignores `py-shell-switch-buffers-on-execute-p' 
(defalias 'py-execute-buffer-python3-noswitch #[nil "\212\306\206\307 \310\211\203$\311!\312\f!\206\313\f!\211q\210*ed\314\n	\315\310\316%-\207" [py-master-file end beg wholebuf filename buffer t py-fetch-py-master-file nil expand-file-name get-file-buffer find-file-noselect py-execute-region "python3" noswitch] 7 (#$ . 561769) nil])
#@54 Send buffer at point to Python3 unique interpreter. 
(defalias 'py-execute-buffer-python3-dedicated #[nil "\212\306\206\307 \310\211\203$\311!\312\f!\206\313\f!\211q\210*ed\314\n	\315\306\310%-\207" [py-master-file end beg wholebuf filename buffer t py-fetch-py-master-file nil expand-file-name get-file-buffer find-file-noselect py-execute-region "python3"] 7 (#$ . 562242) nil])
#@75 Send buffer at point to Python3 unique interpreter and switch to result. 
(defalias 'py-execute-buffer-python3-dedicated-switch #[nil "\212\306\206\307 \310\211\203$\311!\312\f!\206\313\f!\211q\210*ed\314\n	\315\306\316%-\207" [py-master-file end beg wholebuf filename buffer t py-fetch-py-master-file nil expand-file-name get-file-buffer find-file-noselect py-execute-region "python3" switch] 7 (#$ . 562645) nil])
#@47 Send buffer at point to Python2 interpreter. 
(defalias 'py-execute-buffer-python2 #[nil "\212\306\206\307 \310\211\203$\311!\312\f!\206\313\f!\211q\210*ed\314\n	\315\310\211%-\207" [py-master-file end beg wholebuf filename buffer t py-fetch-py-master-file nil expand-file-name get-file-buffer find-file-noselect py-execute-region "python2"] 7 (#$ . 563083) nil])
#@121 Send buffer at point to Python2 interpreter.

Switch to output buffer. Ignores `py-shell-switch-buffers-on-execute-p'. 
(defalias 'py-execute-buffer-python2-switch #[nil "\212\306\206\307 \310\211\203$\311!\312\f!\206\313\f!\211q\210*ed\314\n	\315\310\316%-\207" [py-master-file end beg wholebuf filename buffer t py-fetch-py-master-file nil expand-file-name get-file-buffer find-file-noselect py-execute-region "python2" switch] 7 (#$ . 563470) nil])
#@116 Send buffer at point to Python2 interpreter.

Keep current buffer. Ignores `py-shell-switch-buffers-on-execute-p' 
(defalias 'py-execute-buffer-python2-noswitch #[nil "\212\306\206\307 \310\211\203$\311!\312\f!\206\313\f!\211q\210*ed\314\n	\315\310\316%-\207" [py-master-file end beg wholebuf filename buffer t py-fetch-py-master-file nil expand-file-name get-file-buffer find-file-noselect py-execute-region "python2" noswitch] 7 (#$ . 563945) nil])
#@54 Send buffer at point to Python2 unique interpreter. 
(defalias 'py-execute-buffer-python2-dedicated #[nil "\212\306\206\307 \310\211\203$\311!\312\f!\206\313\f!\211q\210*ed\314\n	\315\306\310%-\207" [py-master-file end beg wholebuf filename buffer t py-fetch-py-master-file nil expand-file-name get-file-buffer find-file-noselect py-execute-region "python2"] 7 (#$ . 564418) nil])
#@75 Send buffer at point to Python2 unique interpreter and switch to result. 
(defalias 'py-execute-buffer-python2-dedicated-switch #[nil "\212\306\206\307 \310\211\203$\311!\312\f!\206\313\f!\211q\210*ed\314\n	\315\306\316%-\207" [py-master-file end beg wholebuf filename buffer t py-fetch-py-master-file nil expand-file-name get-file-buffer find-file-noselect py-execute-region "python2" switch] 7 (#$ . 564821) nil])
#@49 Send buffer at point to Python2.7 interpreter. 
(defalias 'py-execute-buffer-python2\.7 #[nil "\212\306\206\307 \310\211\203$\311!\312\f!\206\313\f!\211q\210*ed\314\n	\315\310\211%-\207" [py-master-file end beg wholebuf filename buffer t py-fetch-py-master-file nil expand-file-name get-file-buffer find-file-noselect py-execute-region "python2.7"] 7 (#$ . 565259) nil])
#@123 Send buffer at point to Python2.7 interpreter.

Switch to output buffer. Ignores `py-shell-switch-buffers-on-execute-p'. 
(defalias 'py-execute-buffer-python2\.7-switch #[nil "\212\306\206\307 \310\211\203$\311!\312\f!\206\313\f!\211q\210*ed\314\n	\315\310\316%-\207" [py-master-file end beg wholebuf filename buffer t py-fetch-py-master-file nil expand-file-name get-file-buffer find-file-noselect py-execute-region "python2.7" switch] 7 (#$ . 565653) nil])
#@118 Send buffer at point to Python2.7 interpreter.

Keep current buffer. Ignores `py-shell-switch-buffers-on-execute-p' 
(defalias 'py-execute-buffer-python2\.7-noswitch #[nil "\212\306\206\307 \310\211\203$\311!\312\f!\206\313\f!\211q\210*ed\314\n	\315\310\316%-\207" [py-master-file end beg wholebuf filename buffer t py-fetch-py-master-file nil expand-file-name get-file-buffer find-file-noselect py-execute-region "python2.7" noswitch] 7 (#$ . 566135) nil])
#@56 Send buffer at point to Python2.7 unique interpreter. 
(defalias 'py-execute-buffer-python2\.7-dedicated #[nil "\212\306\206\307 \310\211\203$\311!\312\f!\206\313\f!\211q\210*ed\314\n	\315\306\310%-\207" [py-master-file end beg wholebuf filename buffer t py-fetch-py-master-file nil expand-file-name get-file-buffer find-file-noselect py-execute-region "python2.7"] 7 (#$ . 566615) nil])
#@77 Send buffer at point to Python2.7 unique interpreter and switch to result. 
(defalias 'py-execute-buffer-python2\.7-dedicated-switch #[nil "\212\306\206\307 \310\211\203$\311!\312\f!\206\313\f!\211q\210*ed\314\n	\315\306\316%-\207" [py-master-file end beg wholebuf filename buffer t py-fetch-py-master-file nil expand-file-name get-file-buffer find-file-noselect py-execute-region "python2.7" switch] 7 (#$ . 567025) nil])
#@46 Send buffer at point to Jython interpreter. 
(defalias 'py-execute-buffer-jython #[nil "\212\306\206\307 \310\211\203$\311!\312\f!\206\313\f!\211q\210*ed\314\n	\315\310\211%-\207" [py-master-file end beg wholebuf filename buffer t py-fetch-py-master-file nil expand-file-name get-file-buffer find-file-noselect py-execute-region "jython"] 7 (#$ . 567470) nil])
#@120 Send buffer at point to Jython interpreter.

Switch to output buffer. Ignores `py-shell-switch-buffers-on-execute-p'. 
(defalias 'py-execute-buffer-jython-switch #[nil "\212\306\206\307 \310\211\203$\311!\312\f!\206\313\f!\211q\210*ed\314\n	\315\310\316%-\207" [py-master-file end beg wholebuf filename buffer t py-fetch-py-master-file nil expand-file-name get-file-buffer find-file-noselect py-execute-region "jython" switch] 7 (#$ . 567854) nil])
#@115 Send buffer at point to Jython interpreter.

Keep current buffer. Ignores `py-shell-switch-buffers-on-execute-p' 
(defalias 'py-execute-buffer-jython-noswitch #[nil "\212\306\206\307 \310\211\203$\311!\312\f!\206\313\f!\211q\210*ed\314\n	\315\310\316%-\207" [py-master-file end beg wholebuf filename buffer t py-fetch-py-master-file nil expand-file-name get-file-buffer find-file-noselect py-execute-region "jython" noswitch] 7 (#$ . 568326) nil])
#@53 Send buffer at point to Jython unique interpreter. 
(defalias 'py-execute-buffer-jython-dedicated #[nil "\212\306\206\307 \310\211\203$\311!\312\f!\206\313\f!\211q\210*ed\314\n	\315\306\310%-\207" [py-master-file end beg wholebuf filename buffer t py-fetch-py-master-file nil expand-file-name get-file-buffer find-file-noselect py-execute-region "jython"] 7 (#$ . 568796) nil])
#@74 Send buffer at point to Jython unique interpreter and switch to result. 
(defalias 'py-execute-buffer-jython-dedicated-switch #[nil "\212\306\206\307 \310\211\203$\311!\312\f!\206\313\f!\211q\210*ed\314\n	\315\306\316%-\207" [py-master-file end beg wholebuf filename buffer t py-fetch-py-master-file nil expand-file-name get-file-buffer find-file-noselect py-execute-region "jython" switch] 7 (#$ . 569196) nil])
#@49 Send buffer at point to Python3.2 interpreter. 
(defalias 'py-execute-buffer-python3\.2 #[nil "\212\306\206\307 \310\211\203$\311!\312\f!\206\313\f!\211q\210*ed\314\n	\315\310\211%-\207" [py-master-file end beg wholebuf filename buffer t py-fetch-py-master-file nil expand-file-name get-file-buffer find-file-noselect py-execute-region "python3.2"] 7 (#$ . 569631) nil])
#@123 Send buffer at point to Python3.2 interpreter.

Switch to output buffer. Ignores `py-shell-switch-buffers-on-execute-p'. 
(defalias 'py-execute-buffer-python3\.2-switch #[nil "\212\306\206\307 \310\211\203$\311!\312\f!\206\313\f!\211q\210*ed\314\n	\315\310\316%-\207" [py-master-file end beg wholebuf filename buffer t py-fetch-py-master-file nil expand-file-name get-file-buffer find-file-noselect py-execute-region "python3.2" switch] 7 (#$ . 570025) nil])
#@118 Send buffer at point to Python3.2 interpreter.

Keep current buffer. Ignores `py-shell-switch-buffers-on-execute-p' 
(defalias 'py-execute-buffer-python3\.2-noswitch #[nil "\212\306\206\307 \310\211\203$\311!\312\f!\206\313\f!\211q\210*ed\314\n	\315\310\316%-\207" [py-master-file end beg wholebuf filename buffer t py-fetch-py-master-file nil expand-file-name get-file-buffer find-file-noselect py-execute-region "python3.2" noswitch] 7 (#$ . 570507) nil])
#@56 Send buffer at point to Python3.2 unique interpreter. 
(defalias 'py-execute-buffer-python3\.2-dedicated #[nil "\212\306\206\307 \310\211\203$\311!\312\f!\206\313\f!\211q\210*ed\314\n	\315\306\310%-\207" [py-master-file end beg wholebuf filename buffer t py-fetch-py-master-file nil expand-file-name get-file-buffer find-file-noselect py-execute-region "python3.2"] 7 (#$ . 570987) nil])
#@77 Send buffer at point to Python3.2 unique interpreter and switch to result. 
(defalias 'py-execute-buffer-python3\.2-dedicated-switch #[nil "\212\306\206\307 \310\211\203$\311!\312\f!\206\313\f!\211q\210*ed\314\n	\315\306\316%-\207" [py-master-file end beg wholebuf filename buffer t py-fetch-py-master-file nil expand-file-name get-file-buffer find-file-noselect py-execute-region "python3.2" switch] 7 (#$ . 571397) nil])
#@50 Send expression at point to Python interpreter. 
(defalias 'py-execute-expression-python #[nil "\300\301\302\303\211$\207" [py-execute-prepare "expression" "python" nil] 5 (#$ . 571842) nil])
#@124 Send expression at point to Python interpreter.

Switch to output buffer. Ignores `py-shell-switch-buffers-on-execute-p'. 
(defalias 'py-execute-expression-python-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "expression" "python" nil switch] 5 (#$ . 572041) nil])
#@119 Send expression at point to Python interpreter.

Keep current buffer. Ignores `py-shell-switch-buffers-on-execute-p' 
(defalias 'py-execute-expression-python-noswitch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "expression" "python" nil noswitch] 5 (#$ . 572328) nil])
#@57 Send expression at point to Python unique interpreter. 
(defalias 'py-execute-expression-python-dedicated #[nil "\300\301\302\303\304$\207" [py-execute-prepare "expression" "python" t nil] 5 (#$ . 572613) nil])
#@78 Send expression at point to Python unique interpreter and switch to result. 
(defalias 'py-execute-expression-python-dedicated-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "expression" "python" t switch] 5 (#$ . 572830) nil])
#@51 Send expression at point to IPython interpreter. 
(defalias 'py-execute-expression-ipython #[nil "\300\301\302\303\211$\207" [py-execute-prepare "expression" "ipython" nil] 5 (#$ . 573078) nil])
#@125 Send expression at point to IPython interpreter.

Switch to output buffer. Ignores `py-shell-switch-buffers-on-execute-p'. 
(defalias 'py-execute-expression-ipython-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "expression" "ipython" nil switch] 5 (#$ . 573280) nil])
#@120 Send expression at point to IPython interpreter.

Keep current buffer. Ignores `py-shell-switch-buffers-on-execute-p' 
(defalias 'py-execute-expression-ipython-noswitch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "expression" "ipython" nil noswitch] 5 (#$ . 573570) nil])
#@58 Send expression at point to IPython unique interpreter. 
(defalias 'py-execute-expression-ipython-dedicated #[nil "\300\301\302\303\304$\207" [py-execute-prepare "expression" "ipython" t nil] 5 (#$ . 573858) nil])
#@79 Send expression at point to IPython unique interpreter and switch to result. 
(defalias 'py-execute-expression-ipython-dedicated-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "expression" "ipython" t switch] 5 (#$ . 574078) nil])
#@51 Send expression at point to Python3 interpreter. 
(defalias 'py-execute-expression-python3 #[nil "\300\301\302\303\211$\207" [py-execute-prepare "expression" "python3" nil] 5 (#$ . 574329) nil])
#@125 Send expression at point to Python3 interpreter.

Switch to output buffer. Ignores `py-shell-switch-buffers-on-execute-p'. 
(defalias 'py-execute-expression-python3-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "expression" "python3" nil switch] 5 (#$ . 574531) nil])
#@120 Send expression at point to Python3 interpreter.

Keep current buffer. Ignores `py-shell-switch-buffers-on-execute-p' 
(defalias 'py-execute-expression-python3-noswitch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "expression" "python3" nil noswitch] 5 (#$ . 574821) nil])
#@58 Send expression at point to Python3 unique interpreter. 
(defalias 'py-execute-expression-python3-dedicated #[nil "\300\301\302\303\304$\207" [py-execute-prepare "expression" "python3" t nil] 5 (#$ . 575109) nil])
#@79 Send expression at point to Python3 unique interpreter and switch to result. 
(defalias 'py-execute-expression-python3-dedicated-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "expression" "python3" t switch] 5 (#$ . 575329) nil])
#@51 Send expression at point to Python2 interpreter. 
(defalias 'py-execute-expression-python2 #[nil "\300\301\302\303\211$\207" [py-execute-prepare "expression" "python2" nil] 5 (#$ . 575580) nil])
#@125 Send expression at point to Python2 interpreter.

Switch to output buffer. Ignores `py-shell-switch-buffers-on-execute-p'. 
(defalias 'py-execute-expression-python2-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "expression" "python2" nil switch] 5 (#$ . 575782) nil])
#@120 Send expression at point to Python2 interpreter.

Keep current buffer. Ignores `py-shell-switch-buffers-on-execute-p' 
(defalias 'py-execute-expression-python2-noswitch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "expression" "python2" nil noswitch] 5 (#$ . 576072) nil])
#@58 Send expression at point to Python2 unique interpreter. 
(defalias 'py-execute-expression-python2-dedicated #[nil "\300\301\302\303\304$\207" [py-execute-prepare "expression" "python2" t nil] 5 (#$ . 576360) nil])
#@79 Send expression at point to Python2 unique interpreter and switch to result. 
(defalias 'py-execute-expression-python2-dedicated-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "expression" "python2" t switch] 5 (#$ . 576580) nil])
#@53 Send expression at point to Python2.7 interpreter. 
(defalias 'py-execute-expression-python2\.7 #[nil "\300\301\302\303\211$\207" [py-execute-prepare "expression" "python2.7" nil] 5 (#$ . 576831) nil])
#@127 Send expression at point to Python2.7 interpreter.

Switch to output buffer. Ignores `py-shell-switch-buffers-on-execute-p'. 
(defalias 'py-execute-expression-python2\.7-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "expression" "python2.7" nil switch] 5 (#$ . 577040) nil])
#@122 Send expression at point to Python2.7 interpreter.

Keep current buffer. Ignores `py-shell-switch-buffers-on-execute-p' 
(defalias 'py-execute-expression-python2\.7-noswitch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "expression" "python2.7" nil noswitch] 5 (#$ . 577337) nil])
#@60 Send expression at point to Python2.7 unique interpreter. 
(defalias 'py-execute-expression-python2\.7-dedicated #[nil "\300\301\302\303\304$\207" [py-execute-prepare "expression" "python2.7" t nil] 5 (#$ . 577632) nil])
#@81 Send expression at point to Python2.7 unique interpreter and switch to result. 
(defalias 'py-execute-expression-python2\.7-dedicated-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "expression" "python2.7" t switch] 5 (#$ . 577859) nil])
#@50 Send expression at point to Jython interpreter. 
(defalias 'py-execute-expression-jython #[nil "\300\301\302\303\211$\207" [py-execute-prepare "expression" "jython" nil] 5 (#$ . 578117) nil])
#@124 Send expression at point to Jython interpreter.

Switch to output buffer. Ignores `py-shell-switch-buffers-on-execute-p'. 
(defalias 'py-execute-expression-jython-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "expression" "jython" nil switch] 5 (#$ . 578316) nil])
#@119 Send expression at point to Jython interpreter.

Keep current buffer. Ignores `py-shell-switch-buffers-on-execute-p' 
(defalias 'py-execute-expression-jython-noswitch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "expression" "jython" nil noswitch] 5 (#$ . 578603) nil])
#@57 Send expression at point to Jython unique interpreter. 
(defalias 'py-execute-expression-jython-dedicated #[nil "\300\301\302\303\304$\207" [py-execute-prepare "expression" "jython" t nil] 5 (#$ . 578888) nil])
#@78 Send expression at point to Jython unique interpreter and switch to result. 
(defalias 'py-execute-expression-jython-dedicated-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "expression" "jython" t switch] 5 (#$ . 579105) nil])
#@53 Send expression at point to Python3.2 interpreter. 
(defalias 'py-execute-expression-python3\.2 #[nil "\300\301\302\303\211$\207" [py-execute-prepare "expression" "python3.2" nil] 5 (#$ . 579353) nil])
#@127 Send expression at point to Python3.2 interpreter.

Switch to output buffer. Ignores `py-shell-switch-buffers-on-execute-p'. 
(defalias 'py-execute-expression-python3\.2-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "expression" "python3.2" nil switch] 5 (#$ . 579562) nil])
#@122 Send expression at point to Python3.2 interpreter.

Keep current buffer. Ignores `py-shell-switch-buffers-on-execute-p' 
(defalias 'py-execute-expression-python3\.2-noswitch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "expression" "python3.2" nil noswitch] 5 (#$ . 579859) nil])
#@60 Send expression at point to Python3.2 unique interpreter. 
(defalias 'py-execute-expression-python3\.2-dedicated #[nil "\300\301\302\303\304$\207" [py-execute-prepare "expression" "python3.2" t nil] 5 (#$ . 580154) nil])
#@81 Send expression at point to Python3.2 unique interpreter and switch to result. 
(defalias 'py-execute-expression-python3\.2-dedicated-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "expression" "python3.2" t switch] 5 (#$ . 580381) nil])
#@58 Send partial-expression at point to Python interpreter. 
(defalias 'py-execute-partial-expression-python #[nil "\300\301\302\303\211$\207" [py-execute-prepare "partial-expression" "python" nil] 5 (#$ . 580639) nil])
#@132 Send partial-expression at point to Python interpreter.

Switch to output buffer. Ignores `py-shell-switch-buffers-on-execute-p'. 
(defalias 'py-execute-partial-expression-python-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "partial-expression" "python" nil switch] 5 (#$ . 580862) nil])
#@127 Send partial-expression at point to Python interpreter.

Keep current buffer. Ignores `py-shell-switch-buffers-on-execute-p' 
(defalias 'py-execute-partial-expression-python-noswitch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "partial-expression" "python" nil noswitch] 5 (#$ . 581173) nil])
#@65 Send partial-expression at point to Python unique interpreter. 
(defalias 'py-execute-partial-expression-python-dedicated #[nil "\300\301\302\303\304$\207" [py-execute-prepare "partial-expression" "python" t nil] 5 (#$ . 581482) nil])
#@86 Send partial-expression at point to Python unique interpreter and switch to result. 
(defalias 'py-execute-partial-expression-python-dedicated-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "partial-expression" "python" t switch] 5 (#$ . 581723) nil])
#@59 Send partial-expression at point to IPython interpreter. 
(defalias 'py-execute-partial-expression-ipython #[nil "\300\301\302\303\211$\207" [py-execute-prepare "partial-expression" "ipython" nil] 5 (#$ . 581995) nil])
#@133 Send partial-expression at point to IPython interpreter.

Switch to output buffer. Ignores `py-shell-switch-buffers-on-execute-p'. 
(defalias 'py-execute-partial-expression-ipython-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "partial-expression" "ipython" nil switch] 5 (#$ . 582221) nil])
#@128 Send partial-expression at point to IPython interpreter.

Keep current buffer. Ignores `py-shell-switch-buffers-on-execute-p' 
(defalias 'py-execute-partial-expression-ipython-noswitch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "partial-expression" "ipython" nil noswitch] 5 (#$ . 582535) nil])
#@66 Send partial-expression at point to IPython unique interpreter. 
(defalias 'py-execute-partial-expression-ipython-dedicated #[nil "\300\301\302\303\304$\207" [py-execute-prepare "partial-expression" "ipython" t nil] 5 (#$ . 582847) nil])
#@87 Send partial-expression at point to IPython unique interpreter and switch to result. 
(defalias 'py-execute-partial-expression-ipython-dedicated-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "partial-expression" "ipython" t switch] 5 (#$ . 583091) nil])
#@59 Send partial-expression at point to Python3 interpreter. 
(defalias 'py-execute-partial-expression-python3 #[nil "\300\301\302\303\211$\207" [py-execute-prepare "partial-expression" "python3" nil] 5 (#$ . 583366) nil])
#@133 Send partial-expression at point to Python3 interpreter.

Switch to output buffer. Ignores `py-shell-switch-buffers-on-execute-p'. 
(defalias 'py-execute-partial-expression-python3-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "partial-expression" "python3" nil switch] 5 (#$ . 583592) nil])
#@128 Send partial-expression at point to Python3 interpreter.

Keep current buffer. Ignores `py-shell-switch-buffers-on-execute-p' 
(defalias 'py-execute-partial-expression-python3-noswitch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "partial-expression" "python3" nil noswitch] 5 (#$ . 583906) nil])
#@66 Send partial-expression at point to Python3 unique interpreter. 
(defalias 'py-execute-partial-expression-python3-dedicated #[nil "\300\301\302\303\304$\207" [py-execute-prepare "partial-expression" "python3" t nil] 5 (#$ . 584218) nil])
#@87 Send partial-expression at point to Python3 unique interpreter and switch to result. 
(defalias 'py-execute-partial-expression-python3-dedicated-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "partial-expression" "python3" t switch] 5 (#$ . 584462) nil])
#@59 Send partial-expression at point to Python2 interpreter. 
(defalias 'py-execute-partial-expression-python2 #[nil "\300\301\302\303\211$\207" [py-execute-prepare "partial-expression" "python2" nil] 5 (#$ . 584737) nil])
#@133 Send partial-expression at point to Python2 interpreter.

Switch to output buffer. Ignores `py-shell-switch-buffers-on-execute-p'. 
(defalias 'py-execute-partial-expression-python2-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "partial-expression" "python2" nil switch] 5 (#$ . 584963) nil])
#@128 Send partial-expression at point to Python2 interpreter.

Keep current buffer. Ignores `py-shell-switch-buffers-on-execute-p' 
(defalias 'py-execute-partial-expression-python2-noswitch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "partial-expression" "python2" nil noswitch] 5 (#$ . 585277) nil])
#@66 Send partial-expression at point to Python2 unique interpreter. 
(defalias 'py-execute-partial-expression-python2-dedicated #[nil "\300\301\302\303\304$\207" [py-execute-prepare "partial-expression" "python2" t nil] 5 (#$ . 585589) nil])
#@87 Send partial-expression at point to Python2 unique interpreter and switch to result. 
(defalias 'py-execute-partial-expression-python2-dedicated-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "partial-expression" "python2" t switch] 5 (#$ . 585833) nil])
#@61 Send partial-expression at point to Python2.7 interpreter. 
(defalias 'py-execute-partial-expression-python2\.7 #[nil "\300\301\302\303\211$\207" [py-execute-prepare "partial-expression" "python2.7" nil] 5 (#$ . 586108) nil])
#@135 Send partial-expression at point to Python2.7 interpreter.

Switch to output buffer. Ignores `py-shell-switch-buffers-on-execute-p'. 
(defalias 'py-execute-partial-expression-python2\.7-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "partial-expression" "python2.7" nil switch] 5 (#$ . 586341) nil])
#@130 Send partial-expression at point to Python2.7 interpreter.

Keep current buffer. Ignores `py-shell-switch-buffers-on-execute-p' 
(defalias 'py-execute-partial-expression-python2\.7-noswitch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "partial-expression" "python2.7" nil noswitch] 5 (#$ . 586662) nil])
#@68 Send partial-expression at point to Python2.7 unique interpreter. 
(defalias 'py-execute-partial-expression-python2\.7-dedicated #[nil "\300\301\302\303\304$\207" [py-execute-prepare "partial-expression" "python2.7" t nil] 5 (#$ . 586981) nil])
#@89 Send partial-expression at point to Python2.7 unique interpreter and switch to result. 
(defalias 'py-execute-partial-expression-python2\.7-dedicated-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "partial-expression" "python2.7" t switch] 5 (#$ . 587232) nil])
#@58 Send partial-expression at point to Jython interpreter. 
(defalias 'py-execute-partial-expression-jython #[nil "\300\301\302\303\211$\207" [py-execute-prepare "partial-expression" "jython" nil] 5 (#$ . 587514) nil])
#@132 Send partial-expression at point to Jython interpreter.

Switch to output buffer. Ignores `py-shell-switch-buffers-on-execute-p'. 
(defalias 'py-execute-partial-expression-jython-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "partial-expression" "jython" nil switch] 5 (#$ . 587737) nil])
#@127 Send partial-expression at point to Jython interpreter.

Keep current buffer. Ignores `py-shell-switch-buffers-on-execute-p' 
(defalias 'py-execute-partial-expression-jython-noswitch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "partial-expression" "jython" nil noswitch] 5 (#$ . 588048) nil])
#@65 Send partial-expression at point to Jython unique interpreter. 
(defalias 'py-execute-partial-expression-jython-dedicated #[nil "\300\301\302\303\304$\207" [py-execute-prepare "partial-expression" "jython" t nil] 5 (#$ . 588357) nil])
#@86 Send partial-expression at point to Jython unique interpreter and switch to result. 
(defalias 'py-execute-partial-expression-jython-dedicated-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "partial-expression" "jython" t switch] 5 (#$ . 588598) nil])
#@61 Send partial-expression at point to Python3.2 interpreter. 
(defalias 'py-execute-partial-expression-python3\.2 #[nil "\300\301\302\303\211$\207" [py-execute-prepare "partial-expression" "python3.2" nil] 5 (#$ . 588870) nil])
#@135 Send partial-expression at point to Python3.2 interpreter.

Switch to output buffer. Ignores `py-shell-switch-buffers-on-execute-p'. 
(defalias 'py-execute-partial-expression-python3\.2-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "partial-expression" "python3.2" nil switch] 5 (#$ . 589103) nil])
#@130 Send partial-expression at point to Python3.2 interpreter.

Keep current buffer. Ignores `py-shell-switch-buffers-on-execute-p' 
(defalias 'py-execute-partial-expression-python3\.2-noswitch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "partial-expression" "python3.2" nil noswitch] 5 (#$ . 589424) nil])
#@68 Send partial-expression at point to Python3.2 unique interpreter. 
(defalias 'py-execute-partial-expression-python3\.2-dedicated #[nil "\300\301\302\303\304$\207" [py-execute-prepare "partial-expression" "python3.2" t nil] 5 (#$ . 589743) nil])
#@89 Send partial-expression at point to Python3.2 unique interpreter and switch to result. 
(defalias 'py-execute-partial-expression-python3\.2-dedicated-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "partial-expression" "python3.2" t switch] 5 (#$ . 589994) nil])
#@44 Send line at point to Python interpreter. 
(defalias 'py-execute-line-python #[nil "\300\301\302\303\211$\207" [py-execute-prepare "line" "python" nil] 5 (#$ . 590276) nil])
#@118 Send line at point to Python interpreter.

Switch to output buffer. Ignores `py-shell-switch-buffers-on-execute-p'. 
(defalias 'py-execute-line-python-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "line" "python" nil switch] 5 (#$ . 590457) nil])
#@113 Send line at point to Python interpreter.

Keep current buffer. Ignores `py-shell-switch-buffers-on-execute-p' 
(defalias 'py-execute-line-python-noswitch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "line" "python" nil noswitch] 5 (#$ . 590726) nil])
#@51 Send line at point to Python unique interpreter. 
(defalias 'py-execute-line-python-dedicated #[nil "\300\301\302\303\304$\207" [py-execute-prepare "line" "python" t nil] 5 (#$ . 590993) nil])
#@72 Send line at point to Python unique interpreter and switch to result. 
(defalias 'py-execute-line-python-dedicated-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "line" "python" t switch] 5 (#$ . 591192) nil])
#@45 Send line at point to IPython interpreter. 
(defalias 'py-execute-line-ipython #[nil "\300\301\302\303\211$\207" [py-execute-prepare "line" "ipython" nil] 5 (#$ . 591422) nil])
#@119 Send line at point to IPython interpreter.

Switch to output buffer. Ignores `py-shell-switch-buffers-on-execute-p'. 
(defalias 'py-execute-line-ipython-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "line" "ipython" nil switch] 5 (#$ . 591606) nil])
#@114 Send line at point to IPython interpreter.

Keep current buffer. Ignores `py-shell-switch-buffers-on-execute-p' 
(defalias 'py-execute-line-ipython-noswitch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "line" "ipython" nil noswitch] 5 (#$ . 591878) nil])
#@52 Send line at point to IPython unique interpreter. 
(defalias 'py-execute-line-ipython-dedicated #[nil "\300\301\302\303\304$\207" [py-execute-prepare "line" "ipython" t nil] 5 (#$ . 592148) nil])
#@73 Send line at point to IPython unique interpreter and switch to result. 
(defalias 'py-execute-line-ipython-dedicated-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "line" "ipython" t switch] 5 (#$ . 592350) nil])
#@45 Send line at point to Python3 interpreter. 
(defalias 'py-execute-line-python3 #[nil "\300\301\302\303\211$\207" [py-execute-prepare "line" "python3" nil] 5 (#$ . 592583) nil])
#@119 Send line at point to Python3 interpreter.

Switch to output buffer. Ignores `py-shell-switch-buffers-on-execute-p'. 
(defalias 'py-execute-line-python3-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "line" "python3" nil switch] 5 (#$ . 592767) nil])
#@114 Send line at point to Python3 interpreter.

Keep current buffer. Ignores `py-shell-switch-buffers-on-execute-p' 
(defalias 'py-execute-line-python3-noswitch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "line" "python3" nil noswitch] 5 (#$ . 593039) nil])
#@52 Send line at point to Python3 unique interpreter. 
(defalias 'py-execute-line-python3-dedicated #[nil "\300\301\302\303\304$\207" [py-execute-prepare "line" "python3" t nil] 5 (#$ . 593309) nil])
#@73 Send line at point to Python3 unique interpreter and switch to result. 
(defalias 'py-execute-line-python3-dedicated-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "line" "python3" t switch] 5 (#$ . 593511) nil])
#@45 Send line at point to Python2 interpreter. 
(defalias 'py-execute-line-python2 #[nil "\300\301\302\303\211$\207" [py-execute-prepare "line" "python2" nil] 5 (#$ . 593744) nil])
#@119 Send line at point to Python2 interpreter.

Switch to output buffer. Ignores `py-shell-switch-buffers-on-execute-p'. 
(defalias 'py-execute-line-python2-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "line" "python2" nil switch] 5 (#$ . 593928) nil])
#@114 Send line at point to Python2 interpreter.

Keep current buffer. Ignores `py-shell-switch-buffers-on-execute-p' 
(defalias 'py-execute-line-python2-noswitch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "line" "python2" nil noswitch] 5 (#$ . 594200) nil])
#@52 Send line at point to Python2 unique interpreter. 
(defalias 'py-execute-line-python2-dedicated #[nil "\300\301\302\303\304$\207" [py-execute-prepare "line" "python2" t nil] 5 (#$ . 594470) nil])
#@73 Send line at point to Python2 unique interpreter and switch to result. 
(defalias 'py-execute-line-python2-dedicated-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "line" "python2" t switch] 5 (#$ . 594672) nil])
#@47 Send line at point to Python2.7 interpreter. 
(defalias 'py-execute-line-python2\.7 #[nil "\300\301\302\303\211$\207" [py-execute-prepare "line" "python2.7" nil] 5 (#$ . 594905) nil])
#@121 Send line at point to Python2.7 interpreter.

Switch to output buffer. Ignores `py-shell-switch-buffers-on-execute-p'. 
(defalias 'py-execute-line-python2\.7-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "line" "python2.7" nil switch] 5 (#$ . 595096) nil])
#@116 Send line at point to Python2.7 interpreter.

Keep current buffer. Ignores `py-shell-switch-buffers-on-execute-p' 
(defalias 'py-execute-line-python2\.7-noswitch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "line" "python2.7" nil noswitch] 5 (#$ . 595375) nil])
#@54 Send line at point to Python2.7 unique interpreter. 
(defalias 'py-execute-line-python2\.7-dedicated #[nil "\300\301\302\303\304$\207" [py-execute-prepare "line" "python2.7" t nil] 5 (#$ . 595652) nil])
#@75 Send line at point to Python2.7 unique interpreter and switch to result. 
(defalias 'py-execute-line-python2\.7-dedicated-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "line" "python2.7" t switch] 5 (#$ . 595861) nil])
#@44 Send line at point to Jython interpreter. 
(defalias 'py-execute-line-jython #[nil "\300\301\302\303\211$\207" [py-execute-prepare "line" "jython" nil] 5 (#$ . 596101) nil])
#@118 Send line at point to Jython interpreter.

Switch to output buffer. Ignores `py-shell-switch-buffers-on-execute-p'. 
(defalias 'py-execute-line-jython-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "line" "jython" nil switch] 5 (#$ . 596282) nil])
#@113 Send line at point to Jython interpreter.

Keep current buffer. Ignores `py-shell-switch-buffers-on-execute-p' 
(defalias 'py-execute-line-jython-noswitch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "line" "jython" nil noswitch] 5 (#$ . 596551) nil])
#@51 Send line at point to Jython unique interpreter. 
(defalias 'py-execute-line-jython-dedicated #[nil "\300\301\302\303\304$\207" [py-execute-prepare "line" "jython" t nil] 5 (#$ . 596818) nil])
#@72 Send line at point to Jython unique interpreter and switch to result. 
(defalias 'py-execute-line-jython-dedicated-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "line" "jython" t switch] 5 (#$ . 597017) nil])
#@47 Send line at point to Python3.2 interpreter. 
(defalias 'py-execute-line-python3\.2 #[nil "\300\301\302\303\211$\207" [py-execute-prepare "line" "python3.2" nil] 5 (#$ . 597247) nil])
#@121 Send line at point to Python3.2 interpreter.

Switch to output buffer. Ignores `py-shell-switch-buffers-on-execute-p'. 
(defalias 'py-execute-line-python3\.2-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "line" "python3.2" nil switch] 5 (#$ . 597438) nil])
#@116 Send line at point to Python3.2 interpreter.

Keep current buffer. Ignores `py-shell-switch-buffers-on-execute-p' 
(defalias 'py-execute-line-python3\.2-noswitch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "line" "python3.2" nil noswitch] 5 (#$ . 597717) nil])
#@54 Send line at point to Python3.2 unique interpreter. 
(defalias 'py-execute-line-python3\.2-dedicated #[nil "\300\301\302\303\304$\207" [py-execute-prepare "line" "python3.2" t nil] 5 (#$ . 597994) nil])
#@75 Send line at point to Python3.2 unique interpreter and switch to result. 
(defalias 'py-execute-line-python3\.2-dedicated-switch #[nil "\300\301\302\303\304$\207" [py-execute-prepare "line" "python3.2" t switch] 5 (#$ . 598203) nil])
(custom-declare-face 'column-marker-1 '((t (:background "gray"))) "Face used for a column marker.  Usually a background color." :group 'faces)
#@110 Face used for a column marker.  Usually a background color.
Changing this directly affects only new markers.
(defvar column-marker-1-face 'column-marker-1 (#$ . 598587))
(custom-declare-face 'column-marker-2 '((t (:background "cyan3"))) "Face used for a column marker.  Usually a background color." :group 'faces)
#@110 Face used for a column marker.  Usually a background color.
Changing this directly affects only new markers.
(defvar column-marker-2-face 'column-marker-2 (#$ . 598908))
(custom-declare-face 'column-marker-3 '((t (:background "orchid3"))) "Face used for a column marker.  Usually a background color." :group 'faces)
#@110 Face used for a column marker.  Usually a background color.
Changing this directly affects only new markers.
(defvar column-marker-3-face 'column-marker-3 (#$ . 599231))
#@46 List of all internal column-marker variables
(defvar column-marker-vars nil (#$ . 599407))
(make-variable-buffer-local 'column-marker-vars)
#@106 Define a column marker named VAR.
FACE is the face to use.  If nil, then face `column-marker-1' is used.
(defalias 'column-marker-create '(macro . #[(var &optional face) "\206\302\303\304	\305BB\306\307	DD\310	\311\312\313!\314\315\316\317\260\320\321\322\307	D\323BB\324\307	D\325BBE\326\327\330\307	D\331FD\332\333\334\330\307	D\335BB\336BBBD\337\330\307	D\340FD\341BBBB\257F\207" [face var column-marker-1 progn defvar (nil "Buffer local. Used internally to store column marker spec.") make-variable-buffer-local quote defun (arg) "Highlight column with face `" symbol-name "'.\nWith no prefix argument, highlight current column.\n" "With non-negative numeric prefix arg, highlight that column number.\n" "With plain `C-u' (no number), turn off this column marker.\n" "With `C-u C-u' or negative prefix arg, turn off all column-marker highlighting." (interactive "P") unless memq (column-marker-vars) push (column-marker-vars) cond (null arg) column-marker-internal (1+ (current-column)) (consp arg) if (= 4 (car arg)) (nil) ((dolist (var column-marker-vars) (column-marker-internal var nil))) (and (integerp arg) (>= arg 0)) (1+ (prefix-numeric-value arg)) ((t (dolist (var column-marker-vars) (column-marker-internal var nil))))] 17 (#$ . 599554)]))
#@121 Defines a function to locate a character in column COL.
Returns the function symbol, named `column-marker-move-to-COL'.
(defalias 'column-marker-find #[(col) "\302\303\304\"!\211\305\306\307\310\311\312\313\314E\315BB\316\313\317E\320DE\321\322\313\323E\324BB\320DE\325\322\326\327BB\330BB\331BB\257EM\210	)\207" [col fn-symb intern format "column-marker-move-to-%d" lambda (end) let ((start (point))) (when (> end (point-max)) (setq end (point-max))) unless < (current-column) ((forward-line 1)) when (current-column) move-to-column while and (current-column) ((< (point) end) (= 0 (+ (forward-line 1) (current-column)))) if = ((current-column)) ((<= (point) end) (> (point) start)) ((progn (set-match-data (list (1- (point)) (point))) t) (goto-char start) nil)] 15 (#$ . 600825)])
#@229 SYM is the symbol for holding the column marker context.
COL is the column in which a marker should be set.
Supplying nil or 0 for COL turns off the marker.
FACE is the face to use.  If nil, then face `column-marker-1' is used.
(defalias 'column-marker-internal #[(sym col &optional face) "\206\303	J\203\304\305	J\"\210	\305L\210\n<\204 \n\306W\203\"\305\n\203<	\307\n!\306\310D\311BBDCL\210\312\305	J\313#\210\314 \207" [face sym col column-marker-1 font-lock-remove-keywords nil 0 column-marker-find quote (prepend t) font-lock-add-keywords t font-lock-fontify-buffer] 5 (#$ . 601624)])
#@60 Buffer local. Used internally to store column marker spec.
(defvar column-marker-1 nil (#$ . 602231))
(make-variable-buffer-local 'column-marker-1)
#@310 Highlight column with face `column-marker-1-face'.
With no prefix argument, highlight current column.
With non-negative numeric prefix arg, highlight that column number.
With plain `C-u' (no number), turn off this column marker.
With `C-u C-u' or negative prefix arg, turn off all column-marker highlighting.
(defalias 'column-marker-1 #[(arg) "\306>\204\n\306B	\204\307\306iT\n#\207	:\203@	@\310U\203&\307\306\311\"\207\311\211\205>\f@\307\311\"\210\fA\211\204.\311*\207	\250\203T	\312Y\203T\307\306\313	!T\n#\207\311\211\205l
@\307\311\"\210
A\211\204\\\311*\207" [column-marker-vars arg column-marker-1-face var #1=#:--cl-dolist-temp-- #2=#:--cl-dolist-temp-- column-marker-1 column-marker-internal 4 nil 0 prefix-numeric-value] 5 (#$ . 602386) "P"])
#@60 Buffer local. Used internally to store column marker spec.
(defvar column-marker-2 nil (#$ . 603172))
(make-variable-buffer-local 'column-marker-2)
#@310 Highlight column with face `column-marker-2-face'.
With no prefix argument, highlight current column.
With non-negative numeric prefix arg, highlight that column number.
With plain `C-u' (no number), turn off this column marker.
With `C-u C-u' or negative prefix arg, turn off all column-marker highlighting.
(defalias 'column-marker-2 #[(arg) "\306>\204\n\306B	\204\307\306iT\n#\207	:\203@	@\310U\203&\307\306\311\"\207\311\211\205>\f@\307\311\"\210\fA\211\204.\311*\207	\250\203T	\312Y\203T\307\306\313	!T\n#\207\311\211\205l
@\307\311\"\210
A\211\204\\\311*\207" [column-marker-vars arg column-marker-2-face var #1=#:--cl-dolist-temp-- #2=#:--cl-dolist-temp-- column-marker-2 column-marker-internal 4 nil 0 prefix-numeric-value] 5 (#$ . 603327) "P"])
#@60 Buffer local. Used internally to store column marker spec.
(defvar column-marker-3 nil (#$ . 604113))
(make-variable-buffer-local 'column-marker-3)
#@310 Highlight column with face `column-marker-3-face'.
With no prefix argument, highlight current column.
With non-negative numeric prefix arg, highlight that column number.
With plain `C-u' (no number), turn off this column marker.
With `C-u C-u' or negative prefix arg, turn off all column-marker highlighting.
(defalias 'column-marker-3 #[(arg) "\306>\204\n\306B	\204\307\306iT\n#\207	:\203@	@\310U\203&\307\306\311\"\207\311\211\205>\f@\307\311\"\210\fA\211\204.\311*\207	\250\203T	\312Y\203T\307\306\313	!T\n#\207\311\211\205l
@\307\311\"\210
A\211\204\\\311*\207" [column-marker-vars arg column-marker-3-face var #1=#:--cl-dolist-temp-- #2=#:--cl-dolist-temp-- column-marker-3 column-marker-internal 4 nil 0 prefix-numeric-value] 5 (#$ . 604268) "P"])
(byte-code "\300\301\302\"\210\300\303\304\"\210\300\305\306\"\210\300\307\310\"\210\300\311\310\"\210\312\313!\207" [defalias ipython-send-and-indent py-execute-line-ipython py-execute-region-in-shell py-execute-region py-shell-command-on-region py-execute-region-region py-send-region-ipython py-execute-region-ipython py-ipython-shell-command-on-region provide python-mode] 3)
