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



#@33 Number of columns in the array.
(defvar array-max-column nil (#$ . 84))
#@35 Number of array columns per line.
(defvar array-columns-per-line nil (#$ . 162))
#@47 Current column number of point in the buffer.
(defvar array-buffer-column nil (#$ . 249))
#@32 Length of a line in the array.
(defvar array-line-length nil (#$ . 345))
#@45 Current line number of point in the buffer.
(defvar array-buffer-line nil (#$ . 424))
#@32 Number of lines per array row.
(defvar array-lines-per-row nil (#$ . 516))
#@30 Number of rows in the array.
(defvar array-max-row nil (#$ . 597))
#@32 Width of a field in the array.
(defvar array-field-width nil (#$ . 670))
#@38 Current array row location of point.
(defvar array-row nil (#$ . 749))
#@41 Current array column location of point.
(defvar array-column nil (#$ . 826))
#@34 Are rows numbered in the buffer?
(defvar array-rows-numbered nil (#$ . 909))
#@36 Current field string being copied.
(defvar array-copy-string nil (#$ . 992))
#@37 Should TAB conversion be prevented?
(defvar array-respect-tabs nil (#$ . 1075))
#@85 Return t if the cursor is in a valid array cell.
Its ok to be on a row number line.
(defalias 'array-cursor-in-array-range #[0 "	\246\nY\206(\f
_Y\206(\fT
\246\306U\205(\211\306U?\205(\n
_Y?\207" [array-max-column array-columns-per-line array-buffer-column array-line-length array-buffer-line array-lines-per-row 0 array-max-row array-field-width] 4 (#$ . 1161)])
#@67 Return the array row of the field in which the cursor is located.
(defalias 'array-current-row #[0 "\302 \205\n\303	\"T\207" [array-buffer-line array-lines-per-row array-cursor-in-array-range floor] 3 (#$ . 1541)])
#@70 Return the array column of the field in which the cursor is located.
(defalias 'array-current-column #[0 "\306 \205(\205	\n\246\307U?\205(\203	\n\246S\202!	\n\246_\310\f
\"T\\\207" [array-rows-numbered array-buffer-line array-lines-per-row array-columns-per-line array-buffer-column array-field-width array-cursor-in-array-range 0 floor] 4 (#$ . 1764)])
#@169 Set `array-row' and `array-column' to their current values.
Set them to the optional arguments A-ROW and A-COLUMN if those are supplied.

(fn &optional A-ROW A-COLUMN)
(defalias 'array-update-array-position #[512 "
\206\302 \211\206
\303 \211\207" [array-row array-column array-current-row array-current-column] 4 (#$ . 2135)])
#@76 Set `array-buffer-line' and `array-buffer-column' to their current values.
(defalias 'array-update-buffer-position #[0 "\302 i\211\207" [array-buffer-line array-buffer-column current-line] 2 (#$ . 2474)])
#@63 Display the row and column in which the cursor is positioned.
(defalias 'array-what-position #[0 "\302 i\303\304\305\306 !\305\307 !#*\207" [array-buffer-column array-buffer-line current-line message "Array row: %s  Array column: %s" prin1-to-string array-current-row array-current-column] 5 (#$ . 2687) nil])
#@69 Display the current state of the local variables in the minibuffer.
(defalias 'array-display-local-variables #[0 "\306p!r\307\310!q\210p\311 \210
\312\211\313\211\313\314 \210\315\316!\210+\211\317!\210\320 \210\321\322\323\"!\210\321\322\324\325!\"!\210\321\322\326\325!\"!\210\321\322\327\325 !\"!\210\321\322\330\325!!\"!\210\321\322\331\325\"!\"!\210\321\322\332\325#!\"!\210\321\322\333\325$!\"!\334!\210)\207" [default-directory buffer-read-only buffer-file-name buffer-undo-list inhibit-modification-hooks inhibit-read-only buffer-name get-buffer-create "*Local Variables*" kill-all-local-variables nil t erase-buffer run-hooks temp-buffer-setup-hook buffer-disable-undo terpri princ format " Buffer:             %s\n\n" "  max-row:           %s\n" prin1-to-string "  max-column:        %s\n" "  columns-per-line:  %s\n" "  field-width:       %s\n" "  rows-numbered:     %s\n" "  lines-per-row:     %s\n" "  line-length:       %s\n" internal-temp-output-buffer-show standard-output array-max-row array-max-column array-columns-per-line array-field-width array-rows-numbered array-lines-per-row array-line-length] 9 (#$ . 3005) nil])
#@143 Return the column of the beginning of the current field.
Optional argument GO-THERE, if non-nil, means go there too.

(fn &optional GO-THERE)
(defalias 'array-beginning-of-field #[256 "\211	\246Z\211\203\303\n!\202\n)\207" [array-buffer-column array-field-width goal-column move-to-column-untabify] 4 (#$ . 4174)])
#@139 Return the column of the end of the current array field.
If optional argument GO-THERE is non-nil, go there too.

(fn &optional GO-THERE)
(defalias 'array-end-of-field #[256 "\211	\246Z	\\\211\203\303\n!\202\n)\207" [array-buffer-column array-field-width goal-column move-to-column-untabify] 4 (#$ . 4502)])
#@149 Move to array row A-ROW and array column A-COLUMN.
Leave point at the beginning of the field and return the new buffer column.

(fn A-ROW A-COLUMN)
(defalias 'array-move-to-cell #[514 "S_	\203\f\305\202
\306\\\307S\n\"\\S\n\246_eb\210\211y\210\310\f!)\207" [array-lines-per-row array-rows-numbered array-columns-per-line array-field-width goal-column 1 0 floor move-to-column-untabify] 6 (#$ . 4823)])
#@146 Move to array row A-ROW preserving the current array column.
Leave point at the beginning of the field and return the new array row.

(fn A-ROW)
(defalias 'array-move-to-row #[257 "
S_	\246\\\n\211\246Z\211	Zy\210\305\f!\210
)\207" [array-lines-per-row array-buffer-line array-buffer-column array-field-width goal-column move-to-column-untabify] 5 (#$ . 5240)])
#@155 Move to array column A-COLUMN preserving the current array row.
Leave point at the beginning of the field and return the new array column.

(fn A-COLUMN)
(defalias 'array-move-to-column #[257 "\211	\246Z\n\203
\306\202\307\\\310S\"\\\fS\246_\211Zy\210\311
!\210
)\207" [array-buffer-line array-lines-per-row array-rows-numbered array-columns-per-line array-field-width goal-column 1 0 floor move-to-column-untabify] 5 (#$ . 5613)])
#@195 Move one array row in direction SIGN (1 or -1).
Leave point at the beginning of the field and return the new array row.
If requested to move beyond the array bounds, signal an error.

(fn SIGN)
(defalias 'array-move-one-row #[257 "\304 \305 \206\n\306\307!\nU\203\211\310U\203\306\311!\202<\310U\2030\211\312U\2030\306\313!\202<\211_y\210\314	!\210
\\*\207" [array-row goal-column array-max-row array-lines-per-row array-beginning-of-field array-current-row error "Cursor is not in a valid array cell" 1 "End of array" -1 "Beginning of array" move-to-column-untabify] 4 (#$ . 6062)])
#@201 Move one array column in direction SIGN (1 or -1).
Leave point at the beginning of the field and return the new array column.
If requested to move beyond the array bounds, signal an error.

(fn SIGN)
(defalias 'array-move-one-column #[257 "\304 \206\305\306!\211	U\203\211\307U\203\305\310!\202h\307U\203-\211\311U\203-\305\312!\202h\211\311U\203H\n\246\307U\203H\311y\210\313\nS_!\210\202e\211\307U\203\\\n\246\314U\203\\\307y\210\202e\313\315 _\\!\210
\\)\207" [array-column array-max-column array-columns-per-line array-field-width array-current-column error "Cursor is not in a valid array cell" 1 "End of array" -1 "Beginning of array" move-to-column-untabify 0 array-beginning-of-field] 6 (#$ . 6668)])
#@131 Move the cursor to the first non-whitespace character in the field.
If necessary, scroll horizontally to keep the cursor in view.
(defalias 'array-normalize-cursor #[0 "i\301\212\302\303!\210`)Sw\210\304 )\207" [array-buffer-column " 	" array-end-of-field t array-maybe-scroll-horizontally] 3 (#$ . 7408)])
#@63 If necessary, scroll horizontally to keep the cursor in view.
(defalias 'array-maybe-scroll-horizontally #[0 "\301 \302 Y\203\\X\203\303\207\\V\203&\304Z\305\245Z!\207\306Z\305\245\\!\207" [array-buffer-column window-hscroll window-width nil scroll-left 2 scroll-right] 6 (#$ . 7722)])
#@135 Move down one array row, staying in the current array column.
If optional ARG is given, move down ARG array rows.

(fn &optional ARG)
(defalias 'array-next-row #[256 "\303 i\304
!\305U\203\306
!\210\202$\307\310\311 \206\312\313!\\\n\"!\210*\314 \207" [array-buffer-column array-buffer-line array-max-row current-line abs 1 array-move-one-row array-move-to-row limit-index array-current-row error "Cursor is not in an array cell" array-normalize-cursor] 5 (#$ . 8034) "p"])
#@131 Move up one array row, staying in the current array column.
If optional ARG is given, move up ARG array rows.

(fn &optional ARG)
(defalias 'array-previous-row #[256 "\300
[!\207" [array-next-row] 3 (#$ . 8523) "p"])
#@209 Move forward one field, staying in the current array row.
If optional ARG is given, move forward ARG array columns.
If necessary, keep the cursor in the window by scrolling right or left.

(fn &optional ARG)
(defalias 'array-forward-column #[256 "\303 i\304
!\305U\203\306
!\210\202$\307\310\311 \206\312\313!\\\n\"!\210*\314 \207" [array-buffer-column array-buffer-line array-max-column current-line abs 1 array-move-one-column array-move-to-column limit-index array-current-column error "Cursor is not in an array cell" array-normalize-cursor] 5 (#$ . 8747) "p"])
#@211 Move backward one field, staying in the current array row.
If optional ARG is given, move backward ARG array columns.
If necessary, keep the cursor in the window by scrolling right or left.

(fn &optional ARG)
(defalias 'array-backward-column #[256 "\300
[!\207" [array-forward-column] 3 (#$ . 9328) "p"])
#@71 Go to array row A-ROW and array column A-COLUMN.

(fn A-ROW A-COLUMN)
(defalias 'array-goto-cell #[514 "\302\303\"\303	\"\"\210\304 \207" [array-max-row array-max-column array-move-to-cell limit-index array-normalize-cursor] 7 (#$ . 9640) "nArray row: \nnArray column: "])
#@57 Return the field string at the current cursor location.
(defalias 'array-field-string #[0 "\212\300\301!\210`)\212\302\301!\210`){\207" [array-beginning-of-field t array-end-of-field] 3 (#$ . 9922)])
#@218 Copy the current field into one array row in direction SIGN (1 or -1).
Leave point at the beginning of the field and return the new array row.
If requested to move beyond the array bounds, signal an error.

(fn SIGN)
(defalias 'array-copy-once-vertically #[257 "\303
!\304`\212\305\304!\210`)|\210	c\210)\306\n!\210\207" [inhibit-quit array-copy-string array-buffer-column array-move-one-row t array-end-of-field move-to-column] 5 (#$ . 10129)])
#@224 Copy the current field into one array column in direction SIGN (1 or -1).
Leave point at the beginning of the field and return the new array column.
If requested to move beyond the array bounds, signal an error.

(fn SIGN)
(defalias 'array-copy-once-horizontally #[257 "\303
!\304 \210\305`\212\306\305!\210`)|\210	c\210)\307\n!\210\207" [inhibit-quit array-copy-string array-buffer-column array-move-one-column array-update-buffer-position t array-end-of-field move-to-column] 5 (#$ . 10583)])
#@133 Copy the current field vertically into every cell up to and including A-ROW.
Leave point at the beginning of the field.

(fn A-ROW)
(defalias 'array-copy-to-row #[257 "\211Z\304
!\211\305U?\205

\245
\305V\2058\306
!\210\307 \210\310`\212\311\310!\210`)|\210\nc\210)\312!\210
S\262\202\207" [array-row inhibit-quit array-copy-string array-buffer-column abs 0 array-move-one-row array-update-buffer-position t array-end-of-field move-to-column] 7 (#$ . 11086)])
#@137 Copy current field horizontally into every cell up to and including A-COLUMN.
Leave point at the beginning of the field.

(fn A-COLUMN)
(defalias 'array-copy-to-column #[257 "\211Z\304
!\211\305U?\205

\245
\305V\2058\306
!\210\307 \210\310`\212\311\310!\210`)|\210\nc\210)\312!\210
S\262\202\207" [array-column inhibit-quit array-copy-string array-buffer-column abs 0 array-move-one-column array-update-buffer-position t array-end-of-field move-to-column] 7 (#$ . 11563)])
#@122 Copy the current field into the cell at A-ROW, A-COLUMN.
Leave point at the beginning of the field.

(fn A-ROW A-COLUMN)
(defalias 'array-copy-to-cell #[514 "\302\"\210\303 \210`\212\304\305!\210`)|\210c\210\306	!\207" [array-copy-string array-buffer-column array-move-to-cell array-update-buffer-position array-end-of-field t move-to-column] 5 (#$ . 12053)])
#@124 Copy the current field one array row down.
If optional ARG is given, copy down through ARG array rows.

(fn &optional ARG)
(defalias 'array-copy-down #[256 "\305 i\306 \206
\307\310!\311 \312
!\313U\203 \314
!\210\202)\315\316\n\\\f\"!\210,\317 \207" [array-buffer-line array-buffer-column array-row array-copy-string array-max-row current-line array-current-row error "Cursor is not in a valid array cell" array-field-string abs 1 array-copy-once-vertically array-copy-to-row limit-index array-normalize-cursor] 5 (#$ . 12423) "p"])
#@120 Copy the current field one array row up.
If optional ARG is given, copy up through ARG array rows.

(fn &optional ARG)
(defalias 'array-copy-up #[256 "\300
[!\207" [array-copy-down] 3 (#$ . 12972) "p"])
#@146 Copy the current field one array column to the right.
If optional ARG is given, copy through ARG array columns to the right.

(fn &optional ARG)
(defalias 'array-copy-forward #[256 "\305 i\306 \206
\307\310!\311 \312
!\313U\203 \314
!\210\202)\315\316\n\\\f\"!\210,\317 \207" [array-buffer-line array-buffer-column array-column array-copy-string array-max-column current-line array-current-column error "Cursor is not in a valid array cell" array-field-string abs 1 array-copy-once-horizontally array-copy-to-column limit-index array-normalize-cursor] 5 (#$ . 13182) "p"])
#@144 Copy the current field one array column to the left.
If optional ARG is given, copy through ARG array columns to the left.

(fn &optional ARG)
(defalias 'array-copy-backward #[256 "\300
[!\207" [array-copy-forward] 3 (#$ . 13770) "p"])
#@154 Copy the entire current column in to the column to the right.
If optional ARG is given, copy through ARG array columns to the right.

(fn &optional ARG)
(defalias 'array-copy-column-forward #[256 "\305 \210\306 \210\204\307\310!\210\311\312!\210\313\211	W\203D\211T\262
\314
\"\210\305 \210\315 \316!\317U\2037\320!\210\202@\321\322\\\"!\210)\202\210\311\323!\210\324\f!\210\325 \207" [array-column array-max-row array-copy-string array-max-column array-row array-update-buffer-position array-update-array-position error "Cursor is not in a valid array cell" message "Working..." 0 array-move-to-cell array-field-string abs 1 array-copy-once-horizontally array-copy-to-column limit-index "Working...done" array-move-to-row array-normalize-cursor] 6 (#$ . 14013) "p"])
#@140 Copy the entire current column one column to the left.
If optional ARG is given, copy through ARG columns to the left.

(fn &optional ARG)
(defalias 'array-copy-column-backward #[256 "\300
[!\207" [array-copy-column-forward] 3 (#$ . 14803) "p"])
#@117 Copy the entire current row one row down.
If optional ARG is given, copy through ARG rows down.

(fn &optional ARG)
(defalias 'array-copy-row-down #[256 "\306 \210\307 \210\204\310\311!\210\312U\203!\211\313U\203!\310\314!\210\202\230	U\2034\211\312U\2034\310\315!\210\202\230\212\316\312\"\210`)\212\316\n\"\210\312y\210`){\317
\\	\"\211Z\320
!\211\321U?\205`

\245
\321V\203\214
\\\262\316\312\"\210\322`\212\316\n\"\210\312y\210`)|\210c\210)
S\262\202`\316
\206\223\312\"\210)\266\323 \207" [array-row array-max-row array-max-column array-copy-string inhibit-quit array-column array-update-buffer-position array-update-array-position error "Cursor is not in a valid array cell" 1 -1 "Beginning of array" "End of array" array-move-to-cell limit-index abs 0 t array-normalize-cursor] 10 (#$ . 15056) "p"])
#@127 Copy the entire current array row into the row above.
If optional ARG is given, copy through ARG rows up.

(fn &optional ARG)
(defalias 'array-copy-row-up #[256 "\300
[!\207" [array-copy-row-down] 3 (#$ . 15901) "p"])
#@64 Copy the field at mark into every cell between mark and point.
(defalias 'array-fill-rectangle #[0 "\303 \210\304 \206\305\306!\307 \206\305\306!\212\310 \210\303 \210\304 \206\"\305\311!)\212\310 \210\303 \210\307 \2062\305\311!)\312\313!\210
^]^]\212\314\"\210\303 \210\315 )\316\"\210\317\"\210\303 \210\320
!\210)\314\"\210`\212\314\"\210i\321\322!\210`){
\211U\204\246\211T\262
\314
\"\210\322`\212\314\"\210i\321\322!\210`)|\210c\210)\202})\266\312\323!\210\324\"\207" [array-copy-string array-buffer-column inhibit-quit array-update-buffer-position array-current-row error "Cursor is not in a valid array cell" array-current-column exchange-point-and-mark "Mark is not in a valid array cell" message "Working..." array-move-to-cell array-field-string array-copy-to-cell array-update-array-position array-copy-to-column array-end-of-field t "Working...done" array-goto-cell] 14 (#$ . 16125) nil])
#@34 Create the template of an array.
(defalias 'array-make-template #[0 "\305\306\211\203-\307\310!\262
\211G\262
U\204'\311\312\313\"!\203
\306\262\202\306\262\202eb\210\314\315!\210\316\211	X\203r\n\203E\312\317\"c\210\316\211X\203gc\210\211\f\246\320U\203`\211U\204`\321 \210\211T\262
\202F\210\211T\262
\321 \210\2025\210\314\322!\266\323\316\211\"\207" [array-field-width array-max-row array-rows-numbered array-max-column array-columns-per-line t nil read-string "Initial field value: " y-or-n-p format "Change field width to %d? " message "Working..." 1 "%d:\n" 0 newline "Working...done" array-goto-cell] 7 (#$ . 17076) nil])
#@293 Reconfigure the state of `array-rows-numbered' and `array-columns-per-line'.
NEW-COLUMNS-PER-LINE is the desired value of `array-columns-per-line' and
NEW-ROWS-NUMBERED (a character, either ?y or ?n) is the desired value
of `array-rows-numbered'.

(fn NEW-COLUMNS-PER-LINE NEW-ROWS-NUMBERED)
(defalias 'array-reconfigure-rows #[514 "\306\211\203$\307Y\203X\203\310\262
\202
\311\312\313\314\"!!\262\202
\210\211\315\267\2027\306\262
\202<\310\262
\202<\316\317!\262
\320\321!\210\322 \210\323p!\324\325!	\n\f
%\307\326 \210\327	ed#\210q\210eb\210\211X\203\371\203s\n\204\222\204|\n\203\222\203\214\n\204\214\330\307!\210\202\222\313\331\"c\210\fU\203\252\203\243\307\202\244\332Zy\210\202\362\333S\"\332\333	S\"\332W\203\323\334T_!\210\330\307!\210T\262\202\272\335 \210\211W\203\356\334_!\210\336 \210\211T\262
\202\326\307y\266\211T\262
\202c\306&	q\210\337 \210\340	!\210\n\f_%\333S
\"\203$
\341\202%
\307\\\342'\206.
\307(\2064
\307\"\210)\343	!\266\320\344!\207" [array-max-column array-max-row array-rows-numbered array-columns-per-line array-lines-per-row array-field-width t 1 nil string-to-number read-string format "Columns per line (1 - %d): " #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (121 43 110 49)) y-or-n-p "Rows numbered? " message "Working..." array-update-buffer-position buffer-name generate-new-buffer " *Array*" array-update-array-position copy-to-buffer kill-line "%d:\n" 0 floor move-to-column-untabify beginning-of-line newline erase-buffer insert-buffer-substring 2 array-goto-cell kill-buffer "Working...done" array-line-length inhibit-quit array-row array-column] 19 (#$ . 17740) "nColumns per line: \ncRows numbered? (y or n) "])
#@66 Expand the rows so each fits on one line and remove row numbers.
(defalias 'array-expand-rows #[0 "\301\302\"\207" [array-max-column array-reconfigure-rows 110] 3 (#$ . 19541) nil])
#@20 

(fn INDEX LIMIT)
(defalias 'limit-index #[514 "
\300W\203\300\207

V\203\207
\207" [1] 4 (#$ . 19730)])
#@64 Return the current buffer line at point.  The first line is 0.
(defalias 'current-line #[0 "\300e\301 \"\207" [count-lines line-beginning-position] 3 (#$ . 19846)])
#@91 Move to COLUMN on the current line, untabifying if necessary.
Return COLUMN.

(fn COLUMN)
(defalias 'move-to-column-untabify #[257 "\211\301!U\203\f\211\206\203\302\303!\207\304 \210\301
!\207" [array-respect-tabs move-to-column error "There is a TAB character in the way" untabify-backward] 4 (#$ . 20017)])
#@29 Untabify the preceding TAB.
(defalias 'untabify-backward #[0 "\212`\300u\210\301`\"\262
)\207" [-1 untabify] 4 (#$ . 20339)])
#@28 Keymap used in array mode.
(defvar array-mode-map (byte-code "\300 \301
\302\303#\210\301
\304\305#\210\301
\306\307#\210\301
\310\311#\210\301
\312\313#\210\301
\314\315#\210\301
\316\317#\210\301
\320\321#\210\301
\322\323#\210\301
\324\325#\210\301
\326\327#\210\301
\330\331#\210\301
\332\333#\210\301
\334\335#\210\301
\336\337#\210\301
\340\341#\210\301
\342\343#\210\301
\344\345#\210\301
\346\347#\210\207" [make-keymap define-key "\341d" array-display-local-variables "\341m" array-make-template "\341e" array-expand-rows "\341r" array-reconfigure-rows "\341=" array-what-position "\341g" array-goto-cell "\341f" array-fill-rectangle "" array-next-row "" array-previous-row "" array-forward-column "" array-backward-column "\356" array-copy-down "\360" array-copy-up "\346" array-copy-forward "\342" array-copy-backward "\216" array-copy-row-down "\220" array-copy-row-up "\206" array-copy-column-forward "\202" array-copy-column-backward] 5) (#$ . 20472))
(put 'array-mode 'mode-class 'special)
(defvar array-mode-hook nil)
(byte-code "\300\301N\204\f\302\300\301\303#\210\304\305!\204\302\305\306\307#\210\300\207" [array-mode-hook variable-documentation put "Hook run after entering Array mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" boundp array-mode-map definition-name array-mode] 4)
(defvar array-mode-map (make-sparse-keymap))
(byte-code "\301\302N\204\303\301\302\304\305!#\210\306\307!\204\303\307\310\311#\210\312\313 !\210\307\302N\204-\303\307\302\304\314!#\210\306\300!\204B\303\300\310\311#\210\315\316\300\317\"\210!\210\300\302N\204P\303\300\302\304\320!#\210\303\311\321\317#\207" [array-mode-abbrev-table array-mode-map variable-documentation put purecopy "Keymap for `array-mode'." boundp array-mode-syntax-table definition-name array-mode (lambda (#1=#:def-tmp-var) (defvar array-mode-syntax-table #1#)) make-syntax-table "Syntax table for `array-mode'." (lambda (#1#) (defvar array-mode-abbrev-table #1#)) define-abbrev-table nil "Abbrev table for `array-mode'." derived-mode-parent] 5)
#@3065 Major mode for editing arrays.

  Array mode is a specialized mode for editing arrays.  An array is
considered to be a two-dimensional set of strings.  The strings are
NOT recognized as integers or real numbers.

  The array MUST reside at the top of the buffer.

  TABs are not respected, and may be converted into spaces at any time.
Setting the variable `array-respect-tabs' to non-nil will prevent
TAB conversion, but will cause many functions to give errors if
they encounter one.

  Upon entering array mode, you will be prompted for the values of
several variables.  Others will be calculated based on the values you
supply.  These variables are all local to the buffer.  Other buffer
in array mode may have different values assigned to the variables.
The variables are:

Variables you assign:
     `array-max-row':          The number of rows in the array.
     `array-max-column':       The number of columns in the array.
     `array-columns-per-line': The number of columns in the array
                             per line of buffer.
     `array-field-width':      The width of each field, in characters.
     `array-rows-numbered':    A logical variable describing whether to ignore
                             row numbers in the buffer.

Variables which are calculated:
     `array-line-length':      The number of characters in a buffer line.
     `array-lines-per-row':    The number of buffer lines used to
                             display each row.

  The following commands are available (an asterisk indicates it may
take a numeric prefix argument):

    *  	\<array-mode-map>\[array-forward-column]	  Move forward one column.
    *  	\[array-backward-column]	  Move backward one column.
    *  	\[array-next-row]	  Move down one row.
    *  	\[array-previous-row]	  Move up one row.

    *   \[array-copy-forward]	  Copy current field into the column to the right.
    *   \[array-copy-backward]	  Copy current field into the column to the left.
    *   \[array-copy-down]	  Copy current field into the row below.
    *   \[array-copy-up]	  Copy current field into the row above.

    *   \[array-copy-column-forward]   Copy current column into the column to the right.
    *   \[array-copy-column-backward]   Copy current column into the column to the left.
    *   \[array-copy-row-down]   Copy the current row into the row below.
    *   \[array-copy-row-up]   Copy the current row into the row above.

        \[array-fill-rectangle]   Copy field at mark into every cell with row and column
                  between that of point and mark.

	\[array-what-position]	  Display the current array row and column.
	\[array-goto-cell]	  Go to a particular array cell.

	\[array-make-template]	  Make a template for a new array.
	\[array-reconfigure-rows]	  Reconfigure the array.
        \[array-expand-rows]   Expand the array (remove row numbers and
                  newlines inside rows)

        \[array-display-local-variables]   Display current values of local variables.

Entering array mode calls the function `array-mode-hook'.
(defalias 'array-mode #[0 "\306\300!\210\307\310 \210\311\312\313!\210\314\f!\210
,\306\315!\210\306\316!\210\306\317!\210\306\320!\210\306\321!\210\306\322!\210\323\306\324!\210\325\326!\306\327!\210\325\330!\306\331!\210\325\332!\306\333!\210\325\334!\306\335!\210\336\337!\306\340!\210_ \306\341!\210\342S\"\203\343\202\200\344\\!\345\346!\210\347 \210\306\350!\210\307(\351-)\352\353!\207" [delay-mode-hooks major-mode mode-name array-mode-map array-mode-syntax-table array-mode-abbrev-table make-local-variable t kill-all-local-variables array-mode "Array" use-local-map set-syntax-table array-buffer-line array-buffer-column array-row array-column array-copy-string array-respect-tabs nil array-max-row read-number "Number of array rows: " array-max-column "Number of array columns: " array-columns-per-line "Array columns per line: " array-field-width "Field width: " array-rows-numbered y-or-n-p "Rows numbered? " array-line-length array-lines-per-row floor 2 1 message "" force-mode-line-update truncate-lines overwrite-mode-textual run-mode-hooks array-mode-hook local-abbrev-table overwrite-mode] 3 (#$ . 22602) nil])
(provide 'array)