;ELC
;;; Compiled
;;; in Emacs version 28.2
;;; with all optimizations.



(byte-code "\300\301!\210\300\302!\207" [require calc calc-macs] 2)
#@36 The history list for `quick-calc'.
(defvar calc-quick-calc-history nil (#$ . 152))
#@25 

(fn &optional INSERT)
(defalias 'calc-do-quick-calc #[256 "\306\307!\210\310 \210\311=\203\312\313!\207\314\211\212\315 \210\314\n\316\3133\317>\203*\320\202,33\321\322\323\313\324$\325\326\"\211G\327U\203u\211@\242\330=\203u\211@G\331U\203u\211@A@\242\332=\203u\333
@A@8\333@8L\210\334\333@A@8!\210\333
@8C\262
\211\335\336\337#\262\262\211G\327U\203\342\211@\242\204\342G\340W\203\3424\341U\203\342\342\3434\344@\345\")\346\3474\344@\345\")\346\3334\344@\345\")@\250\203\334@\316V\203\334@\350W\203\334\351\352	@\"\202\335\322\353\260	\262G\354 W\203


G\327U\203

\355\307!\203

\344@\345\"\356Q\211G\354 \347ZX\203\f
\211\262\210\357 \210\360\361\"\210-\266)\204$
5\341=\203'
\211c\207\362
!\207" [major-mode calc-command-flags calc-quick-prev-results calc-dollar-values calc-dollar-used enable-recursive-minibuffers require calc-ext calc-check-defines calc-mode calc-algebraic-entry t nil calc-create-buffer 0 (nil big) flat calc-do-alg-entry "" "Quick calc: " calc-quick-calc-history mapcar math-evaluate-expr 1 calcFunc-assign 3 var 2 calc-refresh-evaltos mapconcat #[257 "\300
\301\"\207" [math-format-value 1000] 4 "\n\n(fn X)"] " " 20 10 "  (" 16 math-format-value 1000 ", " 8 127 format ", \"%c\"" ")" frame-width featurep " =>  " calc-handle-whys message "Result: %s" kill-new calc-language calc-number-radix last-command-event] 15 (#$ . 241)])
#@27 

(fn STR SEPARATOR ARGS)
(defalias 'calc-do-calc-eval #[771 "\306 \210\3072_\212\310 \210:\203\310@9\204\310\311\312 \313\314\311\211\315\316\311\211\211\317\320\311\321\322\323\324\311\211\325\311\326\327\330\331\311\211\211\332 A
@A	B\nCD\fE
FGHIJKLMNOPQRSTUVW\211\203\270\211@
A@L\210\211AA\262
\202\245\333\"@\"\"#.\266\237\202]
\334\267\202k
\335\325\"\202]\336\337!\210pX\340X!\341 
\203\372\342\343\"\216\344!\210\345\311@#\210)\202
\346 \342\347\"\216\344\350 !\210\351X!\210\345\311@#\210)\210)\266\311\202]\250\203/
\352U\204/
\353\354 ^!\210\354 \202]\250\205]\352V\205]\354 X\205]\355\356@\"\357\"\202]\250\205]\352V\205]\354 X\205]\356@\"\202]\311\211YZW\360>\203|
\361\202~
WW\362\363\"[\352\\;\203\224
\364!\202\226
C\311
@\365=\203\245
\366A!\202Z\362\367\"\262\370Y>\203\266
\371\372!\210\373\267\202:\336\337!\210
G\374U\203\316
\375@!\202Z\366\376!\202Z
G\374U\203\340

@\202Z\366\377!\202Z
\202Z
G\374U\203(\201]@!\203\201^=\203\n\355@\357\"\202Z
@\202Z\366\352Z\203 \201_Z@!\202#\201`D!\202Z\366\201a!\202Z\201b!\210\311\202Z
\203Y\211
\205J\206J\201c\355@\357\"Q\262

A\262\202:\211-\266\202)0\207" [calc-display-working-message calc-simplify-mode calc-display-strings calc-infinite-mode calc-complex-mode calc-matrix-brackets calc-check-defines calc-error calc-create-buffer nil math-standard-ops 12 32 deg 10 "." (":" nil) "%s@ %s' %s\"" ((H ":" mm C SS pp " ") Www " " Mmm " " D ", " YYYY) (float 0) (float 0) t "," "[]" (R O) cplx lots calc-do-calc-eval #s(hash-table size 5 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (eval 206 macro 213 pop 285 top 308 rawtop 337)) eval require calc-ext get-buffer-window selected-window make-closure #[0 "\301\300!\205	\302\300!\207" [V0 window-point select-window] 2] select-window calc-execute-kbd-macro current-window-configuration #[0 "\301\300!\207" [V0 set-window-configuration] 2] get-largest-window switch-to-buffer 0 calc-pop calc-stack-size math-format-value calc-top-n 1000 (nil big) flat mapcar #[257 "\211;\203\300
!\262
\211\242\301=\203\302\303\304A!\"\207\211@\207\207" [math-read-exprs error throw calc-error calc-eval-error] 5 "\n\n(fn X)"] math-read-exprs error calc-eval-error calc-normalize clear-message message "" #s(hash-table size 6 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (pred 444 raw 468 list 486 num 490 rawnum 490 push 560)) 1 math-is-true (0 "Single value expected") (0 "Single value expected") calc-vector-brackets calc-vector-commas calc-break-vectors calc-full-vectors calc-matrix-just calc-complex-format calc-full-float-format calc-float-format calc-date-format calc-hms-format calc-prefer-frac calc-frac-format calc-point-char calc-group-digits calc-leading-zeros calc-twos-complement-mode calc-number-radix calc-angle-mode calc-matrix-mode calc-symbolic-mode calc-word-size calc-internal-prec math-expr-opers calc-language calc-buffer calc-command-flags calc-next-why calc-dollar-values calc-dollar-used math-constp num calc-explain-why "Number expected" (0 "Single value expected") calc-push-list ", "] 39 (#$ . 1664)])
#@216 Determines how calc handles errors.
If nil, return a list containing the character position of error.
STRING means return error message as string rather than list.
The value t means abort and give an error message.
(defvar calc-eval-error nil (#$ . 4932))
#@12 

(fn MSG)
(defalias 'calc-eval-error #[257 "\203\301=\203\211A@\207\302\303A@\"\207\207" [calc-eval-error string error "%s"] 4 (#$ . 5194)])
#@25 

(fn &optional PREFIX)
(defalias 'calc-auto-algebraic-entry #[256 "\300
\301\"\207" [calc-algebraic-entry t] 4 (#$ . 5349) "P"])
#@30 

(fn &optional PREFIX AUTO)
(defalias 'calc-algebraic-entry #[512 "\300\301\302#!\207" [calc-do make-closure #[0 "\300?\205\n\300\203\305 \202\306 \307\301\205\310\f!!*\207" [V0 V1 calc-language math-expr-opers last-command-event math-standard-ops math-expr-ops calc-alg-entry char-to-string] 3]] 7 (#$ . 5485) "P"])
#@30 History for algebraic entry.
(defvar calc-alg-entry-history nil (#$ . 5821))
(defvar calc-plain-entry nil)
#@33 

(fn &optional INITIAL PROMPT)
(defalias 'calc-alg-entry #[512 "\306\307	\233\"\310\311\312\311\313$\211;\203 \314\315!\210\316
!\202o
\317=\203*\320\202,\306\321\"
\203k\322\323\315!\203B@\202D
@\324\"\210\325@@\232?\205Y\323\315!\205Y\326@C#\210
A\262\211A\262
\310\2022)\210\327 +\207" [calc-stack-top calc-stack calc-dollar-values calc-dollar-used calc-plain-entry last-command-event mapcar calc-get-stack-element 0 t calc-do-alg-entry calc-alg-entry-history require calc-ext calc-alg-edit 10 none calc-normalize calc-record featurep "alg'" calc-pop-push-record-list "" calc-handle-whys calc-simplify-mode] 8 (#$ . 5934)])
#@38 The keymap used for algebraic entry.
(defvar calc-alg-ent-map (byte-code "\301 \302
\"\210\303
\304\305#\210\303
\306\307#\210\303
\310\311#\210\303
\312\311#\210\207" [minibuffer-local-map make-sparse-keymap set-keymap-parent define-key "'" calcAlg-previous "`" calcAlg-edit "
" calcAlg-enter "\n"] 5) (#$ . 6596))
#@49 The keymap used for escapes in algebraic entry.
(defvar calc-alg-ent-esc-map (byte-code "\301 \302\303\"\210\211\304W\203\305\306!\307#\210\211T\262
\202
\207" [esc-map make-keymap 33 set-keymap-parent 127 define-key vector calcAlg-escape] 6) (#$ . 6919))
#@54 

(fn &optional INITIAL PROMPT NO-NORMALIZE HISTORY)
(defalias 'calc-do-alg-entry #[1024 "p\306\307\310\311\312#\210\f\313=\203\310\311
#\210\202E\310\314\315#\210\310\316\317#\210\310\320\321#\210\310\322\321#\210\310\323\324#\210\310\325\326#\210\310\327\330#\210\312 \331\206N\332\206S\333\312%\n\307=\203j\334
!\211\242\307=\203j\312\335 \204z\n\203z\336\337\n\"\n\262
+\207" [calc-buffer blink-matching-check-function calc-alg-exp calc-alg-ent-map calc-algebraic-mode calc-alg-ent-esc-map calcAlg-blink-matching-check error define-key "" nil total "+" calcAlg-plus-minus "m" calcAlg-mod "=" calcAlg-equals "
" "p" previous-history-element "n" next-history-element "%" self-insert-command read-from-minibuffer "Algebraic: " "" math-read-exprs "alg'" mapcar calc-normalize calc-aborted-prefix] 10 (#$ . 7189)])
(defalias 'calcAlg-plus-minus #[0 "\300\301!\203	\302c\207\303c\207" [calc-minibuffer-contains ".* \\'" "+/- " " +/- "] 2 nil nil])
(defalias 'calcAlg-mod #[0 "\301\302!\204	\303c\210\301\304!\203\203\305\306\"c\207\307 \207\310c\207" [calc-previous-modulo calc-minibuffer-contains ".* \\'" " " ".* mod +\\'" math-format-flat-expr 0 beep "mod "] 3 nil nil])
(defalias 'calcAlg-previous #[0 "\300\301!\203\n\302\303!\207\304c\207" [calc-minibuffer-contains "\\'" previous-history-element 1 "'"] 2 nil nil])
(defalias 'calcAlg-equals #[0 "\300\216\301 )\207" [#[0 ":\205G\302\303!\207" [calc-alg-exp prefix-arg calc-unread-command 61] 2] calcAlg-enter] 1 nil nil])
(defalias 'calcAlg-escape #[0 "\301 \210\212\302 \210\303!\210)\304 \207" [calc-mode-map calc-unread-command calc-select-buffer use-local-map calcAlg-enter] 2 nil nil])
(defalias 'calcAlg-edit #[0 "\203\n\302\303!\203
\304c\207\305 \306 \207" [calc-plain-entry calc-alg-exp calc-minibuffer-contains "\\`\\([^\"]*\"[^\"]*\"\\)*[^\"]*\"[^\"]*\\'" "`" minibuffer-contents exit-minibuffer] 2 nil nil])
(defalias 'calcAlg-enter #[0 "\302 \211G\303V\205rq\210\304
!)\211\242\305=\2034\306 b\210\211A@u\210\307 \210\310\311\3128\206-\313\314Q!\210\315 \207\316\317!\203>\320\202?\211\321 \207" [calc-buffer calc-alg-exp minibuffer-contents 0 math-read-exprs error minibuffer-prompt-end beep calc-temp-minibuffer-message " [" 2 "Error" "]" calc-clear-unread-commands calc-minibuffer-contains "\\` *\\[ *\\'" ((incomplete vec)) exit-minibuffer] 6 nil nil])
#@23 

(fn LEFTPT RIGHTPT)
(defalias 'calcAlg-blink-matching-check #[514 "\211\206`Sf\205
f\2051
\300U\203\211\301U\204)
\302U\2051\211\303U\2051\212b\210\304\305!)?\2059\306\"\207" [41 91 93 40 looking-at ".+\\(\\.\\.\\|\\\\dots\\|\\\\ldots\\)" blink-matching-check-mismatch] 7 (#$ . 9587)])
(defalias 'calc-alg-digit-entry #[0 "\300\301 !\207" [calc-alg-entry calc-digit-start-entry] 2])
(defalias 'calcDigit-algebraic #[0 "\301\302!\203	\303 \207\304 \305 \207" [calc-digit-value calc-minibuffer-contains ".*[@oh] *[^'m ]+[^'m]*\\'" calcDigit-key minibuffer-contents exit-minibuffer] 2 nil nil])
(defalias 'calcDigit-edit #[0 "\301 \210\302 \303 \207" [calc-digit-value calc-unread-command minibuffer-contents exit-minibuffer] 1 nil nil])
#@65 A list indicating replacements to make in Calc algebraic input.
(defvar math-read-replacement-list '(("±" "+/-") ("×" "*") ("÷" ":") ("−" "-") ("∕" "/") ("∗" "*") ("∞" "inf") ("≤" "<=") ("≥" ">=") ("≦" "<=") ("≧" ">=") ("µ" "μ") ("¼" "(1:4)") ("½" "(1:2)") ("¾" "(3:4)") ("⅓" "(1:3)") ("⅔" "(2:3)") ("⅕" "(1:5)") ("⅖" "(2:5)") ("⅗" "(3:5)") ("⅘" "(4:5)") ("⅙" "(1:6)") ("⅚" "(5:6)") ("⅛" "(1:8)") ("⅜" "(3:8)") ("⅝" "(5:8)") ("⅞" "(7:8)") ("⅟" "1:") ("⁰" "0") ("¹" "1") ("²" "2") ("³" "3") ("⁴" "4") ("⁵" "5") ("⁶" "6") ("⁷" "7") ("⁸" "8") ("⁹" "9") ("⁺" "+") ("⁻" "-") ("⁽" "(") ("⁾" ")") ("ⁿ" "n") ("ⁱ" "i") ("₀" "0") ("₁" "1") ("₂" "2") ("₃" "3") ("₄" "4") ("₅" "5") ("₆" "6") ("₇" "7") ("₈" "8") ("₉" "9") ("₊" "+") ("₋" "-") ("₍" "(") ("₎" ")")) (#$ . 10349))
#@58 A string consisting of the superscripts allowed by Calc.
(defvar math-read-superscripts "⁰¹²³⁴⁵⁶⁷⁸⁹⁺⁻⁽⁾ⁿⁱ" (#$ . 11227))
#@56 A string consisting of the subscripts allowed by Calc.
(defvar math-read-subscripts "₀₁₂₃₄₅₆₇₈₉₊₋₍₎" (#$ . 11383))
#@63 Replace some substrings of STR by Calc equivalents.

(fn STR)
(defalias 'math-read-preprocess-string #[257 "\303\304\305Q\306#\262
\303\304	\305Q\307#\262
\n\211\203,\303
@@@A@#\262\211A\262
\202\210\207" [math-read-superscripts math-read-subscripts math-read-replacement-list replace-regexp-in-string "[" "]+" "^(\\&)" "_(\\&)"] 6 (#$ . 11532)])
#@12 

(fn STR)
(defalias 'math-read-exprs #[257 "\211\306\211\307\211\211\310
!>\203\311
!\203&
!\312\313
\"\211\203?
\306	O\314
	\315\\\307OQ\202&\316 \210\317 \210\3202L\321 0\211;\203X\322E\202f	\323=\203b\211\202f\322\324E\262
.\207" [math-expr-data math-exp-token math-exp-keep-spaces math-exp-old-pos math-exp-pos math-exp-str 0 nil math-read-preprocess-string math-remove-percentsigns string-match "\\.\\.\\([^.]\\|.[^.]\\)" "\\dots" 2 math-build-parse-table math-read-token syntax math-read-expr-list error end "Syntax error" calc-language calc-lang-allow-percentsigns calc-language-input-filter] 7 (#$ . 11894)])
(defalias 'math-read-expr-list #[0 "\302\303\304!C\211	\305\232\203\306 \210\303\304!C

\241\210\262
\202
)\207" [math-exp-keep-spaces math-expr-data nil math-read-expr-level 0 "," math-read-token] 5])
(defvar calc-user-parse-table nil)
(defvar calc-last-main-parse-table nil)
(defvar calc-last-user-lang-parse-table nil)
(defvar calc-last-lang-parse-table nil)
(defvar calc-user-tokens nil)
(defvar calc-user-token-chars nil)
#@74 Tokens to pass between math-build-parse-table and math-find-user-tokens.
(defvar math-toks nil (#$ . 12983))
(defalias 'math-build-parse-table #[0 "\306\236A	\236A	\307N\n=\203
=\203\211\f=\206R\310#\306\211\306\211\203;\311
@@!\210\211A\262
\202*\312\313\314\315\316
\"\317\"\320#
\211)\262
\207" [calc-user-parse-tables calc-language calc-last-main-parse-table calc-last-user-lang-parse-table calc-last-lang-parse-table math-toks nil math-parse-table append math-find-user-tokens mapconcat identity sort mapcar car #[514 "
G
GV\207" [] 4 "\n\n(fn X Y)"] "\\|" calc-user-parse-table calc-user-token-chars calc-user-tokens] 10])
#@10 

(fn P)
(defalias 'math-find-user-tokens #[257 "\211\205\207\211@;\203d\211@G\302V\204 \211@\303\232\204 \211@\304\232\203d\305\306@\"\203d\307
@!\305\310\"\2038\311
P\262
\305\312\"\203D\211\313P\262
\314
\"\204`\211CB
@\315H	>\204`
@\315H	B\210\202\200\211@:\203\200\316
@A@!\210\211@@\317=\204\200\316\320@8!\210\211A\262
\202\207" [math-toks calc-user-token-chars 1 "$" "\"" string-match "[^a-zA-Zα-ωΑ-Ω0-9]" regexp-quote "\\`[a-zA-Zα-ωΑ-Ω0-9]" "\\<" "[a-zA-Zα-ωΑ-Ω0-9]\\'" "\\>" assoc 0 math-find-user-tokens \? 2] 5 (#$ . 13644)])
(defalias 'math-read-token #[0 "	GY\203\306\307\211\207\310	H\211\311>\203+T
\203(\312\313\211\207\314 \207\211=>\203M\310>\315?	#)=\203M\316\317	\320\"\320\225\211\207\211\321Y\203Y\211\322X\204}\211\323Y\203e\211\324X\204}\211\325Y\203q\211\326X\204}\211\327Y\203\274\211\330X\203\274\315@A>\203\222@B>\203\222\331\202\237@A>\203\236\332\202\237\333	#\210\334\320\225\335\317	\320\"!@\336N\211\262\205
 \207\211\337Y\203\310\211\340X\204
\211\341=\203\330\315\342	#=\204
\211\343=\203&
\315\344	#=\203&
\320=\204
@A>\204&
\315\345	S#S=\203&
@C>\203
\315\346	#=\204
\315\347	#\210\350\317	\320\"\320\225\211\207\211@\351N\236\211\262\203B
\352A@\353\"\203B
\352\3548\353\"\207\211\355\267\202\220
\315\356	#=\203]
\357\317	\360\"![\202i
\315\361	#\210\320\225\320\224Z\362\320\225\211\207\315\363	#=\203\207
\357\317	\360\"!\320\225\202\214
\360T\364\211\207\315\365	#=\203\246
\316\317	\320\"\320\225\211\207\211\366=\203\300
\315\367	#\203\300
\370\317	\360\"\320\225\211\207@\371N\211\262\203\333
\352@\353\"\203\333
\352A@\353\"\206\315\372	#=\203\353
\320\225\314 \207\211@\373N\236\211\262\203\373

A\262
\316\374
!T\211\207" [math-exp-pos math-exp-str math-exp-old-pos math-exp-token math-expr-data math-exp-keep-spaces end "" nil (32 10 9) space " " math-read-token string-match punc math-match-substring 0 97 122 65 90 945 969 913 937 "[a-zA-Zα-ωΑ-Ω0-9_'#]*" "[a-zA-Zα-ωΑ-Ω0-9_#]*" "[a-zA-Zα-ωΑ-Ω0-9'#]*" symbol math-restore-dashes math-lang-adjust-words 48 57 46 "\\.[0-9]" 95 "_\\.?[0-9]" "[^])}\"a-zA-Zα-ωΑ-Ω0-9'$]_" "0[xX][[:xdigit:]]+" "_?\\([0-9]+.?0*@ *\\)?\\([0-9]+.?0*' *\\)?\\(0*\\([2-9]\\|1[0-4]\\)\\(#[#]?\\|\\^\\^\\)[0-9a-dA-D.]+[eE][-+_]?[0-9]+\\|0*\\([2-9]\\|[0-2][0-9]\\|3[0-6]\\)\\(#[#]?\\|\\^\\^\\)[0-9a-zA-Zα-ωΑ-Ω:.]+\\|[0-9]+:[0-9:]+\\|[0-9.]+\\([eE][-+_]?[0-9]+\\)?\"?\\)?" number math-lang-read-symbol eval t 2 #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (36 328 35 368)) "\\$\\([1-9][0-9]*\\)" string-to-number 1 "\\$+" dollar "#\\([1-9][0-9]*\\)" hash "~=\\|<=\\|>=\\|<>\\|/=\\|\\+/-\\|\\\\dots\\|\\\\ldots\\|\\*\\*\\|<<\\|>>\\|==\\|!=\\|&&&\\||||\\|!!!\\|&&\\|||\\|!!\\|:=\\|::\\|=>" 34 "\\(\"\\([^\"\\]\\|\\\\.\\)*\\)\\(\"\\|\\'\\)" string math-lang-read "%%.*$" math-punc-table char-to-string calc-user-token-chars case-fold-search calc-user-tokens calc-language calc-lang-allow-underscores calc-lang-allow-percentsigns calc-lang-c-type-hex] 6])
(defconst math-alg-inequalities '(calcFunc-lt calcFunc-gt calcFunc-leq calcFunc-geq calcFunc-eq calcFunc-neq))
#@36 

(fn EXP-PREC &optional EXP-TERM)
(defalias 'math-read-expr-level #[513 "\306 \307 \310\311\211	\203!\312\"\211\262\203!
\262\313\211\262\204\335\314\n\"\211\262\203e\3158\316U\204e\314\n>A\"\211\262\203\335\3178\316U\3178\316U?=\203\335\317
8\316U\320 ?=\203\335\211\211\262\204\335\202\335\3158\316=\204\222\321>\204\222\n\322\232\204\222\n\323\232\203\206
\f\324N\323\232\204\206

\203\222\242\325=\204\206
\314\n\"\211\262\203\244\3158\316U\204\206
	\203\323\326=\203\323	\211\203\314\211@@@\250\203\305\211@@A@\n\232\204\314\211A\262
\202\257\211?\262
\203\206
\314\327\"\211\262\203\206
\203\347\n\232\204\206
\3158Y\203\206

@\327\232\204\372\330 \210
A@\331>\203
\332\333!\210
A@:\203

A@@\"\202~
\3178\316=\203R

A@\334=\203+
\202~

A@\335=\203J
\3158=\203C
\336\262\202~
\337\340\341\"\202~

A@D\202~
\204r

A@$>\203r
\242$>\203r
\332\333!\210\342\"\202~

A@\343\3178\"E\262\311\262\202)\207" [math-expr-opers calc-user-parse-table math-expr-data math-exp-token calc-language math-exp-keep-spaces math-expr-ops math-read-factor t nil calc-check-user-syntax ("2x" ident 999999 -1) assoc 2 -1 3 math-factor-after (symbol number dollar hash) "(" "[" math-function-open vec symbol "2x" math-read-token (sdev mod) require calc-ext ident closing 1000 throw syntax "Mismatched delimiters" math-composite-inequalities math-read-expr-level math-alg-inequalities] 11 (#$ . 16899)])
#@25 

(fn &optional X PREC)
(defalias 'calc-check-user-syntax #[512 "\306\211\211\203i
@@\262
\203)\211@\250\203b
\211@Y\203b
	
A\211\262@\232\202-	
@\232\203b
\n\f	\307!\211\262<?\206]
\310\311!\210
\306\211\f\203R\f\nB\262\n\n@A\262	\242\312=\203|G\313U\203|\314\315\3168!\"\262A@\262	\202X
\203<
\203<
\310\311!\210
@\242\317=\203\332
@\262
\211G\313U\204\301\211G\316U\203\276\211A@\242\320=\203\276\211A@G\313U\203\276\211A@\211\262\204\301\306\262	\321\322\3168
#!\nB\262\n\211A@B\262\2025

@\242\323=\203#

@G\313U\203#
\324\322@A@
#\316@8\"\262
\211\325=\203
\306\262	\2025
\211A\211\262\2035
\316
@8\nB\262\n\211@A@B\262\202
\326\327\322@#!!\2045
\306\262	
A\262\202|\203Q
\322	\f#\211\262\n?\266\207\202_
\211\266\203\266\204\203i
A\262\202\205n

\207" [calc-user-parse-table math-expr-data math-exp-pos math-exp-old-pos math-exp-token calc-arg-values nil calc-match-user-syntax require calc-ext calcFunc-condition 3 append math-flatten-lands 2 calcFunc-let calcFunc-assign math-normalize math-multi-subst calcFunc-matches calcFunc-vmatches 0 math-is-true math-simplify] 19 (#$ . 18368)])
#@25 

(fn P &optional TERM)
(defalias 'calc-match-user-syntax #[513 "\304	\n\304\203
@;\203 @\232\203
\305 \210\202
@\250\203g\3062R\307@	A\203N	A@:\203G	A@A@@\202P	A@\202P\"0\211\262\203
\211;\204

C\244\211\262\202
@@\310=\203\256\311@A@!\262
\312@8\204\216\313<\205\211BC\244\262\211<\204
\312@8\203
\312@8@\314H\315=\203
\n\316=\202
\311@A@\312\n@8@\"\262
\211<\203

\313
B\304\211\262\311\312\f@8\206\330@A@\312
@8@\"\211\262<\203\364V\203\364
\244\262\202\307C\244\211\262\n\266\203\202
@@\317=\203
\320C\244\211\262\203
A\262\202\203,

\321\262\207" [math-exp-pos math-exp-old-pos math-exp-token math-expr-data nil math-read-token syntax math-read-expr-level \? calc-match-user-syntax 2 vec 0 36 end * (vec) "Failed"] 15 (#$ . 19549)])
#@10 

(fn X)
(defalias 'math-remove-dashes #[257 "\300\301\"\203\302\303\304\"\305\303\306\"Q!\207\207" [string-match "\\`\\(.*\\)-\\(.*\\)\\'" math-remove-dashes math-match-substring 1 "#" 2] 7 (#$ . 20394)])
#@10 

(fn X)
(defalias 'math-remove-percentsigns #[257 "\300\301\"\203\302\303\304\"\305\303\306\"Q!\207\207" [string-match "\\`\\(.*\\)%\\(.*\\)\\'" math-remove-percentsigns math-match-substring 1 "o'o" 2] 7 (#$ . 20611)])
#@10 

(fn X)
(defalias 'math-restore-dashes #[257 "\300\301\"\203\302\303\304\"\305\303\306\"Q!\207\207" [string-match "\\`\\(.*\\)[#_]\\(.*\\)\\'" math-restore-dashes math-match-substring 1 "-" 2] 7 (#$ . 20842)])
#@183 Replace placeholders by the proper characters in the symbol x.
This includes `#' for `_' and `'' for `%'.
If the current Calc language does not use placeholders, return nil.

(fn X)
(defalias 'math-restore-placeholders #[257 "	>\204\f\n>\205.\303
!\n>\203\304\305!\210\306
!\262
	>\203)\307
!\262
\310
!\262
\207" [calc-language calc-lang-allow-underscores calc-lang-allow-percentsigns symbol-name require calccomp math-to-percentsigns math-string-restore-underscores intern-soft] 4 (#$ . 21065)])
#@61 Replace pound signs by underscores in the string x.

(fn X)
(defalias 'math-string-restore-underscores #[257 "\300\301\"\203\302\303\304\"\305\303\306\"Q!\207\207" [string-match "\\`\\(.*\\)#\\(.*\\)\\'" math-string-restore-underscores math-match-substring 1 "_" 2] 7 (#$ . 21578)])
#@16 

(fn COND OP)
(defalias 'math-read-if #[514 "\301\302!\303\232\204\304\305\306\"\210\307 \210\310\301\3118!F\207" [math-expr-data math-read-expr-level 0 ":" throw syntax "Expected `:'" math-read-token calcFunc-if 3] 9 (#$ . 21872)])
(defalias 'math-factor-after #[0 "\305\211\211\306 \210\n\307>\2060\310	\311\"\203!\310\312	P\f\"\2060\313\310	\f\"8\314=\2060\310	\315\",\207" [math-exp-pos math-expr-data math-exp-token math-exp-old-pos math-expr-opers nil math-read-token (number symbol dollar hash string) assoc (("-") ("+") ("!") ("|") ("/")) "u" 2 -1 (("(") ("[") ("{"))] 4])
(defalias 'math-read-factor #[0 "\306 \307
	\310=\2031\311\n!\211\204\312\313\314\"\210\315 \210
\203+\211:\203+\316
D\202,\211\262
\202(@\203B\317 \211\262\203B\211\202(\n\320\232\204`\n\321\232\204`\n\322\232\204`\n\323\232\204`\n\324\232\203i\325\nP\326 \202(\327\n\"\211\262\203\306\330
8\331=\203\306\211A@:\203\213\211A@@
!\202(\315 \210\332\3338!
A@\334=\203\237\211\202\301\211\211:?\206\252\211@\335>\262
\203\274
@\336\232\203\274\337
!\202\301
A@
D\262
\202(	\340\267\202\220\341\n!\315 \210\nA\232\203\205
\211B\236\315 \210\211A:\203\357\211A@
\"\202\200
\nC\232\206\371	\342=?\205\377\343 \nC\232\204
	\342=\204
\312\313\344\"\210\315 \210DE>\203A
\211\203A
\345\346!\203A
\347F\350\351\341\352\353!P!E!)\203A
\354\"\202~

\203L

A\262\202{
\353!\355H\356U\203i
\357G!\355W\203i
\341\353!\360\307O!\262\361\320\353!\"\204{
\341\362\353!P!\262
B\262
\262
\202
\203\215
\211\202\351\341\363\353!!!\361\320\353!\"\203\242
\202\251
\341\352\353!P!E\211A@H\236\206\273
\364
A@!H\236\211\203\335
\211A:\203\316
\211A@
\"\202\333
\351\341\353A!\365\307O!AE\262\210DI>\203\n\366\232\203\315 \210\343 \211\203\367\370D@C\"\262\211A\262
\202\361
\210\n\371\232\203\315 \210\202\336
\312\313\372\"\210\202\336
\211\262
\262
\202(\n\355V\203-\n\202/\n[JG
Y\203M\n\315 \210K
]K\373SJ8!\262
\202Z\312\313J\203X\374\202Y\375\"\262
\202(L\204i\312\313\376\"\210\345\346!\210\nMGX\203\211\n\315 \210L
]L\211SM8\262
\202(\312\313\377\"\202(\n\201O\232\203\336\307N\315 \210\n\201P\232\204\256\n\201Q\232\203\264\201R\202\267\332\355!)\307N\n\201S\267\202m\315 \210\332\355!\211\203
\211:?\206\332\211@\201T>\262
\203\211\211:?\206\354\211@\201T>\262
\203\201U\201VE!\266\202\202\262\201W\201X\201YEE\266\202\202\262\315 \210\332\355!\211\203O
\211:?\206)\211@\201T>\262
\203O\211\211:?\206;\211@\201Z>\262
\203O\201U\201[E!\266\202\202\262\345\346!\210\201X\201\\\201X\201]!\201^EDE\266\202\202\262\n\201P\232\204}\n\201Q\232\203\262\315 \210\n\201_\232\204\224\n\371\232\204\224	\342=\203\232\201`\202\235\332\355!\201a\n\201_\232\203\254\355\202\255\360F\266\202)\n\201_\232\204\325\n\371\232\203\312\211\242\201a=\204\325	\342=\204\325\312\313\344\"\210\315 \210\211\262
\202(	\201b=\203\361\345\346!\210\201c \202(\n\201d\267\202\"\345\346!\210\201e\201f\371\"\202(\345\346!\210\201e\307\201g\"\202(\345\346!\210\201h \202(\312\313\201i\")\207" [math-expr-opers math-exp-token math-expr-data math-exp-pos math-exp-old-pos math-read-expr-quotes math-expr-ops nil number math-read-number throw syntax "Bad format" math-read-token quote calc-check-user-syntax "-" "+" "!" "|" "/" "u" math-read-factor assoc 2 -1 math-read-expr-level 3 ident (frac float cplx polar) "u-" math-neg #s(hash-table size 3 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (symbol 204 dollar 547 hash 607)) intern end math-read-expr-list "Expected `)'" require calc-ext scalar math-known-matrixp var "var-" symbol-name math-parse-fortran-subscr 0 92 prefix-numeric-value 1 string-search "calcFunc-" math-remove-dashes math-restore-placeholders 4 "[" append calcFunc-subscr "]" "Expected `]'" math-check-complete "Too many $'s" "$'s not allowed in this context" "#'s not allowed in this context" "Too many # arguments" calc-user-parse-table calc-function-open math-expr-function-mapping calc-function-close calc-language calc-lang-parens-are-subscripts calc-matrix-mode calc-language-option math-expr-variable-mapping calc-lang-brackets-are-subscripts calc-dollar-values calc-dollar-used calc-hashes-used calc-arg-values math-exp-keep-spaces "(" "\\dots" "\\ldots" (neg (var inf var-inf)) #s(hash-table size 2 test equal rehash-size 1.5 rehash-threshold 0.8125 purecopy t data ("," 707 ";" 786)) (frac float) math-normalize cplx + * (var i var-i) (frac float hms) polar calcFunc-exp math-to-radians-2 (var i var-i) ")" (var inf var-inf) intv string math-read-string #s(hash-table size 3 test equal rehash-size 1.5 rehash-threshold 0.8125 purecopy t data ("[" 1017 "{" 1032 "<" 1047)) math-read-brackets t "}" math-read-angle-brackets "Expected a number"] 12])
(provide 'calc-aent)