? Fallagassrini
Fallagassrini Bypass Shell

echo"Fallagassrini ";
Current Path : /usr/share/emacs/24.3/lisp/calc/
Linux gator3171.hostgator.com 4.19.286-203.ELK.el7.x86_64 #1 SMP Wed Jun 14 04:33:55 CDT 2023 x86_64
Current File : //usr/share/emacs/24.3/lisp/calc/calc.elc
;ELC
;;; Compiled by mockbuild@buildfarm06-new.corp.cloudlinux.com on Fri Oct 11 10:10:47 2024
;;; from file /builddir/build/BUILD/emacs-24.3/lisp/calc/calc.el
;;; in Emacs version 24.3.1
;;; with all optimizations.

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

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


(byte-code "\300\301!\210\302\303\304\305\306\307\310\311\312\313&	\210\314\315\316\317\312\303\320\321&\210\314\322\323\324\312\303\320\325&\210\314\326\327\330\312\303\320\331&\210\314\332\333\334\312\303\320\335&\210\314\336\337\340\312\303\320\341&\210\314\342\343\344\312\303\320\345&\210\314\346\304\347\312\303\320\350&\210\314\351\352\353\312\303\320\354&\210\314\355\304\356\312\303\320\357&\210\314\360\361\362\312\303\320\363&\210\314\364\365\366\312\303\320\367&\210\314\370\371\372\312\303\320\373&\210\314\374\375\376\312\303\320\377&\210\314\201@\375\201A\312\303\320\201B&\210\314\201C\304\201D\312\303\320\201E&\210\314\201F\201G\201H\312\303\320\201I&\210\314\201J\201K\201L\312\303\320\201M&\210\314\201N\201O\201P\312\303\320\201Q&\210\314\201R\201S\201T\312\303\320\201U&\210\314\201V\304\201W\312\303\320\201X&\210\314\201Y\201Z\201[\312\303\320\201\\&\210\314\201]\201^\201_\312\303\320\201`&\210\314\201a\304\201b\312\303\201c\201d\320\201`&	\210\314\201e\201f\201g\312\303\320\201h&\210\314\201i\304\201j\201c\201k\312\303\320\201`&	\210\314\201l\201m\201n\201c\201k\312\303\320\201o&	\210\314\201p\201q\201r\201c\201k\312\303\320\201s&	\210\314\201t\201u\201v\201c\201k\320\201w\312\303&	\210\201x\201y\201z\201{\312\303%\210\201x\201|\201}\201~\312\303%\207" [require calc-macs custom-declare-group calc nil "Advanced desk calculator and mathematical tool." :prefix "calc-" :tag "Calc" :group applications custom-declare-variable calc-settings-file (locate-user-emacs-file "calc.el" ".calc.el") "File in which to record permanent settings." :type (file) calc-language-alist '((latex-mode . latex) (tex-mode . tex) (plain-tex-mode . tex) (context-mode . tex) (nroff-mode . eqn) (pascal-mode . pascal) (c-mode . c) (c++-mode . c) (fortran-mode . fortran) (f90-mode . fortran) (texinfo-mode . calc-normal-language)) "Alist of major modes with appropriate Calc languages." (alist :key-type (symbol :tag "Major mode") :value-type (symbol :tag "Calc language")) calc-embedded-announce-formula "%Embed\n\\(% .*\n\\)*" "A regular expression which is sure to be followed by a calc-embedded formula." (regexp) calc-embedded-announce-formula-alist '((c++-mode . "//Embed\n\\(// .*\n\\)*") (c-mode . "/\\*Embed\\*/\n\\(/\\* .*\\*/\n\\)*") (f90-mode . "!Embed\n\\(! .*\n\\)*") (fortran-mode . "C Embed\n\\(C .*\n\\)*") (html-helper-mode . "<!-- Embed -->\n\\(<!-- .* -->\n\\)*") (html-mode . "<!-- Embed -->\n\\(<!-- .* -->\n\\)*") (nroff-mode . "\\\\\"Embed\n\\(\\\\\" .*\n\\)*") (pascal-mode . "{Embed}\n\\({.*}\n\\)*") (sgml-mode . "<!-- Embed -->\n\\(<!-- .* -->\n\\)*") (xml-mode . "<!-- Embed -->\n\\(<!-- .* -->\n\\)*") (texinfo-mode . "@c Embed\n\\(@c .*\n\\)*")) "Alist of major modes with appropriate values for `calc-embedded-announce-formula'." (alist :key-type (symbol :tag "Major mode") :value-type (regexp :tag "Regexp to announce formula")) calc-embedded-open-formula "\\`\\|^\n\\|\\$\\$?\\|\\\\\\[\\|^\\\\begin[^{].*\n\\|^\\\\begin{.*[^x]}.*\n\\|^@.*\n\\|^\\.EQ.*\n\\|\\\\(\\|^%\n\\|^\\.\\\\\"\n" "A regular expression for the opening delimiter of a formula used by calc-embedded." (regexp) calc-embedded-close-formula "\\'\\|\n$\\|\\$\\$?\\|\\\\]\\|^\\\\end[^{].*\n\\|^\\\\end{.*[^x]}.*\n\\|^@.*\n\\|^\\.EN.*\n\\|\\\\)\\|\n%\n\\|^\\.\\\\\"\n" "A regular expression for the closing delimiter of a formula used by calc-embedded." (regexp) calc-embedded-open-close-formula-alist "Alist of major modes with pairs of formula delimiters used by calc-embedded." (alist :key-type (symbol :tag "Major mode") :value-type (list (regexp :tag "Opening formula delimiter") (regexp :tag "Closing formula delimiter"))) calc-embedded-word-regexp "[-+]?[0-9]+\\(\\.[0-9]+\\)?\\([eE][-+]?[0-9]+\\)?" "A regular expression determining a word for calc-embedded-word." (regexp) calc-embedded-word-regexp-alist "Alist of major modes with word regexps used by calc-embedded-word." (alist :key-type (symbol :tag "Major mode") :value-type (regexp :tag "Regexp for word")) calc-embedded-open-plain "%%% " "A string which is the opening delimiter for a \"plain\" formula.\nIf calc-show-plain mode is enabled, this is inserted at the front of\neach formula." (string) calc-embedded-close-plain " %%%\n" "A string which is the closing delimiter for a \"plain\" formula.\nSee calc-embedded-open-plain." (string) calc-embedded-open-close-plain-alist '((c++-mode "// %% " " %%\n") (c-mode "/* %% " " %% */\n") (f90-mode "! %% " " %%\n") (fortran-mode "C %% " " %%\n") (html-helper-mode "<!-- %% " " %% -->\n") (html-mode "<!-- %% " " %% -->\n") (nroff-mode "\\\" %% " " %%\n") (pascal-mode "{%% " " %%}\n") (sgml-mode "<!-- %% " " %% -->\n") (xml-mode "<!-- %% " " %% -->\n") (texinfo-mode "@c %% " " %%\n")) "Alist of major modes with pairs of delimiters for \"plain\" formulas." (alist :key-type (symbol :tag "Major mode") :value-type (list (string :tag "Opening \"plain\" delimiter") (string :tag "Closing \"plain\" delimiter"))) calc-embedded-open-new-formula "\n\n" "A string which is inserted at front of formula by calc-embedded-new-formula." (string) calc-embedded-close-new-formula "A string which is inserted at end of formula by calc-embedded-new-formula." (string) calc-embedded-open-close-new-formula-alist "Alist of major modes with pairs of new formula delimiters used by calc-embedded." (alist :key-type (symbol :tag "Major mode") :value-type (list (string :tag "Opening new formula delimiter") (string :tag "Closing new formula delimiter"))) calc-embedded-open-mode "% " "A string which should precede calc-embedded mode annotations.\nThis is not required to be present for user-written mode annotations." (string) calc-embedded-close-mode "\n" "A string which should follow calc-embedded mode annotations.\nThis is not required to be present for user-written mode annotations." (string) calc-embedded-open-close-mode-alist '((c++-mode "// " "\n") (c-mode "/* " " */\n") (f90-mode "! " "\n") (fortran-mode "C " "\n") (html-helper-mode "<!-- " " -->\n") (html-mode "<!-- " " -->\n") (nroff-mode "\\\" " "\n") (pascal-mode "{ " " }\n") (sgml-mode "<!-- " " -->\n") (xml-mode "<!-- " " -->\n") (texinfo-mode "@c " "\n")) "Alist of major modes with pairs of strings to delimit annotations." (alist :key-type (symbol :tag "Major mode") :value-type (list (string :tag "Opening annotation delimiter") (string :tag "Closing annotation delimiter"))) calc-gnuplot-name (if (eq system-type 'windows-nt) "pgnuplot" "gnuplot") "Name of GNUPLOT program, for calc-graph features." (string) calc-gnuplot-plot-command "Name of command for displaying GNUPLOT output; %s = file name to print." (choice (string) (sexp)) calc-gnuplot-print-command "lp %s" "Name of command for printing GNUPLOT output; %s = file name to print." (choice (string) (sexp)) calc-multiplication-has-precedence t "If non-nil, multiplication has precedence over division\nin normal mode." boolean calc-ensure-consistent-units "If non-nil, make sure new units are consistent with current units\nwhen converting units." :version "24.3" calc-undo-length 100 "The number of undo steps that will be preserved when Calc is quit." integer calc-highlight-selections-with-faces "If non-nil, use a separate face to indicate selected sub-formulas.\nIf `calc-show-selections' is non-nil, then selected sub-formulas are shown\nby displaying the rest of the formula in `calc-nonselected-face'.\nIf `calc-show-selections' is nil, then selected sub-formulas are shown\nby displaying the sub-formula in `calc-selected-face'." "24.1" calc-lu-field-reference "20 uPa" "The default reference level for logarithmic units (field)." (string) calc-lu-power-reference "mW" "The default reference level for logarithmic units (power)." (string) calc-note-threshold "1" "The number of cents that a frequency should be near a note\nto be identified as that note." string custom-declare-face calc-nonselected-face ((t :inherit shadow :slant italic)) "Face used to show the non-selected portion of a formula." calc-selected-face ((t :weight bold)) "Face used to show the selected portion of a formula."] 10)
#@66 Address of the maintainer of Calc, for use by `report-calc-bug'.
(defvar calc-bug-address "jay.p.belanger@gmail.com" (#$ . 8696))
#@94 If t, scan keymaps to find all DEL-like keys.
if nil, only DEL itself is mapped to calc-pop.
(defvar calc-scan-for-dels t (#$ . 8832))
#@89 Calculator stack.
Entries are 3-lists:  Formula, Height (in lines), Selection (or nil).
(defvar calc-stack '((top-of-stack 1 nil)) (#$ . 8973))
#@98 Index into `calc-stack' of "top" of stack.
This is 1 unless `calc-truncate-stack' has been used.
(defvar calc-stack-top 1 (#$ . 9123))
#@141 Floating-point numbers with this positive exponent or higher above the
current precision are displayed in scientific notation in calc-mode.
(defvar calc-display-sci-high 0 (#$ . 9265))
#@109 Floating-point numbers with this negative exponent or lower are displayed
scientific notation in calc-mode.
(defvar calc-display-sci-low -3 (#$ . 9457))
#@65 List of used-defined strings to append to Calculator mode line.
(defvar calc-other-modes nil (#$ . 9616))
#@36 List of strings for Y prefix help.
(defvar calc-Y-help-msgs nil (#$ . 9728))
#@48 t if `calc-settings-file' has been loaded yet.
(defvar calc-loaded-settings-file nil (#$ . 9811))
#@49 List of variables used in customizing GNU Calc.
(defvar calc-mode-var-list nil (#$ . 9915))
#@135 Declare VAR as a Calc variable, with default value DEFVAL
and doc-string DOC.
The variable VAR will be added to `calc-mode-var-list'.
(defalias 'defcalcmodevar '(macro . #[(var defval &optional doc) "\303\304	\nF\305\306\307\310D	EEE\207" [var defval doc progn defvar add-to-list 'calc-mode-var-list list quote] 7 (#$ . 10014)]))
#@70 Restore the default values of the variables in `calc-mode-var-list'.
(defalias 'calc-mode-var-list-restore-default-values #[nil "\301\302\"\207" [calc-mode-var-list mapcar #[(v) "@A@L\207" [v] 2]] 3 (#$ . 10352)])
#@73 Restore the user-saved values of the variables in `calc-mode-var-list'.
(defalias 'calc-mode-var-list-restore-saved-values #[nil "\306\212\306\307	!\310\n!\203X\311\n!q\203Xeb\203X\312\313\306\314#\203X\315y\210`\312\316\306\314#\203X\317 \210\320 \210\321`\"\210\f\211\203W
@\211@@JDB)
A\211\204A)+\203d\322\323\"\202f\320 )\207" [newvarlist calc-settings-file file pos calc-mode-var-list varlist nil substitute-in-file-name file-regular-p find-file-noselect search-forward ";;; Mode settings stored by Calc" t 1 "\n;;; End of mode settings" beginning-of-line calc-mode-var-list-restore-default-values eval-region mapcar #[(v) "@A@L\207" [v] 2] var] 5 (#$ . 10575)])
#@73 If non-nil, load the calc-ext module automatically when Calc is loaded.
(defvar calc-always-load-extensions nil (#$ . 11275))
(byte-code "\300\301\302\303D\"\207" [add-to-list calc-mode-var-list calc-always-load-extensions nil] 4)
#@55 If non-nil, display line numbers in Calculator stack.
(defvar calc-line-numbering t (#$ . 11512))
(byte-code "\300\301\302\303D\"\207" [add-to-list calc-mode-var-list calc-line-numbering t] 4)
#@74 If non-nil, break long values across multiple lines in Calculator stack.
(defvar calc-line-breaking t (#$ . 11711))
(byte-code "\300\301\302\303D\"\207" [add-to-list calc-mode-var-list calc-line-breaking t] 4)
#@128 If nil, stack display is left-justified.
If `right', stack display is right-justified.
If `center', stack display is centered.
(defvar calc-display-just nil (#$ . 11928))
(byte-code "\300\301\302\303D\"\207" [add-to-list calc-mode-var-list calc-display-just nil] 4)
#@233 Horizontal origin of displayed stack entries.
In left-justified mode, this is effectively indentation.  (Default 0).
In right-justified mode, this is effectively window width.
In centered mode, center of stack entry is placed here.
(defvar calc-display-origin nil (#$ . 12201))
(byte-code "\300\301\302\303D\"\207" [add-to-list calc-mode-var-list calc-display-origin nil] 4)
#@60 Radix for entry and display of numbers in calc-mode, 2-36.
(defvar calc-number-radix 10 (#$ . 12582))
(byte-code "\300\301\302\303D\"\207" [add-to-list calc-mode-var-list calc-number-radix 10] 4)
#@75 If non-nil, leading zeros are provided to pad integers to calc-word-size.
(defvar calc-leading-zeros nil (#$ . 12784))
(byte-code "\300\301\302\303D\"\207" [add-to-list calc-mode-var-list calc-leading-zeros nil] 4)
#@169 If non-nil, group digits in large displayed integers by inserting spaces.
If an integer, group that many digits at a time.
If t, use 4 for binary and hex, 3 otherwise.
(defvar calc-group-digits nil (#$ . 13006))
(byte-code "\300\301\302\303D\"\207" [add-to-list calc-mode-var-list calc-group-digits nil] 4)
#@126 The character (in the form of a string) to be used for grouping digits.
This is used only when calc-group-digits mode is on.
(defvar calc-group-char "," (#$ . 13320))
(byte-code "\300\301\302\303D\"\207" [add-to-list calc-mode-var-list calc-group-char ","] 4)
#@72 The character (in the form of a string) to be used as a decimal point.
(defvar calc-point-char "." (#$ . 13586))
(byte-code "\300\301\302\303D\"\207" [add-to-list calc-mode-var-list calc-point-char "."] 4)
#@70 Format of displayed fractions; a string of one or two of ":" or "/".
(defvar calc-frac-format '(":" nil) (#$ . 13798))
(byte-code "\300\301\302\303D\"\207" [add-to-list calc-mode-var-list calc-frac-format (":" nil)] 4)
#@60 If non-nil, prefer fractional over floating-point results.
(defvar calc-prefer-frac nil (#$ . 14023))
(byte-code "\300\301\302\303D\"\207" [add-to-list calc-mode-var-list calc-prefer-frac nil] 4)
#@145 Format of displayed hours-minutes-seconds angles, a format string.
String must contain three %s marks for hours, minutes, seconds respectively.
(defvar calc-hms-format "%s@ %s' %s\"" (#$ . 14226))
(byte-code "\300\301\302\303D\"\207" [add-to-list calc-mode-var-list calc-hms-format "%s@ %s' %s\""] 4)
#@33 Format of displayed date forms.
(defvar calc-date-format '((H ":" mm C SS pp " ") Www " " Mmm " " D ", " YYYY) (#$ . 14533))
(byte-code "\300\301\302\303D\"\207" [add-to-list calc-mode-var-list calc-date-format ((H ":" mm C SS pp " ") Www " " Mmm " " D ", " YYYY)] 4)
#@794 Format to use for display of floating-point numbers in calc-mode.
Must be a list of one of the following forms:
 (float 0)      Floating point format, display full precision.
 (float N)      N > 0: Floating point format, at most N significant figures.
 (float -N)     -N < 0: Floating point format, calc-internal-prec - N figs.
 (fix N)        N >= 0: Fixed point format, N places after decimal point.
 (sci 0)        Scientific notation, full precision.
 (sci N)        N > 0: Scientific notation, N significant figures.
 (sci -N)       -N < 0: Scientific notation, calc-internal-prec - N figs.
 (eng 0)        Engineering notation, full precision.
 (eng N)        N > 0: Engineering notation, N significant figures.
 (eng -N)       -N < 0: Engineering notation, calc-internal-prec - N figs.
(defvar calc-float-format '(float 0) (#$ . 14808))
(byte-code "\300\301\302\303D\"\207" [add-to-list calc-mode-var-list calc-float-format (float 0)] 4)
#@54 Format to use when full precision must be displayed.
(defvar calc-full-float-format '(float 0) (#$ . 15759))
(byte-code "\300\301\302\303D\"\207" [add-to-list calc-mode-var-list calc-full-float-format (float 0)] 4)
#@179 Format to use for display of complex numbers in calc-mode.  Must be one of:
  nil            Use (x, y) form.
  i              Use x + yi form.
  j              Use x + yj form.
(defvar calc-complex-format nil (#$ . 15981))
(byte-code "\300\301\302\303D\"\207" [add-to-list calc-mode-var-list calc-complex-format nil] 4)
#@64 Preferred form, either `cplx' or `polar', for complex numbers.
(defvar calc-complex-mode 'cplx (#$ . 16308))
(byte-code "\300\301\302\303D\"\207" [add-to-list calc-mode-var-list calc-complex-mode cplx] 4)
#@159 If nil, 1 / 0 is left unsimplified.
If 0, 1 / 0 is changed to inf (zeros are considered positive).
Otherwise, 1 / 0 is changed to uinf (undirected infinity).
(defvar calc-infinite-mode nil (#$ . 16520))
(byte-code "\300\301\302\303D\"\207" [add-to-list calc-mode-var-list calc-infinite-mode nil] 4)
#@64 If non-nil, display vectors of byte-sized integers as strings.
(defvar calc-display-strings nil (#$ . 16825))
(byte-code "\300\301\302\303D\"\207" [add-to-list calc-mode-var-list calc-display-strings nil] 4)
#@137 If nil, vector elements are left-justified.
If `right', vector elements are right-justified.
If `center', vector elements are centered.
(defvar calc-matrix-just 'center (#$ . 17040))
(byte-code "\300\301\302\303D\"\207" [add-to-list calc-mode-var-list calc-matrix-just center] 4)
#@51 If non-nil, display vectors one element per line.
(defvar calc-break-vectors nil (#$ . 17326))
(byte-code "\300\301\302\303D\"\207" [add-to-list calc-mode-var-list calc-break-vectors nil] 4)
#@74 If non-nil, display long vectors in full.  If nil, use abbreviated form.
(defvar calc-full-vectors t (#$ . 17523))
(byte-code "\300\301\302\303D\"\207" [add-to-list calc-mode-var-list calc-full-vectors t] 4)
#@56 If non-nil, display long vectors in full in the trail.
(defvar calc-full-trail-vectors t (#$ . 17737))
(byte-code "\300\301\302\303D\"\207" [add-to-list calc-mode-var-list calc-full-trail-vectors t] 4)
#@70 If non-nil, separate elements of displayed vectors with this string.
(defvar calc-vector-commas "," (#$ . 17945))
(byte-code "\300\301\302\303D\"\207" [add-to-list calc-mode-var-list calc-vector-commas ","] 4)
#@63 If non-nil, surround displayed vectors with these characters.
(defvar calc-vector-brackets "[]" (#$ . 18161))
(byte-code "\300\301\302\303D\"\207" [add-to-list calc-mode-var-list calc-vector-brackets "[]"] 4)
#@259 A list of code-letter symbols that control "big" matrix display.
If `R' is present, display inner brackets for matrices.
If `O' is present, display outer brackets for matrices (above/below).
If `C' is present, display outer brackets for matrices (centered).
(defvar calc-matrix-brackets '(R O) (#$ . 18377))
(byte-code "\300\301\302\303D\"\207" [add-to-list calc-mode-var-list calc-matrix-brackets (R O)] 4)
#@651 Language or format for entry and display of stack values.  Must be one of:
  nil		Use standard Calc notation.
  flat		Use standard Calc notation, one-line format.
  big		Display formulas in 2-d notation (enter w/std notation).
  unform	Use unformatted display: add(a, mul(b,c)).
  c		Use C language notation.
  pascal	Use Pascal language notation.
  fortran	Use Fortran language notation.
  tex		Use TeX notation.
  latex         Use LaTeX notation.
  eqn		Use eqn notation.
  yacas         Use Yacas notation.
  maxima        Use Maxima notation.
  giac          Use Giac notation.
  math		Use Mathematica(tm) notation.
  maple		Use Maple notation.
(defvar calc-language nil (#$ . 18792))
(byte-code "\300\301\302\303D\"\207" [add-to-list calc-mode-var-list calc-language nil] 4)
#@67 Numeric prefix argument for the command that set `calc-language'.
(defvar calc-language-option nil (#$ . 19579))
(byte-code "\300\301\302\303D\"\207" [add-to-list calc-mode-var-list calc-language-option nil] 4)
#@38 Label to display at left of formula.
(defvar calc-left-label "" (#$ . 19796))
(byte-code "\300\301\302\303D\"\207" [add-to-list calc-mode-var-list calc-left-label ""] 4)
#@39 Label to display at right of formula.
(defvar calc-right-label "" (#$ . 19972))
(byte-code "\300\301\302\303D\"\207" [add-to-list calc-mode-var-list calc-right-label ""] 4)
#@78 Minimum number of bits per word, if any, for binary operations in calc-mode.
(defvar calc-word-size 32 (#$ . 20151))
(byte-code "\300\301\302\303D\"\207" [add-to-list calc-mode-var-list calc-word-size 32] 4)
#@49 Most recently used value of M in a modulo form.
(defvar calc-previous-modulo nil (#$ . 20365))
(byte-code "\300\301\302\303D\"\207" [add-to-list calc-mode-var-list calc-previous-modulo nil] 4)
#@405 Type of simplification applied to results.
If `none', results are not simplified when pushed on the stack.
If `num', functions are simplified only when args are constant.
If nil, only limited simplifications are applied.
If `binary', `math-clip' is applied if appropriate.
If `alg', `math-simplify' is applied.
If `ext', `math-simplify-extended' is applied.
If `units', `math-simplify-units' is applied.
(defvar calc-simplify-mode 'alg (#$ . 20565))
(byte-code "\300\301\302\303D\"\207" [add-to-list calc-mode-var-list calc-simplify-mode alg] 4)
#@62 If non-nil, recompute evalto's automatically when necessary.
(defvar calc-auto-recompute t (#$ . 21117))
(byte-code "\300\301\302\303D\"\207" [add-to-list calc-mode-var-list calc-auto-recompute t] 4)
#@67 If non-nil, display shows unformatted Lisp exprs. (For debugging)
(defvar calc-display-raw nil (#$ . 21323))
(byte-code "\300\301\302\303D\"\207" [add-to-list calc-mode-var-list calc-display-raw nil] 4)
#@68 Number of digits of internal precision for calc-mode calculations.
(defvar calc-internal-prec 12 (#$ . 21532))
(byte-code "\300\301\302\303D\"\207" [add-to-list calc-mode-var-list calc-internal-prec 12] 4)
#@110 If deg, angles are in degrees; if rad, angles are in radians.
If hms, angles are in degrees-minutes-seconds.
(defvar calc-angle-mode 'deg (#$ . 21745))
(byte-code "\300\301\302\303D\"\207" [add-to-list calc-mode-var-list calc-angle-mode deg] 4)
#@119 If non-nil, numeric entry accepts whole algebraic expressions.
If nil, algebraic expressions must be preceded by "'".
(defvar calc-algebraic-mode nil (#$ . 21997))
(byte-code "\300\301\302\303D\"\207" [add-to-list calc-mode-var-list calc-algebraic-mode nil] 4)
#@60 Like calc-algebraic-mode except only affects ( and [ keys.
(defvar calc-incomplete-algebraic-mode nil (#$ . 22264))
(byte-code "\300\301\302\303D\"\207" [add-to-list calc-mode-var-list calc-incomplete-algebraic-mode nil] 4)
#@139 If non-nil, inexact numeric computations like sqrt(2) are postponed.
If nil, computations on numbers always yield numbers where possible.
(defvar calc-symbolic-mode nil (#$ . 22495))
(byte-code "\300\301\302\303D\"\207" [add-to-list calc-mode-var-list calc-symbolic-mode nil] 4)
#@319 If `matrix', variables are assumed to be matrix-valued.
If a number, variables are assumed to be NxN matrices.
If `sqmatrix', variables are assumed to be square matrices of an unspecified size.
If `scalar', variables are assumed to be scalar-valued.
If nil, symbolic math routines make no assumptions about variables.
(defvar calc-matrix-mode nil (#$ . 22781))
(byte-code "\300\301\302\303D\"\207" [add-to-list calc-mode-var-list calc-matrix-mode nil] 4)
#@56 If non-nil, display integers in two's complement mode.
(defvar calc-twos-complement-mode nil (#$ . 23242))
(byte-code "\300\301\302\303D\"\207" [add-to-list calc-mode-var-list calc-twos-complement-mode nil] 4)
#@78 If non-nil, shifted letter keys are prefix keys rather than normal meanings.
(defvar calc-shift-prefix nil (#$ . 23458))
(byte-code "\300\301\302\303D\"\207" [add-to-list calc-mode-var-list calc-shift-prefix nil] 4)
#@38 Initial height of Calculator window.
(defvar calc-window-height 7 (#$ . 23680))
(byte-code "\300\301\302\303D\"\207" [add-to-list calc-mode-var-list calc-window-height 7] 4)
#@68 If non-nil, M-x calc creates a window to display Calculator trail.
(defvar calc-display-trail t (#$ . 23860))
(byte-code "\300\301\302\303D\"\207" [add-to-list calc-mode-var-list calc-display-trail t] 4)
#@152 If non-nil, selected sub-formulas are shown by obscuring rest of formula.
If nil, selected sub-formulas are highlighted by obscuring the sub-formulas.
(defvar calc-show-selections t (#$ . 24071))
(byte-code "\300\301\302\303D\"\207" [add-to-list calc-mode-var-list calc-show-selections t] 4)
#@111 If non-nil, commands operate only on selected portions of formulas.
If nil, selections displayed but ignored.
(defvar calc-use-selections t (#$ . 24370))
(byte-code "\300\301\302\303D\"\207" [add-to-list calc-mode-var-list calc-use-selections t] 4)
#@69 If non-nil, selection hides deep structure of associative formulas.
(defvar calc-assoc-selections t (#$ . 24625))
(byte-code "\300\301\302\303D\"\207" [add-to-list calc-mode-var-list calc-assoc-selections t] 4)
#@76 If non-nil, display "Working..." for potentially slow Calculator commands.
(defvar calc-display-working-message 'lots (#$ . 24842))
(byte-code "\300\301\302\303D\"\207" [add-to-list calc-mode-var-list calc-display-working-message lots] 4)
#@75 If non-nil, automatically execute a "why" command to explain odd results.
(defvar calc-auto-why 'maybe (#$ . 25087))
(byte-code "\300\301\302\303D\"\207" [add-to-list calc-mode-var-list calc-auto-why maybe] 4)
#@62 If non-nil, display timing information on each slow command.
(defvar calc-timing nil (#$ . 25303))
(byte-code "\300\301\302\303D\"\207" [add-to-list calc-mode-var-list calc-timing nil] 4)
(defvar calc-mode-save-mode 'local nil)
(byte-code "\300\301\302\303D\"\207" [add-to-list calc-mode-var-list calc-mode-save-mode local] 4)
(defvar calc-standard-date-formats '("N" "<H:mm:SSpp >Www Mmm D, YYYY" "D Mmm YYYY<, h:mm:SS>" "Www Mmm BD< hh:mm:ss> YYYY" "M/D/Y< H:mm:SSpp>" "D.M.Y< h:mm:SS>" "M-D-Y< H:mm:SSpp>" "D-M-Y< h:mm:SS>" "j<, h:mm:SS>" "YYddd< hh:mm:ss>") nil)
(byte-code "\300\301\302\303D\"\207" [add-to-list calc-mode-var-list calc-standard-date-formats ("N" "<H:mm:SSpp >Www Mmm D, YYYY" "D Mmm YYYY<, h:mm:SS>" "Www Mmm BD< hh:mm:ss> YYYY" "M/D/Y< H:mm:SSpp>" "D.M.Y< h:mm:SS>" "M-D-Y< H:mm:SSpp>" "D-M-Y< h:mm:SS>" "j<, h:mm:SS>" "YYddd< hh:mm:ss>")] 4)
#@82 If non-nil, automatically set unit prefixes to keep units in a reasonable range.
(defvar calc-autorange-units nil (#$ . 26175))
(byte-code "\300\301\302\303D\"\207" [add-to-list calc-mode-var-list calc-autorange-units nil] 4)
#@50 Non-nil if Calc was last invoked in keypad mode.
(defvar calc-was-keypad-mode nil (#$ . 26407))
(byte-code "\300\301\302\303D\"\207" [add-to-list calc-mode-var-list calc-was-keypad-mode nil] 4)
#@55 Non-nil if Calc was last invoked in full-screen mode.
(defvar calc-full-mode nil (#$ . 26607))
(byte-code "\300\301\302\303D\"\207" [add-to-list calc-mode-var-list calc-full-mode nil] 4)
#@51 Alist of languages with user-defined parse rules.
(defvar calc-user-parse-tables nil (#$ . 26800))
(byte-code "\300\301\302\303D\"\207" [add-to-list calc-mode-var-list calc-user-parse-tables nil] 4)
#@47 The default device name for GNUPLOT plotting.
(defvar calc-gnuplot-default-device "default" (#$ . 27005))
(byte-code "\300\301\302\303D\"\207" [add-to-list calc-mode-var-list calc-gnuplot-default-device "default"] 4)
#@47 The default output file for GNUPLOT plotting.
(defvar calc-gnuplot-default-output "STDOUT" (#$ . 27228))
(byte-code "\300\301\302\303D\"\207" [add-to-list calc-mode-var-list calc-gnuplot-default-output "STDOUT"] 4)
#@47 The default device name for GNUPLOT printing.
(defvar calc-gnuplot-print-device "postscript" (#$ . 27449))
(byte-code "\300\301\302\303D\"\207" [add-to-list calc-mode-var-list calc-gnuplot-print-device "postscript"] 4)
#@42 The default output for GNUPLOT printing.
(defvar calc-gnuplot-print-output "auto" (#$ . 27674))
(byte-code "\300\301\302\303D\"\207" [add-to-list calc-mode-var-list calc-gnuplot-print-output "auto"] 4)
#@46 The default geometry for the GNUPLOT window.
(defvar calc-gnuplot-geometry nil (#$ . 27882))
(byte-code "\300\301\302\303D\"\207" [add-to-list calc-mode-var-list calc-gnuplot-geometry nil] 4)
#@57 The default number of data points when plotting curves.
(defvar calc-graph-default-resolution 15 (#$ . 28080))
(byte-code "\300\301\302\303D\"\207" [add-to-list calc-mode-var-list calc-graph-default-resolution 15] 4)
#@69 The default number of x- and y- data points when plotting surfaces.
(defvar calc-graph-default-resolution-3d 5 (#$ . 28303))
(byte-code "\300\301\302\303D\"\207" [add-to-list calc-mode-var-list calc-graph-default-resolution-3d 5] 4)
#@73 A user defined macro for starting Calc.
Used by `calc-user-invocation'.
(defvar calc-invocation-macro nil (#$ . 28542))
(byte-code "\300\301\302\303D\"\207" [add-to-list calc-mode-var-list calc-invocation-macro nil] 4)
#@55 If non-nil, show a friendly greeting above the stack.
(defvar calc-show-banner t (#$ . 28767))
(byte-code "\300\301\302\303D\"\207" [add-to-list calc-mode-var-list calc-show-banner t] 4)
(defconst calc-local-var-list '(calc-stack calc-stack-top calc-undo-list calc-redo-list calc-always-load-extensions calc-mode-save-mode calc-display-raw calc-line-numbering calc-line-breaking calc-display-just calc-display-origin calc-left-label calc-right-label calc-auto-why calc-algebraic-mode calc-incomplete-algebraic-mode calc-symbolic-mode calc-matrix-mode calc-inverse-flag calc-hyperbolic-flag calc-option-flag calc-keep-args-flag calc-angle-mode calc-number-radix calc-leading-zeros calc-group-digits calc-group-char calc-point-char calc-frac-format calc-prefer-frac calc-hms-format calc-date-format calc-standard-date-formats calc-float-format calc-full-float-format calc-complex-format calc-matrix-just calc-full-vectors calc-full-trail-vectors calc-break-vectors calc-vector-commas calc-vector-brackets calc-matrix-brackets calc-complex-mode calc-infinite-mode calc-display-strings calc-simplify-mode calc-auto-recompute calc-autorange-units calc-show-plain calc-show-selections calc-use-selections calc-assoc-selections calc-word-size calc-internal-prec))
#@35 Hook run when entering calc-mode.
(defvar calc-mode-hook nil (#$ . 30030))
#@41 Hook run when entering calc-trail-mode.
(defvar calc-trail-mode-hook nil (#$ . 30111))
#@32 Hook run when calc is started.
(defvar calc-start-hook nil (#$ . 30204))
#@29 Hook run when calc is quit.
(defvar calc-end-hook nil (#$ . 30283))
#@34 Hook run when calc.el is loaded.
(defvar calc-load-hook nil (#$ . 30357))
#@40 Hook called to create the Calc window.
(defvar calc-window-hook nil (#$ . 30437))
#@46 Hook called to create the Calc trail window.
(defvar calc-trail-window-hook nil (#$ . 30525))
#@55 Hook run when starting embedded mode in a new buffer.
(defvar calc-embedded-new-buffer-hook nil (#$ . 30625))
#@56 Hook run when starting embedded mode in a new formula.
(defvar calc-embedded-new-formula-hook nil (#$ . 30741))
#@39 Hook run when starting embedded mode.
(defvar calc-embedded-mode-hook nil (#$ . 30859))
(byte-code "\300\301\302\303#\210\300\304\302\303#\210\300\305\306\307#\210\300\305\310\311#\210\300\312\306\313#\210\300\312\310\314#\210\300\315\306\316#\210\300\315\310\317#\207" [put calc-mode mode-class special calc-trail-mode inexact-result error-conditions (error inexact-result calc-error) error-message "Calc internal error (inexact-result)" math-overflow (error math-overflow calc-error) "Floating-point overflow occurred" math-underflow (error math-underflow calc-error) "Floating-point underflow occurred"] 4)
#@38 The "current" entry in trail buffer.
(defvar calc-trail-pointer nil (#$ . 31475))
#@36 The value of overlay-arrow-string.
(defvar calc-trail-overlay nil (#$ . 31563))
#@43 The list of previous operations for undo.
(defvar calc-undo-list nil (#$ . 31649))
#@37 The list of recent undo operations.
(defvar calc-redo-list nil (#$ . 31738))
#@33 A pointer to Calculator buffer.
(defvar calc-main-buffer nil (#$ . 31821))
#@29 A list of all Calc buffers.
(defvar calc-buffer-list nil (#$ . 31902))
#@33 A pointer to Calc Trail buffer.
(defvar calc-trail-buffer nil (#$ . 31979))
#@37 Explanations of most recent errors.
(defvar calc-why nil (#$ . 32061))
(defvar calc-next-why nil)
#@40 If non-nil, next operation is Inverse.
(defvar calc-inverse-flag nil (#$ . 32165))
#@43 If non-nil, next operation is Hyperbolic.
(defvar calc-hyperbolic-flag nil (#$ . 32254))
#@51 If non-nil, next operation has Optional behavior.
(defvar calc-option-flag nil (#$ . 32349))
#@72 If non-nil, next operation should not remove its arguments from stack.
(defvar calc-keep-args-flag nil (#$ . 32448))
#@53 Open-parenthesis string for function call notation.
(defvar calc-function-open "(" (#$ . 32571))
#@54 Close-parenthesis string for function call notation.
(defvar calc-function-close ")" (#$ . 32674))
#@58 Function through which to pass strings after formatting.
(defvar calc-language-output-filter nil (#$ . 32779))
#@56 Function through which to pass strings before parsing.
(defvar calc-language-input-filter nil (#$ . 32896))
#@51 Formatting function used for non-decimal numbers.
(defvar calc-radix-formatter nil (#$ . 33010))
#@66 A list of languages in which / might represent integer division.
(defvar calc-lang-slash-idiv nil (#$ . 33113))
#@64 A list of languages which allow underscores in variable names.
(defvar calc-lang-allow-underscores nil (#$ . 33231))
#@66 A list of languages which allow percent signs in variable names.
(defvar calc-lang-allow-percentsigns nil (#$ . 33354))
#@77 Languages in which octal and hex numbers are written with leading 0 and 0x,
(defvar calc-lang-c-type-hex nil (#$ . 33480))
#@58 Languages in which subscripts are indicated by brackets.
(defvar calc-lang-brackets-are-subscripts nil (#$ . 33609))
#@61 Languages in which subscripts are indicated by parentheses.
(defvar calc-lang-parens-are-subscripts nil (#$ . 33732))
#@38 The last number killed in calc-mode.
(defvar calc-last-kill nil (#$ . 33856))
#@28 Values to be used for '$'.
(defvar calc-dollar-values nil (#$ . 33940))
#@41 The highest order of '$' that occurred.
(defvar calc-dollar-used nil (#$ . 34018))
#@41 The highest order of '#' that occurred.
(defvar calc-hashes-used nil (#$ . 34107))
#@35 Previous results from Quick Calc.
(defvar calc-quick-prev-results nil (#$ . 34196))
#@52 Non-nil if the welcome message has been displayed.
(defvar calc-said-hello nil (#$ . 34286))
#@60 Non-nil if a keyboard macro is executing from the "K" key.
(defvar calc-executing-macro nil (#$ . 34385))
#@42 Non-nil if there are selections present.
(defvar calc-any-selections nil (#$ . 34497))
#@43 The number of consecutive "?" keystrokes.
(defvar calc-help-phase 0 (#$ . 34590))
#@48 Non-nil if `calc-full-help' is being executed.
(defvar calc-full-help-flag nil (#$ . 34678))
#@37 The number of `calc-refresh' calls.
(defvar calc-refresh-count 0 (#$ . 34777))
#@74 Non-nil if the stack display might not reflect the latest mode settings.
(defvar calc-display-dirty nil (#$ . 34862))
(defvar calc-prepared-composition nil)
(defvar calc-selection-cache-default-entry nil)
#@67 If non-nil, a vector consisting of information for embedded mode.
(defvar calc-embedded-info nil (#$ . 35073))
#@60 Alist of buffers with sorted lists of calc-embedded-infos.
(defvar calc-embedded-active nil (#$ . 35190))
#@48 Non-nil if Emacs started with standalone Calc.
(defvar calc-standalone-flag nil (#$ . 35302))
#@56 User defined rules that Calc will apply automatically.
(defvar var-EvalRules nil (#$ . 35402))
(defvar math-eval-rules-cache-tag t)
(defvar math-radix-explicit-format t)
#@59 Alist of language specific functions with Calc functions.
(defvar math-expr-function-mapping nil (#$ . 35578))
#@59 Alist of language specific variables with Calc variables.
(defvar math-expr-variable-mapping nil (#$ . 35695))
(defvar math-read-expr-quotes nil)
(defvar math-working-step nil)
(defvar math-working-step-2 nil)
(defvar var-i '(special-const (math-imaginary 1)))
(defvar var-pi '(special-const (math-pi)))
(defvar var-π '(special-const (math-pi)))
(defvar var-e '(special-const (math-e)))
(defvar var-phi '(special-const (math-phi)))
(defvar var-φ '(special-const (math-phi)))
(defvar var-gamma '(special-const (math-gamma-const)))
(defvar var-γ '(special-const (math-gamma-const)))
(defvar var-Modes '(special-const (math-get-modes-vec)))
(mapc #[(v) "\301!\206	\302L\207" [v boundp nil] 2] calc-local-var-list)
#@23 The key map for Calc.
(defvar calc-mode-map (byte-code "\301 \302\303\"\210\304\305\306#\210\304\307\310#\210\304\311\312#\210\304\313\314#\210\304\315\316#\210\304\317\320#\210\304\321\322#\210\304\323\324#\210\304\325\326#\210\304\327\330#\210\304\331\332#\210\304\333\334#\210\304\335\336#\210\304\337\340#\210\304\341\342#\210\304\343\344#\210\304\345\346#\210\304\347\350#\210\304\351\350#\210\304\352\353#\210\304\354\355#\210\304\356\357#\210\304\360\344#\210\304\361\362#\210\304\363\364#\210\304\365\366#\210\304\367\366#\210\304\370\371#\210\372\373\374\"\210\372\375\376\"\210\304\377\201@#\210\304\201A\201@#\210\304\201B\201@#\210\372\201C\201D\"\210)\207" [map make-keymap suppress-keymap t define-key "+" calc-plus "-" calc-minus "*" calc-times "/" calc-divide "%" calc-mod "&" calc-inv "^" calc-power "\245" calc-percent "e" calcDigit-start "i" calc-info "n" calc-change-sign "q" calc-quit "Y" nil "Y?" calc-shift-Y-prefix-help "?" calc-help " " calc-enter "'" calc-algebraic-entry "$" calc-auto-algebraic-entry "\"" "	" calc-roll-down "\211" calc-roll-up "" calc-transpose-lines "
" "\215" calc-last-args-stub "\n" calc-over "" calc-yank [mouse-2] [remap undo] calc-undo mapc #[(x) "\302\303	!\304#\207" [map x define-key char-to-string undefined] 4] "lOW" #[(x) "\302\303	!\304#\207" [map x define-key char-to-string calc-missing-key] 4] "ABCDEFGHIJKLMNOPQRSTUVXZabcdfghjkmoprstuvwxyz:\\|!()[]<>{},;=~`" "\367" calc-missing-key "\353" "\227" #[(x) "\302\303	!\304#\207" [map x define-key char-to-string calcDigit-start] 4] "_0123456789.#@"] 4) (#$ . 36418))
#@39 The key map for entering Calc digits.
(defvar calc-digit-map (byte-code "\302 \303\304	\"\210\305\306\307\"\210\305\310\311\"\210\312\313\314#\210\312\315\316#\210\312\317\320#\210)\207" [map calc-mode-map make-keymap map-keymap #[(key bind) "\303\304	!\n\305=\203\305\202\306#\207" [map key bind define-key vector undefined calcDigit-nondigit] 5] mapc #[(x) "\302\303	!\304#\207" [map x define-key char-to-string calcDigit-key] 4] "_0123456789.e+-:n#@oh'\"mspM" #[(x) "\302\303	!\304#\207" [map x define-key char-to-string calcDigit-letter] 4] "abcdfgijklqrtuvwxyzABCDEFGHIJKLNOPQRSTUVWXYZ" define-key "'" calcDigit-algebraic "`" calcDigit-edit "" abort-recursive-edit] 4) (#$ . 38049))
(byte-code "\302\303\203\304\305\306	\"\305\307	\"\305\310	\"\311$\202\312\"\207" [calc-scan-for-dels global-map mapc #[(x) "\300\301\302\217\207" [err (byte-code "\303	\304#\210\303\n	\305#\210\303\n	\210\306\307	\"\310#\207" [calc-digit-map x calc-mode-map define-key calcDigit-backspace calc-pop vconcat "" calc-pop-above] 5) ((error))] 3] append where-is-internal delete-backward-char backward-delete-char backward-delete-char-untabify ("") ("" "")] 8)
#@32 The key map for starting Calc.
(defvar calc-dispatch-map (byte-code "\301 \302\303\304\"\210)\207" [map make-keymap mapc #[(x) "@\305	!A\306\f\n#\210\307\310\n\"\203/\306\f\n\226#\210\307\311\n\"\204/\306\f\312\313	D!#\210\306\f\314\315	\"#+\207" [x x-chr x-str x-def map char-to-string define-key string-match "[a-z]" "[gmv]" vector control format "%c"] 5] ((97 . calc-embedded-activate) (98 . calc-big-or-small) (99 . calc) (100 . calc-embedded-duplicate) (101 . calc-embedded) (102 . calc-embedded-new-formula) (103 . calc-grab-region) (104 . calc-dispatch-help) (105 . calc-info) (106 . calc-embedded-select) (107 . calc-keypad) (108 . calc-load-everything) (109 . read-kbd-macro) (110 . calc-embedded-next) (111 . calc-other-window) (112 . calc-embedded-previous) (113 . quick-calc) (114 . calc-grab-rectangle) (115 . calc-info-summary) (116 . calc-tutorial) (117 . calc-embedded-update-formula) (119 . calc-embedded-word) (120 . calc-quit) (121 . calc-copy-to-buffer) (122 . calc-user-invocation) (39 . calc-embedded-new-formula) (96 . calc-embedded-edit) (58 . calc-grab-sum-down) (95 . calc-grab-sum-across) (48 . calc-reset) (63 . calc-dispatch-help) (35 . calc-same-interface) (38 . calc-same-interface) (92 . calc-same-interface) (61 . calc-same-interface) (42 . calc-same-interface) (47 . calc-same-interface) (43 . calc-same-interface) (45 . calc-same-interface))] 3) (#$ . 39223))
(load "calc-loaddefs.el" nil t)
#@73 Invoke the GNU Emacs Calculator.  See `calc-dispatch-help' for details.
(defalias 'calc-dispatch #[(&optional arg) "\301\302\303\217\210\304!\207" [arg err (byte-code "\302 \211;\2039\303\304\"\2049\305	\"\306=\2049\303\307\"\2033\305	\310\311O\"9\2033\312	\310\311O\313#\210\312	\306#\210)\313\207" [keys calc-dispatch-map this-command-keys string-match "\\`\\|\\`[-0-9#]\\|`[\255\260-\271]" lookup-key calc-same-interface "\\`[-]" 0 1 define-key nil] 6) ((error)) calc-do-dispatch] 3 (#$ . 40670) "P"])
(defvar calc-dispatch-help nil)
#@23 Start the Calculator.
(defalias 'calc-do-dispatch #[(arg) "\303\203	\304\202\305\306\307\310 !\"	\"\311	\n\"\312\313!\210\n\2030\314\n!\204*\315\316!\210\317\n!\2022\320 )\207" [calc-dispatch-help calc-dispatch-map key calc-read-key-sequence "Calc options: Calc, Keypad, Quick, Embed; eXit; Info, Tutorial; Grab; ?=more" format "%s  (Type ? for a list of Calc options)" key-description this-command-keys lookup-key message "" commandp require calc-ext call-interactively beep] 5 (#$ . 41230)])
#@47 Read keys, with prompt PROMPT and keymap MAP.
(defalias 'calc-read-key-sequence #[(prompt map) "\306\307\310\311 !\"\312 \313 \314 \204\315\316\"\210\317\320!\321\322
A!\210\323\216\324!\210\325\321!\210\326\321!.\207" [loc glob prompt2 prompt input-method-function key format "%s " key-description this-command-keys current-global-map current-local-map input-pending-p message "%s" calc-read-key t nil calc-unread-command ((byte-code "\302!\210\303	!\207" [glob loc use-global-map use-local-map] 2)) use-global-map use-local-map read-key-sequence map] 4 (#$ . 41739)])
#@305 Check to see if user wants to kill the Calc stack buffer.
This will look for buffers using the Calc buffer for embedded mode,
and inform the user if there are any.
If the user wants to kill the Calc buffer, this will remove
embedded information from the appropriate buffers and tidy up
the trail buffer.
(defalias 'calc-kill-stack-buffer #[nil "p\306\211	\203+\f	@A@\307H=\203$\310	@@!\203$	@B	A\211\204\f\203}\311\312!\203}\203}r@@q\210
\203o\306@\3138\306\314A@!\210\315\"\211)\316\317 !\210)\320@\"A\211\2049?\205\315\320\f\"\321!\203\311rq\210\f=\203\310\203\251@\202\310\322!\211 \203\302\323 @!\210 A\211 \204\263)\324!\210)\306\325,\207" [calc-embedded-active cea buflist info-list cb calc-embedded-info nil 1 buffer-name yes-or-no-p "This Calc stack is being used for embedded mode. Kill anyway?" 2 use-local-map remq set-buffer-modified-p buffer-modified-p delete buffer-live-p get-buffer-window-list delete-window kill-buffer t calc-embedded-modes mode-line-buffer-identification truncate-lines buffer-read-only calc-override-minor-modes minor-mode-overriding-map-alist str calc-buffer-list calc-trail-buffer calc-main-buffer wl] 5 (#$ . 42328)])
#@1194 Calculator major mode.

This is an RPN calculator featuring arbitrary-precision integer, rational,
floating-point, complex, matrix, and symbolic arithmetic.

RPN calculation:  2 RET 3 +    produces 5.
Algebraic style:  ' 2+3 RET    produces 5.

Basic operators are +, -, *, /, ^, & (reciprocal), % (modulo), n (change-sign).

Press ? repeatedly for more complete help.  Press `h i' to read the
Calc manual on-line, `h s' to read the summary, or `h t' for the tutorial.

Notations:  3.14e6     3.14 * 10^6
            _23        negative number -23 (or type `23 n')
            17:3       the fraction 17/3
            5:2:3      the fraction 5 and 2/3
            16#12C     the integer 12C base 16 = 300 base 10
            8#177:100  the fraction 177:100 base 8 = 127:64 base 10
            (2, 4)     complex number 2 + 4i
            (2; 4)     polar complex number (r; theta)
            [1, 2, 3]  vector  ([[1, 2], [3, 4]] is a matrix)
            [1 .. 4)   semi-open interval, 1 <= x < 4
            2 +/- 3    (p key) number with mean 2, standard deviation 3
            2 mod 3    (M key) number 2 computed modulo 3
	    <1 jan 91> Date form (enter using ' key)


\{calc-mode-map}

(defalias 'calc-mode #[nil "\306\307\"\210\310 \210\311	\312=\203\313\314!\210\n\202!\210\306\315\"\210\315\316!\210\315\317!\210\320\321\322\323\324$\210\320\325\326\324\211$\210\324\211\327,\330-\331.\236.>\206Q\331\332\323EC\211.G/\333.G/\334#/0\204{1\203{12\232\204{\3240\335\3361!\324\"\2103\2114\203\2534@\337\232\203\242\340\3414A@\"\203\242\340\3424A@\"\203\242\32454A\2114\204\203)\313\343!\210\344\345!\210\346\324!\210\347 \210\350 \210+\203\311\351.!.\352\353p\324#\207" [calc-local-var-list calc-algebraic-mode calc-alg-map calc-mode-map truncate-lines buffer-read-only mapc #[(v) "\301\211J\"\207" [v set-default] 3] kill-all-local-variables use-local-map total require calc-ext make-local-variable overlay-arrow-position overlay-arrow-string add-hook change-major-mode-hook font-lock-defontify nil t kill-buffer-query-functions calc-kill-stack-buffer calc-mode "Calculator" top-of-stack 1 - -1 load file-name-sans-extension "-f" string-match "calc" "full" calc-menu run-mode-hooks calc-mode-hook calc-refresh calc-set-mode-line calc-check-defines copy-sequence add-to-list calc-buffer-list major-mode mode-name calc-stack calc-stack-top calc-loaded-settings-file calc-settings-file user-init-file command-line-args p calc-standalone-flag] 6 (#$ . 43577) nil])
(defvar calc-check-defines 'calc-check-defines)
(defalias 'calc-check-defines #[nil "\301\302!\205R\303\301\302!!\211\203A@\204AA\211\204\203M\212\304\305!\210\304\306!\210\307q\210\203G\310\302@\311#\210\312A@!\210AA\211\2042\313 )\202Q\314\302\311\")\207" [plist symbol-plist calc-define copy-sequence require calc-ext calc-macs "*Calculator*" put nil eval calc-check-defines setplist] 5])
#@353 Calc Trail mode.
This mode is used by the *Calc Trail* buffer, which records all results
obtained by the GNU Emacs Calculator.

Calculator commands beginning with the `t' key are used to manipulate
the Trail.

This buffer uses the same key map as the *Calculator* buffer; calculator
commands given here will actually operate on the *Calculator* stack.
(defalias 'calc-trail-mode #[(&optional buf) "\306 \210\307!\210\310\311\312\211\313\314!\210\313\315!\210
\203\"\313\316!\210
\317 \320U\2033\321\322\323\324\325#c\210)\326\327!\207" [calc-mode-map major-mode mode-name truncate-lines buffer-read-only buf fundamental-mode use-local-map calc-trail-mode "Calc Trail" t make-local-variable overlay-arrow-position overlay-arrow-string calc-main-buffer buffer-size 0 nil propertize "Emacs Calculator Trail\n" face italic run-mode-hooks calc-trail-mode-hook] 5 (#$ . 46511) nil])
#@52 Create and initialize a buffer for the Calculator.
(defalias 'calc-create-buffer #[nil "\305\306!q\210\307=\204\307 \210	\310]\n\203\311\312!\210\205'\311\312!\210\313\f\314#\207" [major-mode max-lisp-eval-depth calc-always-load-extensions calc-language calc-language-option get-buffer-create "*Calculator*" calc-mode 1000 require calc-ext calc-set-language t] 4 (#$ . 47404)])
#@72 The Emacs Calculator.  Full documentation is listed under "calc-mode".
(defalias 'calc #[(&optional arg full-display interactive) "\203*\306=?\205\377\307\310!\210\311!\312U\203\313\314 \315 \316#\207\311!\317U\205)\320 \207\321\322!\2039\320 \210\323\324 !q\210	\325=\203B\326 \207p\327 \210\316\f\330=\204W\f\204_
\203_\331p\330\"\210\202\265\321p!\203n\332\321p!!\210\202\265\203z\333\334!\210\202\265\335 23\203\260\3362!\33745\340#V\203\260\3412\342\3362!5\340#\316#2\3432p\"\210\3322!\210\202\264\344p!\210)r\345 q\2106\203\314\346 \347 U\203\314\350\351\330\"\210)\352\353!\210\333\354!\210\355\f!\203\345\356\f!\203\345\332\f!\210\357 \2107\203\3728\203\372\360\340!\210\352\361!\210\330\2117)\207" [arg major-mode oldbuf calc-was-keypad-mode full-display calc-full-mode 0 require calc-ext prefix-numeric-value -1 calc-grab-region region-beginning region-end nil -2 calc-keypad get-buffer-window "*Calc Keypad*" window-buffer selected-window calc-mode calc-quit calc-create-buffer t switch-to-buffer select-window run-hooks calc-window-hook get-largest-window window-height + 2 split-window - set-window-buffer pop-to-buffer calc-trail-buffer window-width frame-width calc-trail-display 1 message "Welcome to the GNU Emacs Calculator!  Press `?' or `h' for help, `q' to quit" calc-start-hook windowp window-point calc-check-defines sit-for "" w pop-up-windows window-min-height calc-window-height calc-display-trail calc-said-hello interactive] 6 (#$ . 47797) "P\ni\np"])
#@56 Invoke the Calculator and give it a full-sized window.
(defalias 'full-calc #[(&optional interactive) "\301\302\303#\207" [interactive calc nil t] 4 (#$ . 49330) "p"])
#@78 Invoke the Calculator using the most recent interface (calc or calc-keypad).
(defalias 'calc-same-interface #[(arg) "\304 \305\232\203\306 \307V\203\310 \207\311=\203\312	!\207\n\203\"\313 \207\314	\315#\207" [major-mode arg calc-was-keypad-mode calc-full-mode buffer-name "*Gnuplot Trail*" recursion-depth 0 exit-recursive-edit calc-edit-mode calc-edit-finish calc-keypad calc t] 4 (#$ . 49505) "P"])
#@47 Quit the Calculator in an appropriate manner.
(defalias 'calc-quit #[(&optional non-fatal interactive) "\203\f	\204\f\306\307!\210\310 \311\232\203\312 \313V\203\314 \210\n\315=\203&\316 \207\203:\f\203:p\f\313H=\203:\317\307!\207\n\320=\204C\321 \210\322\323!\210
\250\203u
\313U\203[\307\211 !\202u
\313V\203u
S \233\211\"\203q\"\307\241\210)\307!\324\325#\"\210p\326p!\327\330!$%&\331\332 !\210%\203\256\333%!\204\256\334%!\203\256\326\330!\204\256\335%!\336Z'\331&!\210$\203\275\331$!\210\337&!\210\337!\210$\205\320\337$!+\207" [calc-standalone-flag non-fatal major-mode interactive calc-embedded-info calc-undo-length save-buffers-kill-emacs nil buffer-name "*Gnuplot Trail*" recursion-depth 0 exit-recursive-edit calc-edit-mode calc-edit-cancel calc-embedded calc-mode calc-create-buffer run-hooks calc-end-hook mapc #[(v) "\301\211J\"\207" [v set-default] 3] get-buffer-window get-buffer "*Calc Keypad*" delete-windows-on calc-trail-buffer window-full-height-p window-full-width-p window-height 2 bury-buffer calc-undo-list calc-redo-list tail calc-local-var-list kbuf win buf calc-window-height] 5 (#$ . 49922) "i\np"])
#@76 Do a quick calculation in the minibuffer without invoking full Calculator.
(defalias 'quick-calc #[nil "\300 \207" [calc-do-quick-calc] 1 (#$ . 51105) nil])
#@203 Do a quick calculation and return the result as a string.
Return value will either be the formatted result in string form,
or a list containing a character position and an error message in string form.
(defalias 'calc-eval #[(str &optional separator &rest args) "\303	\n#\207" [str separator args calc-do-calc-eval] 4 (#$ . 51269)])
#@226 Invoke the Calculator in "visual keypad" mode.
This is most useful in the X window system.
In this mode, click on the Calc "buttons" using the left mouse button.
Or, position the cursor manually and do M-x calc-keypad-press.
(defalias 'calc-keypad #[(&optional interactive) "\302\303!\210\304	\"\207" [calc-full-mode interactive require calc-ext calc-do-keypad] 3 (#$ . 51610) "p"])
#@89 Invoke the Calculator in full-screen "visual keypad" mode.
See calc-keypad for details.
(defalias 'full-calc-keypad #[(&optional interactive) "\301\302!\210\303\304\"\207" [interactive require calc-ext calc-do-keypad t] 3 (#$ . 52000) "p"])
(defvar calc-aborted-prefix nil)
(defvar calc-start-time nil)
(defvar calc-command-flags nil)
(defalias 'calc-do #[(do-body &optional do-slow) "\306 \210\307	\205\n?\205\310\311!\205\312 	\203 \313\202!\314]\307\211\315\316\216\317\320\321\217\210.\307\207" [calc-command-flags calc-timing calc-start-time gc-cons-threshold calc-final-point-line calc-final-point-column calc-check-defines nil require calc-ext current-time-string 2000000 100000 #1="" ((byte-code "\203	\306\307\"\210	\203:\310\311\312 	\f\232\203\313\202,\314\315\316\f!\313\"\315\316	!\313\"\"\317\320
\"\2039\306
\321\"\210,\322 >\204K!\323=\204K\324 \210\325 >\203{!\326=\203ieb\210\"Sy\210\327#!\210\202{r\330 \210eb\210\"Sy\210\327#!\210)\331 >\204\223\212\330 \210\311\211$%\311\211&')\332 >\203\240\333\334\335!!\210\336 \210(\203\253\337 \210\311\207" [calc-aborted-prefix calc-start-time calc-internal-prec calc-date-format end-time time calc-record "<Aborted>" 12 nil current-time-string 0 math-sub calcFunc-unixtime math-parse-date math-lessp 1 "(t)" no-align calc-trail-mode calc-align-stack-window position-point calc-mode move-to-column calc-select-buffer keep-flags do-edit switch-to-buffer get-buffer-create "*Calc Edit*" calc-set-mode-line calc-embedded-finish-command calc-command-flags major-mode calc-final-point-line calc-final-point-column calc-inverse-flag calc-hyperbolic-flag calc-option-flag calc-keep-args-flag calc-embedded-info] 6)) err (byte-code "\212\203\306 \210\202\307 \210	\310=\203\311\312!\203\313\n!\210\203.\f\203.\314\315!\210\316\317!\210
 \210\320\321>\203>\322 \210\317>\203I\314\323!\210)\320\207" [calc-embedded-info calc-algebraic-mode calc-alg-map do-slow calc-display-working-message do-body calc-embedded-select-buffer calc-select-buffer total require calc-ext use-local-map message "Working..." calc-set-command-flag clear-message nil renum-stack calc-renumber-stack #1# calc-aborted-prefix calc-command-flags] 2) ((error (byte-code "@\302=\203A@;\203\303\304A@\"\203\302\305!\210\202'\306\307@A\"\210\306\207" [err calc-aborted-prefix error string-match "max-specpdl-size\\|max-lisp-eval-depth" "Computation got stuck or ran too long.  Type `M' to increase the limit" nil signal] 3))) calc-aborted-prefix] 4])
(defalias 'calc-set-command-flag #[(f) "	>?\205\f	B\211\207" [f calc-command-flags] 2])
(defalias 'calc-select-buffer #[nil "\303=\206	\203
	q\207\304\305!\211\203\nq\202\306\307!)\207" [major-mode calc-main-buffer buf calc-mode get-buffer "*Calculator*" error "Calculator buffer not available"] 3])
(defalias 'calc-cursor-stack-index #[(&optional index) "db\210\301\206	\302![y\207" [index calc-substack-height 1] 2])
(defalias 'calc-stack-size #[nil "G	Z\207" [calc-stack calc-stack-top] 2])
(defalias 'calc-substack-height #[(n) "\305\f\\\305V\203\"	\203\"\n	@A@\\S	A\202\n*\207" [calc-stack stack sum n calc-stack-top 0] 2])
(defalias 'calc-set-mode-line #[nil "\212\306 \210@A@\307\310\203\311Hp=\203\312\202\313\314 G\315V\2038\314 \316\315O\317\232\2038\314 \315\320O\2029\313\f\321\322
!!@\323=\203J\324\202]@\203S\325\202]A\203\\\326\202]\313B\203f\327\202g\313C\330=\203r\331\202\227C\250\203\200\307\332C\"\202\227C\333=\203\213\334\202\227C\335=\203\226\336\202\227\313D\337=\203\242\340\202\243\313E\203\254\341\202\255\313F\204\266\313\202\302F\311=\203\301\342\202\302\343G\344=\203\315\345\202	G\346=\203\330\347\202	G\350=\203\347\307\351H\"\202	G\352=\203\362\313\202	G\353=\203\375\354\202	G\355=\203\356\202	\357I\360U\203\313\202:I\361U\203\362\202:I\363U\203*\364\202:I\365U\2035\366\202:\307\367I\"J\203C\370\202D\313K\203M\371\202N\313L\204W\313\202oL\372N\203gL\372N\373P\202o\321\322L!!\373P	\374=\203\206\375\n!\203\313\202\314\307\376\n\"\202\314	\377=\203\225\307\201\\\n\"\202\314	\201]=\203\262\375\n!\203\251\201^\202\314\307\201_\n\"\202\314	\201`=\205\314\375\n!\203\306\201a\202\314\307\201b\n\"M\204\344N\203\340\307\201cN\"\202\313\202M\201d=\203N\203\374\307\201eN\"\202\201f\202N\203\307\201gN\"\202\201hO\250\203$\307\201iO\"\2020O\203-\313\2020\201jP\2039\313\202<\201kQ\201l=\203K\201m\202\220\204S\313\202\220Q\201n=\203b\201o\202\220Q\201p=\203q\201q\202\220Q\201r=\203\200\201s\202\220Q\201t=\203\217\201u\202\220\313R\203\231\313\202\234\201v\201w\201x!\203\263\201x \203\263\201y\202\264\313\203\322\201z \316V\203\322\201{\311\201|\"\203\322\201}\202\323\313S\203\336\201~\202\337\313T\203\352\201\202\353\313U\203\366\201\200\202\367\313V\203\201\201\202\313W\203\201\202\202\313X\311U\204\201\203\202\313\201\204\201\205Y\"\260&\211Z[\232?\205IZ[\201\206\201\207 !\210\205I\201\210 ,\207" [calc-float-format fmt figs calc-embedded-info calc-internal-prec calc-angle-mode calc-select-buffer format "Calc%s%s: %d %s %-14s" 1 "Embed" "" buffer-name 12 0 "*Calculator*" nil capitalize symbol-name total "Alg* " "Alg " "Alg[( " "Symb " matrix "Matrix " "Matrix%d " sqmatrix "SqMatrix " scalar "Scalar " polar "Polar " "Frac " "+Inf " "Inf " none "NoSimp " num "NumSimp " binary "BinSimp%d " alg ext "ExtSimp " units "UnitSimp " "BasicSimp " 10 2 "Bin " 8 "Oct " 16 "Hex " "Radix%d " "TwosComp " "Zero " math-lang-name " " float zerop "Norm%d " fix calc-algebraic-mode calc-incomplete-algebraic-mode calc-symbolic-mode calc-matrix-mode calc-complex-mode calc-prefer-frac calc-infinite-mode calc-simplify-mode calc-word-size calc-number-radix calc-twos-complement-mode calc-leading-zeros calc-language calc-display-just calc-display-origin calc-line-breaking calc-assoc-selections calc-mode-save-mode calc-auto-recompute calc-display-dirty calc-option-flag calc-inverse-flag calc-hyperbolic-flag calc-keep-args-flag calc-stack-top calc-other-modes new-mode-string mode-line-buffer-identification "Fix%d " sci "Sci " "Sci%d " eng "Eng " "Eng%d " "Left%d " right "Right%d " "Right " "Center%d " "Center " "Wid%d " "Wide " "Break " save "Save " local "Local " edit "LocEdit " perm "LocPerm " global "Global " "Manual " fboundp calc-gnuplot-alive "Graph " calc-stack-size calc-top sel "Sel " "Dirty " "Opt " "Inv " "Hyp " "Keep " "Narrow " apply concat set-buffer-modified-p buffer-modified-p calc-embedded-mode-line-change] 35])
(defalias 'calc-align-stack-window #[nil "\302=\203/\303p!\211\203\304\305!\210\306\307\310	!Z!\210\311	`\"\210)\304\305!\210\312\313!\2056\305\225Sb\207\212\314 \210\315 )\207" [major-mode win calc-mode get-buffer-window calc-cursor-stack-index 0 vertical-motion 2 window-height set-window-start looking-at " *\\.$" calc-select-buffer calc-align-stack-window] 5])
(defalias 'calc-check-stack #[(n) "\301 V\203\302\303!\210\304W\205\302\305!\207" [n calc-stack-size error "Too few elements on stack" 0 "Invalid argument"] 2])
(defalias 'calc-push-list #[(vals &optional m sels) "\205r	\203\306\n#\210\202i\212\307 \210@\211\310@E\n\206#\310\\\311\n\206.\310S!\210\310V\203L\312Z\233
S\233B\241\210\202R
B\313\314
!\315\261\210)\316\317D!\210\320\321!\210,AA\202\207" [vals calc-executing-macro m sels val entry calc-push-list-in-macro calc-select-buffer 1 calc-cursor-stack-index 2 nil math-format-stack-value "\n" calc-record-undo push calc-set-command-flag renum-stack calc-stack-top mm calc-stack buffer-read-only] 5])
(defalias 'calc-pop-push-list #[(n vals &optional m sels) "\203	\204\305\n\f#\207\306\n\f	#\210\307\f	#\207" [calc-any-selections sels n vals m calc-replace-selections calc-pop-stack calc-push-list] 4])
(defalias 'calc-pop-push-record-list #[(n prefix vals &optional m sels) ":\203@\250\204@:\204\203C	\205	C\305\306\n\206'\307\310#!\210\f\203BA\203<\311\f\"\210\202B\312@\f\"\210\313\n	$\207" [vals sels n m prefix calc-check-stack + 1 -1 calc-record-list calc-record calc-pop-push-list] 5])
(defalias 'calc-enter-result #[(n prefix vals &optional m) "\n:\203\n@\250\204\n@:\203\305\306\n\"\202\306\n!\n:\2030\n@\250\2043\n@:\2043\nC\n\307\232\203;\310\311\n\f$\210\312 \207" [prefix calc-aborted-prefix vals n m mapcar calc-normalize ((nil)) nil calc-pop-push-record-list calc-handle-whys] 5])
(defalias 'calc-normalize #[(val) "\302>\203\n\303	!\207\304\305!\210\306	!\207" [calc-simplify-mode val (nil none num) math-normalize require calc-ext calc-normalize-fancy] 2])
(defalias 'calc-handle-whys #[nil "\205\301 \207" [calc-next-why calc-do-handle-whys] 1])
(defalias 'calc-pop-stack #[(&optional n m sel-ok) "\204\306	\204\f\306\n\206\210	\\
\203'\204'\307	\"\203'\310 \210\2033\311\f\"\202\207\312\313\f\314	\315#E!\210\212\316 \210\317\f\306V\203t\320	S!\210`\320\321	\322#!\210`|\210)\f\323Z\233\321\f\322#\233\241\210\202\202\320!\210\233`d|\210)\324\325!))\207" [n m calc-keep-args-flag calc-stack-top mm calc-any-selections 1 calc-top-selected calc-sel-error calc-pop-stack-in-macro calc-record-undo pop calc-top-list full calc-select-buffer nil calc-cursor-stack-index + -1 2 calc-set-command-flag renum-stack sel-ok calc-executing-macro buffer-read-only bot calc-stack] 7])
(defalias 'calc-get-stack-element #[(x &optional sel-mode) "\303=\203	\207\304=\203\305	8\207\305	8\203\"\306=\204\"\n\204%	@\207\203,\307 \207\305	8\207" [sel-mode x calc-use-selections entry sel 2 full calc-sel-error] 2])
(defalias 'calc-top #[(&optional n sel-mode) "\204\304\305!\210\306\307	\310#\n8\"\207" [n calc-stack-top calc-stack sel-mode 1 calc-check-stack calc-get-stack-element + -1] 5])
(defalias 'calc-top-n #[(&optional n sel-mode) "\302\303\304	\"!!\207" [n sel-mode math-check-complete calc-normalize calc-top] 5])
(defalias 'calc-top-list #[(&optional n m sel-mode) "\204\305	\204\f\305\306\307	\310#!\210\311V\2051\312\307	\n\310#\233!S\f\233\313\241\210\314\315\f\"\237)\207" [n m calc-stack-top calc-stack top 1 calc-check-stack + -1 0 copy-sequence nil mapcar #[(x) "\302	\"\207" [x sel-mode calc-get-stack-element] 3]] 5])
(defalias 'calc-top-list-n #[(&optional n m sel-mode) "\303\304\303\305\306	\n#\"\"\207" [n m sel-mode mapcar math-check-complete calc-normalize calc-top-list] 8])
(defalias 'calc-renumber-stack #[nil "\203\226\212\306\307!\210\310\311	\n\233\312\313\311\314#\2038\315 \210\312\313\311\314#\2034\311\315 \210\316\317!\210\320c\210)\202\306\307!\210\321\313\311\314#\203\225\316\317!\210
\322V\203f\323\324
\325\246\326@8\203_\203_\327\202`\330#c\210\202\211\331
!\211\326@8\203|\203|\327\202}\330\332\333GZ\334\"\261\210)\315 \210
TA\2028, \205\235\335 \207" [calc-line-numbering calc-stack-top calc-stack stack buffer-read-only lnum calc-cursor-stack-index 0 1 nil re-search-forward "^[0-9]+[:*]" t beginning-of-line delete-char 4 "    " re-search-backward 999 format "%03d%s" 1000 2 "*" ":" int-to-string make-string 3 32 calc-embedded-stack-change calc-use-selections prefix calc-embedded-info] 6])
(defvar calc-any-evaltos nil)
(defalias 'calc-refresh #[(&optional align) "\306=\203\210	\204\210\307`\310\311\312\217\313\314!\307\211\315 \210 \2030\316\317\320\321#c\210\203Reb\210 \203@\322y\210\323@!\324\261\210A\211\2045\325 \210!\203^\326\327!\210\203l\"\203l\326\330!\210#\204u
\203{\331 \210\202~b\210\f\203\206\332\f!\210.$\203\240\306=\204\240r$\322Hq\210\333#!\210)%T\211%\207" [major-mode calc-executing-macro buffer-read-only save-point save-mark save-aligned calc-mode nil err (mark) ((error)) looking-at "\\.$" erase-buffer propertize "--- Emacs Calculator Mode ---\n" face italic 1 math-format-stack-value "\n" calc-renumber-stack calc-do #[nil "\301\211\207" [calc-display-dirty nil] 2] #[nil "\300 \207" [calc-refresh-evaltos] 1] calc-align-stack-window set-mark calc-refresh calc-stack thing calc-any-evaltos calc-any-selections calc-show-banner calc-display-dirty calc-auto-recompute align calc-embedded-info calc-refresh-count] 5 nil nil])
(defalias 'calc-check-trail-aligned #[nil "\212\301p!\211\205\302dS\"*\207" [win get-buffer-window pos-visible-in-window-p] 4])
(defalias 'calc-trail-buffer #[nil "\203\n\304!\204+\212\305\306!	\307=\204\310\311!\206pq\210	\312=\204*\312\n!\210*\2037\313!=\204Erq\210eb\210\314y\210\315 )\207" [calc-trail-buffer major-mode buf calc-trail-pointer buffer-name get-buffer-create "*Calc Trail*" calc-mode get-buffer "*Calculator*" calc-trail-mode marker-buffer 1 point-marker] 2])
(defalias 'calc-record #[(val &optional prefix) "\306	\204\221p\307 \306\310\203,;\203\202-\311\312\")\202-\313rq\210\314 \306db\210\204H\315c\210\202lG\316V\203e\317\320\316#\203e\312\316O\320\261\210\202l\321\322\"c\210\323\261\210\324!\203\213\203\213\325>\204\213\326 \210dSb\210.	\207" [calc-aborted-prefix calc-executing-macro mainbuf buf calc-display-raw calc-can-abbrev-vectors nil calc-trail-buffer t math-format-flat-expr 0 "" calc-check-trail-aligned "     " 4 string-match " " format "%4s " "\n" get-buffer-window hold-trail calc-trail-here val calc-full-float-format calc-float-format fval buffer-read-only aligned prefix win calc-command-flags] 4])
(defalias 'calc-trail-display #[(flag &optional no-refresh interactive) "\306\305 !	\203	\307>\202?\211\203=\204I\203%\310\303!\210\2026\311\312\313 \314_\315\245\316#\317\f
\"\210)\320\321!\210\202I\203I\322!\210\320\323!\210)
\207" [win flag calc-display-trail calc-trail-window-hook w calc-trail-buffer get-buffer-window (nil 0) run-hooks split-window nil window-width 2 3 t set-window-buffer calc-do #[nil "\n\f\206
\203\306 \207\307 \207" [calc-trail-overlay overlay-arrow-string calc-trail-pointer overlay-arrow-position no-refresh interactive calc-do-refresh calc-refresh] 1] delete-window #[nil "\206
	\203\302 \207\303 \207" [no-refresh interactive calc-do-refresh calc-refresh] 1]] 4 nil "P\ni\np"])
(defalias 'calc-trail-here #[nil "\306=\203i\307 \210o\203\310y\210\202m\203\311y\210o\204\"m\203&\312\211\207\n`p\223\210``\313\\{\314P\211\n\313u\210\315p!\211\205g\212\316
!\317\245y\210\310\316
!Zy\210\320
`\"\210\321
\n\313\\\"\210q\210\n\211))\207\322\323!\207" [major-mode overlay-arrow-position calc-trail-pointer calc-trail-overlay overlay-arrow-string win calc-trail-mode beginning-of-line 1 -1 nil 4 ">" get-buffer-window window-height 2 set-window-start set-window-point error "Not in Calc Trail buffer" calc-main-buffer] 5 nil nil])
(defalias 'calc-record-undo #[(rec) "\206\305	>\203\n@BAB\211\207\nCB\306\307\305!\207" [calc-executing-macro calc-command-flags rec calc-undo-list calc-redo-list undo nil calc-set-command-flag] 2])
(defalias 'calc-binary-op #[(name func arg &optional ident unary func2) "\n\204\306\307\206\f\310\311\312\307!\"B#\207\313\314!\210\315\f\n
%\207" [name calc-aborted-prefix arg func2 func ident calc-enter-result 2 mapcar math-check-complete calc-top-list require calc-ext calc-binary-op-fancy unary] 8])
(defalias 'calc-unary-op #[(name func arg &optional func2) "\n\204\305\306\206\f\307\310\306!!D#\207\311\312!\210\313\f\n#\207" [name calc-aborted-prefix arg func2 func calc-enter-result 1 math-check-complete calc-top require calc-ext calc-unary-op-fancy] 7])
(defalias 'calc-plus #[(arg) "\300\301`\"\207" [calc-do #[nil "\301\302\303\304\305\306&\207" [arg calc-binary-op "+" calcFunc-add 0 nil +] 7]] 3 nil "P"])
(defalias 'calc-minus #[(arg) "\300\301`\"\207" [calc-do #[nil "\301\302\303\304\305\306&\207" [arg calc-binary-op "-" calcFunc-sub 0 neg -] 7]] 3 nil "P"])
(defalias 'calc-times #[(arg) "\300\301`\"\207" [calc-do #[nil "\301\302\303\304\305\306&\207" [arg calc-binary-op "*" calcFunc-mul 1 nil *] 7]] 3 nil "P"])
(defalias 'calc-divide #[(arg) "\300\301`\"\207" [calc-do #[nil "\301\302\303\304\305\306&\207" [arg calc-binary-op "/" calcFunc-div 0 calcFunc-inv /] 7]] 3 nil "P"])
(defalias 'calc-left-divide #[(arg) "\300\301`\"\207" [calc-do #[nil "\301\302\303\304\305\211&\207" [arg calc-binary-op "ldiv" calcFunc-ldiv 0 nil] 7]] 3 nil "P"])
(defalias 'calc-change-sign #[(arg) "\300\301!\207" [calc-do #[nil "\301\302\303#\207" [arg calc-unary-op "chs" neg] 4]] 2 nil "P"])
(defalias 'calc-enter #[(n) "\300\301!\207" [calc-do #[nil "\301W\203\302\303\304[\"!\207\301U\203\302\303\305 !!\207\302\303!!\207" [n 0 calc-push-list calc-top-list 1 calc-stack-size] 4]] 2 nil "p"])
(defalias 'calc-pop #[(n) "\300\301!\207" [calc-do #[nil "\305!?\205\f\306\307!\204A\n\242\310=\203A\nG\nA@\311=\203&\312\202'\313V\203A\314\307\315\n!\211G\313Z\233\316\241\210)C\"\202\214	\317W\203c\f\203Z\320\307	[\"\203Z\321	[!\202\214\322\307	[\323#\202\214	\317U\203r\322\324 \307\323#\202\214\f\203\211	\307U\203\211\320\307\211\"\203\211\321\307!\202\214\322	!*\207" [n nn top tt calc-any-selections prefix-numeric-value calc-top 1 incomplete intv 3 2 calc-pop-push-list copy-sequence nil 0 calc-top-selected calc-delete-selection calc-pop-stack t calc-stack-size] 5]] 2 nil "P"])
(defalias 'calcDigit-start #[nil "\300\301!\207" [calc-do #[nil "\204	\306V\203\n\307=\203\310 \207\311 \210\312\211\312\211p\313\314\"\315\216\316\314\312#\210\317\320\321#* \f\204D\322 !\f;\203P\323\f!\210\202]\f\203]\324\325\326\f!!C!\210
\327=\205i\330\331!\210\332 -\207" [calc-algebraic-mode calc-number-radix last-command-event calc-aborted-prefix calc-digit-value calc-prev-char 14 101 calc-alg-digit-entry calc-unread-command nil lookup-key "" ((define-key global-map "" old-esc)) define-key read-from-minibuffer "Calc: " "" math-read-number calc-alg-entry calc-push-list calc-record calc-normalize dots require calc-ext calc-dots calc-prev-prev-char calc-buffer global-map old-esc calc-digit-map buf] 5]] 2 nil nil])
(defalias 'calc-minibuffer-size #[nil "d\300 Z\207" [minibuffer-prompt-end] 2])
(put 'calc-minibuffer-size 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'calcDigit-nondigit #[nil "\306\302!\204\n\307!\210\310 r\nq\210\311	!))\204+d\312 Z\313V\203+\314 \210\315\316!\207\f\317>\204F
\320\f\321=\205D\322Y\205D!\210\323 \207" [minibuffer-local-map str calc-buffer calc-digit-value last-command-event current-prefix-arg boundp use-local-map minibuffer-contents math-read-number minibuffer-prompt-end 0 beep calc-temp-minibuffer-message " [Bad format]" (32 13) calc-unread-command 27 128 exit-minibuffer prefix-arg last-input-event] 3 nil nil])
(defalias 'calc-minibuffer-contains #[(rex) "\212\301 b\210\302!)\207" [rex minibuffer-prompt-end looking-at] 2])
(defalias 'calcDigit-key #[nil "db\210\306>\203\307 \310V\203h\311U\203(\312>\203.\313\314!\204.\313\315!\204.\316 \210\202\313\317!\203i\320>\203@\321c\210\202i\322>\203R\313\323!\204R\321c\210\202i\324>\203^\325c\210\202i\326=\203i\327	!c\210\313\330!\203x\331=\203x\325c\210\313\332!\203\207\333=\203\207\321c\210\313\334!\203\226\311=\203\226\325c\210\335>\203\242\313\323!\204\272\311=\203\256\313\336!\204\272\337=\203\275\313\340!\203\275\226\341>\203	\342 b\210\343\344\345\346#\203\335\343\347\345\346#\204\335\350 \210\202\313\336!\204\351\343\347\345\346#\210\351\352!\203\363\353\354!\210\351\355!\203\353\354!\210\202\355c\210db\210\202\356=\203<\313\357!\204'\313\360!\204'\313\323!\204'\313\361!\203-\350 \210\202\313\362!\2046\363c\210\364c\210\202\365=\203\210\313\366!\204\210\313\357!\204Z\313\367!\204Z\313\361!\203`\350 \210\202\313\370!\203y\n\203s\371\n\310\"c\210\202\350 \210\202\313\362!\204\202\363c\210\372c\210\202\373!c\210\313\374!\203\302\375\376\224\376\225{!\211\376Y\205\276\377X\205\276\201D>\206\276\201E\226!\211\205\275\fW))\204\312\313\201F!\203\341\201G>\203\201H\363
\"\203\363c\210\202@A=\203\377\333=\203\377\201I\201J!\210\201K \210\202\353\201L!\210\350 \210\201M\201N!\210BC\211B\207" [last-command-event calc-number-radix calc-previous-modulo radix dig calc-hms-format (43 45) buffer-size 0 101 (109 115) calc-minibuffer-contains "[-+]?[0-9]+\\.?0*[@oh].*" "[-+]?\\(1[1-9]\\|[2-9][0-9]\\)#.*" calcDigit-nondigit "\\([-+]?\\|.* \\)\\'" (46 64) "0" (111 104 109) ".*#.*" (58 101) "1" 35 int-to-string "\\([-+]?[0-9]+#\\|[^:]*:\\)\\'" 58 "[-+]?[0-9]+#\\'" 46 "[-+]?0*\\([2-9]\\|1[0-4]\\)#\\'" (104 111 109 115 112) "[-+]?\\(1[5-9]\\|[2-9][0-9]\\)#.*" 110 "[-+]?\\(2[4-9]\\|[3-9][0-9]\\)#.*" (95 110) minibuffer-prompt-end search-forward " +/- " nil t "e" beep looking-at "+" delete-char 1 "-" 112 ".*\\+/-.*" ".*mod.*" ".*[-+e:]\\'" ".* \\'" " " "+/- " 77 "[-+]?\\(2[3-9]\\|[3-9][0-9]\\)#.*" ".*mod *[^ ]+" ".*mod \\'" math-format-flat-expr "mod " char-to-string "[-+]?\\(.*\\+/- *\\|.*mod *\\)?\\([0-9][0-9]?\\)#[#]?[0-9a-zA-Z]*\\(:[0-9a-zA-Z]*\\(:[0-9a-zA-Z]*\\)?\\|.[0-9a-zA-Z]*\\(e[-+]?[0-9]*\\)?\\)?\\'" string-to-number 2 36 this-command last-command calc-prev-char calc-prev-prev-char (35 58 46 101 43 45) math-read-radix-digit "[-+]?\\(.*\\+/- *\\|.*mod *\\)?\\([0-9]+\\.?0*[@oh] *\\)?\\([0-9]+\\.?0*['m] *\\)?[0-9]*\\(\\.?[0-9]*\\(e[-+]?[0-3]?[0-9]?[0-9]?[0-9]?[0-9]?[0-9]?[0-9]?\\)?\\|[0-9]:\\([0-9]+:\\)?[0-9]*\\)?[\"s]?\\'" (64 111 104 39 109) string-match require calc-ext calc-digit-dots -1 calc-temp-minibuffer-message " [Bad format]"] 5 nil nil])
(defalias 'calcDigit-backspace #[nil "db\210\302\303!\203\304\305!\210\202:\302\306!\203\304\305!\210\202:\302\307!\203*\304\310!\210\202:\311=\2036\312 \210\202:\304\313!\210d\314 Z\315U\205G\316\317 \207" [last-command last-command-event calc-minibuffer-contains ".* \\+/- \\'" backward-delete-char 5 ".* mod \\'" ".* \\'" 2 calcDigit-start erase-buffer 1 minibuffer-prompt-end 0 13 calcDigit-nondigit] 2 nil nil])
#@248 The length of a "digit" in Calc bignums.
If a big integer is of the form (bigpos N0 N1 ...), this is the
length of the allowable Emacs integers N0, N1,...
The value of 2*10^(2*MATH-BIGNUM-DIGIT-LENGTH) must be less than the
largest Emacs integer.
(defconst math-bignum-digit-length (byte-code "\301\302\303\245!\303\245!\207" [most-positive-fixnum truncate log10 2] 4) (#$ . 74231))
#@62 An upper bound for the size of the "digit"s in Calc bignums.
(defconst math-bignum-digit-size (expt 10 math-bignum-digit-length) (#$ . 74621))
#@58 An upper bound for the size of "small integer"s in Calc.
(defconst math-small-integer-size (expt math-bignum-digit-size 2) (#$ . 74770))
#@66 Non-nil if the last call the `math-normalize' returned an error.
(defvar math-normalize-error nil (#$ . 74913))
(defalias 'math-normalize #[(math-normalize-a) "\306	:\204!	\250\203	\nY\204	\n[X\203\307	!\207	\207	\207	@\310=\203v	GS	8\311=\203R\312	!\211	\fA\211\203M\f@\311=\204:\f\202:\306\241\210*	AAA\203[	\207	AA\203k	A@\313	8
_\\\207	A\203t	A@\207\311\207	@\314=\203\315	GS	8\311=\203\247\312	!\211	\fA\211\203\242\f@\311=\204\217\f\202\217\306\241\210*	AAA\203\260	\207	AA\203\301	A@\313	8
_\\[\207	A\203\313	A@[\207\311\207	@\315=\203\337\316\317	A@!\313	8\"\207	@\320>\204\372	@\250\204\372	@:\203	@@\321=\204\322\323!\210\324	!\207\203\322\323!\203\325 \2061\326\317	A\"\327\330\331\217\2060	@:\203+\332 \2020	@B)\207" [math-normalize-error math-normalize-a math-small-integer-size last digs math-bignum-digit-size nil math-bignum bigpos 0 copy-sequence 2 bigneg float math-make-float math-normalize (frac cplx polar hms date mod sdev intv vec var quote special-const calcFunc-if calcFunc-lambda calcFunc-quote calcFunc-condition calcFunc-evalto) lambda require calc-ext math-normalize-fancy math-normalize-nonstandard mapcar err (byte-code "@\306\236\n\203/\n=\204\307\310!\210\311 \210\f\204!@
\236\203/\312@B
A\313
$\206c	\203<\314	A\"\202c@:\204]\315@!\204]\316\310!?\205c\307\310!\205c\315@!\205c\314@\")\207" [math-normalize-a func var-EvalRules math-eval-rules-cache-tag math-eval-rules-cache-other math-eval-rules-cache ((+ . math-add) (- . math-sub) (* . math-mul) (/ . math-div) (% . math-mod) (^ . math-pow) (neg . math-neg) (| . math-concat)) require calc-ext math-recompile-eval-rules math-apply-rewrites nil apply fboundp featurep args] 5) ((wrong-number-of-arguments (byte-code "\303\304\305	@\nB\"\210\306\207" [math-normalize-error math-normalize-a args t calc-record-why "*Wrong number of arguments" nil] 4)) (wrong-type-argument (byte-code "\304	\204\305\306\n@B\"\210\307\207" [math-normalize-error calc-next-why math-normalize-a args t calc-record-why "Wrong type of argument" nil] 4)) (args-out-of-range (byte-code "\303\304\305	@\nB\"\210\306\207" [math-normalize-error math-normalize-a args t calc-record-why "*Argument out of range" nil] 4)) (inexact-result (byte-code "\303\304\305	@\nB\"\210\306\207" [math-normalize-error math-normalize-a args t calc-record-why "No exact representation for result" nil] 4)) (math-overflow (byte-code "\303\304\305	@\nB\"\210\306\207" [math-normalize-error math-normalize-a args t calc-record-why "*Floating-point overflow occurred" nil] 4)) (math-underflow (byte-code "\303\304\305	@\nB\"\210\306\207" [math-normalize-error math-normalize-a args t calc-record-why "*Floating-point underflow occurred" nil] 4)) (void-variable (byte-code "\305	A@\302=\203\306\307@\fB!\207\310\311	A@\"\207" [math-normalize-error err var-EvalRules math-normalize-a args t nil math-normalize calc-record-why "*Variable is void"] 3))) math-dimension-error calc-simplify-mode args] 4])
(defalias 'math-floatp #[(a) "\242\301=\203	\302\207\242\303>\203-\304A@!\2069\304\3058!\2069@\306=\205,\304\3078!\207\242\310=\2059\304A@!\207" [a float t (cplx polar mod sdev intv) math-floatp 2 intv 3 date] 3])
(defalias 'math-check-complete #[(a) "\250\203\207\242\301=\203\302!\207:\203\207\303\304!\207" [a incomplete calc-incomplete-error error "Invalid data object encountered"] 2])
(defalias 'math-bignum #[(a) "\301Y\203\f\302\303!B\207\304\303[!B\207" [a 0 bigpos math-bignum-big bigneg] 3])
(defalias 'math-bignum-big #[(a) "\302U?\205	\246\303	\245!B\207" [a math-bignum-digit-size 0 math-bignum-big] 4])
(defalias 'math-make-float #[(mant exp) "\306=\203\307\207	\310!Z\211\306W\203\311\n\"\nZ):\203^A\211@\312\246\306U\203Z\f@\306U\203@\fA
\\\202/\f@\312\246\306U\203S\313\f!T\202@\314@\fB!)\202p\312\246\306U\203p\312\245T\202^\315X\203\207\316\310!\317#\315X\203\207\320\321\322\"\207\323Y\203\236\316\310!\317#\324Y\203\236\320\325\322\"\207\326E\207" [mant calc-internal-prec ldiff exp digs math-bignum-digit-length 0 (float 0 0) math-numdigs math-scale-rounding 10 math-div10-bignum math-normalize -4000000 + -1 signal math-underflow nil 3000000 4000000 math-overflow float] 5])
(defalias 'math-div10-bignum #[(a) "A\203@\302\245A@\302\246\303\302	S\"_\\\304A!B\207@\302\245C\207" [a math-bignum-digit-length 10 expt math-div10-bignum] 5])
(defalias 'math-float #[(a) "\211:?\206\f@\301>)\203\302\303\"\207@\304=\203'\305\306A@!\3078\"\207@\310=\2030\207@\311>\203@@\312\306A\"B\207\313!\207" [a (bigpos bigneg) math-make-float 0 frac math-div math-float 2 float (cplx polar vec hms date sdev mod) mapcar math-float-fancy] 5])
(defalias 'math-neg #[(a) ":\204[\207@\301=\203\302AB\207@\302=\203 \301AB\207@\303>\203O@A@\211:\203G@\301=\203@\302AB\202I\301AB\202I[)\3048E\207@\305>\203_@\306\307A\"B\207\310!\207" [a bigpos bigneg (frac float) 2 (cplx vec hms date calcFunc-idn) mapcar math-neg math-neg-fancy] 5])
(defalias 'math-numdigs #[(a) ":\203A\203GS\2118	S_\304\n!\\*\207\305\207\306Y\203,\304\307\245!\310\\\207\311Y\2034\312\207\313Y\203<\313\207\305U\203D\305\207\314V\203L\313\207\315V\203T\312\207\304[!\207" [a len top math-bignum-digit-length math-numdigs 0 100 1000 3 10 2 1 -10 -100] 4])
(defalias 'math-scale-int #[(a n) "\302U\203	\207\302V\203\303	\"\207\304\305	[\"!\207" [n a 0 math-scale-left math-normalize math-scale-right] 4])
(defalias 'math-scale-left #[(a n) "\305U\203	\207	:\203	@\306	A\"B\207\nY\2039	Y\204)	[X\2030\307\310	!\"\207\307	_\nZ\"\207\311\312\n\313_Z\"	\fY\204O	\f[X\203X\307\310	!\"\202^	\311\312\"_)\207" [n a math-bignum-digit-length math-bignum-digit-size sz 0 math-scale-left-bignum math-scale-left math-bignum expt 10 2] 4])
(defalias 'math-scale-left-bignum #[(a n) "	Y\203\303\nB	Z\211	Y\204\303V\203#\304\n\305\306\"\303#\207\n\207" [n math-bignum-digit-length a 0 math-mul-bignum-digit expt 10] 5])
(defalias 'math-scale-right #[(a n) "\304U\203	\207	:\203	@\305	A\"B\207	\304X\203+	\304U\203$\304\207\306	[\"[\207\nY\203E	\245\211\304V\203E\nZ\211\nY\2041\304V\203R	\307\310\"\245\207	\207" [n a math-bignum-digit-length math-bignum-digit-size 0 math-scale-right-bignum math-scale-right expt 10] 4])
(defalias 'math-scale-right-bignum #[(a n) "	Y\203	\245\n\233	\246\303V\203\"\304\n\305\306	Z\"\303#A\207\n\207" [n math-bignum-digit-length a 0 math-mul-bignum-digit expt 10] 6])
(defalias 'math-scale-rounding #[(a n) "\305Y\203\306	\"\207	:\203t\307	@\n[W\203%\310	A\n[Z\"\202;\305W\2039\311	A\312\313\n\\\"\305#\202;	A\211\203n@\f\314\245Y\203nA\203jA@\fS=\203_\315A\316\"\202pA@TAAB\202p\317\202pA)B!\207	\305W\203\201\320	[\"[\207\321U\203\215	\322\\\313\245\207\323	\321Z\"\322\\\313\245\207" [n a math-bignum-digit-length val math-bignum-digit-size 0 math-scale-left math-normalize math-scale-right-bignum math-mul-bignum-digit expt 10 2 math-add-bignum (1) (1) math-scale-rounding -1 5 math-scale-right] 9])
(defalias 'math-add #[(a b) ":\204%	:\204%	\\\211\n[X\204\nY\203!\304!\202\"\206\211:\203I@\305>?\205L@\306=\203CA@\307=\202L\310!\202L\307=)\203w\242\311=\204w\312!\203s	\211:?\206i@\313>)\203s\314	!\202t	\206	\211:\203\233@\305>?\205\236@\306=\203\225A@\307=\202\236\310!\202\236\307=)\203\311	\242\311=\204\311\312	!\203\305\211:?\206\273@\313>)\203\305\314!\202\306\206\211:?\206\325@\315>)\203		\211:?\206\345@\315>)\203	\211:?\206\365@\316>)\203\210	\211:?\206@\316>)\203\210:\204\304!	:\204\304	!@\317=\203U	@\317=\2034\317\320A	A\"B\202\205\321\322	AA\"\211\323=\203M\317\322A	A\"B\202P\324B)!\202\205	@\317=\203}\321\322A	A\"\211\323=\203u\317\322	AA\"B\202x\324B)!\202\205\324\320A	A\"B\206\211:?\206\224@\313>)\203\265	\211:?\206\244@\313>)\203\265\325\326!\203\265\327	\"\206\211:?\206\301@\330>)\203\374	\211:?\206\321@\330>)\203\374:\203\341@\306=\204\345\314!	:\203\361	@\306=\204\365\314	!\331	\"\206\325\326!\203	\332	\"\206\325\326!\205\333	\"\207" [a b math-small-integer-size diff math-bignum (bigpos bigneg) float 0 math-zerop mod math-floatp (bigpos bigneg frac) math-float (bigpos bigneg frac float cplx polar hms date sdev intv mod vec) (bigpos bigneg) bigneg math-add-bignum math-normalize math-sub-bignum neg bigpos require calc-ext calc-add-fractions (bigpos bigneg frac float) math-add-float math-add-objects-fancy math-add-symb-fancy] 6])
(defalias 'math-add-bignum #[(a b) "\203\252	\203\250\306!\211\307\211\n\203c	\203c\203?\n@	@\\\211
SW\2035\n\fT\240\210\307\202Z\n\f
SZ\240\210\202Z\n@	@\\\211
W\203R\n\f\240\210\202Z\n\f
Z\240\210\310\nA	A\202\203\233	\203t\311	\312\"\244\202\246\n@
S=\203\207\n\313\240\210\nA\211\202u\n\203\225\n\211@T\240\210\202\246\314\244\202\246	\203\245	\244\202\246,\207\207	\207" [a b aa carry sum math-bignum-digit-size copy-sequence nil t math-add-bignum (1) 0 (1)] 5])
(defalias 'math-sub-bignum #[(a b) "\203\275	\203\251\306	!\211\307\211\307\n\203f\203f\203A\n@@Z\211\310Y\2036\n
S\240\210\307\202]\n
\fS\\\240\210\202]\n@@Z\211\311Y\203T\n
\240\210\202]\n
\f\\\240\210\312\nAA\202\203\220\n@\311=\203~\n\fS\240\210\nA\211\202k\n\203\214\n\211@S\240\210	\202\247\313\202\247@\311=\203\236A\211\202\221\203\246\313\202\247	-\207@\311=\203\267A\211\202\252\205\274\313\207	\207" [b a aa borrow sum diff copy-sequence nil 1 0 t neg math-bignum-digit-size] 4])
(defalias 'math-add-float #[(a b) "\3048\304	8Z\211\305Y\2039\n\211\\Y\203\202X\306\307	A@\n\305=\203+A@\2021\310A@\n\"\"\304	8\"\202X\n[\211\211\\Y\203H	\202X\306\307A@\310	A@\n\"\"\3048\")\207" [a b ediff calc-internal-prec 2 0 math-make-float math-add math-scale-left] 7])
(defalias 'math-sub #[(a b) ":\204\n	:\203\303\304	!\"\207	Z\211\n[X\204\"\nY\203&\305!\207\207" [a b math-small-integer-size math-add math-neg math-bignum] 5])
(defalias 'math-sub-float #[(a b) "\3048\304	8Z\211\305Y\203W\n\211\\Y\203\202\224\306\307	A@\211:\203:@\310=\2033\311AB\202<\310AB\202<[)\n\305=\203IA@\202O\312A@\n\"\"\304	8\"\202\224\n[\211\211\\Y\203f	\202\224\306\307A@\312	A@\n\"\211:\203\214@\310=\203\205\311AB\202\216\310AB\202\216[)\"\3048\")\207" [a b ediff calc-internal-prec 2 0 math-make-float math-add bigpos bigneg math-scale-left] 7])
(defalias 'math-mul #[(a b) ":\204*	:\204*\nW\203*\n[V\203*	\nW\203*	\n[V\203*	_\206)\211:\203N@\303>?\205Q@\304=\203HA@\305=\202Q\306!\202Q\305=)\203\227	\242\307=\204\227	\211:?\206h@\310>)\203\214\311	!\203\210\211:?\206~@\312>)\203\210\313!\202\224\202\224\314\315!\210\316	\"\206)	\211:\203\273@\303>?\205\276@\304=\203\265A@\305=\202\276\306!\202\276\305=)\203\242\307=\204\211:?\206\325@\310>)\203\371\311!\203\365	\211:?\206\353@\312>)\203\365\313	!\202	\202\314\315!\210\316	\"\206)\211:?\206@\317>)\203	\211:?\206 @\317>)\203\211:?\2060@\320>)\203\221	\211:?\206@@\320>)\203\221:\204M\321!	:\204V\321	!\322@	@=\203c\323\202d\324AA\203\204	AA\203y\325A	A\"\202\214\326A	A@\305#\202\214\326	AA@\305#B!\206)\211:?\206\235@\312>)\203\276	\211:?\206\255@\312>)\203\276\314\315!\203\276\327	\"\206)\211:?\206\312@\330>)\203	\211:?\206\332@\330>)\203:\203\352@\304=\204\356\313!	:\203\372	@\304=\204\376\313	!\331\332A@	A@\"\3338\333	8\\\"\206)\314\315!\203\334	\"\206)\314\315!\205)\335	\"\207" [a b math-bignum-digit-size (bigpos bigneg) float 0 math-zerop mod (bigpos bigneg frac float cplx polar hms) math-floatp (bigpos bigneg frac) math-float require calc-ext math-mul-zero (bigpos bigneg frac float cplx polar hms date sdev intv mod vec) (bigpos bigneg) math-bignum math-normalize bigpos bigneg math-mul-bignum math-mul-bignum-digit calc-mul-fractions (bigpos bigneg frac float) math-make-float math-mul 2 math-mul-objects-fancy math-mul-symb-fancy] 7])
(defalias 'math-infinitep #[(a &optional undir) ":\203+@\302>\203+@\303=\203\304A@!\203#A@\211\202\3058\211\202:\205N@\306=\205N\3058\307>\205N	\203M\3058\310=\203M\311\207\207" [a undir (* / neg) * math-infinitep 2 var (var-inf var-uinf var-nan) var-inf (var uinf var-uinf)] 3])
(defalias 'math-mul-bignum #[(a b) "\205\267	\205\267	@\306X\203!	@\307U\203\307C\202'\310!\202'\311	@\307#\211\312\211\312\211\f\312
	A\211\203\264A\206G\307C\241\211\f	@\307\f\211@@
_\\\f\\\211
\246\240\210A\211\203\207
\245\fA\206\201\f\307C\241\211\f\202U
Y\2037\fA\203\247\fA
\245\fA@\\\240\210\2027\f
\245C\241\210\2027\n.\207" [a b sum sump c d 1 0 copy-sequence math-mul-bignum-digit nil aa ss prod math-bignum-digit-size] 5])
(defalias 'math-mul-bignum-digit #[(a d c) "\203F	\306X\203	\306U\205E\207\307!\211\310\n\211@	_\f\\\211
\246\240\210\nA\2036\nA
\245\202
Y\203C\n
\245C\241\210+\207\f\311V\205N\fC\207" [a d aa prod c math-bignum-digit-size 1 copy-sequence nil 0] 4])
(defalias 'math-idivmod #[(a b) "\304=\203\305	\306\"\210	:\204:\203h\307!\2033\nW\2033\310	A\"\311	@@B!A)B\207	:\204<\312	!:\204E\312!\313	AA\"\311	@@=\203Y\314\202Z\315@B!\311	@AB!)B\207	\245	\246B\207" [b a math-bignum-digit-size res 0 math-reject-arg "*Division by zero" natnump math-div-bignum-digit math-normalize math-bignum math-div-bignum bigpos bigneg] 4])
(defalias 'math-quotient #[(a b) ":\204	:\204	\306U\203\307\310\"\207	\245\207\311	!\203<	\nW\203<	\306U\2030\307\310\"\207\312@\313A	\"@B!\207:\204E\314!	:\204N\314	!GS	GS\n\fS	A8T\245\315\316A
\306#\316	A
\306#\f$\312@	@=\203~\317\202\320@B!,\207" [a b math-bignum-digit-size alen blen d 0 math-reject-arg "*Division by zero" natnump math-normalize math-div-bignum-digit math-bignum math-div-bignum-big math-mul-bignum-digit bigpos bigneg res] 6])
(defalias 'math-div-bignum #[(a b) "A\203;	GG\fS8T\245\306\307	
\310#\307
\310#\n$
\311U\203.\2029@\312A
\"@B,\207\312	@\"\211@A)CB\207" [b a alen blen math-bignum-digit-size d math-div-bignum-big math-mul-bignum-digit 0 1 math-div-bignum-digit res] 7])
(defalias 'math-div-bignum-digit #[(a b) "\203\305A	\"\211A_@\\\211	\245\n@B\f	\246*B\207\306\207" [a b res math-bignum-digit-size num math-div-bignum-digit (nil . 0)] 4])
(defalias 'math-div-bignum-big #[(a b alen blen) "	W\203\n\306\nB\207\307\nAS	$\n@\fAB\310
	#\211	@\f@B	A+B\207" [alen blen a b res num nil math-div-bignum-big math-div-bignum-part res2] 6])
(defalias 'math-div-bignum-part #[(a b blen) "	8\206\306\n_S	8\206\306\\S\f8
\245\nS^	\307	\f\310\f	\306#	$+\207" [blen a math-bignum-digit-size num b den 0 math-div-bignum-try math-mul-bignum-digit guess] 7])
(defalias 'math-div-bignum-try #[(a b c guess) "\305	\"\211\306=\203\307\305	\"\fS$\202\f\nB)\207" [a c rem b guess math-sub-bignum neg math-div-bignum-try] 7])
(defalias 'math-div #[(a b) "\211:\203$	@\304>?\205'	@\305=\203	A@\306=\202'\307	!\202'	\306=)\2038\310\311!\2038\312	\"\206\236	\211:\203\\	@\304>?\205_	@\305=\203V	A@\306=\202_\307	!\202_	\306=)\203\245\242\313=\204\245\211:?\206v	@\314>)\203\232\315!\203\226	\211:?\206\214	@\316>)\203\226\317	!\202\242	\202\242\310\311!\210\320	\"\206\236	\211:?\206\261	@\321>)\203\224\211:?\206\301	@\321>)\203\224	\211:?\206\321	@\322>)\203\211:?\206\341	@\322>)\203\323	\"\211A\306=\203\366\n@\202\203\310\311!\210\324	\"\202\325\326	\306\"\326\306\"\")\206\236	\211:?\206	@\316>)\203@\211:?\206/	@\316>)\203@\310\311!\203@\327	\"\206\236	\211:?\206L	@\330>)\203\207\211:?\206\\	@\330>)\203\207	:\203l	@\305=\204p\317	!:\203|@\305=\204\200\317!\325	\"\206\236\310\311!\203\224\331	\"\206\236\310\311!\205\236\332	\"\207" [b a q calc-prefer-frac (bigpos bigneg) float 0 math-zerop require calc-ext math-div-by-zero mod (bigpos bigneg frac float cplx polar hms) math-floatp (bigpos bigneg frac) math-float math-div-zero (bigpos bigneg frac float cplx polar hms date sdev intv mod vec) (bigpos bigneg) math-idivmod math-make-frac math-div-float math-make-float calc-div-fractions (bigpos bigneg frac float) math-div-objects-fancy math-div-symb-fancy] 6])
(defalias 'math-div-float #[(a b) "T\304	A@!\304\nA@!ZZ\305]\306\307\310	A@\"\nA@\"\311	8\311\n8ZZ\")\207" [calc-internal-prec a b ldiff math-numdigs 0 math-make-float math-quotient math-scale-int 2] 5])
(defalias 'math-format-stack-value #[(entry) "\n@\306\n8\204\307\202h
\310=\203\311\312\"\202h;\203'\202h\313=\2035\314\315\316\317#\202h*\203?*\202h\211:?\206K@\320>)\203`+\321>\203`\f\204`\322!\202h\323\324!\210\325\326\",\327,!-\330\211./\f\203}\3100-A/-@\211-\326V\203\230\331\332-\333\",\",1\334\232\204\266\331\313=\203\257\3321G\333\"\202\2611,\",2\203\325\331+\335=\203\317\f\203\313\336\202\320\337\202\320\340,\",3\334\232\204\313=\204\323\324!\210\341,\332\342/\343,!3G#\326]\333\"\3443\257,,;\203
\203\345,!\202,\202\346,/\".4\203*4.!.+\335=\203:.\347P.\202H2\203H\350.\306\330OP.\nA\351.!\240\210..\207" [calc-selection-cache-default-entry calc-selection-cache-entry entry a math-comp-selected calc-display-raw 2 "<nil>" t format "%s" top-of-stack propertize "." font-lock-face bold (bigpos bigneg frac float cplx polar hms) (nil flat unform) math-format-number require calc-ext math-compose-expr 0 math-stack-value-offset nil math-comp-concat make-string 32 "" big (tag t "1:  ") "1:  " "    " horiz - math-comp-width (break -1) prin1-to-string math-composition-to-string "\n" "1:" calc-count-lines calc-prepared-composition calc-language c off s w calc-any-selections calc-left-label calc-line-numbering calc-right-label calc-language-output-filter] 8])
(defalias 'math-stack-value-offset #[(math-svo-c) "\203\306\202	\307\310 \311\f\203\312\313!\210\314 \210\202,
\206\"\307
\250\203,
GZ\307]\n	\\+B\207" [calc-line-numbering num math-svo-wid math-svo-off calc-display-just calc-display-origin 4 0 calc-window-width nil require calc-ext math-stack-value-offset-fancy calc-line-breaking calc-left-label] 3])
(defalias 'calc-count-lines #[(s) "\303\304\305\306\n	#\211\203	TT\202*\207" [num pos s 0 1 string-match "\n"] 4])
(defalias 'math-format-value #[(a &optional w) "\211:?\206\f@\304>)\203	\305>\203\306!\207\307\310!\210\311\312\313\314\"\")\207" [a calc-language calc-line-breaking w (bigpos bigneg frac float cplx polar hms) (nil flat unform) math-format-number require calc-ext nil math-composition-to-string math-compose-expr 0] 5])
(defalias 'calc-window-width #[nil "\203\303\304H!\211\203\305	!\202\306 S)\207\305\303p!!\n\203&\307\202'\310Z\207" [calc-embedded-info win calc-line-numbering get-buffer-window 0 window-width frame-width 5 1] 4])
(defalias 'math-comp-concat #[(c1 c2) ";\203	;\203	P\207\302	E\207" [c1 c2 horiz] 3])
(defalias 'math-format-flat-expr #[(a prec) ":\204\n\250\203	\306=\203\306\307\310!P)\207\211:?\206%@\311>)\203J\312\313@G\314V\2037\315\2028\316\312\317\312\320!.\207\321\322!\210\323\"\207" [a calc-display-raw print-escape-newlines calc-frac-format calc-language calc-hms-format t "'" prin1-to-string (bigpos bigneg frac float cplx polar hms) nil "." 1 ("::" nil) (":" nil) "%s@ %s' %s\"" math-format-number require calc-ext math-format-flat-expr-fancy calc-complex-format calc-point-char calc-group-digits prec] 7])
(defalias 'math-format-number #[(a &optional prec) "\306=\203\307\310	\"\207\n\203\241\203\241	\211:?\206	@\311>)\203\241	\312=\204\231	\211:\2037	@\313=\202:	\312V)\203L	\f\314	
\"\315U*\204\231	\211:\203Z	@\316=\202]	\312W)\203\241\317\320!\203\241\314	\211:\203\204	@\313=\203}\316	AB\202\206\313	AB\202\206	[)\f\"\2115\312U\206\2255\315U)\203\241\317\321!\210\322	!\2076A@\203\302	\211:?\206\264	@\311>)\203\302\317\320!\210\323\324	!!\207	\250\203*7\204$8\204$9\325U\203\334\326	!\207	\312W\203\351\327\323	[!P\207\317\320!\210\203 :\203:9\211\330U\203\331	!\202	\332	!\"\207\307\3339\211\330U\203\331	!\202\332	!#\207\332	!\207\323\334	!!\207	;\2031	\207	:\204:\335	!\207	@\313=\203F\336	A!\207	@\316=\203T\327\336	A!P\207	@\337=\203\2179\325U\203\217	A@\211:\203r	@\316=\202u	\312W)\203\201\327\323\340	!!P\207	A@\330	8;@;A@<\341=>?@AB@\342=\203-?\312W\203\264?[\211?\204\302A\343B!\\?[V\203-\344BA?\\\"\211B\250\203\331\326B!\202\336\345BA!\211=G?X\203\367\346?=GZT\347\"=P=?\312V\203=\312?[O>=?[\341OQ=\202=>P=7\203\212\317\320!\210\350=!=\202\212?\312W\203;C?\\??\312V\203a?\343B!Z\211D\312W\203`\344BD\"BADZA)B\250\203n\326B!\202s\345BA!\211=GEAE\\F@\337=\203FCG\\X\203FH\330\\Y\203F\312U\203\256\351>=Q=\202\364A\312X\203\320F\312V\203\320=\312FO>=F\341OQ=\202\364A\312V\203\346=\346A\347\">Q=\202\364\351>\346F[\347\"=R=7\203\211\317\320!\210\350=!=\202\211AE\\I@\352=\203\353I\354\\\355\"T\202 \356\211J=GV\2038=\346J=GZ\347\"P=J=GW\203R=\312JO>=J\341OQ=7\203a\317\320!\210\350=!=\307K\357>\203}L\203yL\360V\203y\361\202~\362\202~\363=IJZ#=**=.\207\317\320!\210\364	L\"\207" [calc-display-raw a calc-twos-complement-mode math-radix-explicit-format math-half-2-word-size b t format "%s" (bigpos bigneg) 0 bigpos math-compare -1 bigneg require calc-ext calc-bin math-format-twos-complement math-format-number math-adjust-fraction 10 int-to-string "-" 2 math-format-binary math-format-radix "%d#%s" math-bignum prin1-to-string math-format-bignum float math-neg nil fix math-numdigs math-scale-rounding math-format-bignum-decimal make-string 48 math-group-float "0" eng math-mod 300002 3 1 (math maple) 191 "(%s*10.^%d)" "%s*10.^%d" "%se%d" math-format-number-fancy comparison calc-frac-format calc-group-digits calc-leading-zeros calc-number-radix calc-radix-formatter calc-float-format calc-point-char str point figs fmt exp mant calc-internal-prec adj len dpos calc-display-sci-high calc-display-sci-low eadj scale calc-language prec] 7])
(defalias 'math-format-bignum #[(a) "\304U\203	\204\n\204\305!\207\306\307!\210\310!\207" [calc-number-radix calc-leading-zeros calc-group-digits a 10 math-format-bignum-decimal require calc-ext math-format-bignum-fancy] 2])
(defalias 'math-format-bignum-decimal #[(a) "\203;\304AA\203)\305\306\307\n\310_!\311QA@_@\\\"	PAA\211\202\312A@\2061\313_@\\!	P)\207\314\207" [a s math-bignum-digit-length math-bignum-digit-size "" format "%0" number-to-string 2 "d" int-to-string 0 "0"] 6])
#@42 Convert the string S into a Calc number.
(defalias 'math-read-number #[(s &optional decimal) "\306\307 \310\216\311\312	\"\203L\313	\314\"\f>\2033\nG\314V\2033\n\315H\316=\2033
\2043\317\320\nP!\202H\nG+\321_X\203C\322\n!\202H\323\324\n!B)\202\207\311\325	\"\203a\317\313	\314\"\313	\321\"P!\202\207\311\326	\"\203\211\317\313	\314\"!\211,\205\205	\315H\327=\203\201,\202\205\330,!)\202\207\311\331	\"\203\232\332\333!\210\334	!\202\207\311\335	\"\203\313	\314\"\313	\321\"-\211.G-G/\2110\315V\203\304\317.\336\"\202\305\315/\315V\203\324\317-\336\"\202\325\315-\211.\205\377-\205\3770\315V\204\360/\315V\205\377\337\340\341./\"-\"/[E.\202\207\311\342	\"\203\206\313	\314\"\313	\321\"1\2112G\315V\203&\3172\336\"\202'\3141G1\315H\343>\2037\344\2028\345X\205@\3221!1\2112\205\2021\205\2022\2113:?\206\\3@\346>)\205\2021\347V\205\2021\350W\205\202\3512!2\3372A@\321281\\E),\202\207\352*!\207" [save-match-data-internal s digs calc-language calc-lang-c-type-hex decimal math-normalize match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) string-match "\\` *\\([0-9]+\\) *\\'" math-match-substring 1 0 48 math-read-number "8#" 2 string-to-number bigpos math-read-bignum "\\`\\(.*\\)[ 	\n]+\\([^]*\\)\\'" "^[-_+]\\(.*\\)$" 43 math-neg "[^-+0-9eE.]" require calc-ext math-read-number-fancy "^\\([0-9]*\\)\\.\\([0-9]*\\)$" t float math-add math-scale-int "^\\(.*\\)[eE]\\([-+]?[0-9]+\\)$" (43 45) 8 7 (bigpos bigneg frac float) -4000000 4000000 math-float nil math-bignum-digit-length val frac int flen ilen exp mant a] 7 (#$ . 98063)])
#@181 Convert the string S into a Calc number.
S is assumed to be a simple number (integer or float without an exponent)
and all digits are kept, regardless of Calc's current precision.
(defalias 'math-read-number-simple #[(s) "\305 \306\216\307\310	\"\2030\307\311	\"\203	\312\225\313O	G\n\314_X\203(\315	!\202r\316\317	!B\202r\307\320	\"\203R	G\n\314_TX\203G\315	!\202r\321\317	\322\313O!B\202r\307\323	\"\203q\324	\322\"\324	\314\"\325\326\fP!G[E*\202r\313*\207" [save-match-data-internal s math-bignum-digit-length frac int match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) string-match "^[0-9]+$" "^\\(0+\\)" 0 nil 2 string-to-number bigpos math-read-bignum "^-[0-9]+$" bigneg 1 "^\\(-?[0-9]*\\)\\.\\([0-9]*\\)$" math-match-substring float math-read-number-simple] 5 (#$ . 99731)])
(defalias 'math-match-substring #[(s n) "\224\203\f	\224\225O\207\302\207" [n s ""] 3])
(defalias 'math-read-bignum #[(s) "G	V\203\302	[\303O!\304\305	[O!B\207\302!C\207" [s math-bignum-digit-length string-to-number nil math-read-bignum 0] 5])
(defconst math-standard-opers '(("_" calcFunc-subscr 1200 1201) ("%" calcFunc-percent 1100 -1) ("u!" calcFunc-lnot -1 1000) ("mod" mod 400 400 185) ("+/-" sdev 300 300 185) ("!!" calcFunc-dfact 210 -1) ("!" calcFunc-fact 210 -1) ("^" ^ 201 200) ("**" ^ 201 200) ("u+" ident -1 197) ("u-" neg -1 197) ("/" / 190 191) ("%" % 190 191) ("\\" calcFunc-idiv 190 191) ("+" + 180 181) ("-" - 180 181) ("|" | 170 171) ("<" calcFunc-lt 160 161) (">" calcFunc-gt 160 161) ("<=" calcFunc-leq 160 161) (">=" calcFunc-geq 160 161) ("=" calcFunc-eq 160 161) ("==" calcFunc-eq 160 161) ("!=" calcFunc-neq 160 161) ("&&" calcFunc-land 110 111) ("||" calcFunc-lor 100 101) ("?" (math-read-if) 91 90) ("!!!" calcFunc-pnot -1 85) ("&&&" calcFunc-pand 80 81) ("|||" calcFunc-por 75 76) (":=" calcFunc-assign 51 50) ("::" calcFunc-condition 45 46) ("=>" calcFunc-evalto 40 41) ("=>" calcFunc-evalto 40 -1)))
(defalias 'math-standard-ops #[nil "\203\n\302\303	BB\207\304\305	BB\207" [calc-multiplication-has-precedence math-standard-opers ("*" * 196 195) ("2x" * 196 195) ("*" * 190 191) ("2x" * 190 191)] 3])
(defvar math-expr-opers (math-standard-ops))
(defalias 'math-standard-ops-p #[nil "\211@@)\211;\205\n\303\230)\207" [math-expr-opers x meo "*"] 3])
(defalias 'math-expr-ops #[nil "\301 \203\302 \207\207" [math-expr-opers math-standard-ops-p math-standard-ops] 1])
#@78 Parse the region as a vector of numbers and push it on the Calculator stack.
(defalias 'calc-grab-region #[(top bot arg) "\303\304!\210\305	\n#\207" [top bot arg require calc-ext calc-do-grab-region] 4 (#$ . 102198) "r\nP"])
#@79 Parse a rectangle as a matrix of numbers and push it on the Calculator stack.
(defalias 'calc-grab-rectangle #[(top bot arg) "\303\304!\210\305	\n#\207" [top bot arg require calc-ext calc-do-grab-rectangle] 4 (#$ . 102430) "r\nP"])
#@63 Parse a rectangle as a matrix of numbers and sum its columns.
(defalias 'calc-grab-sum-down #[(top bot arg) "\303\304!\210\305	\n\306$\207" [top bot arg require calc-ext calc-do-grab-rectangle calcFunc-reduced] 5 (#$ . 102669) "r\nP"])
#@60 Parse a rectangle as a matrix of numbers and sum its rows.
(defalias 'calc-grab-sum-across #[(top bot arg) "\303\304!\210\305	\n\306$\207" [top bot arg require calc-ext calc-do-grab-rectangle calcFunc-reducea] 5 (#$ . 102912) "r\nP"])
#@60 Start Calc Embedded mode on the formula surrounding point.
(defalias 'calc-embedded #[(arg &optional end obeg oend) "\304\305!\210\306	\n$\207" [arg end obeg oend require calc-ext calc-do-embedded] 5 (#$ . 103154) "P"])
#@130 Scan the current editing buffer for all embedded := and => formulas.
Also looks for the equivalent TeX words, \gets and \evalto.
(defalias 'calc-embedded-activate #[(&optional arg cbuf) "\302	\"\207" [arg cbuf calc-do-embedded-activate] 3 (#$ . 103383) "P"])
(defalias 'calc-user-invocation #[nil "\204\301\302!\210\303\304\"\207" [calc-invocation-macro error "Use `Z I' inside Calc to define a `C-x * Z' keyboard macro" execute-kbd-macro nil] 3 nil nil])
#@347 Define Calc function.

Like `defun' except that code in the body of the definition can
make use of the full range of Calc data types and the usual
arithmetic operations are converted to their Calc equivalents.

The prefix `calcFunc-' is added to the specified name to get the
actual Lisp function name.

See Info node `(calc)Defining Functions'.
(defalias 'defmath '(macro . #[(func args &rest body) "\303\304!\210\305	\n#\207" [func args body require calc-ext math-do-defmath] 4 (#$ . 103851)]))
(put 'defmath 'doc-string-elt 3)
(defalias 'calc-read-key #[(&optional optkey) "\300 \211B\207" [read-event] 3])
(defalias 'calc-unread-command #[(&optional input) "\206	\nB\211\207" [input last-command-event unread-command-events] 2])
(defalias 'calc-clear-unread-commands #[nil "\301\211\207" [unread-command-events nil] 2])
#@39 Two to the power of `calc-word-size'.
(defvar math-2-word-size (math-read-number-simple "4294967296") (#$ . 104687))
(byte-code "\300\301\302\303\304!D\"\207" [add-to-list calc-mode-var-list math-2-word-size math-read-number-simple "4294967296"] 5)
#@51 One-half of two to the power of `calc-word-size'.
(defvar math-half-2-word-size (math-read-number-simple "2147483648") (#$ . 104942))
(byte-code "\301\302\303\304\305!D\"\210\203\306\307!\210\310 \210\311\312!\210\313\314!\207" [calc-always-load-extensions add-to-list calc-mode-var-list math-half-2-word-size math-read-number-simple "2147483648" require calc-ext calc-load-everything run-hooks calc-load-hook provide calc] 5)
bypass 1.0, Devloped By El Moujahidin (the source has been moved and devloped)
Email: contact@elmoujehidin.net