;;;  --- extended-executes test
;; Copyright (C) 2015  Andreas Roehler
;; Author: Andreas Roehler <andreas.roehler@online.de>
;; Keywords: languages, convenience

;; This program is free software; you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation, either version 3 of the License, or
;; (at your option) any later version.

;; This program is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;; GNU General Public License for more details.

;; You should have received a copy of the GNU General Public License
;; along with this program.  If not, see <http://www.gnu.org/licenses/>.

;;; Commentary:

;; This file is generated by function from python-mode-utils.el - see in
;; directory devel. Edits here might not be persistent.

;;; Code:



(defun py-execute-statement-python-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-statement-python-test\")"))
  (py-bug-tests-intern 'py-execute-statement-python-base arg teststring)))

(defun py-execute-statement-python-base (arg)
  (py-execute-statement-python)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-statement-python-test" nil nil 1) nil "py-execute-statement-python-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-statement-python-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-statement-python-switch-test\")"))
  (py-bug-tests-intern 'py-execute-statement-python-switch-base arg teststring)))

(defun py-execute-statement-python-switch-base (arg)
  (py-execute-statement-python-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-statement-python-switch-test" nil nil 1) nil "py-execute-statement-python-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-statement-python-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-statement-python-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-statement-python-no-switch-base arg teststring)))

(defun py-execute-statement-python-no-switch-base (arg)
  (py-execute-statement-python-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-statement-python-no-switch-test" nil nil 1) nil "py-execute-statement-python-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-statement-python-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-statement-python-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-statement-python-dedicated-base arg teststring)))

(defun py-execute-statement-python-dedicated-base (arg)
  (py-execute-statement-python-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-statement-python-dedicated-test" nil nil 1) nil "py-execute-statement-python-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-statement-python-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-statement-python-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-statement-python-dedicated-switch-base arg teststring)))

(defun py-execute-statement-python-dedicated-switch-base (arg)
  (py-execute-statement-python-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-statement-python-dedicated-switch-test" nil nil 1) nil "py-execute-statement-python-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-statement-python2-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-statement-python2-test\")"))
  (py-bug-tests-intern 'py-execute-statement-python2-base arg teststring)))

(defun py-execute-statement-python2-base (arg)
  (py-execute-statement-python2)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-statement-python2-test" nil nil 1) nil "py-execute-statement-python2-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-statement-python2-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-statement-python2-switch-test\")"))
  (py-bug-tests-intern 'py-execute-statement-python2-switch-base arg teststring)))

(defun py-execute-statement-python2-switch-base (arg)
  (py-execute-statement-python2-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-statement-python2-switch-test" nil nil 1) nil "py-execute-statement-python2-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-statement-python2-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-statement-python2-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-statement-python2-no-switch-base arg teststring)))

(defun py-execute-statement-python2-no-switch-base (arg)
  (py-execute-statement-python2-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-statement-python2-no-switch-test" nil nil 1) nil "py-execute-statement-python2-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-statement-python2-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-statement-python2-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-statement-python2-dedicated-base arg teststring)))

(defun py-execute-statement-python2-dedicated-base (arg)
  (py-execute-statement-python2-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-statement-python2-dedicated-test" nil nil 1) nil "py-execute-statement-python2-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-statement-python2-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-statement-python2-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-statement-python2-dedicated-switch-base arg teststring)))

(defun py-execute-statement-python2-dedicated-switch-base (arg)
  (py-execute-statement-python2-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-statement-python2-dedicated-switch-test" nil nil 1) nil "py-execute-statement-python2-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-statement-python3-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-statement-python3-test\")"))
  (py-bug-tests-intern 'py-execute-statement-python3-base arg teststring)))

(defun py-execute-statement-python3-base (arg)
  (py-execute-statement-python3)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-statement-python3-test" nil nil 1) nil "py-execute-statement-python3-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-statement-python3-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-statement-python3-switch-test\")"))
  (py-bug-tests-intern 'py-execute-statement-python3-switch-base arg teststring)))

(defun py-execute-statement-python3-switch-base (arg)
  (py-execute-statement-python3-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-statement-python3-switch-test" nil nil 1) nil "py-execute-statement-python3-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-statement-python3-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-statement-python3-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-statement-python3-no-switch-base arg teststring)))

(defun py-execute-statement-python3-no-switch-base (arg)
  (py-execute-statement-python3-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-statement-python3-no-switch-test" nil nil 1) nil "py-execute-statement-python3-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-statement-python3-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-statement-python3-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-statement-python3-dedicated-base arg teststring)))

(defun py-execute-statement-python3-dedicated-base (arg)
  (py-execute-statement-python3-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-statement-python3-dedicated-test" nil nil 1) nil "py-execute-statement-python3-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-statement-python3-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-statement-python3-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-statement-python3-dedicated-switch-base arg teststring)))

(defun py-execute-statement-python3-dedicated-switch-base (arg)
  (py-execute-statement-python3-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-statement-python3-dedicated-switch-test" nil nil 1) nil "py-execute-statement-python3-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-statement-ipython-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-statement-ipython-test\")"))
  (py-bug-tests-intern 'py-execute-statement-ipython-base arg teststring)))

(defun py-execute-statement-ipython-base (arg)
  (py-execute-statement-ipython)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-statement-ipython-test" nil nil 1) nil "py-execute-statement-ipython-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-statement-ipython-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-statement-ipython-switch-test\")"))
  (py-bug-tests-intern 'py-execute-statement-ipython-switch-base arg teststring)))

(defun py-execute-statement-ipython-switch-base (arg)
  (py-execute-statement-ipython-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-statement-ipython-switch-test" nil nil 1) nil "py-execute-statement-ipython-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-statement-ipython-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-statement-ipython-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-statement-ipython-no-switch-base arg teststring)))

(defun py-execute-statement-ipython-no-switch-base (arg)
  (py-execute-statement-ipython-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-statement-ipython-no-switch-test" nil nil 1) nil "py-execute-statement-ipython-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-statement-ipython-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-statement-ipython-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-statement-ipython-dedicated-base arg teststring)))

(defun py-execute-statement-ipython-dedicated-base (arg)
  (py-execute-statement-ipython-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-statement-ipython-dedicated-test" nil nil 1) nil "py-execute-statement-ipython-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-statement-ipython-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-statement-ipython-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-statement-ipython-dedicated-switch-base arg teststring)))

(defun py-execute-statement-ipython-dedicated-switch-base (arg)
  (py-execute-statement-ipython-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-statement-ipython-dedicated-switch-test" nil nil 1) nil "py-execute-statement-ipython-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-statement-ipython2\.7-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-statement-ipython2\.7-test\")"))
  (py-bug-tests-intern 'py-execute-statement-ipython2\.7-base arg teststring)))

(defun py-execute-statement-ipython2\.7-base (arg)
  (py-execute-statement-ipython2\.7)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-statement-ipython2\.7-test" nil nil 1) nil "py-execute-statement-ipython2\.7-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-statement-ipython2\.7-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-statement-ipython2\.7-switch-test\")"))
  (py-bug-tests-intern 'py-execute-statement-ipython2\.7-switch-base arg teststring)))

(defun py-execute-statement-ipython2\.7-switch-base (arg)
  (py-execute-statement-ipython2\.7-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-statement-ipython2\.7-switch-test" nil nil 1) nil "py-execute-statement-ipython2\.7-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-statement-ipython2\.7-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-statement-ipython2\.7-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-statement-ipython2\.7-no-switch-base arg teststring)))

(defun py-execute-statement-ipython2\.7-no-switch-base (arg)
  (py-execute-statement-ipython2\.7-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-statement-ipython2\.7-no-switch-test" nil nil 1) nil "py-execute-statement-ipython2\.7-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-statement-ipython2\.7-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-statement-ipython2\.7-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-statement-ipython2\.7-dedicated-base arg teststring)))

(defun py-execute-statement-ipython2\.7-dedicated-base (arg)
  (py-execute-statement-ipython2\.7-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-statement-ipython2\.7-dedicated-test" nil nil 1) nil "py-execute-statement-ipython2\.7-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-statement-ipython2\.7-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-statement-ipython2\.7-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-statement-ipython2\.7-dedicated-switch-base arg teststring)))

(defun py-execute-statement-ipython2\.7-dedicated-switch-base (arg)
  (py-execute-statement-ipython2\.7-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-statement-ipython2\.7-dedicated-switch-test" nil nil 1) nil "py-execute-statement-ipython2\.7-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-statement-ipython3-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-statement-ipython3-test\")"))
  (py-bug-tests-intern 'py-execute-statement-ipython3-base arg teststring)))

(defun py-execute-statement-ipython3-base (arg)
  (py-execute-statement-ipython3)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-statement-ipython3-test" nil nil 1) nil "py-execute-statement-ipython3-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-statement-ipython3-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-statement-ipython3-switch-test\")"))
  (py-bug-tests-intern 'py-execute-statement-ipython3-switch-base arg teststring)))

(defun py-execute-statement-ipython3-switch-base (arg)
  (py-execute-statement-ipython3-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-statement-ipython3-switch-test" nil nil 1) nil "py-execute-statement-ipython3-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-statement-ipython3-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-statement-ipython3-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-statement-ipython3-no-switch-base arg teststring)))

(defun py-execute-statement-ipython3-no-switch-base (arg)
  (py-execute-statement-ipython3-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-statement-ipython3-no-switch-test" nil nil 1) nil "py-execute-statement-ipython3-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-statement-ipython3-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-statement-ipython3-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-statement-ipython3-dedicated-base arg teststring)))

(defun py-execute-statement-ipython3-dedicated-base (arg)
  (py-execute-statement-ipython3-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-statement-ipython3-dedicated-test" nil nil 1) nil "py-execute-statement-ipython3-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-statement-ipython3-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-statement-ipython3-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-statement-ipython3-dedicated-switch-base arg teststring)))

(defun py-execute-statement-ipython3-dedicated-switch-base (arg)
  (py-execute-statement-ipython3-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-statement-ipython3-dedicated-switch-test" nil nil 1) nil "py-execute-statement-ipython3-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-statement-jython-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-statement-jython-test\")"))
  (py-bug-tests-intern 'py-execute-statement-jython-base arg teststring)))

(defun py-execute-statement-jython-base (arg)
  (py-execute-statement-jython)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-statement-jython-test" nil nil 1) nil "py-execute-statement-jython-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-statement-jython-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-statement-jython-switch-test\")"))
  (py-bug-tests-intern 'py-execute-statement-jython-switch-base arg teststring)))

(defun py-execute-statement-jython-switch-base (arg)
  (py-execute-statement-jython-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-statement-jython-switch-test" nil nil 1) nil "py-execute-statement-jython-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-statement-jython-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-statement-jython-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-statement-jython-no-switch-base arg teststring)))

(defun py-execute-statement-jython-no-switch-base (arg)
  (py-execute-statement-jython-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-statement-jython-no-switch-test" nil nil 1) nil "py-execute-statement-jython-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-statement-jython-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-statement-jython-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-statement-jython-dedicated-base arg teststring)))

(defun py-execute-statement-jython-dedicated-base (arg)
  (py-execute-statement-jython-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-statement-jython-dedicated-test" nil nil 1) nil "py-execute-statement-jython-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-statement-jython-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-statement-jython-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-statement-jython-dedicated-switch-base arg teststring)))

(defun py-execute-statement-jython-dedicated-switch-base (arg)
  (py-execute-statement-jython-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-statement-jython-dedicated-switch-test" nil nil 1) nil "py-execute-statement-jython-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-block-python-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-block-python-test\")"))
  (py-bug-tests-intern 'py-execute-block-python-base arg teststring)))

(defun py-execute-block-python-base (arg)
  (py-execute-block-python)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-block-python-test" nil nil 1) nil "py-execute-block-python-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-block-python-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-block-python-switch-test\")"))
  (py-bug-tests-intern 'py-execute-block-python-switch-base arg teststring)))

(defun py-execute-block-python-switch-base (arg)
  (py-execute-block-python-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-block-python-switch-test" nil nil 1) nil "py-execute-block-python-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-block-python-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-block-python-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-block-python-no-switch-base arg teststring)))

(defun py-execute-block-python-no-switch-base (arg)
  (py-execute-block-python-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-block-python-no-switch-test" nil nil 1) nil "py-execute-block-python-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-block-python-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-block-python-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-block-python-dedicated-base arg teststring)))

(defun py-execute-block-python-dedicated-base (arg)
  (py-execute-block-python-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-block-python-dedicated-test" nil nil 1) nil "py-execute-block-python-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-block-python-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-block-python-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-block-python-dedicated-switch-base arg teststring)))

(defun py-execute-block-python-dedicated-switch-base (arg)
  (py-execute-block-python-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-block-python-dedicated-switch-test" nil nil 1) nil "py-execute-block-python-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-block-python2-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-block-python2-test\")"))
  (py-bug-tests-intern 'py-execute-block-python2-base arg teststring)))

(defun py-execute-block-python2-base (arg)
  (py-execute-block-python2)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-block-python2-test" nil nil 1) nil "py-execute-block-python2-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-block-python2-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-block-python2-switch-test\")"))
  (py-bug-tests-intern 'py-execute-block-python2-switch-base arg teststring)))

(defun py-execute-block-python2-switch-base (arg)
  (py-execute-block-python2-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-block-python2-switch-test" nil nil 1) nil "py-execute-block-python2-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-block-python2-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-block-python2-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-block-python2-no-switch-base arg teststring)))

(defun py-execute-block-python2-no-switch-base (arg)
  (py-execute-block-python2-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-block-python2-no-switch-test" nil nil 1) nil "py-execute-block-python2-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-block-python2-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-block-python2-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-block-python2-dedicated-base arg teststring)))

(defun py-execute-block-python2-dedicated-base (arg)
  (py-execute-block-python2-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-block-python2-dedicated-test" nil nil 1) nil "py-execute-block-python2-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-block-python2-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-block-python2-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-block-python2-dedicated-switch-base arg teststring)))

(defun py-execute-block-python2-dedicated-switch-base (arg)
  (py-execute-block-python2-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-block-python2-dedicated-switch-test" nil nil 1) nil "py-execute-block-python2-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-block-python3-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-block-python3-test\")"))
  (py-bug-tests-intern 'py-execute-block-python3-base arg teststring)))

(defun py-execute-block-python3-base (arg)
  (py-execute-block-python3)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-block-python3-test" nil nil 1) nil "py-execute-block-python3-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-block-python3-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-block-python3-switch-test\")"))
  (py-bug-tests-intern 'py-execute-block-python3-switch-base arg teststring)))

(defun py-execute-block-python3-switch-base (arg)
  (py-execute-block-python3-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-block-python3-switch-test" nil nil 1) nil "py-execute-block-python3-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-block-python3-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-block-python3-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-block-python3-no-switch-base arg teststring)))

(defun py-execute-block-python3-no-switch-base (arg)
  (py-execute-block-python3-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-block-python3-no-switch-test" nil nil 1) nil "py-execute-block-python3-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-block-python3-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-block-python3-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-block-python3-dedicated-base arg teststring)))

(defun py-execute-block-python3-dedicated-base (arg)
  (py-execute-block-python3-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-block-python3-dedicated-test" nil nil 1) nil "py-execute-block-python3-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-block-python3-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-block-python3-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-block-python3-dedicated-switch-base arg teststring)))

(defun py-execute-block-python3-dedicated-switch-base (arg)
  (py-execute-block-python3-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-block-python3-dedicated-switch-test" nil nil 1) nil "py-execute-block-python3-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-block-ipython-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-block-ipython-test\")"))
  (py-bug-tests-intern 'py-execute-block-ipython-base arg teststring)))

(defun py-execute-block-ipython-base (arg)
  (py-execute-block-ipython)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-block-ipython-test" nil nil 1) nil "py-execute-block-ipython-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-block-ipython-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-block-ipython-switch-test\")"))
  (py-bug-tests-intern 'py-execute-block-ipython-switch-base arg teststring)))

(defun py-execute-block-ipython-switch-base (arg)
  (py-execute-block-ipython-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-block-ipython-switch-test" nil nil 1) nil "py-execute-block-ipython-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-block-ipython-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-block-ipython-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-block-ipython-no-switch-base arg teststring)))

(defun py-execute-block-ipython-no-switch-base (arg)
  (py-execute-block-ipython-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-block-ipython-no-switch-test" nil nil 1) nil "py-execute-block-ipython-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-block-ipython-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-block-ipython-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-block-ipython-dedicated-base arg teststring)))

(defun py-execute-block-ipython-dedicated-base (arg)
  (py-execute-block-ipython-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-block-ipython-dedicated-test" nil nil 1) nil "py-execute-block-ipython-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-block-ipython-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-block-ipython-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-block-ipython-dedicated-switch-base arg teststring)))

(defun py-execute-block-ipython-dedicated-switch-base (arg)
  (py-execute-block-ipython-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-block-ipython-dedicated-switch-test" nil nil 1) nil "py-execute-block-ipython-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-block-ipython2\.7-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-block-ipython2\.7-test\")"))
  (py-bug-tests-intern 'py-execute-block-ipython2\.7-base arg teststring)))

(defun py-execute-block-ipython2\.7-base (arg)
  (py-execute-block-ipython2\.7)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-block-ipython2\.7-test" nil nil 1) nil "py-execute-block-ipython2\.7-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-block-ipython2\.7-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-block-ipython2\.7-switch-test\")"))
  (py-bug-tests-intern 'py-execute-block-ipython2\.7-switch-base arg teststring)))

(defun py-execute-block-ipython2\.7-switch-base (arg)
  (py-execute-block-ipython2\.7-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-block-ipython2\.7-switch-test" nil nil 1) nil "py-execute-block-ipython2\.7-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-block-ipython2\.7-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-block-ipython2\.7-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-block-ipython2\.7-no-switch-base arg teststring)))

(defun py-execute-block-ipython2\.7-no-switch-base (arg)
  (py-execute-block-ipython2\.7-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-block-ipython2\.7-no-switch-test" nil nil 1) nil "py-execute-block-ipython2\.7-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-block-ipython2\.7-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-block-ipython2\.7-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-block-ipython2\.7-dedicated-base arg teststring)))

(defun py-execute-block-ipython2\.7-dedicated-base (arg)
  (py-execute-block-ipython2\.7-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-block-ipython2\.7-dedicated-test" nil nil 1) nil "py-execute-block-ipython2\.7-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-block-ipython2\.7-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-block-ipython2\.7-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-block-ipython2\.7-dedicated-switch-base arg teststring)))

(defun py-execute-block-ipython2\.7-dedicated-switch-base (arg)
  (py-execute-block-ipython2\.7-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-block-ipython2\.7-dedicated-switch-test" nil nil 1) nil "py-execute-block-ipython2\.7-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-block-ipython3-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-block-ipython3-test\")"))
  (py-bug-tests-intern 'py-execute-block-ipython3-base arg teststring)))

(defun py-execute-block-ipython3-base (arg)
  (py-execute-block-ipython3)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-block-ipython3-test" nil nil 1) nil "py-execute-block-ipython3-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-block-ipython3-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-block-ipython3-switch-test\")"))
  (py-bug-tests-intern 'py-execute-block-ipython3-switch-base arg teststring)))

(defun py-execute-block-ipython3-switch-base (arg)
  (py-execute-block-ipython3-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-block-ipython3-switch-test" nil nil 1) nil "py-execute-block-ipython3-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-block-ipython3-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-block-ipython3-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-block-ipython3-no-switch-base arg teststring)))

(defun py-execute-block-ipython3-no-switch-base (arg)
  (py-execute-block-ipython3-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-block-ipython3-no-switch-test" nil nil 1) nil "py-execute-block-ipython3-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-block-ipython3-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-block-ipython3-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-block-ipython3-dedicated-base arg teststring)))

(defun py-execute-block-ipython3-dedicated-base (arg)
  (py-execute-block-ipython3-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-block-ipython3-dedicated-test" nil nil 1) nil "py-execute-block-ipython3-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-block-ipython3-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-block-ipython3-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-block-ipython3-dedicated-switch-base arg teststring)))

(defun py-execute-block-ipython3-dedicated-switch-base (arg)
  (py-execute-block-ipython3-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-block-ipython3-dedicated-switch-test" nil nil 1) nil "py-execute-block-ipython3-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-block-jython-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-block-jython-test\")"))
  (py-bug-tests-intern 'py-execute-block-jython-base arg teststring)))

(defun py-execute-block-jython-base (arg)
  (py-execute-block-jython)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-block-jython-test" nil nil 1) nil "py-execute-block-jython-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-block-jython-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-block-jython-switch-test\")"))
  (py-bug-tests-intern 'py-execute-block-jython-switch-base arg teststring)))

(defun py-execute-block-jython-switch-base (arg)
  (py-execute-block-jython-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-block-jython-switch-test" nil nil 1) nil "py-execute-block-jython-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-block-jython-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-block-jython-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-block-jython-no-switch-base arg teststring)))

(defun py-execute-block-jython-no-switch-base (arg)
  (py-execute-block-jython-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-block-jython-no-switch-test" nil nil 1) nil "py-execute-block-jython-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-block-jython-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-block-jython-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-block-jython-dedicated-base arg teststring)))

(defun py-execute-block-jython-dedicated-base (arg)
  (py-execute-block-jython-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-block-jython-dedicated-test" nil nil 1) nil "py-execute-block-jython-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-block-jython-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-block-jython-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-block-jython-dedicated-switch-base arg teststring)))

(defun py-execute-block-jython-dedicated-switch-base (arg)
  (py-execute-block-jython-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-block-jython-dedicated-switch-test" nil nil 1) nil "py-execute-block-jython-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-clause-python-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-clause-python-test\")"))
  (py-bug-tests-intern 'py-execute-clause-python-base arg teststring)))

(defun py-execute-clause-python-base (arg)
  (py-execute-clause-python)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-clause-python-test" nil nil 1) nil "py-execute-clause-python-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-clause-python-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-clause-python-switch-test\")"))
  (py-bug-tests-intern 'py-execute-clause-python-switch-base arg teststring)))

(defun py-execute-clause-python-switch-base (arg)
  (py-execute-clause-python-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-clause-python-switch-test" nil nil 1) nil "py-execute-clause-python-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-clause-python-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-clause-python-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-clause-python-no-switch-base arg teststring)))

(defun py-execute-clause-python-no-switch-base (arg)
  (py-execute-clause-python-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-clause-python-no-switch-test" nil nil 1) nil "py-execute-clause-python-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-clause-python-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-clause-python-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-clause-python-dedicated-base arg teststring)))

(defun py-execute-clause-python-dedicated-base (arg)
  (py-execute-clause-python-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-clause-python-dedicated-test" nil nil 1) nil "py-execute-clause-python-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-clause-python-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-clause-python-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-clause-python-dedicated-switch-base arg teststring)))

(defun py-execute-clause-python-dedicated-switch-base (arg)
  (py-execute-clause-python-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-clause-python-dedicated-switch-test" nil nil 1) nil "py-execute-clause-python-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-clause-python2-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-clause-python2-test\")"))
  (py-bug-tests-intern 'py-execute-clause-python2-base arg teststring)))

(defun py-execute-clause-python2-base (arg)
  (py-execute-clause-python2)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-clause-python2-test" nil nil 1) nil "py-execute-clause-python2-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-clause-python2-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-clause-python2-switch-test\")"))
  (py-bug-tests-intern 'py-execute-clause-python2-switch-base arg teststring)))

(defun py-execute-clause-python2-switch-base (arg)
  (py-execute-clause-python2-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-clause-python2-switch-test" nil nil 1) nil "py-execute-clause-python2-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-clause-python2-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-clause-python2-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-clause-python2-no-switch-base arg teststring)))

(defun py-execute-clause-python2-no-switch-base (arg)
  (py-execute-clause-python2-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-clause-python2-no-switch-test" nil nil 1) nil "py-execute-clause-python2-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-clause-python2-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-clause-python2-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-clause-python2-dedicated-base arg teststring)))

(defun py-execute-clause-python2-dedicated-base (arg)
  (py-execute-clause-python2-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-clause-python2-dedicated-test" nil nil 1) nil "py-execute-clause-python2-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-clause-python2-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-clause-python2-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-clause-python2-dedicated-switch-base arg teststring)))

(defun py-execute-clause-python2-dedicated-switch-base (arg)
  (py-execute-clause-python2-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-clause-python2-dedicated-switch-test" nil nil 1) nil "py-execute-clause-python2-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-clause-python3-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-clause-python3-test\")"))
  (py-bug-tests-intern 'py-execute-clause-python3-base arg teststring)))

(defun py-execute-clause-python3-base (arg)
  (py-execute-clause-python3)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-clause-python3-test" nil nil 1) nil "py-execute-clause-python3-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-clause-python3-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-clause-python3-switch-test\")"))
  (py-bug-tests-intern 'py-execute-clause-python3-switch-base arg teststring)))

(defun py-execute-clause-python3-switch-base (arg)
  (py-execute-clause-python3-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-clause-python3-switch-test" nil nil 1) nil "py-execute-clause-python3-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-clause-python3-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-clause-python3-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-clause-python3-no-switch-base arg teststring)))

(defun py-execute-clause-python3-no-switch-base (arg)
  (py-execute-clause-python3-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-clause-python3-no-switch-test" nil nil 1) nil "py-execute-clause-python3-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-clause-python3-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-clause-python3-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-clause-python3-dedicated-base arg teststring)))

(defun py-execute-clause-python3-dedicated-base (arg)
  (py-execute-clause-python3-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-clause-python3-dedicated-test" nil nil 1) nil "py-execute-clause-python3-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-clause-python3-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-clause-python3-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-clause-python3-dedicated-switch-base arg teststring)))

(defun py-execute-clause-python3-dedicated-switch-base (arg)
  (py-execute-clause-python3-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-clause-python3-dedicated-switch-test" nil nil 1) nil "py-execute-clause-python3-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-clause-ipython-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-clause-ipython-test\")"))
  (py-bug-tests-intern 'py-execute-clause-ipython-base arg teststring)))

(defun py-execute-clause-ipython-base (arg)
  (py-execute-clause-ipython)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-clause-ipython-test" nil nil 1) nil "py-execute-clause-ipython-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-clause-ipython-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-clause-ipython-switch-test\")"))
  (py-bug-tests-intern 'py-execute-clause-ipython-switch-base arg teststring)))

(defun py-execute-clause-ipython-switch-base (arg)
  (py-execute-clause-ipython-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-clause-ipython-switch-test" nil nil 1) nil "py-execute-clause-ipython-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-clause-ipython-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-clause-ipython-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-clause-ipython-no-switch-base arg teststring)))

(defun py-execute-clause-ipython-no-switch-base (arg)
  (py-execute-clause-ipython-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-clause-ipython-no-switch-test" nil nil 1) nil "py-execute-clause-ipython-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-clause-ipython-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-clause-ipython-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-clause-ipython-dedicated-base arg teststring)))

(defun py-execute-clause-ipython-dedicated-base (arg)
  (py-execute-clause-ipython-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-clause-ipython-dedicated-test" nil nil 1) nil "py-execute-clause-ipython-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-clause-ipython-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-clause-ipython-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-clause-ipython-dedicated-switch-base arg teststring)))

(defun py-execute-clause-ipython-dedicated-switch-base (arg)
  (py-execute-clause-ipython-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-clause-ipython-dedicated-switch-test" nil nil 1) nil "py-execute-clause-ipython-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-clause-ipython2\.7-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-clause-ipython2\.7-test\")"))
  (py-bug-tests-intern 'py-execute-clause-ipython2\.7-base arg teststring)))

(defun py-execute-clause-ipython2\.7-base (arg)
  (py-execute-clause-ipython2\.7)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-clause-ipython2\.7-test" nil nil 1) nil "py-execute-clause-ipython2\.7-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-clause-ipython2\.7-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-clause-ipython2\.7-switch-test\")"))
  (py-bug-tests-intern 'py-execute-clause-ipython2\.7-switch-base arg teststring)))

(defun py-execute-clause-ipython2\.7-switch-base (arg)
  (py-execute-clause-ipython2\.7-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-clause-ipython2\.7-switch-test" nil nil 1) nil "py-execute-clause-ipython2\.7-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-clause-ipython2\.7-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-clause-ipython2\.7-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-clause-ipython2\.7-no-switch-base arg teststring)))

(defun py-execute-clause-ipython2\.7-no-switch-base (arg)
  (py-execute-clause-ipython2\.7-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-clause-ipython2\.7-no-switch-test" nil nil 1) nil "py-execute-clause-ipython2\.7-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-clause-ipython2\.7-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-clause-ipython2\.7-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-clause-ipython2\.7-dedicated-base arg teststring)))

(defun py-execute-clause-ipython2\.7-dedicated-base (arg)
  (py-execute-clause-ipython2\.7-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-clause-ipython2\.7-dedicated-test" nil nil 1) nil "py-execute-clause-ipython2\.7-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-clause-ipython2\.7-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-clause-ipython2\.7-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-clause-ipython2\.7-dedicated-switch-base arg teststring)))

(defun py-execute-clause-ipython2\.7-dedicated-switch-base (arg)
  (py-execute-clause-ipython2\.7-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-clause-ipython2\.7-dedicated-switch-test" nil nil 1) nil "py-execute-clause-ipython2\.7-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-clause-ipython3-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-clause-ipython3-test\")"))
  (py-bug-tests-intern 'py-execute-clause-ipython3-base arg teststring)))

(defun py-execute-clause-ipython3-base (arg)
  (py-execute-clause-ipython3)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-clause-ipython3-test" nil nil 1) nil "py-execute-clause-ipython3-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-clause-ipython3-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-clause-ipython3-switch-test\")"))
  (py-bug-tests-intern 'py-execute-clause-ipython3-switch-base arg teststring)))

(defun py-execute-clause-ipython3-switch-base (arg)
  (py-execute-clause-ipython3-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-clause-ipython3-switch-test" nil nil 1) nil "py-execute-clause-ipython3-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-clause-ipython3-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-clause-ipython3-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-clause-ipython3-no-switch-base arg teststring)))

(defun py-execute-clause-ipython3-no-switch-base (arg)
  (py-execute-clause-ipython3-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-clause-ipython3-no-switch-test" nil nil 1) nil "py-execute-clause-ipython3-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-clause-ipython3-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-clause-ipython3-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-clause-ipython3-dedicated-base arg teststring)))

(defun py-execute-clause-ipython3-dedicated-base (arg)
  (py-execute-clause-ipython3-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-clause-ipython3-dedicated-test" nil nil 1) nil "py-execute-clause-ipython3-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-clause-ipython3-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-clause-ipython3-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-clause-ipython3-dedicated-switch-base arg teststring)))

(defun py-execute-clause-ipython3-dedicated-switch-base (arg)
  (py-execute-clause-ipython3-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-clause-ipython3-dedicated-switch-test" nil nil 1) nil "py-execute-clause-ipython3-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-clause-jython-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-clause-jython-test\")"))
  (py-bug-tests-intern 'py-execute-clause-jython-base arg teststring)))

(defun py-execute-clause-jython-base (arg)
  (py-execute-clause-jython)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-clause-jython-test" nil nil 1) nil "py-execute-clause-jython-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-clause-jython-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-clause-jython-switch-test\")"))
  (py-bug-tests-intern 'py-execute-clause-jython-switch-base arg teststring)))

(defun py-execute-clause-jython-switch-base (arg)
  (py-execute-clause-jython-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-clause-jython-switch-test" nil nil 1) nil "py-execute-clause-jython-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-clause-jython-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-clause-jython-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-clause-jython-no-switch-base arg teststring)))

(defun py-execute-clause-jython-no-switch-base (arg)
  (py-execute-clause-jython-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-clause-jython-no-switch-test" nil nil 1) nil "py-execute-clause-jython-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-clause-jython-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-clause-jython-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-clause-jython-dedicated-base arg teststring)))

(defun py-execute-clause-jython-dedicated-base (arg)
  (py-execute-clause-jython-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-clause-jython-dedicated-test" nil nil 1) nil "py-execute-clause-jython-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-clause-jython-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-clause-jython-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-clause-jython-dedicated-switch-base arg teststring)))

(defun py-execute-clause-jython-dedicated-switch-base (arg)
  (py-execute-clause-jython-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-clause-jython-dedicated-switch-test" nil nil 1) nil "py-execute-clause-jython-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-block-or-clause-python-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-block-or-clause-python-test\")"))
  (py-bug-tests-intern 'py-execute-block-or-clause-python-base arg teststring)))

(defun py-execute-block-or-clause-python-base (arg)
  (py-execute-block-or-clause-python)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-block-or-clause-python-test" nil nil 1) nil "py-execute-block-or-clause-python-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-block-or-clause-python-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-block-or-clause-python-switch-test\")"))
  (py-bug-tests-intern 'py-execute-block-or-clause-python-switch-base arg teststring)))

(defun py-execute-block-or-clause-python-switch-base (arg)
  (py-execute-block-or-clause-python-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-block-or-clause-python-switch-test" nil nil 1) nil "py-execute-block-or-clause-python-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-block-or-clause-python-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-block-or-clause-python-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-block-or-clause-python-no-switch-base arg teststring)))

(defun py-execute-block-or-clause-python-no-switch-base (arg)
  (py-execute-block-or-clause-python-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-block-or-clause-python-no-switch-test" nil nil 1) nil "py-execute-block-or-clause-python-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-block-or-clause-python-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-block-or-clause-python-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-block-or-clause-python-dedicated-base arg teststring)))

(defun py-execute-block-or-clause-python-dedicated-base (arg)
  (py-execute-block-or-clause-python-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-block-or-clause-python-dedicated-test" nil nil 1) nil "py-execute-block-or-clause-python-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-block-or-clause-python-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-block-or-clause-python-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-block-or-clause-python-dedicated-switch-base arg teststring)))

(defun py-execute-block-or-clause-python-dedicated-switch-base (arg)
  (py-execute-block-or-clause-python-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-block-or-clause-python-dedicated-switch-test" nil nil 1) nil "py-execute-block-or-clause-python-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-block-or-clause-python2-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-block-or-clause-python2-test\")"))
  (py-bug-tests-intern 'py-execute-block-or-clause-python2-base arg teststring)))

(defun py-execute-block-or-clause-python2-base (arg)
  (py-execute-block-or-clause-python2)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-block-or-clause-python2-test" nil nil 1) nil "py-execute-block-or-clause-python2-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-block-or-clause-python2-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-block-or-clause-python2-switch-test\")"))
  (py-bug-tests-intern 'py-execute-block-or-clause-python2-switch-base arg teststring)))

(defun py-execute-block-or-clause-python2-switch-base (arg)
  (py-execute-block-or-clause-python2-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-block-or-clause-python2-switch-test" nil nil 1) nil "py-execute-block-or-clause-python2-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-block-or-clause-python2-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-block-or-clause-python2-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-block-or-clause-python2-no-switch-base arg teststring)))

(defun py-execute-block-or-clause-python2-no-switch-base (arg)
  (py-execute-block-or-clause-python2-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-block-or-clause-python2-no-switch-test" nil nil 1) nil "py-execute-block-or-clause-python2-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-block-or-clause-python2-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-block-or-clause-python2-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-block-or-clause-python2-dedicated-base arg teststring)))

(defun py-execute-block-or-clause-python2-dedicated-base (arg)
  (py-execute-block-or-clause-python2-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-block-or-clause-python2-dedicated-test" nil nil 1) nil "py-execute-block-or-clause-python2-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-block-or-clause-python2-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-block-or-clause-python2-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-block-or-clause-python2-dedicated-switch-base arg teststring)))

(defun py-execute-block-or-clause-python2-dedicated-switch-base (arg)
  (py-execute-block-or-clause-python2-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-block-or-clause-python2-dedicated-switch-test" nil nil 1) nil "py-execute-block-or-clause-python2-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-block-or-clause-python3-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-block-or-clause-python3-test\")"))
  (py-bug-tests-intern 'py-execute-block-or-clause-python3-base arg teststring)))

(defun py-execute-block-or-clause-python3-base (arg)
  (py-execute-block-or-clause-python3)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-block-or-clause-python3-test" nil nil 1) nil "py-execute-block-or-clause-python3-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-block-or-clause-python3-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-block-or-clause-python3-switch-test\")"))
  (py-bug-tests-intern 'py-execute-block-or-clause-python3-switch-base arg teststring)))

(defun py-execute-block-or-clause-python3-switch-base (arg)
  (py-execute-block-or-clause-python3-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-block-or-clause-python3-switch-test" nil nil 1) nil "py-execute-block-or-clause-python3-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-block-or-clause-python3-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-block-or-clause-python3-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-block-or-clause-python3-no-switch-base arg teststring)))

(defun py-execute-block-or-clause-python3-no-switch-base (arg)
  (py-execute-block-or-clause-python3-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-block-or-clause-python3-no-switch-test" nil nil 1) nil "py-execute-block-or-clause-python3-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-block-or-clause-python3-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-block-or-clause-python3-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-block-or-clause-python3-dedicated-base arg teststring)))

(defun py-execute-block-or-clause-python3-dedicated-base (arg)
  (py-execute-block-or-clause-python3-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-block-or-clause-python3-dedicated-test" nil nil 1) nil "py-execute-block-or-clause-python3-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-block-or-clause-python3-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-block-or-clause-python3-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-block-or-clause-python3-dedicated-switch-base arg teststring)))

(defun py-execute-block-or-clause-python3-dedicated-switch-base (arg)
  (py-execute-block-or-clause-python3-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-block-or-clause-python3-dedicated-switch-test" nil nil 1) nil "py-execute-block-or-clause-python3-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-block-or-clause-ipython-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-block-or-clause-ipython-test\")"))
  (py-bug-tests-intern 'py-execute-block-or-clause-ipython-base arg teststring)))

(defun py-execute-block-or-clause-ipython-base (arg)
  (py-execute-block-or-clause-ipython)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-block-or-clause-ipython-test" nil nil 1) nil "py-execute-block-or-clause-ipython-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-block-or-clause-ipython-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-block-or-clause-ipython-switch-test\")"))
  (py-bug-tests-intern 'py-execute-block-or-clause-ipython-switch-base arg teststring)))

(defun py-execute-block-or-clause-ipython-switch-base (arg)
  (py-execute-block-or-clause-ipython-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-block-or-clause-ipython-switch-test" nil nil 1) nil "py-execute-block-or-clause-ipython-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-block-or-clause-ipython-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-block-or-clause-ipython-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-block-or-clause-ipython-no-switch-base arg teststring)))

(defun py-execute-block-or-clause-ipython-no-switch-base (arg)
  (py-execute-block-or-clause-ipython-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-block-or-clause-ipython-no-switch-test" nil nil 1) nil "py-execute-block-or-clause-ipython-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-block-or-clause-ipython-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-block-or-clause-ipython-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-block-or-clause-ipython-dedicated-base arg teststring)))

(defun py-execute-block-or-clause-ipython-dedicated-base (arg)
  (py-execute-block-or-clause-ipython-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-block-or-clause-ipython-dedicated-test" nil nil 1) nil "py-execute-block-or-clause-ipython-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-block-or-clause-ipython-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-block-or-clause-ipython-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-block-or-clause-ipython-dedicated-switch-base arg teststring)))

(defun py-execute-block-or-clause-ipython-dedicated-switch-base (arg)
  (py-execute-block-or-clause-ipython-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-block-or-clause-ipython-dedicated-switch-test" nil nil 1) nil "py-execute-block-or-clause-ipython-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-block-or-clause-ipython2\.7-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-block-or-clause-ipython2\.7-test\")"))
  (py-bug-tests-intern 'py-execute-block-or-clause-ipython2\.7-base arg teststring)))

(defun py-execute-block-or-clause-ipython2\.7-base (arg)
  (py-execute-block-or-clause-ipython2\.7)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-block-or-clause-ipython2\.7-test" nil nil 1) nil "py-execute-block-or-clause-ipython2\.7-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-block-or-clause-ipython2\.7-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-block-or-clause-ipython2\.7-switch-test\")"))
  (py-bug-tests-intern 'py-execute-block-or-clause-ipython2\.7-switch-base arg teststring)))

(defun py-execute-block-or-clause-ipython2\.7-switch-base (arg)
  (py-execute-block-or-clause-ipython2\.7-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-block-or-clause-ipython2\.7-switch-test" nil nil 1) nil "py-execute-block-or-clause-ipython2\.7-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-block-or-clause-ipython2\.7-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-block-or-clause-ipython2\.7-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-block-or-clause-ipython2\.7-no-switch-base arg teststring)))

(defun py-execute-block-or-clause-ipython2\.7-no-switch-base (arg)
  (py-execute-block-or-clause-ipython2\.7-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-block-or-clause-ipython2\.7-no-switch-test" nil nil 1) nil "py-execute-block-or-clause-ipython2\.7-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-block-or-clause-ipython2\.7-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-block-or-clause-ipython2\.7-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-block-or-clause-ipython2\.7-dedicated-base arg teststring)))

(defun py-execute-block-or-clause-ipython2\.7-dedicated-base (arg)
  (py-execute-block-or-clause-ipython2\.7-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-block-or-clause-ipython2\.7-dedicated-test" nil nil 1) nil "py-execute-block-or-clause-ipython2\.7-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-block-or-clause-ipython2\.7-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-block-or-clause-ipython2\.7-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-block-or-clause-ipython2\.7-dedicated-switch-base arg teststring)))

(defun py-execute-block-or-clause-ipython2\.7-dedicated-switch-base (arg)
  (py-execute-block-or-clause-ipython2\.7-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-block-or-clause-ipython2\.7-dedicated-switch-test" nil nil 1) nil "py-execute-block-or-clause-ipython2\.7-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-block-or-clause-ipython3-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-block-or-clause-ipython3-test\")"))
  (py-bug-tests-intern 'py-execute-block-or-clause-ipython3-base arg teststring)))

(defun py-execute-block-or-clause-ipython3-base (arg)
  (py-execute-block-or-clause-ipython3)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-block-or-clause-ipython3-test" nil nil 1) nil "py-execute-block-or-clause-ipython3-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-block-or-clause-ipython3-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-block-or-clause-ipython3-switch-test\")"))
  (py-bug-tests-intern 'py-execute-block-or-clause-ipython3-switch-base arg teststring)))

(defun py-execute-block-or-clause-ipython3-switch-base (arg)
  (py-execute-block-or-clause-ipython3-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-block-or-clause-ipython3-switch-test" nil nil 1) nil "py-execute-block-or-clause-ipython3-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-block-or-clause-ipython3-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-block-or-clause-ipython3-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-block-or-clause-ipython3-no-switch-base arg teststring)))

(defun py-execute-block-or-clause-ipython3-no-switch-base (arg)
  (py-execute-block-or-clause-ipython3-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-block-or-clause-ipython3-no-switch-test" nil nil 1) nil "py-execute-block-or-clause-ipython3-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-block-or-clause-ipython3-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-block-or-clause-ipython3-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-block-or-clause-ipython3-dedicated-base arg teststring)))

(defun py-execute-block-or-clause-ipython3-dedicated-base (arg)
  (py-execute-block-or-clause-ipython3-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-block-or-clause-ipython3-dedicated-test" nil nil 1) nil "py-execute-block-or-clause-ipython3-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-block-or-clause-ipython3-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-block-or-clause-ipython3-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-block-or-clause-ipython3-dedicated-switch-base arg teststring)))

(defun py-execute-block-or-clause-ipython3-dedicated-switch-base (arg)
  (py-execute-block-or-clause-ipython3-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-block-or-clause-ipython3-dedicated-switch-test" nil nil 1) nil "py-execute-block-or-clause-ipython3-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-block-or-clause-jython-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-block-or-clause-jython-test\")"))
  (py-bug-tests-intern 'py-execute-block-or-clause-jython-base arg teststring)))

(defun py-execute-block-or-clause-jython-base (arg)
  (py-execute-block-or-clause-jython)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-block-or-clause-jython-test" nil nil 1) nil "py-execute-block-or-clause-jython-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-block-or-clause-jython-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-block-or-clause-jython-switch-test\")"))
  (py-bug-tests-intern 'py-execute-block-or-clause-jython-switch-base arg teststring)))

(defun py-execute-block-or-clause-jython-switch-base (arg)
  (py-execute-block-or-clause-jython-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-block-or-clause-jython-switch-test" nil nil 1) nil "py-execute-block-or-clause-jython-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-block-or-clause-jython-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-block-or-clause-jython-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-block-or-clause-jython-no-switch-base arg teststring)))

(defun py-execute-block-or-clause-jython-no-switch-base (arg)
  (py-execute-block-or-clause-jython-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-block-or-clause-jython-no-switch-test" nil nil 1) nil "py-execute-block-or-clause-jython-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-block-or-clause-jython-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-block-or-clause-jython-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-block-or-clause-jython-dedicated-base arg teststring)))

(defun py-execute-block-or-clause-jython-dedicated-base (arg)
  (py-execute-block-or-clause-jython-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-block-or-clause-jython-dedicated-test" nil nil 1) nil "py-execute-block-or-clause-jython-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-block-or-clause-jython-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-block-or-clause-jython-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-block-or-clause-jython-dedicated-switch-base arg teststring)))

(defun py-execute-block-or-clause-jython-dedicated-switch-base (arg)
  (py-execute-block-or-clause-jython-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-block-or-clause-jython-dedicated-switch-test" nil nil 1) nil "py-execute-block-or-clause-jython-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-def-python-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "def foo (): print(\"I'm the py-execute-def-python-test\")
foo()"))
  (py-bug-tests-intern 'py-execute-def-python-base arg teststring)))

(defun py-execute-def-python-base (arg)
  (py-execute-def-python)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-def-python-test" nil nil 1) nil "py-execute-def-python-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-def-python-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "def foo (): print(\"I'm the py-execute-def-python-switch-test\")
foo()"))
  (py-bug-tests-intern 'py-execute-def-python-switch-base arg teststring)))

(defun py-execute-def-python-switch-base (arg)
  (py-execute-def-python-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-def-python-switch-test" nil nil 1) nil "py-execute-def-python-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-def-python-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "def foo (): print(\"I'm the py-execute-def-python-no-switch-test\")
foo()"))
  (py-bug-tests-intern 'py-execute-def-python-no-switch-base arg teststring)))

(defun py-execute-def-python-no-switch-base (arg)
  (py-execute-def-python-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-def-python-no-switch-test" nil nil 1) nil "py-execute-def-python-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-def-python-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "def foo (): print(\"I'm the py-execute-def-python-dedicated-test\")
foo()"))
  (py-bug-tests-intern 'py-execute-def-python-dedicated-base arg teststring)))

(defun py-execute-def-python-dedicated-base (arg)
  (py-execute-def-python-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-def-python-dedicated-test" nil nil 1) nil "py-execute-def-python-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-def-python-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "def foo (): print(\"I'm the py-execute-def-python-dedicated-switch-test\")
foo()"))
  (py-bug-tests-intern 'py-execute-def-python-dedicated-switch-base arg teststring)))

(defun py-execute-def-python-dedicated-switch-base (arg)
  (py-execute-def-python-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-def-python-dedicated-switch-test" nil nil 1) nil "py-execute-def-python-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-def-python2-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "def foo (): print(\"I'm the py-execute-def-python2-test\")
foo()"))
  (py-bug-tests-intern 'py-execute-def-python2-base arg teststring)))

(defun py-execute-def-python2-base (arg)
  (py-execute-def-python2)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-def-python2-test" nil nil 1) nil "py-execute-def-python2-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-def-python2-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "def foo (): print(\"I'm the py-execute-def-python2-switch-test\")
foo()"))
  (py-bug-tests-intern 'py-execute-def-python2-switch-base arg teststring)))

(defun py-execute-def-python2-switch-base (arg)
  (py-execute-def-python2-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-def-python2-switch-test" nil nil 1) nil "py-execute-def-python2-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-def-python2-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "def foo (): print(\"I'm the py-execute-def-python2-no-switch-test\")
foo()"))
  (py-bug-tests-intern 'py-execute-def-python2-no-switch-base arg teststring)))

(defun py-execute-def-python2-no-switch-base (arg)
  (py-execute-def-python2-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-def-python2-no-switch-test" nil nil 1) nil "py-execute-def-python2-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-def-python2-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "def foo (): print(\"I'm the py-execute-def-python2-dedicated-test\")
foo()"))
  (py-bug-tests-intern 'py-execute-def-python2-dedicated-base arg teststring)))

(defun py-execute-def-python2-dedicated-base (arg)
  (py-execute-def-python2-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-def-python2-dedicated-test" nil nil 1) nil "py-execute-def-python2-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-def-python2-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "def foo (): print(\"I'm the py-execute-def-python2-dedicated-switch-test\")
foo()"))
  (py-bug-tests-intern 'py-execute-def-python2-dedicated-switch-base arg teststring)))

(defun py-execute-def-python2-dedicated-switch-base (arg)
  (py-execute-def-python2-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-def-python2-dedicated-switch-test" nil nil 1) nil "py-execute-def-python2-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-def-python3-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "def foo (): print(\"I'm the py-execute-def-python3-test\")
foo()"))
  (py-bug-tests-intern 'py-execute-def-python3-base arg teststring)))

(defun py-execute-def-python3-base (arg)
  (py-execute-def-python3)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-def-python3-test" nil nil 1) nil "py-execute-def-python3-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-def-python3-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "def foo (): print(\"I'm the py-execute-def-python3-switch-test\")
foo()"))
  (py-bug-tests-intern 'py-execute-def-python3-switch-base arg teststring)))

(defun py-execute-def-python3-switch-base (arg)
  (py-execute-def-python3-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-def-python3-switch-test" nil nil 1) nil "py-execute-def-python3-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-def-python3-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "def foo (): print(\"I'm the py-execute-def-python3-no-switch-test\")
foo()"))
  (py-bug-tests-intern 'py-execute-def-python3-no-switch-base arg teststring)))

(defun py-execute-def-python3-no-switch-base (arg)
  (py-execute-def-python3-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-def-python3-no-switch-test" nil nil 1) nil "py-execute-def-python3-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-def-python3-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "def foo (): print(\"I'm the py-execute-def-python3-dedicated-test\")
foo()"))
  (py-bug-tests-intern 'py-execute-def-python3-dedicated-base arg teststring)))

(defun py-execute-def-python3-dedicated-base (arg)
  (py-execute-def-python3-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-def-python3-dedicated-test" nil nil 1) nil "py-execute-def-python3-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-def-python3-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "def foo (): print(\"I'm the py-execute-def-python3-dedicated-switch-test\")
foo()"))
  (py-bug-tests-intern 'py-execute-def-python3-dedicated-switch-base arg teststring)))

(defun py-execute-def-python3-dedicated-switch-base (arg)
  (py-execute-def-python3-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-def-python3-dedicated-switch-test" nil nil 1) nil "py-execute-def-python3-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-def-ipython-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "def foo (): print(\"I'm the py-execute-def-ipython-test\")
foo()"))
  (py-bug-tests-intern 'py-execute-def-ipython-base arg teststring)))

(defun py-execute-def-ipython-base (arg)
  (py-execute-def-ipython)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-def-ipython-test" nil nil 1) nil "py-execute-def-ipython-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-def-ipython-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "def foo (): print(\"I'm the py-execute-def-ipython-switch-test\")
foo()"))
  (py-bug-tests-intern 'py-execute-def-ipython-switch-base arg teststring)))

(defun py-execute-def-ipython-switch-base (arg)
  (py-execute-def-ipython-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-def-ipython-switch-test" nil nil 1) nil "py-execute-def-ipython-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-def-ipython-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "def foo (): print(\"I'm the py-execute-def-ipython-no-switch-test\")
foo()"))
  (py-bug-tests-intern 'py-execute-def-ipython-no-switch-base arg teststring)))

(defun py-execute-def-ipython-no-switch-base (arg)
  (py-execute-def-ipython-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-def-ipython-no-switch-test" nil nil 1) nil "py-execute-def-ipython-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-def-ipython-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "def foo (): print(\"I'm the py-execute-def-ipython-dedicated-test\")
foo()"))
  (py-bug-tests-intern 'py-execute-def-ipython-dedicated-base arg teststring)))

(defun py-execute-def-ipython-dedicated-base (arg)
  (py-execute-def-ipython-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-def-ipython-dedicated-test" nil nil 1) nil "py-execute-def-ipython-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-def-ipython-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "def foo (): print(\"I'm the py-execute-def-ipython-dedicated-switch-test\")
foo()"))
  (py-bug-tests-intern 'py-execute-def-ipython-dedicated-switch-base arg teststring)))

(defun py-execute-def-ipython-dedicated-switch-base (arg)
  (py-execute-def-ipython-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-def-ipython-dedicated-switch-test" nil nil 1) nil "py-execute-def-ipython-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-def-ipython2\.7-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "def foo (): print(\"I'm the py-execute-def-ipython2\.7-test\")
foo()"))
  (py-bug-tests-intern 'py-execute-def-ipython2\.7-base arg teststring)))

(defun py-execute-def-ipython2\.7-base (arg)
  (py-execute-def-ipython2\.7)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-def-ipython2\.7-test" nil nil 1) nil "py-execute-def-ipython2\.7-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-def-ipython2\.7-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "def foo (): print(\"I'm the py-execute-def-ipython2\.7-switch-test\")
foo()"))
  (py-bug-tests-intern 'py-execute-def-ipython2\.7-switch-base arg teststring)))

(defun py-execute-def-ipython2\.7-switch-base (arg)
  (py-execute-def-ipython2\.7-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-def-ipython2\.7-switch-test" nil nil 1) nil "py-execute-def-ipython2\.7-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-def-ipython2\.7-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "def foo (): print(\"I'm the py-execute-def-ipython2\.7-no-switch-test\")
foo()"))
  (py-bug-tests-intern 'py-execute-def-ipython2\.7-no-switch-base arg teststring)))

(defun py-execute-def-ipython2\.7-no-switch-base (arg)
  (py-execute-def-ipython2\.7-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-def-ipython2\.7-no-switch-test" nil nil 1) nil "py-execute-def-ipython2\.7-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-def-ipython2\.7-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "def foo (): print(\"I'm the py-execute-def-ipython2\.7-dedicated-test\")
foo()"))
  (py-bug-tests-intern 'py-execute-def-ipython2\.7-dedicated-base arg teststring)))

(defun py-execute-def-ipython2\.7-dedicated-base (arg)
  (py-execute-def-ipython2\.7-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-def-ipython2\.7-dedicated-test" nil nil 1) nil "py-execute-def-ipython2\.7-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-def-ipython2\.7-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "def foo (): print(\"I'm the py-execute-def-ipython2\.7-dedicated-switch-test\")
foo()"))
  (py-bug-tests-intern 'py-execute-def-ipython2\.7-dedicated-switch-base arg teststring)))

(defun py-execute-def-ipython2\.7-dedicated-switch-base (arg)
  (py-execute-def-ipython2\.7-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-def-ipython2\.7-dedicated-switch-test" nil nil 1) nil "py-execute-def-ipython2\.7-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-def-ipython3-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "def foo (): print(\"I'm the py-execute-def-ipython3-test\")
foo()"))
  (py-bug-tests-intern 'py-execute-def-ipython3-base arg teststring)))

(defun py-execute-def-ipython3-base (arg)
  (py-execute-def-ipython3)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-def-ipython3-test" nil nil 1) nil "py-execute-def-ipython3-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-def-ipython3-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "def foo (): print(\"I'm the py-execute-def-ipython3-switch-test\")
foo()"))
  (py-bug-tests-intern 'py-execute-def-ipython3-switch-base arg teststring)))

(defun py-execute-def-ipython3-switch-base (arg)
  (py-execute-def-ipython3-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-def-ipython3-switch-test" nil nil 1) nil "py-execute-def-ipython3-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-def-ipython3-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "def foo (): print(\"I'm the py-execute-def-ipython3-no-switch-test\")
foo()"))
  (py-bug-tests-intern 'py-execute-def-ipython3-no-switch-base arg teststring)))

(defun py-execute-def-ipython3-no-switch-base (arg)
  (py-execute-def-ipython3-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-def-ipython3-no-switch-test" nil nil 1) nil "py-execute-def-ipython3-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-def-ipython3-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "def foo (): print(\"I'm the py-execute-def-ipython3-dedicated-test\")
foo()"))
  (py-bug-tests-intern 'py-execute-def-ipython3-dedicated-base arg teststring)))

(defun py-execute-def-ipython3-dedicated-base (arg)
  (py-execute-def-ipython3-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-def-ipython3-dedicated-test" nil nil 1) nil "py-execute-def-ipython3-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-def-ipython3-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "def foo (): print(\"I'm the py-execute-def-ipython3-dedicated-switch-test\")
foo()"))
  (py-bug-tests-intern 'py-execute-def-ipython3-dedicated-switch-base arg teststring)))

(defun py-execute-def-ipython3-dedicated-switch-base (arg)
  (py-execute-def-ipython3-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-def-ipython3-dedicated-switch-test" nil nil 1) nil "py-execute-def-ipython3-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-def-jython-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "def foo (): print(\"I'm the py-execute-def-jython-test\")
foo()"))
  (py-bug-tests-intern 'py-execute-def-jython-base arg teststring)))

(defun py-execute-def-jython-base (arg)
  (py-execute-def-jython)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-def-jython-test" nil nil 1) nil "py-execute-def-jython-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-def-jython-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "def foo (): print(\"I'm the py-execute-def-jython-switch-test\")
foo()"))
  (py-bug-tests-intern 'py-execute-def-jython-switch-base arg teststring)))

(defun py-execute-def-jython-switch-base (arg)
  (py-execute-def-jython-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-def-jython-switch-test" nil nil 1) nil "py-execute-def-jython-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-def-jython-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "def foo (): print(\"I'm the py-execute-def-jython-no-switch-test\")
foo()"))
  (py-bug-tests-intern 'py-execute-def-jython-no-switch-base arg teststring)))

(defun py-execute-def-jython-no-switch-base (arg)
  (py-execute-def-jython-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-def-jython-no-switch-test" nil nil 1) nil "py-execute-def-jython-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-def-jython-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "def foo (): print(\"I'm the py-execute-def-jython-dedicated-test\")
foo()"))
  (py-bug-tests-intern 'py-execute-def-jython-dedicated-base arg teststring)))

(defun py-execute-def-jython-dedicated-base (arg)
  (py-execute-def-jython-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-def-jython-dedicated-test" nil nil 1) nil "py-execute-def-jython-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-def-jython-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "def foo (): print(\"I'm the py-execute-def-jython-dedicated-switch-test\")
foo()"))
  (py-bug-tests-intern 'py-execute-def-jython-dedicated-switch-base arg teststring)))

(defun py-execute-def-jython-dedicated-switch-base (arg)
  (py-execute-def-jython-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-def-jython-dedicated-switch-test" nil nil 1) nil "py-execute-def-jython-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-class-python-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "class foo (): print(\"I'm the py-execute-class-python-test\")"))
  (py-bug-tests-intern 'py-execute-class-python-base arg teststring)))

(defun py-execute-class-python-base (arg)
  (py-execute-class-python)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-class-python-test" nil nil 1) nil "py-execute-class-python-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-class-python-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "class foo (): print(\"I'm the py-execute-class-python-switch-test\")"))
  (py-bug-tests-intern 'py-execute-class-python-switch-base arg teststring)))

(defun py-execute-class-python-switch-base (arg)
  (py-execute-class-python-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-class-python-switch-test" nil nil 1) nil "py-execute-class-python-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-class-python-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "class foo (): print(\"I'm the py-execute-class-python-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-class-python-no-switch-base arg teststring)))

(defun py-execute-class-python-no-switch-base (arg)
  (py-execute-class-python-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-class-python-no-switch-test" nil nil 1) nil "py-execute-class-python-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-class-python-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "class foo (): print(\"I'm the py-execute-class-python-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-class-python-dedicated-base arg teststring)))

(defun py-execute-class-python-dedicated-base (arg)
  (py-execute-class-python-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-class-python-dedicated-test" nil nil 1) nil "py-execute-class-python-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-class-python-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "class foo (): print(\"I'm the py-execute-class-python-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-class-python-dedicated-switch-base arg teststring)))

(defun py-execute-class-python-dedicated-switch-base (arg)
  (py-execute-class-python-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-class-python-dedicated-switch-test" nil nil 1) nil "py-execute-class-python-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-class-python2-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "class foo (): print(\"I'm the py-execute-class-python2-test\")"))
  (py-bug-tests-intern 'py-execute-class-python2-base arg teststring)))

(defun py-execute-class-python2-base (arg)
  (py-execute-class-python2)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-class-python2-test" nil nil 1) nil "py-execute-class-python2-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-class-python2-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "class foo (): print(\"I'm the py-execute-class-python2-switch-test\")"))
  (py-bug-tests-intern 'py-execute-class-python2-switch-base arg teststring)))

(defun py-execute-class-python2-switch-base (arg)
  (py-execute-class-python2-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-class-python2-switch-test" nil nil 1) nil "py-execute-class-python2-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-class-python2-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "class foo (): print(\"I'm the py-execute-class-python2-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-class-python2-no-switch-base arg teststring)))

(defun py-execute-class-python2-no-switch-base (arg)
  (py-execute-class-python2-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-class-python2-no-switch-test" nil nil 1) nil "py-execute-class-python2-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-class-python2-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "class foo (): print(\"I'm the py-execute-class-python2-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-class-python2-dedicated-base arg teststring)))

(defun py-execute-class-python2-dedicated-base (arg)
  (py-execute-class-python2-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-class-python2-dedicated-test" nil nil 1) nil "py-execute-class-python2-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-class-python2-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "class foo (): print(\"I'm the py-execute-class-python2-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-class-python2-dedicated-switch-base arg teststring)))

(defun py-execute-class-python2-dedicated-switch-base (arg)
  (py-execute-class-python2-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-class-python2-dedicated-switch-test" nil nil 1) nil "py-execute-class-python2-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-class-python3-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "class foo (): print(\"I'm the py-execute-class-python3-test\")"))
  (py-bug-tests-intern 'py-execute-class-python3-base arg teststring)))

(defun py-execute-class-python3-base (arg)
  (py-execute-class-python3)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-class-python3-test" nil nil 1) nil "py-execute-class-python3-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-class-python3-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "class foo (): print(\"I'm the py-execute-class-python3-switch-test\")"))
  (py-bug-tests-intern 'py-execute-class-python3-switch-base arg teststring)))

(defun py-execute-class-python3-switch-base (arg)
  (py-execute-class-python3-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-class-python3-switch-test" nil nil 1) nil "py-execute-class-python3-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-class-python3-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "class foo (): print(\"I'm the py-execute-class-python3-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-class-python3-no-switch-base arg teststring)))

(defun py-execute-class-python3-no-switch-base (arg)
  (py-execute-class-python3-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-class-python3-no-switch-test" nil nil 1) nil "py-execute-class-python3-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-class-python3-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "class foo (): print(\"I'm the py-execute-class-python3-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-class-python3-dedicated-base arg teststring)))

(defun py-execute-class-python3-dedicated-base (arg)
  (py-execute-class-python3-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-class-python3-dedicated-test" nil nil 1) nil "py-execute-class-python3-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-class-python3-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "class foo (): print(\"I'm the py-execute-class-python3-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-class-python3-dedicated-switch-base arg teststring)))

(defun py-execute-class-python3-dedicated-switch-base (arg)
  (py-execute-class-python3-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-class-python3-dedicated-switch-test" nil nil 1) nil "py-execute-class-python3-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-class-ipython-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "class foo (): print(\"I'm the py-execute-class-ipython-test\")"))
  (py-bug-tests-intern 'py-execute-class-ipython-base arg teststring)))

(defun py-execute-class-ipython-base (arg)
  (py-execute-class-ipython)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-class-ipython-test" nil nil 1) nil "py-execute-class-ipython-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-class-ipython-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "class foo (): print(\"I'm the py-execute-class-ipython-switch-test\")"))
  (py-bug-tests-intern 'py-execute-class-ipython-switch-base arg teststring)))

(defun py-execute-class-ipython-switch-base (arg)
  (py-execute-class-ipython-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-class-ipython-switch-test" nil nil 1) nil "py-execute-class-ipython-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-class-ipython-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "class foo (): print(\"I'm the py-execute-class-ipython-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-class-ipython-no-switch-base arg teststring)))

(defun py-execute-class-ipython-no-switch-base (arg)
  (py-execute-class-ipython-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-class-ipython-no-switch-test" nil nil 1) nil "py-execute-class-ipython-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-class-ipython-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "class foo (): print(\"I'm the py-execute-class-ipython-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-class-ipython-dedicated-base arg teststring)))

(defun py-execute-class-ipython-dedicated-base (arg)
  (py-execute-class-ipython-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-class-ipython-dedicated-test" nil nil 1) nil "py-execute-class-ipython-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-class-ipython-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "class foo (): print(\"I'm the py-execute-class-ipython-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-class-ipython-dedicated-switch-base arg teststring)))

(defun py-execute-class-ipython-dedicated-switch-base (arg)
  (py-execute-class-ipython-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-class-ipython-dedicated-switch-test" nil nil 1) nil "py-execute-class-ipython-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-class-ipython2\.7-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "class foo (): print(\"I'm the py-execute-class-ipython2\.7-test\")"))
  (py-bug-tests-intern 'py-execute-class-ipython2\.7-base arg teststring)))

(defun py-execute-class-ipython2\.7-base (arg)
  (py-execute-class-ipython2\.7)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-class-ipython2\.7-test" nil nil 1) nil "py-execute-class-ipython2\.7-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-class-ipython2\.7-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "class foo (): print(\"I'm the py-execute-class-ipython2\.7-switch-test\")"))
  (py-bug-tests-intern 'py-execute-class-ipython2\.7-switch-base arg teststring)))

(defun py-execute-class-ipython2\.7-switch-base (arg)
  (py-execute-class-ipython2\.7-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-class-ipython2\.7-switch-test" nil nil 1) nil "py-execute-class-ipython2\.7-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-class-ipython2\.7-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "class foo (): print(\"I'm the py-execute-class-ipython2\.7-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-class-ipython2\.7-no-switch-base arg teststring)))

(defun py-execute-class-ipython2\.7-no-switch-base (arg)
  (py-execute-class-ipython2\.7-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-class-ipython2\.7-no-switch-test" nil nil 1) nil "py-execute-class-ipython2\.7-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-class-ipython2\.7-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "class foo (): print(\"I'm the py-execute-class-ipython2\.7-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-class-ipython2\.7-dedicated-base arg teststring)))

(defun py-execute-class-ipython2\.7-dedicated-base (arg)
  (py-execute-class-ipython2\.7-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-class-ipython2\.7-dedicated-test" nil nil 1) nil "py-execute-class-ipython2\.7-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-class-ipython2\.7-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "class foo (): print(\"I'm the py-execute-class-ipython2\.7-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-class-ipython2\.7-dedicated-switch-base arg teststring)))

(defun py-execute-class-ipython2\.7-dedicated-switch-base (arg)
  (py-execute-class-ipython2\.7-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-class-ipython2\.7-dedicated-switch-test" nil nil 1) nil "py-execute-class-ipython2\.7-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-class-ipython3-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "class foo (): print(\"I'm the py-execute-class-ipython3-test\")"))
  (py-bug-tests-intern 'py-execute-class-ipython3-base arg teststring)))

(defun py-execute-class-ipython3-base (arg)
  (py-execute-class-ipython3)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-class-ipython3-test" nil nil 1) nil "py-execute-class-ipython3-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-class-ipython3-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "class foo (): print(\"I'm the py-execute-class-ipython3-switch-test\")"))
  (py-bug-tests-intern 'py-execute-class-ipython3-switch-base arg teststring)))

(defun py-execute-class-ipython3-switch-base (arg)
  (py-execute-class-ipython3-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-class-ipython3-switch-test" nil nil 1) nil "py-execute-class-ipython3-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-class-ipython3-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "class foo (): print(\"I'm the py-execute-class-ipython3-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-class-ipython3-no-switch-base arg teststring)))

(defun py-execute-class-ipython3-no-switch-base (arg)
  (py-execute-class-ipython3-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-class-ipython3-no-switch-test" nil nil 1) nil "py-execute-class-ipython3-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-class-ipython3-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "class foo (): print(\"I'm the py-execute-class-ipython3-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-class-ipython3-dedicated-base arg teststring)))

(defun py-execute-class-ipython3-dedicated-base (arg)
  (py-execute-class-ipython3-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-class-ipython3-dedicated-test" nil nil 1) nil "py-execute-class-ipython3-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-class-ipython3-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "class foo (): print(\"I'm the py-execute-class-ipython3-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-class-ipython3-dedicated-switch-base arg teststring)))

(defun py-execute-class-ipython3-dedicated-switch-base (arg)
  (py-execute-class-ipython3-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-class-ipython3-dedicated-switch-test" nil nil 1) nil "py-execute-class-ipython3-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-class-jython-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "class foo (): print(\"I'm the py-execute-class-jython-test\")"))
  (py-bug-tests-intern 'py-execute-class-jython-base arg teststring)))

(defun py-execute-class-jython-base (arg)
  (py-execute-class-jython)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-class-jython-test" nil nil 1) nil "py-execute-class-jython-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-class-jython-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "class foo (): print(\"I'm the py-execute-class-jython-switch-test\")"))
  (py-bug-tests-intern 'py-execute-class-jython-switch-base arg teststring)))

(defun py-execute-class-jython-switch-base (arg)
  (py-execute-class-jython-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-class-jython-switch-test" nil nil 1) nil "py-execute-class-jython-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-class-jython-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "class foo (): print(\"I'm the py-execute-class-jython-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-class-jython-no-switch-base arg teststring)))

(defun py-execute-class-jython-no-switch-base (arg)
  (py-execute-class-jython-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-class-jython-no-switch-test" nil nil 1) nil "py-execute-class-jython-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-class-jython-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "class foo (): print(\"I'm the py-execute-class-jython-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-class-jython-dedicated-base arg teststring)))

(defun py-execute-class-jython-dedicated-base (arg)
  (py-execute-class-jython-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-class-jython-dedicated-test" nil nil 1) nil "py-execute-class-jython-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-class-jython-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "class foo (): print(\"I'm the py-execute-class-jython-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-class-jython-dedicated-switch-base arg teststring)))

(defun py-execute-class-jython-dedicated-switch-base (arg)
  (py-execute-class-jython-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-class-jython-dedicated-switch-test" nil nil 1) nil "py-execute-class-jython-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-def-or-class-python-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "def foo (): print(\"I'm the py-execute-def-or-class-python-test\")
foo()"))
  (py-bug-tests-intern 'py-execute-def-or-class-python-base arg teststring)))

(defun py-execute-def-or-class-python-base (arg)
  (py-execute-def-or-class-python)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-def-or-class-python-test" nil nil 1) nil "py-execute-def-or-class-python-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-def-or-class-python-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "def foo (): print(\"I'm the py-execute-def-or-class-python-switch-test\")
foo()"))
  (py-bug-tests-intern 'py-execute-def-or-class-python-switch-base arg teststring)))

(defun py-execute-def-or-class-python-switch-base (arg)
  (py-execute-def-or-class-python-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-def-or-class-python-switch-test" nil nil 1) nil "py-execute-def-or-class-python-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-def-or-class-python-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "def foo (): print(\"I'm the py-execute-def-or-class-python-no-switch-test\")
foo()"))
  (py-bug-tests-intern 'py-execute-def-or-class-python-no-switch-base arg teststring)))

(defun py-execute-def-or-class-python-no-switch-base (arg)
  (py-execute-def-or-class-python-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-def-or-class-python-no-switch-test" nil nil 1) nil "py-execute-def-or-class-python-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-def-or-class-python-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "def foo (): print(\"I'm the py-execute-def-or-class-python-dedicated-test\")
foo()"))
  (py-bug-tests-intern 'py-execute-def-or-class-python-dedicated-base arg teststring)))

(defun py-execute-def-or-class-python-dedicated-base (arg)
  (py-execute-def-or-class-python-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-def-or-class-python-dedicated-test" nil nil 1) nil "py-execute-def-or-class-python-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-def-or-class-python-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "def foo (): print(\"I'm the py-execute-def-or-class-python-dedicated-switch-test\")
foo()"))
  (py-bug-tests-intern 'py-execute-def-or-class-python-dedicated-switch-base arg teststring)))

(defun py-execute-def-or-class-python-dedicated-switch-base (arg)
  (py-execute-def-or-class-python-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-def-or-class-python-dedicated-switch-test" nil nil 1) nil "py-execute-def-or-class-python-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-def-or-class-python2-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "def foo (): print(\"I'm the py-execute-def-or-class-python2-test\")
foo()"))
  (py-bug-tests-intern 'py-execute-def-or-class-python2-base arg teststring)))

(defun py-execute-def-or-class-python2-base (arg)
  (py-execute-def-or-class-python2)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-def-or-class-python2-test" nil nil 1) nil "py-execute-def-or-class-python2-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-def-or-class-python2-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "def foo (): print(\"I'm the py-execute-def-or-class-python2-switch-test\")
foo()"))
  (py-bug-tests-intern 'py-execute-def-or-class-python2-switch-base arg teststring)))

(defun py-execute-def-or-class-python2-switch-base (arg)
  (py-execute-def-or-class-python2-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-def-or-class-python2-switch-test" nil nil 1) nil "py-execute-def-or-class-python2-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-def-or-class-python2-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "def foo (): print(\"I'm the py-execute-def-or-class-python2-no-switch-test\")
foo()"))
  (py-bug-tests-intern 'py-execute-def-or-class-python2-no-switch-base arg teststring)))

(defun py-execute-def-or-class-python2-no-switch-base (arg)
  (py-execute-def-or-class-python2-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-def-or-class-python2-no-switch-test" nil nil 1) nil "py-execute-def-or-class-python2-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-def-or-class-python2-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "def foo (): print(\"I'm the py-execute-def-or-class-python2-dedicated-test\")
foo()"))
  (py-bug-tests-intern 'py-execute-def-or-class-python2-dedicated-base arg teststring)))

(defun py-execute-def-or-class-python2-dedicated-base (arg)
  (py-execute-def-or-class-python2-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-def-or-class-python2-dedicated-test" nil nil 1) nil "py-execute-def-or-class-python2-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-def-or-class-python2-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "def foo (): print(\"I'm the py-execute-def-or-class-python2-dedicated-switch-test\")
foo()"))
  (py-bug-tests-intern 'py-execute-def-or-class-python2-dedicated-switch-base arg teststring)))

(defun py-execute-def-or-class-python2-dedicated-switch-base (arg)
  (py-execute-def-or-class-python2-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-def-or-class-python2-dedicated-switch-test" nil nil 1) nil "py-execute-def-or-class-python2-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-def-or-class-python3-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "def foo (): print(\"I'm the py-execute-def-or-class-python3-test\")
foo()"))
  (py-bug-tests-intern 'py-execute-def-or-class-python3-base arg teststring)))

(defun py-execute-def-or-class-python3-base (arg)
  (py-execute-def-or-class-python3)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-def-or-class-python3-test" nil nil 1) nil "py-execute-def-or-class-python3-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-def-or-class-python3-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "def foo (): print(\"I'm the py-execute-def-or-class-python3-switch-test\")
foo()"))
  (py-bug-tests-intern 'py-execute-def-or-class-python3-switch-base arg teststring)))

(defun py-execute-def-or-class-python3-switch-base (arg)
  (py-execute-def-or-class-python3-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-def-or-class-python3-switch-test" nil nil 1) nil "py-execute-def-or-class-python3-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-def-or-class-python3-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "def foo (): print(\"I'm the py-execute-def-or-class-python3-no-switch-test\")
foo()"))
  (py-bug-tests-intern 'py-execute-def-or-class-python3-no-switch-base arg teststring)))

(defun py-execute-def-or-class-python3-no-switch-base (arg)
  (py-execute-def-or-class-python3-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-def-or-class-python3-no-switch-test" nil nil 1) nil "py-execute-def-or-class-python3-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-def-or-class-python3-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "def foo (): print(\"I'm the py-execute-def-or-class-python3-dedicated-test\")
foo()"))
  (py-bug-tests-intern 'py-execute-def-or-class-python3-dedicated-base arg teststring)))

(defun py-execute-def-or-class-python3-dedicated-base (arg)
  (py-execute-def-or-class-python3-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-def-or-class-python3-dedicated-test" nil nil 1) nil "py-execute-def-or-class-python3-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-def-or-class-python3-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "def foo (): print(\"I'm the py-execute-def-or-class-python3-dedicated-switch-test\")
foo()"))
  (py-bug-tests-intern 'py-execute-def-or-class-python3-dedicated-switch-base arg teststring)))

(defun py-execute-def-or-class-python3-dedicated-switch-base (arg)
  (py-execute-def-or-class-python3-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-def-or-class-python3-dedicated-switch-test" nil nil 1) nil "py-execute-def-or-class-python3-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-def-or-class-ipython-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "def foo (): print(\"I'm the py-execute-def-or-class-ipython-test\")
foo()"))
  (py-bug-tests-intern 'py-execute-def-or-class-ipython-base arg teststring)))

(defun py-execute-def-or-class-ipython-base (arg)
  (py-execute-def-or-class-ipython)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-def-or-class-ipython-test" nil nil 1) nil "py-execute-def-or-class-ipython-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-def-or-class-ipython-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "def foo (): print(\"I'm the py-execute-def-or-class-ipython-switch-test\")
foo()"))
  (py-bug-tests-intern 'py-execute-def-or-class-ipython-switch-base arg teststring)))

(defun py-execute-def-or-class-ipython-switch-base (arg)
  (py-execute-def-or-class-ipython-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-def-or-class-ipython-switch-test" nil nil 1) nil "py-execute-def-or-class-ipython-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-def-or-class-ipython-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "def foo (): print(\"I'm the py-execute-def-or-class-ipython-no-switch-test\")
foo()"))
  (py-bug-tests-intern 'py-execute-def-or-class-ipython-no-switch-base arg teststring)))

(defun py-execute-def-or-class-ipython-no-switch-base (arg)
  (py-execute-def-or-class-ipython-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-def-or-class-ipython-no-switch-test" nil nil 1) nil "py-execute-def-or-class-ipython-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-def-or-class-ipython-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "def foo (): print(\"I'm the py-execute-def-or-class-ipython-dedicated-test\")
foo()"))
  (py-bug-tests-intern 'py-execute-def-or-class-ipython-dedicated-base arg teststring)))

(defun py-execute-def-or-class-ipython-dedicated-base (arg)
  (py-execute-def-or-class-ipython-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-def-or-class-ipython-dedicated-test" nil nil 1) nil "py-execute-def-or-class-ipython-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-def-or-class-ipython-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "def foo (): print(\"I'm the py-execute-def-or-class-ipython-dedicated-switch-test\")
foo()"))
  (py-bug-tests-intern 'py-execute-def-or-class-ipython-dedicated-switch-base arg teststring)))

(defun py-execute-def-or-class-ipython-dedicated-switch-base (arg)
  (py-execute-def-or-class-ipython-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-def-or-class-ipython-dedicated-switch-test" nil nil 1) nil "py-execute-def-or-class-ipython-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-def-or-class-ipython2\.7-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "def foo (): print(\"I'm the py-execute-def-or-class-ipython2\.7-test\")
foo()"))
  (py-bug-tests-intern 'py-execute-def-or-class-ipython2\.7-base arg teststring)))

(defun py-execute-def-or-class-ipython2\.7-base (arg)
  (py-execute-def-or-class-ipython2\.7)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-def-or-class-ipython2\.7-test" nil nil 1) nil "py-execute-def-or-class-ipython2\.7-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-def-or-class-ipython2\.7-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "def foo (): print(\"I'm the py-execute-def-or-class-ipython2\.7-switch-test\")
foo()"))
  (py-bug-tests-intern 'py-execute-def-or-class-ipython2\.7-switch-base arg teststring)))

(defun py-execute-def-or-class-ipython2\.7-switch-base (arg)
  (py-execute-def-or-class-ipython2\.7-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-def-or-class-ipython2\.7-switch-test" nil nil 1) nil "py-execute-def-or-class-ipython2\.7-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-def-or-class-ipython2\.7-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "def foo (): print(\"I'm the py-execute-def-or-class-ipython2\.7-no-switch-test\")
foo()"))
  (py-bug-tests-intern 'py-execute-def-or-class-ipython2\.7-no-switch-base arg teststring)))

(defun py-execute-def-or-class-ipython2\.7-no-switch-base (arg)
  (py-execute-def-or-class-ipython2\.7-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-def-or-class-ipython2\.7-no-switch-test" nil nil 1) nil "py-execute-def-or-class-ipython2\.7-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-def-or-class-ipython2\.7-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "def foo (): print(\"I'm the py-execute-def-or-class-ipython2\.7-dedicated-test\")
foo()"))
  (py-bug-tests-intern 'py-execute-def-or-class-ipython2\.7-dedicated-base arg teststring)))

(defun py-execute-def-or-class-ipython2\.7-dedicated-base (arg)
  (py-execute-def-or-class-ipython2\.7-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-def-or-class-ipython2\.7-dedicated-test" nil nil 1) nil "py-execute-def-or-class-ipython2\.7-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-def-or-class-ipython2\.7-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "def foo (): print(\"I'm the py-execute-def-or-class-ipython2\.7-dedicated-switch-test\")
foo()"))
  (py-bug-tests-intern 'py-execute-def-or-class-ipython2\.7-dedicated-switch-base arg teststring)))

(defun py-execute-def-or-class-ipython2\.7-dedicated-switch-base (arg)
  (py-execute-def-or-class-ipython2\.7-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-def-or-class-ipython2\.7-dedicated-switch-test" nil nil 1) nil "py-execute-def-or-class-ipython2\.7-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-def-or-class-ipython3-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "def foo (): print(\"I'm the py-execute-def-or-class-ipython3-test\")
foo()"))
  (py-bug-tests-intern 'py-execute-def-or-class-ipython3-base arg teststring)))

(defun py-execute-def-or-class-ipython3-base (arg)
  (py-execute-def-or-class-ipython3)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-def-or-class-ipython3-test" nil nil 1) nil "py-execute-def-or-class-ipython3-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-def-or-class-ipython3-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "def foo (): print(\"I'm the py-execute-def-or-class-ipython3-switch-test\")
foo()"))
  (py-bug-tests-intern 'py-execute-def-or-class-ipython3-switch-base arg teststring)))

(defun py-execute-def-or-class-ipython3-switch-base (arg)
  (py-execute-def-or-class-ipython3-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-def-or-class-ipython3-switch-test" nil nil 1) nil "py-execute-def-or-class-ipython3-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-def-or-class-ipython3-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "def foo (): print(\"I'm the py-execute-def-or-class-ipython3-no-switch-test\")
foo()"))
  (py-bug-tests-intern 'py-execute-def-or-class-ipython3-no-switch-base arg teststring)))

(defun py-execute-def-or-class-ipython3-no-switch-base (arg)
  (py-execute-def-or-class-ipython3-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-def-or-class-ipython3-no-switch-test" nil nil 1) nil "py-execute-def-or-class-ipython3-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-def-or-class-ipython3-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "def foo (): print(\"I'm the py-execute-def-or-class-ipython3-dedicated-test\")
foo()"))
  (py-bug-tests-intern 'py-execute-def-or-class-ipython3-dedicated-base arg teststring)))

(defun py-execute-def-or-class-ipython3-dedicated-base (arg)
  (py-execute-def-or-class-ipython3-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-def-or-class-ipython3-dedicated-test" nil nil 1) nil "py-execute-def-or-class-ipython3-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-def-or-class-ipython3-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "def foo (): print(\"I'm the py-execute-def-or-class-ipython3-dedicated-switch-test\")
foo()"))
  (py-bug-tests-intern 'py-execute-def-or-class-ipython3-dedicated-switch-base arg teststring)))

(defun py-execute-def-or-class-ipython3-dedicated-switch-base (arg)
  (py-execute-def-or-class-ipython3-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-def-or-class-ipython3-dedicated-switch-test" nil nil 1) nil "py-execute-def-or-class-ipython3-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-def-or-class-jython-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "def foo (): print(\"I'm the py-execute-def-or-class-jython-test\")
foo()"))
  (py-bug-tests-intern 'py-execute-def-or-class-jython-base arg teststring)))

(defun py-execute-def-or-class-jython-base (arg)
  (py-execute-def-or-class-jython)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-def-or-class-jython-test" nil nil 1) nil "py-execute-def-or-class-jython-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-def-or-class-jython-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "def foo (): print(\"I'm the py-execute-def-or-class-jython-switch-test\")
foo()"))
  (py-bug-tests-intern 'py-execute-def-or-class-jython-switch-base arg teststring)))

(defun py-execute-def-or-class-jython-switch-base (arg)
  (py-execute-def-or-class-jython-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-def-or-class-jython-switch-test" nil nil 1) nil "py-execute-def-or-class-jython-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-def-or-class-jython-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "def foo (): print(\"I'm the py-execute-def-or-class-jython-no-switch-test\")
foo()"))
  (py-bug-tests-intern 'py-execute-def-or-class-jython-no-switch-base arg teststring)))

(defun py-execute-def-or-class-jython-no-switch-base (arg)
  (py-execute-def-or-class-jython-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-def-or-class-jython-no-switch-test" nil nil 1) nil "py-execute-def-or-class-jython-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-def-or-class-jython-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "def foo (): print(\"I'm the py-execute-def-or-class-jython-dedicated-test\")
foo()"))
  (py-bug-tests-intern 'py-execute-def-or-class-jython-dedicated-base arg teststring)))

(defun py-execute-def-or-class-jython-dedicated-base (arg)
  (py-execute-def-or-class-jython-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-def-or-class-jython-dedicated-test" nil nil 1) nil "py-execute-def-or-class-jython-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-def-or-class-jython-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "def foo (): print(\"I'm the py-execute-def-or-class-jython-dedicated-switch-test\")
foo()"))
  (py-bug-tests-intern 'py-execute-def-or-class-jython-dedicated-switch-base arg teststring)))

(defun py-execute-def-or-class-jython-dedicated-switch-base (arg)
  (py-execute-def-or-class-jython-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-def-or-class-jython-dedicated-switch-test" nil nil 1) nil "py-execute-def-or-class-jython-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-buffer-python-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-buffer-python-test\")"))
  (py-bug-tests-intern 'py-execute-buffer-python-base arg teststring)))

(defun py-execute-buffer-python-base (arg)
  (py-execute-buffer-python)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-buffer-python-test" nil nil 1) nil "py-execute-buffer-python-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-buffer-python-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-buffer-python-switch-test\")"))
  (py-bug-tests-intern 'py-execute-buffer-python-switch-base arg teststring)))

(defun py-execute-buffer-python-switch-base (arg)
  (py-execute-buffer-python-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-buffer-python-switch-test" nil nil 1) nil "py-execute-buffer-python-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-buffer-python-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-buffer-python-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-buffer-python-no-switch-base arg teststring)))

(defun py-execute-buffer-python-no-switch-base (arg)
  (py-execute-buffer-python-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-buffer-python-no-switch-test" nil nil 1) nil "py-execute-buffer-python-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-buffer-python-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-buffer-python-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-buffer-python-dedicated-base arg teststring)))

(defun py-execute-buffer-python-dedicated-base (arg)
  (py-execute-buffer-python-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-buffer-python-dedicated-test" nil nil 1) nil "py-execute-buffer-python-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-buffer-python-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-buffer-python-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-buffer-python-dedicated-switch-base arg teststring)))

(defun py-execute-buffer-python-dedicated-switch-base (arg)
  (py-execute-buffer-python-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-buffer-python-dedicated-switch-test" nil nil 1) nil "py-execute-buffer-python-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-buffer-python2-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-buffer-python2-test\")"))
  (py-bug-tests-intern 'py-execute-buffer-python2-base arg teststring)))

(defun py-execute-buffer-python2-base (arg)
  (py-execute-buffer-python2)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-buffer-python2-test" nil nil 1) nil "py-execute-buffer-python2-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-buffer-python2-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-buffer-python2-switch-test\")"))
  (py-bug-tests-intern 'py-execute-buffer-python2-switch-base arg teststring)))

(defun py-execute-buffer-python2-switch-base (arg)
  (py-execute-buffer-python2-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-buffer-python2-switch-test" nil nil 1) nil "py-execute-buffer-python2-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-buffer-python2-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-buffer-python2-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-buffer-python2-no-switch-base arg teststring)))

(defun py-execute-buffer-python2-no-switch-base (arg)
  (py-execute-buffer-python2-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-buffer-python2-no-switch-test" nil nil 1) nil "py-execute-buffer-python2-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-buffer-python2-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-buffer-python2-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-buffer-python2-dedicated-base arg teststring)))

(defun py-execute-buffer-python2-dedicated-base (arg)
  (py-execute-buffer-python2-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-buffer-python2-dedicated-test" nil nil 1) nil "py-execute-buffer-python2-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-buffer-python2-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-buffer-python2-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-buffer-python2-dedicated-switch-base arg teststring)))

(defun py-execute-buffer-python2-dedicated-switch-base (arg)
  (py-execute-buffer-python2-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-buffer-python2-dedicated-switch-test" nil nil 1) nil "py-execute-buffer-python2-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-buffer-python3-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-buffer-python3-test\")"))
  (py-bug-tests-intern 'py-execute-buffer-python3-base arg teststring)))

(defun py-execute-buffer-python3-base (arg)
  (py-execute-buffer-python3)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-buffer-python3-test" nil nil 1) nil "py-execute-buffer-python3-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-buffer-python3-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-buffer-python3-switch-test\")"))
  (py-bug-tests-intern 'py-execute-buffer-python3-switch-base arg teststring)))

(defun py-execute-buffer-python3-switch-base (arg)
  (py-execute-buffer-python3-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-buffer-python3-switch-test" nil nil 1) nil "py-execute-buffer-python3-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-buffer-python3-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-buffer-python3-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-buffer-python3-no-switch-base arg teststring)))

(defun py-execute-buffer-python3-no-switch-base (arg)
  (py-execute-buffer-python3-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-buffer-python3-no-switch-test" nil nil 1) nil "py-execute-buffer-python3-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-buffer-python3-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-buffer-python3-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-buffer-python3-dedicated-base arg teststring)))

(defun py-execute-buffer-python3-dedicated-base (arg)
  (py-execute-buffer-python3-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-buffer-python3-dedicated-test" nil nil 1) nil "py-execute-buffer-python3-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-buffer-python3-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-buffer-python3-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-buffer-python3-dedicated-switch-base arg teststring)))

(defun py-execute-buffer-python3-dedicated-switch-base (arg)
  (py-execute-buffer-python3-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-buffer-python3-dedicated-switch-test" nil nil 1) nil "py-execute-buffer-python3-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-buffer-ipython-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-buffer-ipython-test\")"))
  (py-bug-tests-intern 'py-execute-buffer-ipython-base arg teststring)))

(defun py-execute-buffer-ipython-base (arg)
  (py-execute-buffer-ipython)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-buffer-ipython-test" nil nil 1) nil "py-execute-buffer-ipython-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-buffer-ipython-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-buffer-ipython-switch-test\")"))
  (py-bug-tests-intern 'py-execute-buffer-ipython-switch-base arg teststring)))

(defun py-execute-buffer-ipython-switch-base (arg)
  (py-execute-buffer-ipython-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-buffer-ipython-switch-test" nil nil 1) nil "py-execute-buffer-ipython-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-buffer-ipython-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-buffer-ipython-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-buffer-ipython-no-switch-base arg teststring)))

(defun py-execute-buffer-ipython-no-switch-base (arg)
  (py-execute-buffer-ipython-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-buffer-ipython-no-switch-test" nil nil 1) nil "py-execute-buffer-ipython-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-buffer-ipython-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-buffer-ipython-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-buffer-ipython-dedicated-base arg teststring)))

(defun py-execute-buffer-ipython-dedicated-base (arg)
  (py-execute-buffer-ipython-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-buffer-ipython-dedicated-test" nil nil 1) nil "py-execute-buffer-ipython-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-buffer-ipython-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-buffer-ipython-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-buffer-ipython-dedicated-switch-base arg teststring)))

(defun py-execute-buffer-ipython-dedicated-switch-base (arg)
  (py-execute-buffer-ipython-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-buffer-ipython-dedicated-switch-test" nil nil 1) nil "py-execute-buffer-ipython-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-buffer-ipython2\.7-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-buffer-ipython2\.7-test\")"))
  (py-bug-tests-intern 'py-execute-buffer-ipython2\.7-base arg teststring)))

(defun py-execute-buffer-ipython2\.7-base (arg)
  (py-execute-buffer-ipython2\.7)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-buffer-ipython2\.7-test" nil nil 1) nil "py-execute-buffer-ipython2\.7-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-buffer-ipython2\.7-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-buffer-ipython2\.7-switch-test\")"))
  (py-bug-tests-intern 'py-execute-buffer-ipython2\.7-switch-base arg teststring)))

(defun py-execute-buffer-ipython2\.7-switch-base (arg)
  (py-execute-buffer-ipython2\.7-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-buffer-ipython2\.7-switch-test" nil nil 1) nil "py-execute-buffer-ipython2\.7-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-buffer-ipython2\.7-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-buffer-ipython2\.7-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-buffer-ipython2\.7-no-switch-base arg teststring)))

(defun py-execute-buffer-ipython2\.7-no-switch-base (arg)
  (py-execute-buffer-ipython2\.7-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-buffer-ipython2\.7-no-switch-test" nil nil 1) nil "py-execute-buffer-ipython2\.7-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-buffer-ipython2\.7-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-buffer-ipython2\.7-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-buffer-ipython2\.7-dedicated-base arg teststring)))

(defun py-execute-buffer-ipython2\.7-dedicated-base (arg)
  (py-execute-buffer-ipython2\.7-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-buffer-ipython2\.7-dedicated-test" nil nil 1) nil "py-execute-buffer-ipython2\.7-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-buffer-ipython2\.7-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-buffer-ipython2\.7-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-buffer-ipython2\.7-dedicated-switch-base arg teststring)))

(defun py-execute-buffer-ipython2\.7-dedicated-switch-base (arg)
  (py-execute-buffer-ipython2\.7-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-buffer-ipython2\.7-dedicated-switch-test" nil nil 1) nil "py-execute-buffer-ipython2\.7-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-buffer-ipython3-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-buffer-ipython3-test\")"))
  (py-bug-tests-intern 'py-execute-buffer-ipython3-base arg teststring)))

(defun py-execute-buffer-ipython3-base (arg)
  (py-execute-buffer-ipython3)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-buffer-ipython3-test" nil nil 1) nil "py-execute-buffer-ipython3-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-buffer-ipython3-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-buffer-ipython3-switch-test\")"))
  (py-bug-tests-intern 'py-execute-buffer-ipython3-switch-base arg teststring)))

(defun py-execute-buffer-ipython3-switch-base (arg)
  (py-execute-buffer-ipython3-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-buffer-ipython3-switch-test" nil nil 1) nil "py-execute-buffer-ipython3-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-buffer-ipython3-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-buffer-ipython3-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-buffer-ipython3-no-switch-base arg teststring)))

(defun py-execute-buffer-ipython3-no-switch-base (arg)
  (py-execute-buffer-ipython3-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-buffer-ipython3-no-switch-test" nil nil 1) nil "py-execute-buffer-ipython3-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-buffer-ipython3-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-buffer-ipython3-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-buffer-ipython3-dedicated-base arg teststring)))

(defun py-execute-buffer-ipython3-dedicated-base (arg)
  (py-execute-buffer-ipython3-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-buffer-ipython3-dedicated-test" nil nil 1) nil "py-execute-buffer-ipython3-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-buffer-ipython3-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-buffer-ipython3-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-buffer-ipython3-dedicated-switch-base arg teststring)))

(defun py-execute-buffer-ipython3-dedicated-switch-base (arg)
  (py-execute-buffer-ipython3-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-buffer-ipython3-dedicated-switch-test" nil nil 1) nil "py-execute-buffer-ipython3-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-buffer-jython-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-buffer-jython-test\")"))
  (py-bug-tests-intern 'py-execute-buffer-jython-base arg teststring)))

(defun py-execute-buffer-jython-base (arg)
  (py-execute-buffer-jython)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-buffer-jython-test" nil nil 1) nil "py-execute-buffer-jython-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-buffer-jython-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-buffer-jython-switch-test\")"))
  (py-bug-tests-intern 'py-execute-buffer-jython-switch-base arg teststring)))

(defun py-execute-buffer-jython-switch-base (arg)
  (py-execute-buffer-jython-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-buffer-jython-switch-test" nil nil 1) nil "py-execute-buffer-jython-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-buffer-jython-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-buffer-jython-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-buffer-jython-no-switch-base arg teststring)))

(defun py-execute-buffer-jython-no-switch-base (arg)
  (py-execute-buffer-jython-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-buffer-jython-no-switch-test" nil nil 1) nil "py-execute-buffer-jython-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-buffer-jython-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-buffer-jython-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-buffer-jython-dedicated-base arg teststring)))

(defun py-execute-buffer-jython-dedicated-base (arg)
  (py-execute-buffer-jython-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-buffer-jython-dedicated-test" nil nil 1) nil "py-execute-buffer-jython-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-buffer-jython-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-buffer-jython-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-buffer-jython-dedicated-switch-base arg teststring)))

(defun py-execute-buffer-jython-dedicated-switch-base (arg)
  (py-execute-buffer-jython-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-buffer-jython-dedicated-switch-test" nil nil 1) nil "py-execute-buffer-jython-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-expression-python-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-expression-python-test\")"))
  (py-bug-tests-intern 'py-execute-expression-python-base arg teststring)))

(defun py-execute-expression-python-base (arg)
  (py-execute-expression-python)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-expression-python-test" nil nil 1) nil "py-execute-expression-python-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-expression-python-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-expression-python-switch-test\")"))
  (py-bug-tests-intern 'py-execute-expression-python-switch-base arg teststring)))

(defun py-execute-expression-python-switch-base (arg)
  (py-execute-expression-python-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-expression-python-switch-test" nil nil 1) nil "py-execute-expression-python-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-expression-python-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-expression-python-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-expression-python-no-switch-base arg teststring)))

(defun py-execute-expression-python-no-switch-base (arg)
  (py-execute-expression-python-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-expression-python-no-switch-test" nil nil 1) nil "py-execute-expression-python-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-expression-python-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-expression-python-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-expression-python-dedicated-base arg teststring)))

(defun py-execute-expression-python-dedicated-base (arg)
  (py-execute-expression-python-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-expression-python-dedicated-test" nil nil 1) nil "py-execute-expression-python-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-expression-python-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-expression-python-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-expression-python-dedicated-switch-base arg teststring)))

(defun py-execute-expression-python-dedicated-switch-base (arg)
  (py-execute-expression-python-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-expression-python-dedicated-switch-test" nil nil 1) nil "py-execute-expression-python-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-expression-python2-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-expression-python2-test\")"))
  (py-bug-tests-intern 'py-execute-expression-python2-base arg teststring)))

(defun py-execute-expression-python2-base (arg)
  (py-execute-expression-python2)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-expression-python2-test" nil nil 1) nil "py-execute-expression-python2-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-expression-python2-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-expression-python2-switch-test\")"))
  (py-bug-tests-intern 'py-execute-expression-python2-switch-base arg teststring)))

(defun py-execute-expression-python2-switch-base (arg)
  (py-execute-expression-python2-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-expression-python2-switch-test" nil nil 1) nil "py-execute-expression-python2-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-expression-python2-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-expression-python2-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-expression-python2-no-switch-base arg teststring)))

(defun py-execute-expression-python2-no-switch-base (arg)
  (py-execute-expression-python2-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-expression-python2-no-switch-test" nil nil 1) nil "py-execute-expression-python2-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-expression-python2-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-expression-python2-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-expression-python2-dedicated-base arg teststring)))

(defun py-execute-expression-python2-dedicated-base (arg)
  (py-execute-expression-python2-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-expression-python2-dedicated-test" nil nil 1) nil "py-execute-expression-python2-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-expression-python2-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-expression-python2-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-expression-python2-dedicated-switch-base arg teststring)))

(defun py-execute-expression-python2-dedicated-switch-base (arg)
  (py-execute-expression-python2-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-expression-python2-dedicated-switch-test" nil nil 1) nil "py-execute-expression-python2-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-expression-python3-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-expression-python3-test\")"))
  (py-bug-tests-intern 'py-execute-expression-python3-base arg teststring)))

(defun py-execute-expression-python3-base (arg)
  (py-execute-expression-python3)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-expression-python3-test" nil nil 1) nil "py-execute-expression-python3-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-expression-python3-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-expression-python3-switch-test\")"))
  (py-bug-tests-intern 'py-execute-expression-python3-switch-base arg teststring)))

(defun py-execute-expression-python3-switch-base (arg)
  (py-execute-expression-python3-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-expression-python3-switch-test" nil nil 1) nil "py-execute-expression-python3-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-expression-python3-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-expression-python3-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-expression-python3-no-switch-base arg teststring)))

(defun py-execute-expression-python3-no-switch-base (arg)
  (py-execute-expression-python3-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-expression-python3-no-switch-test" nil nil 1) nil "py-execute-expression-python3-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-expression-python3-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-expression-python3-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-expression-python3-dedicated-base arg teststring)))

(defun py-execute-expression-python3-dedicated-base (arg)
  (py-execute-expression-python3-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-expression-python3-dedicated-test" nil nil 1) nil "py-execute-expression-python3-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-expression-python3-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-expression-python3-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-expression-python3-dedicated-switch-base arg teststring)))

(defun py-execute-expression-python3-dedicated-switch-base (arg)
  (py-execute-expression-python3-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-expression-python3-dedicated-switch-test" nil nil 1) nil "py-execute-expression-python3-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-expression-ipython-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-expression-ipython-test\")"))
  (py-bug-tests-intern 'py-execute-expression-ipython-base arg teststring)))

(defun py-execute-expression-ipython-base (arg)
  (py-execute-expression-ipython)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-expression-ipython-test" nil nil 1) nil "py-execute-expression-ipython-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-expression-ipython-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-expression-ipython-switch-test\")"))
  (py-bug-tests-intern 'py-execute-expression-ipython-switch-base arg teststring)))

(defun py-execute-expression-ipython-switch-base (arg)
  (py-execute-expression-ipython-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-expression-ipython-switch-test" nil nil 1) nil "py-execute-expression-ipython-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-expression-ipython-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-expression-ipython-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-expression-ipython-no-switch-base arg teststring)))

(defun py-execute-expression-ipython-no-switch-base (arg)
  (py-execute-expression-ipython-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-expression-ipython-no-switch-test" nil nil 1) nil "py-execute-expression-ipython-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-expression-ipython-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-expression-ipython-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-expression-ipython-dedicated-base arg teststring)))

(defun py-execute-expression-ipython-dedicated-base (arg)
  (py-execute-expression-ipython-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-expression-ipython-dedicated-test" nil nil 1) nil "py-execute-expression-ipython-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-expression-ipython-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-expression-ipython-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-expression-ipython-dedicated-switch-base arg teststring)))

(defun py-execute-expression-ipython-dedicated-switch-base (arg)
  (py-execute-expression-ipython-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-expression-ipython-dedicated-switch-test" nil nil 1) nil "py-execute-expression-ipython-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-expression-ipython2\.7-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-expression-ipython2\.7-test\")"))
  (py-bug-tests-intern 'py-execute-expression-ipython2\.7-base arg teststring)))

(defun py-execute-expression-ipython2\.7-base (arg)
  (py-execute-expression-ipython2\.7)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-expression-ipython2\.7-test" nil nil 1) nil "py-execute-expression-ipython2\.7-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-expression-ipython2\.7-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-expression-ipython2\.7-switch-test\")"))
  (py-bug-tests-intern 'py-execute-expression-ipython2\.7-switch-base arg teststring)))

(defun py-execute-expression-ipython2\.7-switch-base (arg)
  (py-execute-expression-ipython2\.7-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-expression-ipython2\.7-switch-test" nil nil 1) nil "py-execute-expression-ipython2\.7-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-expression-ipython2\.7-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-expression-ipython2\.7-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-expression-ipython2\.7-no-switch-base arg teststring)))

(defun py-execute-expression-ipython2\.7-no-switch-base (arg)
  (py-execute-expression-ipython2\.7-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-expression-ipython2\.7-no-switch-test" nil nil 1) nil "py-execute-expression-ipython2\.7-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-expression-ipython2\.7-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-expression-ipython2\.7-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-expression-ipython2\.7-dedicated-base arg teststring)))

(defun py-execute-expression-ipython2\.7-dedicated-base (arg)
  (py-execute-expression-ipython2\.7-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-expression-ipython2\.7-dedicated-test" nil nil 1) nil "py-execute-expression-ipython2\.7-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-expression-ipython2\.7-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-expression-ipython2\.7-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-expression-ipython2\.7-dedicated-switch-base arg teststring)))

(defun py-execute-expression-ipython2\.7-dedicated-switch-base (arg)
  (py-execute-expression-ipython2\.7-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-expression-ipython2\.7-dedicated-switch-test" nil nil 1) nil "py-execute-expression-ipython2\.7-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-expression-ipython3-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-expression-ipython3-test\")"))
  (py-bug-tests-intern 'py-execute-expression-ipython3-base arg teststring)))

(defun py-execute-expression-ipython3-base (arg)
  (py-execute-expression-ipython3)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-expression-ipython3-test" nil nil 1) nil "py-execute-expression-ipython3-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-expression-ipython3-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-expression-ipython3-switch-test\")"))
  (py-bug-tests-intern 'py-execute-expression-ipython3-switch-base arg teststring)))

(defun py-execute-expression-ipython3-switch-base (arg)
  (py-execute-expression-ipython3-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-expression-ipython3-switch-test" nil nil 1) nil "py-execute-expression-ipython3-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-expression-ipython3-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-expression-ipython3-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-expression-ipython3-no-switch-base arg teststring)))

(defun py-execute-expression-ipython3-no-switch-base (arg)
  (py-execute-expression-ipython3-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-expression-ipython3-no-switch-test" nil nil 1) nil "py-execute-expression-ipython3-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-expression-ipython3-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-expression-ipython3-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-expression-ipython3-dedicated-base arg teststring)))

(defun py-execute-expression-ipython3-dedicated-base (arg)
  (py-execute-expression-ipython3-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-expression-ipython3-dedicated-test" nil nil 1) nil "py-execute-expression-ipython3-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-expression-ipython3-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-expression-ipython3-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-expression-ipython3-dedicated-switch-base arg teststring)))

(defun py-execute-expression-ipython3-dedicated-switch-base (arg)
  (py-execute-expression-ipython3-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-expression-ipython3-dedicated-switch-test" nil nil 1) nil "py-execute-expression-ipython3-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-expression-jython-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-expression-jython-test\")"))
  (py-bug-tests-intern 'py-execute-expression-jython-base arg teststring)))

(defun py-execute-expression-jython-base (arg)
  (py-execute-expression-jython)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-expression-jython-test" nil nil 1) nil "py-execute-expression-jython-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-expression-jython-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-expression-jython-switch-test\")"))
  (py-bug-tests-intern 'py-execute-expression-jython-switch-base arg teststring)))

(defun py-execute-expression-jython-switch-base (arg)
  (py-execute-expression-jython-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-expression-jython-switch-test" nil nil 1) nil "py-execute-expression-jython-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-expression-jython-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-expression-jython-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-expression-jython-no-switch-base arg teststring)))

(defun py-execute-expression-jython-no-switch-base (arg)
  (py-execute-expression-jython-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-expression-jython-no-switch-test" nil nil 1) nil "py-execute-expression-jython-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-expression-jython-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-expression-jython-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-expression-jython-dedicated-base arg teststring)))

(defun py-execute-expression-jython-dedicated-base (arg)
  (py-execute-expression-jython-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-expression-jython-dedicated-test" nil nil 1) nil "py-execute-expression-jython-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-expression-jython-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-expression-jython-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-expression-jython-dedicated-switch-base arg teststring)))

(defun py-execute-expression-jython-dedicated-switch-base (arg)
  (py-execute-expression-jython-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-expression-jython-dedicated-switch-test" nil nil 1) nil "py-execute-expression-jython-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-partial-expression-python-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-partial-expression-python-test\")"))
  (py-bug-tests-intern 'py-execute-partial-expression-python-base arg teststring)))

(defun py-execute-partial-expression-python-base (arg)
  (py-execute-partial-expression-python)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-partial-expression-python-test" nil nil 1) nil "py-execute-partial-expression-python-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-partial-expression-python-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-partial-expression-python-switch-test\")"))
  (py-bug-tests-intern 'py-execute-partial-expression-python-switch-base arg teststring)))

(defun py-execute-partial-expression-python-switch-base (arg)
  (py-execute-partial-expression-python-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-partial-expression-python-switch-test" nil nil 1) nil "py-execute-partial-expression-python-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-partial-expression-python-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-partial-expression-python-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-partial-expression-python-no-switch-base arg teststring)))

(defun py-execute-partial-expression-python-no-switch-base (arg)
  (py-execute-partial-expression-python-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-partial-expression-python-no-switch-test" nil nil 1) nil "py-execute-partial-expression-python-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-partial-expression-python-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-partial-expression-python-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-partial-expression-python-dedicated-base arg teststring)))

(defun py-execute-partial-expression-python-dedicated-base (arg)
  (py-execute-partial-expression-python-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-partial-expression-python-dedicated-test" nil nil 1) nil "py-execute-partial-expression-python-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-partial-expression-python-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-partial-expression-python-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-partial-expression-python-dedicated-switch-base arg teststring)))

(defun py-execute-partial-expression-python-dedicated-switch-base (arg)
  (py-execute-partial-expression-python-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-partial-expression-python-dedicated-switch-test" nil nil 1) nil "py-execute-partial-expression-python-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-partial-expression-python2-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-partial-expression-python2-test\")"))
  (py-bug-tests-intern 'py-execute-partial-expression-python2-base arg teststring)))

(defun py-execute-partial-expression-python2-base (arg)
  (py-execute-partial-expression-python2)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-partial-expression-python2-test" nil nil 1) nil "py-execute-partial-expression-python2-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-partial-expression-python2-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-partial-expression-python2-switch-test\")"))
  (py-bug-tests-intern 'py-execute-partial-expression-python2-switch-base arg teststring)))

(defun py-execute-partial-expression-python2-switch-base (arg)
  (py-execute-partial-expression-python2-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-partial-expression-python2-switch-test" nil nil 1) nil "py-execute-partial-expression-python2-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-partial-expression-python2-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-partial-expression-python2-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-partial-expression-python2-no-switch-base arg teststring)))

(defun py-execute-partial-expression-python2-no-switch-base (arg)
  (py-execute-partial-expression-python2-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-partial-expression-python2-no-switch-test" nil nil 1) nil "py-execute-partial-expression-python2-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-partial-expression-python2-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-partial-expression-python2-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-partial-expression-python2-dedicated-base arg teststring)))

(defun py-execute-partial-expression-python2-dedicated-base (arg)
  (py-execute-partial-expression-python2-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-partial-expression-python2-dedicated-test" nil nil 1) nil "py-execute-partial-expression-python2-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-partial-expression-python2-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-partial-expression-python2-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-partial-expression-python2-dedicated-switch-base arg teststring)))

(defun py-execute-partial-expression-python2-dedicated-switch-base (arg)
  (py-execute-partial-expression-python2-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-partial-expression-python2-dedicated-switch-test" nil nil 1) nil "py-execute-partial-expression-python2-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-partial-expression-python3-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-partial-expression-python3-test\")"))
  (py-bug-tests-intern 'py-execute-partial-expression-python3-base arg teststring)))

(defun py-execute-partial-expression-python3-base (arg)
  (py-execute-partial-expression-python3)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-partial-expression-python3-test" nil nil 1) nil "py-execute-partial-expression-python3-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-partial-expression-python3-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-partial-expression-python3-switch-test\")"))
  (py-bug-tests-intern 'py-execute-partial-expression-python3-switch-base arg teststring)))

(defun py-execute-partial-expression-python3-switch-base (arg)
  (py-execute-partial-expression-python3-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-partial-expression-python3-switch-test" nil nil 1) nil "py-execute-partial-expression-python3-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-partial-expression-python3-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-partial-expression-python3-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-partial-expression-python3-no-switch-base arg teststring)))

(defun py-execute-partial-expression-python3-no-switch-base (arg)
  (py-execute-partial-expression-python3-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-partial-expression-python3-no-switch-test" nil nil 1) nil "py-execute-partial-expression-python3-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-partial-expression-python3-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-partial-expression-python3-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-partial-expression-python3-dedicated-base arg teststring)))

(defun py-execute-partial-expression-python3-dedicated-base (arg)
  (py-execute-partial-expression-python3-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-partial-expression-python3-dedicated-test" nil nil 1) nil "py-execute-partial-expression-python3-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-partial-expression-python3-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-partial-expression-python3-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-partial-expression-python3-dedicated-switch-base arg teststring)))

(defun py-execute-partial-expression-python3-dedicated-switch-base (arg)
  (py-execute-partial-expression-python3-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-partial-expression-python3-dedicated-switch-test" nil nil 1) nil "py-execute-partial-expression-python3-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-partial-expression-ipython-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-partial-expression-ipython-test\")"))
  (py-bug-tests-intern 'py-execute-partial-expression-ipython-base arg teststring)))

(defun py-execute-partial-expression-ipython-base (arg)
  (py-execute-partial-expression-ipython)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-partial-expression-ipython-test" nil nil 1) nil "py-execute-partial-expression-ipython-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-partial-expression-ipython-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-partial-expression-ipython-switch-test\")"))
  (py-bug-tests-intern 'py-execute-partial-expression-ipython-switch-base arg teststring)))

(defun py-execute-partial-expression-ipython-switch-base (arg)
  (py-execute-partial-expression-ipython-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-partial-expression-ipython-switch-test" nil nil 1) nil "py-execute-partial-expression-ipython-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-partial-expression-ipython-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-partial-expression-ipython-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-partial-expression-ipython-no-switch-base arg teststring)))

(defun py-execute-partial-expression-ipython-no-switch-base (arg)
  (py-execute-partial-expression-ipython-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-partial-expression-ipython-no-switch-test" nil nil 1) nil "py-execute-partial-expression-ipython-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-partial-expression-ipython-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-partial-expression-ipython-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-partial-expression-ipython-dedicated-base arg teststring)))

(defun py-execute-partial-expression-ipython-dedicated-base (arg)
  (py-execute-partial-expression-ipython-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-partial-expression-ipython-dedicated-test" nil nil 1) nil "py-execute-partial-expression-ipython-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-partial-expression-ipython-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-partial-expression-ipython-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-partial-expression-ipython-dedicated-switch-base arg teststring)))

(defun py-execute-partial-expression-ipython-dedicated-switch-base (arg)
  (py-execute-partial-expression-ipython-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-partial-expression-ipython-dedicated-switch-test" nil nil 1) nil "py-execute-partial-expression-ipython-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-partial-expression-ipython2\.7-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-partial-expression-ipython2\.7-test\")"))
  (py-bug-tests-intern 'py-execute-partial-expression-ipython2\.7-base arg teststring)))

(defun py-execute-partial-expression-ipython2\.7-base (arg)
  (py-execute-partial-expression-ipython2\.7)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-partial-expression-ipython2\.7-test" nil nil 1) nil "py-execute-partial-expression-ipython2\.7-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-partial-expression-ipython2\.7-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-partial-expression-ipython2\.7-switch-test\")"))
  (py-bug-tests-intern 'py-execute-partial-expression-ipython2\.7-switch-base arg teststring)))

(defun py-execute-partial-expression-ipython2\.7-switch-base (arg)
  (py-execute-partial-expression-ipython2\.7-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-partial-expression-ipython2\.7-switch-test" nil nil 1) nil "py-execute-partial-expression-ipython2\.7-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-partial-expression-ipython2\.7-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-partial-expression-ipython2\.7-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-partial-expression-ipython2\.7-no-switch-base arg teststring)))

(defun py-execute-partial-expression-ipython2\.7-no-switch-base (arg)
  (py-execute-partial-expression-ipython2\.7-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-partial-expression-ipython2\.7-no-switch-test" nil nil 1) nil "py-execute-partial-expression-ipython2\.7-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-partial-expression-ipython2\.7-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-partial-expression-ipython2\.7-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-partial-expression-ipython2\.7-dedicated-base arg teststring)))

(defun py-execute-partial-expression-ipython2\.7-dedicated-base (arg)
  (py-execute-partial-expression-ipython2\.7-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-partial-expression-ipython2\.7-dedicated-test" nil nil 1) nil "py-execute-partial-expression-ipython2\.7-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-partial-expression-ipython2\.7-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-partial-expression-ipython2\.7-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-partial-expression-ipython2\.7-dedicated-switch-base arg teststring)))

(defun py-execute-partial-expression-ipython2\.7-dedicated-switch-base (arg)
  (py-execute-partial-expression-ipython2\.7-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-partial-expression-ipython2\.7-dedicated-switch-test" nil nil 1) nil "py-execute-partial-expression-ipython2\.7-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-partial-expression-ipython3-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-partial-expression-ipython3-test\")"))
  (py-bug-tests-intern 'py-execute-partial-expression-ipython3-base arg teststring)))

(defun py-execute-partial-expression-ipython3-base (arg)
  (py-execute-partial-expression-ipython3)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-partial-expression-ipython3-test" nil nil 1) nil "py-execute-partial-expression-ipython3-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-partial-expression-ipython3-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-partial-expression-ipython3-switch-test\")"))
  (py-bug-tests-intern 'py-execute-partial-expression-ipython3-switch-base arg teststring)))

(defun py-execute-partial-expression-ipython3-switch-base (arg)
  (py-execute-partial-expression-ipython3-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-partial-expression-ipython3-switch-test" nil nil 1) nil "py-execute-partial-expression-ipython3-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-partial-expression-ipython3-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-partial-expression-ipython3-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-partial-expression-ipython3-no-switch-base arg teststring)))

(defun py-execute-partial-expression-ipython3-no-switch-base (arg)
  (py-execute-partial-expression-ipython3-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-partial-expression-ipython3-no-switch-test" nil nil 1) nil "py-execute-partial-expression-ipython3-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-partial-expression-ipython3-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-partial-expression-ipython3-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-partial-expression-ipython3-dedicated-base arg teststring)))

(defun py-execute-partial-expression-ipython3-dedicated-base (arg)
  (py-execute-partial-expression-ipython3-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-partial-expression-ipython3-dedicated-test" nil nil 1) nil "py-execute-partial-expression-ipython3-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-partial-expression-ipython3-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-partial-expression-ipython3-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-partial-expression-ipython3-dedicated-switch-base arg teststring)))

(defun py-execute-partial-expression-ipython3-dedicated-switch-base (arg)
  (py-execute-partial-expression-ipython3-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-partial-expression-ipython3-dedicated-switch-test" nil nil 1) nil "py-execute-partial-expression-ipython3-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-partial-expression-jython-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-partial-expression-jython-test\")"))
  (py-bug-tests-intern 'py-execute-partial-expression-jython-base arg teststring)))

(defun py-execute-partial-expression-jython-base (arg)
  (py-execute-partial-expression-jython)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-partial-expression-jython-test" nil nil 1) nil "py-execute-partial-expression-jython-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-partial-expression-jython-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-partial-expression-jython-switch-test\")"))
  (py-bug-tests-intern 'py-execute-partial-expression-jython-switch-base arg teststring)))

(defun py-execute-partial-expression-jython-switch-base (arg)
  (py-execute-partial-expression-jython-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-partial-expression-jython-switch-test" nil nil 1) nil "py-execute-partial-expression-jython-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-partial-expression-jython-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-partial-expression-jython-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-partial-expression-jython-no-switch-base arg teststring)))

(defun py-execute-partial-expression-jython-no-switch-base (arg)
  (py-execute-partial-expression-jython-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-partial-expression-jython-no-switch-test" nil nil 1) nil "py-execute-partial-expression-jython-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-partial-expression-jython-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-partial-expression-jython-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-partial-expression-jython-dedicated-base arg teststring)))

(defun py-execute-partial-expression-jython-dedicated-base (arg)
  (py-execute-partial-expression-jython-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-partial-expression-jython-dedicated-test" nil nil 1) nil "py-execute-partial-expression-jython-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-partial-expression-jython-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-partial-expression-jython-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-partial-expression-jython-dedicated-switch-base arg teststring)))

(defun py-execute-partial-expression-jython-dedicated-switch-base (arg)
  (py-execute-partial-expression-jython-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-partial-expression-jython-dedicated-switch-test" nil nil 1) nil "py-execute-partial-expression-jython-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-minor-block-python-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-minor-block-python-test\")"))
  (py-bug-tests-intern 'py-execute-minor-block-python-base arg teststring)))

(defun py-execute-minor-block-python-base (arg)
  (py-execute-minor-block-python)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-minor-block-python-test" nil nil 1) nil "py-execute-minor-block-python-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-minor-block-python-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-minor-block-python-switch-test\")"))
  (py-bug-tests-intern 'py-execute-minor-block-python-switch-base arg teststring)))

(defun py-execute-minor-block-python-switch-base (arg)
  (py-execute-minor-block-python-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-minor-block-python-switch-test" nil nil 1) nil "py-execute-minor-block-python-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-minor-block-python-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-minor-block-python-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-minor-block-python-no-switch-base arg teststring)))

(defun py-execute-minor-block-python-no-switch-base (arg)
  (py-execute-minor-block-python-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-minor-block-python-no-switch-test" nil nil 1) nil "py-execute-minor-block-python-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-minor-block-python-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-minor-block-python-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-minor-block-python-dedicated-base arg teststring)))

(defun py-execute-minor-block-python-dedicated-base (arg)
  (py-execute-minor-block-python-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-minor-block-python-dedicated-test" nil nil 1) nil "py-execute-minor-block-python-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-minor-block-python-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-minor-block-python-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-minor-block-python-dedicated-switch-base arg teststring)))

(defun py-execute-minor-block-python-dedicated-switch-base (arg)
  (py-execute-minor-block-python-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-minor-block-python-dedicated-switch-test" nil nil 1) nil "py-execute-minor-block-python-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-minor-block-python2-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-minor-block-python2-test\")"))
  (py-bug-tests-intern 'py-execute-minor-block-python2-base arg teststring)))

(defun py-execute-minor-block-python2-base (arg)
  (py-execute-minor-block-python2)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-minor-block-python2-test" nil nil 1) nil "py-execute-minor-block-python2-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-minor-block-python2-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-minor-block-python2-switch-test\")"))
  (py-bug-tests-intern 'py-execute-minor-block-python2-switch-base arg teststring)))

(defun py-execute-minor-block-python2-switch-base (arg)
  (py-execute-minor-block-python2-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-minor-block-python2-switch-test" nil nil 1) nil "py-execute-minor-block-python2-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-minor-block-python2-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-minor-block-python2-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-minor-block-python2-no-switch-base arg teststring)))

(defun py-execute-minor-block-python2-no-switch-base (arg)
  (py-execute-minor-block-python2-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-minor-block-python2-no-switch-test" nil nil 1) nil "py-execute-minor-block-python2-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-minor-block-python2-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-minor-block-python2-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-minor-block-python2-dedicated-base arg teststring)))

(defun py-execute-minor-block-python2-dedicated-base (arg)
  (py-execute-minor-block-python2-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-minor-block-python2-dedicated-test" nil nil 1) nil "py-execute-minor-block-python2-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-minor-block-python2-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-minor-block-python2-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-minor-block-python2-dedicated-switch-base arg teststring)))

(defun py-execute-minor-block-python2-dedicated-switch-base (arg)
  (py-execute-minor-block-python2-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-minor-block-python2-dedicated-switch-test" nil nil 1) nil "py-execute-minor-block-python2-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-minor-block-python3-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-minor-block-python3-test\")"))
  (py-bug-tests-intern 'py-execute-minor-block-python3-base arg teststring)))

(defun py-execute-minor-block-python3-base (arg)
  (py-execute-minor-block-python3)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-minor-block-python3-test" nil nil 1) nil "py-execute-minor-block-python3-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-minor-block-python3-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-minor-block-python3-switch-test\")"))
  (py-bug-tests-intern 'py-execute-minor-block-python3-switch-base arg teststring)))

(defun py-execute-minor-block-python3-switch-base (arg)
  (py-execute-minor-block-python3-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-minor-block-python3-switch-test" nil nil 1) nil "py-execute-minor-block-python3-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-minor-block-python3-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-minor-block-python3-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-minor-block-python3-no-switch-base arg teststring)))

(defun py-execute-minor-block-python3-no-switch-base (arg)
  (py-execute-minor-block-python3-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-minor-block-python3-no-switch-test" nil nil 1) nil "py-execute-minor-block-python3-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-minor-block-python3-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-minor-block-python3-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-minor-block-python3-dedicated-base arg teststring)))

(defun py-execute-minor-block-python3-dedicated-base (arg)
  (py-execute-minor-block-python3-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-minor-block-python3-dedicated-test" nil nil 1) nil "py-execute-minor-block-python3-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-minor-block-python3-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-minor-block-python3-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-minor-block-python3-dedicated-switch-base arg teststring)))

(defun py-execute-minor-block-python3-dedicated-switch-base (arg)
  (py-execute-minor-block-python3-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-minor-block-python3-dedicated-switch-test" nil nil 1) nil "py-execute-minor-block-python3-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-minor-block-ipython-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-minor-block-ipython-test\")"))
  (py-bug-tests-intern 'py-execute-minor-block-ipython-base arg teststring)))

(defun py-execute-minor-block-ipython-base (arg)
  (py-execute-minor-block-ipython)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-minor-block-ipython-test" nil nil 1) nil "py-execute-minor-block-ipython-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-minor-block-ipython-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-minor-block-ipython-switch-test\")"))
  (py-bug-tests-intern 'py-execute-minor-block-ipython-switch-base arg teststring)))

(defun py-execute-minor-block-ipython-switch-base (arg)
  (py-execute-minor-block-ipython-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-minor-block-ipython-switch-test" nil nil 1) nil "py-execute-minor-block-ipython-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-minor-block-ipython-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-minor-block-ipython-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-minor-block-ipython-no-switch-base arg teststring)))

(defun py-execute-minor-block-ipython-no-switch-base (arg)
  (py-execute-minor-block-ipython-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-minor-block-ipython-no-switch-test" nil nil 1) nil "py-execute-minor-block-ipython-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-minor-block-ipython-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-minor-block-ipython-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-minor-block-ipython-dedicated-base arg teststring)))

(defun py-execute-minor-block-ipython-dedicated-base (arg)
  (py-execute-minor-block-ipython-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-minor-block-ipython-dedicated-test" nil nil 1) nil "py-execute-minor-block-ipython-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-minor-block-ipython-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-minor-block-ipython-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-minor-block-ipython-dedicated-switch-base arg teststring)))

(defun py-execute-minor-block-ipython-dedicated-switch-base (arg)
  (py-execute-minor-block-ipython-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-minor-block-ipython-dedicated-switch-test" nil nil 1) nil "py-execute-minor-block-ipython-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-minor-block-ipython2\.7-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-minor-block-ipython2\.7-test\")"))
  (py-bug-tests-intern 'py-execute-minor-block-ipython2\.7-base arg teststring)))

(defun py-execute-minor-block-ipython2\.7-base (arg)
  (py-execute-minor-block-ipython2\.7)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-minor-block-ipython2\.7-test" nil nil 1) nil "py-execute-minor-block-ipython2\.7-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-minor-block-ipython2\.7-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-minor-block-ipython2\.7-switch-test\")"))
  (py-bug-tests-intern 'py-execute-minor-block-ipython2\.7-switch-base arg teststring)))

(defun py-execute-minor-block-ipython2\.7-switch-base (arg)
  (py-execute-minor-block-ipython2\.7-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-minor-block-ipython2\.7-switch-test" nil nil 1) nil "py-execute-minor-block-ipython2\.7-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-minor-block-ipython2\.7-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-minor-block-ipython2\.7-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-minor-block-ipython2\.7-no-switch-base arg teststring)))

(defun py-execute-minor-block-ipython2\.7-no-switch-base (arg)
  (py-execute-minor-block-ipython2\.7-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-minor-block-ipython2\.7-no-switch-test" nil nil 1) nil "py-execute-minor-block-ipython2\.7-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-minor-block-ipython2\.7-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-minor-block-ipython2\.7-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-minor-block-ipython2\.7-dedicated-base arg teststring)))

(defun py-execute-minor-block-ipython2\.7-dedicated-base (arg)
  (py-execute-minor-block-ipython2\.7-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-minor-block-ipython2\.7-dedicated-test" nil nil 1) nil "py-execute-minor-block-ipython2\.7-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-minor-block-ipython2\.7-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-minor-block-ipython2\.7-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-minor-block-ipython2\.7-dedicated-switch-base arg teststring)))

(defun py-execute-minor-block-ipython2\.7-dedicated-switch-base (arg)
  (py-execute-minor-block-ipython2\.7-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-minor-block-ipython2\.7-dedicated-switch-test" nil nil 1) nil "py-execute-minor-block-ipython2\.7-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-minor-block-ipython3-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-minor-block-ipython3-test\")"))
  (py-bug-tests-intern 'py-execute-minor-block-ipython3-base arg teststring)))

(defun py-execute-minor-block-ipython3-base (arg)
  (py-execute-minor-block-ipython3)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-minor-block-ipython3-test" nil nil 1) nil "py-execute-minor-block-ipython3-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-minor-block-ipython3-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-minor-block-ipython3-switch-test\")"))
  (py-bug-tests-intern 'py-execute-minor-block-ipython3-switch-base arg teststring)))

(defun py-execute-minor-block-ipython3-switch-base (arg)
  (py-execute-minor-block-ipython3-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-minor-block-ipython3-switch-test" nil nil 1) nil "py-execute-minor-block-ipython3-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-minor-block-ipython3-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-minor-block-ipython3-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-minor-block-ipython3-no-switch-base arg teststring)))

(defun py-execute-minor-block-ipython3-no-switch-base (arg)
  (py-execute-minor-block-ipython3-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-minor-block-ipython3-no-switch-test" nil nil 1) nil "py-execute-minor-block-ipython3-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-minor-block-ipython3-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-minor-block-ipython3-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-minor-block-ipython3-dedicated-base arg teststring)))

(defun py-execute-minor-block-ipython3-dedicated-base (arg)
  (py-execute-minor-block-ipython3-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-minor-block-ipython3-dedicated-test" nil nil 1) nil "py-execute-minor-block-ipython3-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-minor-block-ipython3-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-minor-block-ipython3-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-minor-block-ipython3-dedicated-switch-base arg teststring)))

(defun py-execute-minor-block-ipython3-dedicated-switch-base (arg)
  (py-execute-minor-block-ipython3-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-minor-block-ipython3-dedicated-switch-test" nil nil 1) nil "py-execute-minor-block-ipython3-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-minor-block-jython-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-minor-block-jython-test\")"))
  (py-bug-tests-intern 'py-execute-minor-block-jython-base arg teststring)))

(defun py-execute-minor-block-jython-base (arg)
  (py-execute-minor-block-jython)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-minor-block-jython-test" nil nil 1) nil "py-execute-minor-block-jython-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-minor-block-jython-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-minor-block-jython-switch-test\")"))
  (py-bug-tests-intern 'py-execute-minor-block-jython-switch-base arg teststring)))

(defun py-execute-minor-block-jython-switch-base (arg)
  (py-execute-minor-block-jython-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-minor-block-jython-switch-test" nil nil 1) nil "py-execute-minor-block-jython-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-minor-block-jython-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-minor-block-jython-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-minor-block-jython-no-switch-base arg teststring)))

(defun py-execute-minor-block-jython-no-switch-base (arg)
  (py-execute-minor-block-jython-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-minor-block-jython-no-switch-test" nil nil 1) nil "py-execute-minor-block-jython-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-minor-block-jython-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-minor-block-jython-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-minor-block-jython-dedicated-base arg teststring)))

(defun py-execute-minor-block-jython-dedicated-base (arg)
  (py-execute-minor-block-jython-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-minor-block-jython-dedicated-test" nil nil 1) nil "py-execute-minor-block-jython-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-minor-block-jython-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-minor-block-jython-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-minor-block-jython-dedicated-switch-base arg teststring)))

(defun py-execute-minor-block-jython-dedicated-switch-base (arg)
  (py-execute-minor-block-jython-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-minor-block-jython-dedicated-switch-test" nil nil 1) nil "py-execute-minor-block-jython-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-if-block-python-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-if-block-python-test\")"))
  (py-bug-tests-intern 'py-execute-if-block-python-base arg teststring)))

(defun py-execute-if-block-python-base (arg)
  (py-execute-if-block-python)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-if-block-python-test" nil nil 1) nil "py-execute-if-block-python-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-if-block-python-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-if-block-python-switch-test\")"))
  (py-bug-tests-intern 'py-execute-if-block-python-switch-base arg teststring)))

(defun py-execute-if-block-python-switch-base (arg)
  (py-execute-if-block-python-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-if-block-python-switch-test" nil nil 1) nil "py-execute-if-block-python-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-if-block-python-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-if-block-python-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-if-block-python-no-switch-base arg teststring)))

(defun py-execute-if-block-python-no-switch-base (arg)
  (py-execute-if-block-python-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-if-block-python-no-switch-test" nil nil 1) nil "py-execute-if-block-python-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-if-block-python-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-if-block-python-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-if-block-python-dedicated-base arg teststring)))

(defun py-execute-if-block-python-dedicated-base (arg)
  (py-execute-if-block-python-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-if-block-python-dedicated-test" nil nil 1) nil "py-execute-if-block-python-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-if-block-python-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-if-block-python-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-if-block-python-dedicated-switch-base arg teststring)))

(defun py-execute-if-block-python-dedicated-switch-base (arg)
  (py-execute-if-block-python-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-if-block-python-dedicated-switch-test" nil nil 1) nil "py-execute-if-block-python-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-if-block-python2-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-if-block-python2-test\")"))
  (py-bug-tests-intern 'py-execute-if-block-python2-base arg teststring)))

(defun py-execute-if-block-python2-base (arg)
  (py-execute-if-block-python2)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-if-block-python2-test" nil nil 1) nil "py-execute-if-block-python2-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-if-block-python2-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-if-block-python2-switch-test\")"))
  (py-bug-tests-intern 'py-execute-if-block-python2-switch-base arg teststring)))

(defun py-execute-if-block-python2-switch-base (arg)
  (py-execute-if-block-python2-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-if-block-python2-switch-test" nil nil 1) nil "py-execute-if-block-python2-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-if-block-python2-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-if-block-python2-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-if-block-python2-no-switch-base arg teststring)))

(defun py-execute-if-block-python2-no-switch-base (arg)
  (py-execute-if-block-python2-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-if-block-python2-no-switch-test" nil nil 1) nil "py-execute-if-block-python2-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-if-block-python2-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-if-block-python2-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-if-block-python2-dedicated-base arg teststring)))

(defun py-execute-if-block-python2-dedicated-base (arg)
  (py-execute-if-block-python2-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-if-block-python2-dedicated-test" nil nil 1) nil "py-execute-if-block-python2-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-if-block-python2-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-if-block-python2-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-if-block-python2-dedicated-switch-base arg teststring)))

(defun py-execute-if-block-python2-dedicated-switch-base (arg)
  (py-execute-if-block-python2-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-if-block-python2-dedicated-switch-test" nil nil 1) nil "py-execute-if-block-python2-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-if-block-python3-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-if-block-python3-test\")"))
  (py-bug-tests-intern 'py-execute-if-block-python3-base arg teststring)))

(defun py-execute-if-block-python3-base (arg)
  (py-execute-if-block-python3)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-if-block-python3-test" nil nil 1) nil "py-execute-if-block-python3-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-if-block-python3-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-if-block-python3-switch-test\")"))
  (py-bug-tests-intern 'py-execute-if-block-python3-switch-base arg teststring)))

(defun py-execute-if-block-python3-switch-base (arg)
  (py-execute-if-block-python3-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-if-block-python3-switch-test" nil nil 1) nil "py-execute-if-block-python3-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-if-block-python3-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-if-block-python3-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-if-block-python3-no-switch-base arg teststring)))

(defun py-execute-if-block-python3-no-switch-base (arg)
  (py-execute-if-block-python3-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-if-block-python3-no-switch-test" nil nil 1) nil "py-execute-if-block-python3-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-if-block-python3-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-if-block-python3-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-if-block-python3-dedicated-base arg teststring)))

(defun py-execute-if-block-python3-dedicated-base (arg)
  (py-execute-if-block-python3-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-if-block-python3-dedicated-test" nil nil 1) nil "py-execute-if-block-python3-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-if-block-python3-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-if-block-python3-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-if-block-python3-dedicated-switch-base arg teststring)))

(defun py-execute-if-block-python3-dedicated-switch-base (arg)
  (py-execute-if-block-python3-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-if-block-python3-dedicated-switch-test" nil nil 1) nil "py-execute-if-block-python3-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-if-block-ipython-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-if-block-ipython-test\")"))
  (py-bug-tests-intern 'py-execute-if-block-ipython-base arg teststring)))

(defun py-execute-if-block-ipython-base (arg)
  (py-execute-if-block-ipython)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-if-block-ipython-test" nil nil 1) nil "py-execute-if-block-ipython-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-if-block-ipython-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-if-block-ipython-switch-test\")"))
  (py-bug-tests-intern 'py-execute-if-block-ipython-switch-base arg teststring)))

(defun py-execute-if-block-ipython-switch-base (arg)
  (py-execute-if-block-ipython-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-if-block-ipython-switch-test" nil nil 1) nil "py-execute-if-block-ipython-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-if-block-ipython-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-if-block-ipython-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-if-block-ipython-no-switch-base arg teststring)))

(defun py-execute-if-block-ipython-no-switch-base (arg)
  (py-execute-if-block-ipython-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-if-block-ipython-no-switch-test" nil nil 1) nil "py-execute-if-block-ipython-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-if-block-ipython-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-if-block-ipython-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-if-block-ipython-dedicated-base arg teststring)))

(defun py-execute-if-block-ipython-dedicated-base (arg)
  (py-execute-if-block-ipython-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-if-block-ipython-dedicated-test" nil nil 1) nil "py-execute-if-block-ipython-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-if-block-ipython-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-if-block-ipython-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-if-block-ipython-dedicated-switch-base arg teststring)))

(defun py-execute-if-block-ipython-dedicated-switch-base (arg)
  (py-execute-if-block-ipython-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-if-block-ipython-dedicated-switch-test" nil nil 1) nil "py-execute-if-block-ipython-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-if-block-ipython2\.7-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-if-block-ipython2\.7-test\")"))
  (py-bug-tests-intern 'py-execute-if-block-ipython2\.7-base arg teststring)))

(defun py-execute-if-block-ipython2\.7-base (arg)
  (py-execute-if-block-ipython2\.7)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-if-block-ipython2\.7-test" nil nil 1) nil "py-execute-if-block-ipython2\.7-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-if-block-ipython2\.7-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-if-block-ipython2\.7-switch-test\")"))
  (py-bug-tests-intern 'py-execute-if-block-ipython2\.7-switch-base arg teststring)))

(defun py-execute-if-block-ipython2\.7-switch-base (arg)
  (py-execute-if-block-ipython2\.7-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-if-block-ipython2\.7-switch-test" nil nil 1) nil "py-execute-if-block-ipython2\.7-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-if-block-ipython2\.7-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-if-block-ipython2\.7-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-if-block-ipython2\.7-no-switch-base arg teststring)))

(defun py-execute-if-block-ipython2\.7-no-switch-base (arg)
  (py-execute-if-block-ipython2\.7-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-if-block-ipython2\.7-no-switch-test" nil nil 1) nil "py-execute-if-block-ipython2\.7-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-if-block-ipython2\.7-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-if-block-ipython2\.7-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-if-block-ipython2\.7-dedicated-base arg teststring)))

(defun py-execute-if-block-ipython2\.7-dedicated-base (arg)
  (py-execute-if-block-ipython2\.7-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-if-block-ipython2\.7-dedicated-test" nil nil 1) nil "py-execute-if-block-ipython2\.7-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-if-block-ipython2\.7-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-if-block-ipython2\.7-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-if-block-ipython2\.7-dedicated-switch-base arg teststring)))

(defun py-execute-if-block-ipython2\.7-dedicated-switch-base (arg)
  (py-execute-if-block-ipython2\.7-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-if-block-ipython2\.7-dedicated-switch-test" nil nil 1) nil "py-execute-if-block-ipython2\.7-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-if-block-ipython3-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-if-block-ipython3-test\")"))
  (py-bug-tests-intern 'py-execute-if-block-ipython3-base arg teststring)))

(defun py-execute-if-block-ipython3-base (arg)
  (py-execute-if-block-ipython3)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-if-block-ipython3-test" nil nil 1) nil "py-execute-if-block-ipython3-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-if-block-ipython3-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-if-block-ipython3-switch-test\")"))
  (py-bug-tests-intern 'py-execute-if-block-ipython3-switch-base arg teststring)))

(defun py-execute-if-block-ipython3-switch-base (arg)
  (py-execute-if-block-ipython3-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-if-block-ipython3-switch-test" nil nil 1) nil "py-execute-if-block-ipython3-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-if-block-ipython3-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-if-block-ipython3-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-if-block-ipython3-no-switch-base arg teststring)))

(defun py-execute-if-block-ipython3-no-switch-base (arg)
  (py-execute-if-block-ipython3-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-if-block-ipython3-no-switch-test" nil nil 1) nil "py-execute-if-block-ipython3-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-if-block-ipython3-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-if-block-ipython3-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-if-block-ipython3-dedicated-base arg teststring)))

(defun py-execute-if-block-ipython3-dedicated-base (arg)
  (py-execute-if-block-ipython3-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-if-block-ipython3-dedicated-test" nil nil 1) nil "py-execute-if-block-ipython3-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-if-block-ipython3-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-if-block-ipython3-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-if-block-ipython3-dedicated-switch-base arg teststring)))

(defun py-execute-if-block-ipython3-dedicated-switch-base (arg)
  (py-execute-if-block-ipython3-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-if-block-ipython3-dedicated-switch-test" nil nil 1) nil "py-execute-if-block-ipython3-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-if-block-jython-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-if-block-jython-test\")"))
  (py-bug-tests-intern 'py-execute-if-block-jython-base arg teststring)))

(defun py-execute-if-block-jython-base (arg)
  (py-execute-if-block-jython)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-if-block-jython-test" nil nil 1) nil "py-execute-if-block-jython-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-if-block-jython-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-if-block-jython-switch-test\")"))
  (py-bug-tests-intern 'py-execute-if-block-jython-switch-base arg teststring)))

(defun py-execute-if-block-jython-switch-base (arg)
  (py-execute-if-block-jython-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-if-block-jython-switch-test" nil nil 1) nil "py-execute-if-block-jython-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-if-block-jython-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-if-block-jython-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-if-block-jython-no-switch-base arg teststring)))

(defun py-execute-if-block-jython-no-switch-base (arg)
  (py-execute-if-block-jython-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-if-block-jython-no-switch-test" nil nil 1) nil "py-execute-if-block-jython-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-if-block-jython-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-if-block-jython-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-if-block-jython-dedicated-base arg teststring)))

(defun py-execute-if-block-jython-dedicated-base (arg)
  (py-execute-if-block-jython-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-if-block-jython-dedicated-test" nil nil 1) nil "py-execute-if-block-jython-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-if-block-jython-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-if-block-jython-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-if-block-jython-dedicated-switch-base arg teststring)))

(defun py-execute-if-block-jython-dedicated-switch-base (arg)
  (py-execute-if-block-jython-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-if-block-jython-dedicated-switch-test" nil nil 1) nil "py-execute-if-block-jython-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-try-block-python-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-try-block-python-test\")"))
  (py-bug-tests-intern 'py-execute-try-block-python-base arg teststring)))

(defun py-execute-try-block-python-base (arg)
  (py-execute-try-block-python)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-try-block-python-test" nil nil 1) nil "py-execute-try-block-python-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-try-block-python-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-try-block-python-switch-test\")"))
  (py-bug-tests-intern 'py-execute-try-block-python-switch-base arg teststring)))

(defun py-execute-try-block-python-switch-base (arg)
  (py-execute-try-block-python-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-try-block-python-switch-test" nil nil 1) nil "py-execute-try-block-python-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-try-block-python-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-try-block-python-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-try-block-python-no-switch-base arg teststring)))

(defun py-execute-try-block-python-no-switch-base (arg)
  (py-execute-try-block-python-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-try-block-python-no-switch-test" nil nil 1) nil "py-execute-try-block-python-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-try-block-python-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-try-block-python-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-try-block-python-dedicated-base arg teststring)))

(defun py-execute-try-block-python-dedicated-base (arg)
  (py-execute-try-block-python-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-try-block-python-dedicated-test" nil nil 1) nil "py-execute-try-block-python-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-try-block-python-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-try-block-python-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-try-block-python-dedicated-switch-base arg teststring)))

(defun py-execute-try-block-python-dedicated-switch-base (arg)
  (py-execute-try-block-python-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-try-block-python-dedicated-switch-test" nil nil 1) nil "py-execute-try-block-python-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-try-block-python2-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-try-block-python2-test\")"))
  (py-bug-tests-intern 'py-execute-try-block-python2-base arg teststring)))

(defun py-execute-try-block-python2-base (arg)
  (py-execute-try-block-python2)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-try-block-python2-test" nil nil 1) nil "py-execute-try-block-python2-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-try-block-python2-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-try-block-python2-switch-test\")"))
  (py-bug-tests-intern 'py-execute-try-block-python2-switch-base arg teststring)))

(defun py-execute-try-block-python2-switch-base (arg)
  (py-execute-try-block-python2-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-try-block-python2-switch-test" nil nil 1) nil "py-execute-try-block-python2-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-try-block-python2-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-try-block-python2-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-try-block-python2-no-switch-base arg teststring)))

(defun py-execute-try-block-python2-no-switch-base (arg)
  (py-execute-try-block-python2-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-try-block-python2-no-switch-test" nil nil 1) nil "py-execute-try-block-python2-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-try-block-python2-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-try-block-python2-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-try-block-python2-dedicated-base arg teststring)))

(defun py-execute-try-block-python2-dedicated-base (arg)
  (py-execute-try-block-python2-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-try-block-python2-dedicated-test" nil nil 1) nil "py-execute-try-block-python2-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-try-block-python2-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-try-block-python2-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-try-block-python2-dedicated-switch-base arg teststring)))

(defun py-execute-try-block-python2-dedicated-switch-base (arg)
  (py-execute-try-block-python2-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-try-block-python2-dedicated-switch-test" nil nil 1) nil "py-execute-try-block-python2-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-try-block-python3-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-try-block-python3-test\")"))
  (py-bug-tests-intern 'py-execute-try-block-python3-base arg teststring)))

(defun py-execute-try-block-python3-base (arg)
  (py-execute-try-block-python3)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-try-block-python3-test" nil nil 1) nil "py-execute-try-block-python3-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-try-block-python3-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-try-block-python3-switch-test\")"))
  (py-bug-tests-intern 'py-execute-try-block-python3-switch-base arg teststring)))

(defun py-execute-try-block-python3-switch-base (arg)
  (py-execute-try-block-python3-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-try-block-python3-switch-test" nil nil 1) nil "py-execute-try-block-python3-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-try-block-python3-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-try-block-python3-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-try-block-python3-no-switch-base arg teststring)))

(defun py-execute-try-block-python3-no-switch-base (arg)
  (py-execute-try-block-python3-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-try-block-python3-no-switch-test" nil nil 1) nil "py-execute-try-block-python3-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-try-block-python3-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-try-block-python3-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-try-block-python3-dedicated-base arg teststring)))

(defun py-execute-try-block-python3-dedicated-base (arg)
  (py-execute-try-block-python3-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-try-block-python3-dedicated-test" nil nil 1) nil "py-execute-try-block-python3-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-try-block-python3-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-try-block-python3-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-try-block-python3-dedicated-switch-base arg teststring)))

(defun py-execute-try-block-python3-dedicated-switch-base (arg)
  (py-execute-try-block-python3-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-try-block-python3-dedicated-switch-test" nil nil 1) nil "py-execute-try-block-python3-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-try-block-ipython-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-try-block-ipython-test\")"))
  (py-bug-tests-intern 'py-execute-try-block-ipython-base arg teststring)))

(defun py-execute-try-block-ipython-base (arg)
  (py-execute-try-block-ipython)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-try-block-ipython-test" nil nil 1) nil "py-execute-try-block-ipython-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-try-block-ipython-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-try-block-ipython-switch-test\")"))
  (py-bug-tests-intern 'py-execute-try-block-ipython-switch-base arg teststring)))

(defun py-execute-try-block-ipython-switch-base (arg)
  (py-execute-try-block-ipython-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-try-block-ipython-switch-test" nil nil 1) nil "py-execute-try-block-ipython-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-try-block-ipython-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-try-block-ipython-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-try-block-ipython-no-switch-base arg teststring)))

(defun py-execute-try-block-ipython-no-switch-base (arg)
  (py-execute-try-block-ipython-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-try-block-ipython-no-switch-test" nil nil 1) nil "py-execute-try-block-ipython-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-try-block-ipython-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-try-block-ipython-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-try-block-ipython-dedicated-base arg teststring)))

(defun py-execute-try-block-ipython-dedicated-base (arg)
  (py-execute-try-block-ipython-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-try-block-ipython-dedicated-test" nil nil 1) nil "py-execute-try-block-ipython-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-try-block-ipython-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-try-block-ipython-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-try-block-ipython-dedicated-switch-base arg teststring)))

(defun py-execute-try-block-ipython-dedicated-switch-base (arg)
  (py-execute-try-block-ipython-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-try-block-ipython-dedicated-switch-test" nil nil 1) nil "py-execute-try-block-ipython-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-try-block-ipython2\.7-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-try-block-ipython2\.7-test\")"))
  (py-bug-tests-intern 'py-execute-try-block-ipython2\.7-base arg teststring)))

(defun py-execute-try-block-ipython2\.7-base (arg)
  (py-execute-try-block-ipython2\.7)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-try-block-ipython2\.7-test" nil nil 1) nil "py-execute-try-block-ipython2\.7-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-try-block-ipython2\.7-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-try-block-ipython2\.7-switch-test\")"))
  (py-bug-tests-intern 'py-execute-try-block-ipython2\.7-switch-base arg teststring)))

(defun py-execute-try-block-ipython2\.7-switch-base (arg)
  (py-execute-try-block-ipython2\.7-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-try-block-ipython2\.7-switch-test" nil nil 1) nil "py-execute-try-block-ipython2\.7-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-try-block-ipython2\.7-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-try-block-ipython2\.7-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-try-block-ipython2\.7-no-switch-base arg teststring)))

(defun py-execute-try-block-ipython2\.7-no-switch-base (arg)
  (py-execute-try-block-ipython2\.7-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-try-block-ipython2\.7-no-switch-test" nil nil 1) nil "py-execute-try-block-ipython2\.7-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-try-block-ipython2\.7-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-try-block-ipython2\.7-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-try-block-ipython2\.7-dedicated-base arg teststring)))

(defun py-execute-try-block-ipython2\.7-dedicated-base (arg)
  (py-execute-try-block-ipython2\.7-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-try-block-ipython2\.7-dedicated-test" nil nil 1) nil "py-execute-try-block-ipython2\.7-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-try-block-ipython2\.7-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-try-block-ipython2\.7-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-try-block-ipython2\.7-dedicated-switch-base arg teststring)))

(defun py-execute-try-block-ipython2\.7-dedicated-switch-base (arg)
  (py-execute-try-block-ipython2\.7-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-try-block-ipython2\.7-dedicated-switch-test" nil nil 1) nil "py-execute-try-block-ipython2\.7-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-try-block-ipython3-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-try-block-ipython3-test\")"))
  (py-bug-tests-intern 'py-execute-try-block-ipython3-base arg teststring)))

(defun py-execute-try-block-ipython3-base (arg)
  (py-execute-try-block-ipython3)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-try-block-ipython3-test" nil nil 1) nil "py-execute-try-block-ipython3-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-try-block-ipython3-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-try-block-ipython3-switch-test\")"))
  (py-bug-tests-intern 'py-execute-try-block-ipython3-switch-base arg teststring)))

(defun py-execute-try-block-ipython3-switch-base (arg)
  (py-execute-try-block-ipython3-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-try-block-ipython3-switch-test" nil nil 1) nil "py-execute-try-block-ipython3-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-try-block-ipython3-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-try-block-ipython3-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-try-block-ipython3-no-switch-base arg teststring)))

(defun py-execute-try-block-ipython3-no-switch-base (arg)
  (py-execute-try-block-ipython3-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-try-block-ipython3-no-switch-test" nil nil 1) nil "py-execute-try-block-ipython3-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-try-block-ipython3-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-try-block-ipython3-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-try-block-ipython3-dedicated-base arg teststring)))

(defun py-execute-try-block-ipython3-dedicated-base (arg)
  (py-execute-try-block-ipython3-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-try-block-ipython3-dedicated-test" nil nil 1) nil "py-execute-try-block-ipython3-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-try-block-ipython3-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-try-block-ipython3-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-try-block-ipython3-dedicated-switch-base arg teststring)))

(defun py-execute-try-block-ipython3-dedicated-switch-base (arg)
  (py-execute-try-block-ipython3-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-try-block-ipython3-dedicated-switch-test" nil nil 1) nil "py-execute-try-block-ipython3-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-try-block-jython-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-try-block-jython-test\")"))
  (py-bug-tests-intern 'py-execute-try-block-jython-base arg teststring)))

(defun py-execute-try-block-jython-base (arg)
  (py-execute-try-block-jython)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-try-block-jython-test" nil nil 1) nil "py-execute-try-block-jython-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-try-block-jython-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-try-block-jython-switch-test\")"))
  (py-bug-tests-intern 'py-execute-try-block-jython-switch-base arg teststring)))

(defun py-execute-try-block-jython-switch-base (arg)
  (py-execute-try-block-jython-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-try-block-jython-switch-test" nil nil 1) nil "py-execute-try-block-jython-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-try-block-jython-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-try-block-jython-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-try-block-jython-no-switch-base arg teststring)))

(defun py-execute-try-block-jython-no-switch-base (arg)
  (py-execute-try-block-jython-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-try-block-jython-no-switch-test" nil nil 1) nil "py-execute-try-block-jython-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-try-block-jython-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-try-block-jython-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-try-block-jython-dedicated-base arg teststring)))

(defun py-execute-try-block-jython-dedicated-base (arg)
  (py-execute-try-block-jython-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-try-block-jython-dedicated-test" nil nil 1) nil "py-execute-try-block-jython-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-try-block-jython-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-try-block-jython-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-try-block-jython-dedicated-switch-base arg teststring)))

(defun py-execute-try-block-jython-dedicated-switch-base (arg)
  (py-execute-try-block-jython-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-try-block-jython-dedicated-switch-test" nil nil 1) nil "py-execute-try-block-jython-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-except-block-python-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-except-block-python-test\")"))
  (py-bug-tests-intern 'py-execute-except-block-python-base arg teststring)))

(defun py-execute-except-block-python-base (arg)
  (py-execute-except-block-python)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-except-block-python-test" nil nil 1) nil "py-execute-except-block-python-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-except-block-python-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-except-block-python-switch-test\")"))
  (py-bug-tests-intern 'py-execute-except-block-python-switch-base arg teststring)))

(defun py-execute-except-block-python-switch-base (arg)
  (py-execute-except-block-python-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-except-block-python-switch-test" nil nil 1) nil "py-execute-except-block-python-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-except-block-python-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-except-block-python-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-except-block-python-no-switch-base arg teststring)))

(defun py-execute-except-block-python-no-switch-base (arg)
  (py-execute-except-block-python-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-except-block-python-no-switch-test" nil nil 1) nil "py-execute-except-block-python-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-except-block-python-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-except-block-python-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-except-block-python-dedicated-base arg teststring)))

(defun py-execute-except-block-python-dedicated-base (arg)
  (py-execute-except-block-python-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-except-block-python-dedicated-test" nil nil 1) nil "py-execute-except-block-python-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-except-block-python-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-except-block-python-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-except-block-python-dedicated-switch-base arg teststring)))

(defun py-execute-except-block-python-dedicated-switch-base (arg)
  (py-execute-except-block-python-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-except-block-python-dedicated-switch-test" nil nil 1) nil "py-execute-except-block-python-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-except-block-python2-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-except-block-python2-test\")"))
  (py-bug-tests-intern 'py-execute-except-block-python2-base arg teststring)))

(defun py-execute-except-block-python2-base (arg)
  (py-execute-except-block-python2)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-except-block-python2-test" nil nil 1) nil "py-execute-except-block-python2-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-except-block-python2-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-except-block-python2-switch-test\")"))
  (py-bug-tests-intern 'py-execute-except-block-python2-switch-base arg teststring)))

(defun py-execute-except-block-python2-switch-base (arg)
  (py-execute-except-block-python2-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-except-block-python2-switch-test" nil nil 1) nil "py-execute-except-block-python2-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-except-block-python2-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-except-block-python2-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-except-block-python2-no-switch-base arg teststring)))

(defun py-execute-except-block-python2-no-switch-base (arg)
  (py-execute-except-block-python2-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-except-block-python2-no-switch-test" nil nil 1) nil "py-execute-except-block-python2-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-except-block-python2-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-except-block-python2-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-except-block-python2-dedicated-base arg teststring)))

(defun py-execute-except-block-python2-dedicated-base (arg)
  (py-execute-except-block-python2-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-except-block-python2-dedicated-test" nil nil 1) nil "py-execute-except-block-python2-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-except-block-python2-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-except-block-python2-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-except-block-python2-dedicated-switch-base arg teststring)))

(defun py-execute-except-block-python2-dedicated-switch-base (arg)
  (py-execute-except-block-python2-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-except-block-python2-dedicated-switch-test" nil nil 1) nil "py-execute-except-block-python2-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-except-block-python3-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-except-block-python3-test\")"))
  (py-bug-tests-intern 'py-execute-except-block-python3-base arg teststring)))

(defun py-execute-except-block-python3-base (arg)
  (py-execute-except-block-python3)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-except-block-python3-test" nil nil 1) nil "py-execute-except-block-python3-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-except-block-python3-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-except-block-python3-switch-test\")"))
  (py-bug-tests-intern 'py-execute-except-block-python3-switch-base arg teststring)))

(defun py-execute-except-block-python3-switch-base (arg)
  (py-execute-except-block-python3-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-except-block-python3-switch-test" nil nil 1) nil "py-execute-except-block-python3-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-except-block-python3-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-except-block-python3-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-except-block-python3-no-switch-base arg teststring)))

(defun py-execute-except-block-python3-no-switch-base (arg)
  (py-execute-except-block-python3-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-except-block-python3-no-switch-test" nil nil 1) nil "py-execute-except-block-python3-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-except-block-python3-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-except-block-python3-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-except-block-python3-dedicated-base arg teststring)))

(defun py-execute-except-block-python3-dedicated-base (arg)
  (py-execute-except-block-python3-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-except-block-python3-dedicated-test" nil nil 1) nil "py-execute-except-block-python3-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-except-block-python3-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-except-block-python3-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-except-block-python3-dedicated-switch-base arg teststring)))

(defun py-execute-except-block-python3-dedicated-switch-base (arg)
  (py-execute-except-block-python3-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-except-block-python3-dedicated-switch-test" nil nil 1) nil "py-execute-except-block-python3-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-except-block-ipython-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-except-block-ipython-test\")"))
  (py-bug-tests-intern 'py-execute-except-block-ipython-base arg teststring)))

(defun py-execute-except-block-ipython-base (arg)
  (py-execute-except-block-ipython)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-except-block-ipython-test" nil nil 1) nil "py-execute-except-block-ipython-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-except-block-ipython-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-except-block-ipython-switch-test\")"))
  (py-bug-tests-intern 'py-execute-except-block-ipython-switch-base arg teststring)))

(defun py-execute-except-block-ipython-switch-base (arg)
  (py-execute-except-block-ipython-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-except-block-ipython-switch-test" nil nil 1) nil "py-execute-except-block-ipython-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-except-block-ipython-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-except-block-ipython-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-except-block-ipython-no-switch-base arg teststring)))

(defun py-execute-except-block-ipython-no-switch-base (arg)
  (py-execute-except-block-ipython-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-except-block-ipython-no-switch-test" nil nil 1) nil "py-execute-except-block-ipython-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-except-block-ipython-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-except-block-ipython-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-except-block-ipython-dedicated-base arg teststring)))

(defun py-execute-except-block-ipython-dedicated-base (arg)
  (py-execute-except-block-ipython-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-except-block-ipython-dedicated-test" nil nil 1) nil "py-execute-except-block-ipython-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-except-block-ipython-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-except-block-ipython-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-except-block-ipython-dedicated-switch-base arg teststring)))

(defun py-execute-except-block-ipython-dedicated-switch-base (arg)
  (py-execute-except-block-ipython-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-except-block-ipython-dedicated-switch-test" nil nil 1) nil "py-execute-except-block-ipython-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-except-block-ipython2\.7-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-except-block-ipython2\.7-test\")"))
  (py-bug-tests-intern 'py-execute-except-block-ipython2\.7-base arg teststring)))

(defun py-execute-except-block-ipython2\.7-base (arg)
  (py-execute-except-block-ipython2\.7)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-except-block-ipython2\.7-test" nil nil 1) nil "py-execute-except-block-ipython2\.7-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-except-block-ipython2\.7-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-except-block-ipython2\.7-switch-test\")"))
  (py-bug-tests-intern 'py-execute-except-block-ipython2\.7-switch-base arg teststring)))

(defun py-execute-except-block-ipython2\.7-switch-base (arg)
  (py-execute-except-block-ipython2\.7-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-except-block-ipython2\.7-switch-test" nil nil 1) nil "py-execute-except-block-ipython2\.7-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-except-block-ipython2\.7-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-except-block-ipython2\.7-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-except-block-ipython2\.7-no-switch-base arg teststring)))

(defun py-execute-except-block-ipython2\.7-no-switch-base (arg)
  (py-execute-except-block-ipython2\.7-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-except-block-ipython2\.7-no-switch-test" nil nil 1) nil "py-execute-except-block-ipython2\.7-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-except-block-ipython2\.7-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-except-block-ipython2\.7-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-except-block-ipython2\.7-dedicated-base arg teststring)))

(defun py-execute-except-block-ipython2\.7-dedicated-base (arg)
  (py-execute-except-block-ipython2\.7-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-except-block-ipython2\.7-dedicated-test" nil nil 1) nil "py-execute-except-block-ipython2\.7-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-except-block-ipython2\.7-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-except-block-ipython2\.7-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-except-block-ipython2\.7-dedicated-switch-base arg teststring)))

(defun py-execute-except-block-ipython2\.7-dedicated-switch-base (arg)
  (py-execute-except-block-ipython2\.7-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-except-block-ipython2\.7-dedicated-switch-test" nil nil 1) nil "py-execute-except-block-ipython2\.7-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-except-block-ipython3-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-except-block-ipython3-test\")"))
  (py-bug-tests-intern 'py-execute-except-block-ipython3-base arg teststring)))

(defun py-execute-except-block-ipython3-base (arg)
  (py-execute-except-block-ipython3)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-except-block-ipython3-test" nil nil 1) nil "py-execute-except-block-ipython3-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-except-block-ipython3-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-except-block-ipython3-switch-test\")"))
  (py-bug-tests-intern 'py-execute-except-block-ipython3-switch-base arg teststring)))

(defun py-execute-except-block-ipython3-switch-base (arg)
  (py-execute-except-block-ipython3-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-except-block-ipython3-switch-test" nil nil 1) nil "py-execute-except-block-ipython3-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-except-block-ipython3-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-except-block-ipython3-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-except-block-ipython3-no-switch-base arg teststring)))

(defun py-execute-except-block-ipython3-no-switch-base (arg)
  (py-execute-except-block-ipython3-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-except-block-ipython3-no-switch-test" nil nil 1) nil "py-execute-except-block-ipython3-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-except-block-ipython3-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-except-block-ipython3-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-except-block-ipython3-dedicated-base arg teststring)))

(defun py-execute-except-block-ipython3-dedicated-base (arg)
  (py-execute-except-block-ipython3-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-except-block-ipython3-dedicated-test" nil nil 1) nil "py-execute-except-block-ipython3-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-except-block-ipython3-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-except-block-ipython3-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-except-block-ipython3-dedicated-switch-base arg teststring)))

(defun py-execute-except-block-ipython3-dedicated-switch-base (arg)
  (py-execute-except-block-ipython3-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-except-block-ipython3-dedicated-switch-test" nil nil 1) nil "py-execute-except-block-ipython3-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-except-block-jython-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-except-block-jython-test\")"))
  (py-bug-tests-intern 'py-execute-except-block-jython-base arg teststring)))

(defun py-execute-except-block-jython-base (arg)
  (py-execute-except-block-jython)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-except-block-jython-test" nil nil 1) nil "py-execute-except-block-jython-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-except-block-jython-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-except-block-jython-switch-test\")"))
  (py-bug-tests-intern 'py-execute-except-block-jython-switch-base arg teststring)))

(defun py-execute-except-block-jython-switch-base (arg)
  (py-execute-except-block-jython-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-except-block-jython-switch-test" nil nil 1) nil "py-execute-except-block-jython-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-except-block-jython-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-except-block-jython-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-except-block-jython-no-switch-base arg teststring)))

(defun py-execute-except-block-jython-no-switch-base (arg)
  (py-execute-except-block-jython-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-except-block-jython-no-switch-test" nil nil 1) nil "py-execute-except-block-jython-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-except-block-jython-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-except-block-jython-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-except-block-jython-dedicated-base arg teststring)))

(defun py-execute-except-block-jython-dedicated-base (arg)
  (py-execute-except-block-jython-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-except-block-jython-dedicated-test" nil nil 1) nil "py-execute-except-block-jython-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-except-block-jython-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "if True: print(\"I'm the py-execute-except-block-jython-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-except-block-jython-dedicated-switch-base arg teststring)))

(defun py-execute-except-block-jython-dedicated-switch-base (arg)
  (py-execute-except-block-jython-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-except-block-jython-dedicated-switch-test" nil nil 1) nil "py-execute-except-block-jython-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-top-level-python-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-top-level-python-test\")"))
  (py-bug-tests-intern 'py-execute-top-level-python-base arg teststring)))

(defun py-execute-top-level-python-base (arg)
  (py-execute-top-level-python)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-top-level-python-test" nil nil 1) nil "py-execute-top-level-python-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-top-level-python-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-top-level-python-switch-test\")"))
  (py-bug-tests-intern 'py-execute-top-level-python-switch-base arg teststring)))

(defun py-execute-top-level-python-switch-base (arg)
  (py-execute-top-level-python-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-top-level-python-switch-test" nil nil 1) nil "py-execute-top-level-python-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-top-level-python-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-top-level-python-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-top-level-python-no-switch-base arg teststring)))

(defun py-execute-top-level-python-no-switch-base (arg)
  (py-execute-top-level-python-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-top-level-python-no-switch-test" nil nil 1) nil "py-execute-top-level-python-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-top-level-python-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-top-level-python-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-top-level-python-dedicated-base arg teststring)))

(defun py-execute-top-level-python-dedicated-base (arg)
  (py-execute-top-level-python-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-top-level-python-dedicated-test" nil nil 1) nil "py-execute-top-level-python-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-top-level-python-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-top-level-python-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-top-level-python-dedicated-switch-base arg teststring)))

(defun py-execute-top-level-python-dedicated-switch-base (arg)
  (py-execute-top-level-python-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-top-level-python-dedicated-switch-test" nil nil 1) nil "py-execute-top-level-python-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-top-level-python2-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-top-level-python2-test\")"))
  (py-bug-tests-intern 'py-execute-top-level-python2-base arg teststring)))

(defun py-execute-top-level-python2-base (arg)
  (py-execute-top-level-python2)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-top-level-python2-test" nil nil 1) nil "py-execute-top-level-python2-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-top-level-python2-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-top-level-python2-switch-test\")"))
  (py-bug-tests-intern 'py-execute-top-level-python2-switch-base arg teststring)))

(defun py-execute-top-level-python2-switch-base (arg)
  (py-execute-top-level-python2-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-top-level-python2-switch-test" nil nil 1) nil "py-execute-top-level-python2-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-top-level-python2-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-top-level-python2-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-top-level-python2-no-switch-base arg teststring)))

(defun py-execute-top-level-python2-no-switch-base (arg)
  (py-execute-top-level-python2-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-top-level-python2-no-switch-test" nil nil 1) nil "py-execute-top-level-python2-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-top-level-python2-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-top-level-python2-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-top-level-python2-dedicated-base arg teststring)))

(defun py-execute-top-level-python2-dedicated-base (arg)
  (py-execute-top-level-python2-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-top-level-python2-dedicated-test" nil nil 1) nil "py-execute-top-level-python2-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-top-level-python2-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-top-level-python2-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-top-level-python2-dedicated-switch-base arg teststring)))

(defun py-execute-top-level-python2-dedicated-switch-base (arg)
  (py-execute-top-level-python2-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-top-level-python2-dedicated-switch-test" nil nil 1) nil "py-execute-top-level-python2-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-top-level-python3-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-top-level-python3-test\")"))
  (py-bug-tests-intern 'py-execute-top-level-python3-base arg teststring)))

(defun py-execute-top-level-python3-base (arg)
  (py-execute-top-level-python3)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-top-level-python3-test" nil nil 1) nil "py-execute-top-level-python3-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-top-level-python3-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-top-level-python3-switch-test\")"))
  (py-bug-tests-intern 'py-execute-top-level-python3-switch-base arg teststring)))

(defun py-execute-top-level-python3-switch-base (arg)
  (py-execute-top-level-python3-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-top-level-python3-switch-test" nil nil 1) nil "py-execute-top-level-python3-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-top-level-python3-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-top-level-python3-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-top-level-python3-no-switch-base arg teststring)))

(defun py-execute-top-level-python3-no-switch-base (arg)
  (py-execute-top-level-python3-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-top-level-python3-no-switch-test" nil nil 1) nil "py-execute-top-level-python3-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-top-level-python3-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-top-level-python3-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-top-level-python3-dedicated-base arg teststring)))

(defun py-execute-top-level-python3-dedicated-base (arg)
  (py-execute-top-level-python3-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-top-level-python3-dedicated-test" nil nil 1) nil "py-execute-top-level-python3-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-top-level-python3-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-top-level-python3-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-top-level-python3-dedicated-switch-base arg teststring)))

(defun py-execute-top-level-python3-dedicated-switch-base (arg)
  (py-execute-top-level-python3-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-top-level-python3-dedicated-switch-test" nil nil 1) nil "py-execute-top-level-python3-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-top-level-ipython-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-top-level-ipython-test\")"))
  (py-bug-tests-intern 'py-execute-top-level-ipython-base arg teststring)))

(defun py-execute-top-level-ipython-base (arg)
  (py-execute-top-level-ipython)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-top-level-ipython-test" nil nil 1) nil "py-execute-top-level-ipython-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-top-level-ipython-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-top-level-ipython-switch-test\")"))
  (py-bug-tests-intern 'py-execute-top-level-ipython-switch-base arg teststring)))

(defun py-execute-top-level-ipython-switch-base (arg)
  (py-execute-top-level-ipython-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-top-level-ipython-switch-test" nil nil 1) nil "py-execute-top-level-ipython-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-top-level-ipython-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-top-level-ipython-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-top-level-ipython-no-switch-base arg teststring)))

(defun py-execute-top-level-ipython-no-switch-base (arg)
  (py-execute-top-level-ipython-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-top-level-ipython-no-switch-test" nil nil 1) nil "py-execute-top-level-ipython-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-top-level-ipython-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-top-level-ipython-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-top-level-ipython-dedicated-base arg teststring)))

(defun py-execute-top-level-ipython-dedicated-base (arg)
  (py-execute-top-level-ipython-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-top-level-ipython-dedicated-test" nil nil 1) nil "py-execute-top-level-ipython-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-top-level-ipython-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-top-level-ipython-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-top-level-ipython-dedicated-switch-base arg teststring)))

(defun py-execute-top-level-ipython-dedicated-switch-base (arg)
  (py-execute-top-level-ipython-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-top-level-ipython-dedicated-switch-test" nil nil 1) nil "py-execute-top-level-ipython-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-top-level-ipython2\.7-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-top-level-ipython2\.7-test\")"))
  (py-bug-tests-intern 'py-execute-top-level-ipython2\.7-base arg teststring)))

(defun py-execute-top-level-ipython2\.7-base (arg)
  (py-execute-top-level-ipython2\.7)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-top-level-ipython2\.7-test" nil nil 1) nil "py-execute-top-level-ipython2\.7-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-top-level-ipython2\.7-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-top-level-ipython2\.7-switch-test\")"))
  (py-bug-tests-intern 'py-execute-top-level-ipython2\.7-switch-base arg teststring)))

(defun py-execute-top-level-ipython2\.7-switch-base (arg)
  (py-execute-top-level-ipython2\.7-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-top-level-ipython2\.7-switch-test" nil nil 1) nil "py-execute-top-level-ipython2\.7-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-top-level-ipython2\.7-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-top-level-ipython2\.7-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-top-level-ipython2\.7-no-switch-base arg teststring)))

(defun py-execute-top-level-ipython2\.7-no-switch-base (arg)
  (py-execute-top-level-ipython2\.7-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-top-level-ipython2\.7-no-switch-test" nil nil 1) nil "py-execute-top-level-ipython2\.7-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-top-level-ipython2\.7-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-top-level-ipython2\.7-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-top-level-ipython2\.7-dedicated-base arg teststring)))

(defun py-execute-top-level-ipython2\.7-dedicated-base (arg)
  (py-execute-top-level-ipython2\.7-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-top-level-ipython2\.7-dedicated-test" nil nil 1) nil "py-execute-top-level-ipython2\.7-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-top-level-ipython2\.7-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-top-level-ipython2\.7-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-top-level-ipython2\.7-dedicated-switch-base arg teststring)))

(defun py-execute-top-level-ipython2\.7-dedicated-switch-base (arg)
  (py-execute-top-level-ipython2\.7-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-top-level-ipython2\.7-dedicated-switch-test" nil nil 1) nil "py-execute-top-level-ipython2\.7-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-top-level-ipython3-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-top-level-ipython3-test\")"))
  (py-bug-tests-intern 'py-execute-top-level-ipython3-base arg teststring)))

(defun py-execute-top-level-ipython3-base (arg)
  (py-execute-top-level-ipython3)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-top-level-ipython3-test" nil nil 1) nil "py-execute-top-level-ipython3-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-top-level-ipython3-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-top-level-ipython3-switch-test\")"))
  (py-bug-tests-intern 'py-execute-top-level-ipython3-switch-base arg teststring)))

(defun py-execute-top-level-ipython3-switch-base (arg)
  (py-execute-top-level-ipython3-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-top-level-ipython3-switch-test" nil nil 1) nil "py-execute-top-level-ipython3-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-top-level-ipython3-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-top-level-ipython3-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-top-level-ipython3-no-switch-base arg teststring)))

(defun py-execute-top-level-ipython3-no-switch-base (arg)
  (py-execute-top-level-ipython3-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-top-level-ipython3-no-switch-test" nil nil 1) nil "py-execute-top-level-ipython3-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-top-level-ipython3-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-top-level-ipython3-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-top-level-ipython3-dedicated-base arg teststring)))

(defun py-execute-top-level-ipython3-dedicated-base (arg)
  (py-execute-top-level-ipython3-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-top-level-ipython3-dedicated-test" nil nil 1) nil "py-execute-top-level-ipython3-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-top-level-ipython3-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-top-level-ipython3-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-top-level-ipython3-dedicated-switch-base arg teststring)))

(defun py-execute-top-level-ipython3-dedicated-switch-base (arg)
  (py-execute-top-level-ipython3-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-top-level-ipython3-dedicated-switch-test" nil nil 1) nil "py-execute-top-level-ipython3-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-top-level-jython-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-top-level-jython-test\")"))
  (py-bug-tests-intern 'py-execute-top-level-jython-base arg teststring)))

(defun py-execute-top-level-jython-base (arg)
  (py-execute-top-level-jython)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-top-level-jython-test" nil nil 1) nil "py-execute-top-level-jython-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-top-level-jython-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-top-level-jython-switch-test\")"))
  (py-bug-tests-intern 'py-execute-top-level-jython-switch-base arg teststring)))

(defun py-execute-top-level-jython-switch-base (arg)
  (py-execute-top-level-jython-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-top-level-jython-switch-test" nil nil 1) nil "py-execute-top-level-jython-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-top-level-jython-no-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-top-level-jython-no-switch-test\")"))
  (py-bug-tests-intern 'py-execute-top-level-jython-no-switch-base arg teststring)))

(defun py-execute-top-level-jython-no-switch-base (arg)
  (py-execute-top-level-jython-no-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-top-level-jython-no-switch-test" nil nil 1) nil "py-execute-top-level-jython-no-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-top-level-jython-dedicated-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-top-level-jython-dedicated-test\")"))
  (py-bug-tests-intern 'py-execute-top-level-jython-dedicated-base arg teststring)))

(defun py-execute-top-level-jython-dedicated-base (arg)
  (py-execute-top-level-jython-dedicated)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-top-level-jython-dedicated-test" nil nil 1) nil "py-execute-top-level-jython-dedicated-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(defun py-execute-top-level-jython-dedicated-switch-test (&optional arg load-branch-function)
  (interactive "p")
  (let ((py-store-result-p t)
        py-result
        (teststring "print(\"I'm the py-execute-top-level-jython-dedicated-switch-test\")"))
  (py-bug-tests-intern 'py-execute-top-level-jython-dedicated-switch-base arg teststring)))

(defun py-execute-top-level-jython-dedicated-switch-base (arg)
  (py-execute-top-level-jython-dedicated-switch)
  (if (string-match "*I" py-buffer-name) (sit-for 1 t) (sit-for 0.1 t))
  (set-buffer py-buffer-name)
  (when py-debug-p (switch-to-buffer (current-buffer)))
  (goto-char (point-max))
  (sit-for 0.1 t)
  (when py-verbose-p (message "py-result %s" (or py-error py-result)))
  (when
      (assert (search-backward "the py-execute-top-level-jython-dedicated-switch-test" nil nil 1) nil "py-execute-top-level-jython-dedicated-switch-test failed")
    (kill-buffer-unconditional py-buffer-name)))

(provide 'python-extended-executes-test)
;;; python-extended-executes-test.el ends here
 
