2 @c This is part of the GNU Emacs Lisp Reference Manual.
3 @c Copyright (C) 1990, 1991, 1992, 1993, 1994, 2001, 2002, 2003, 2004,
4 @c 2005, 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
5 @c See the file elisp.texi for copying conditions.
6 @setfilename ../../info/compile
7 @node Byte Compilation, Advising Functions, Loading, Top
8 @chapter Byte Compilation
9 @cindex byte compilation
11 @cindex compilation (Emacs Lisp)
13 Emacs Lisp has a @dfn{compiler} that translates functions written
14 in Lisp into a special representation called @dfn{byte-code} that can be
15 executed more efficiently. The compiler replaces Lisp function
16 definitions with byte-code. When a byte-code function is called, its
17 definition is evaluated by the @dfn{byte-code interpreter}.
19 Because the byte-compiled code is evaluated by the byte-code
20 interpreter, instead of being executed directly by the machine's
21 hardware (as true compiled code is), byte-code is completely
22 transportable from machine to machine without recompilation. It is not,
23 however, as fast as true compiled code.
25 In general, any version of Emacs can run byte-compiled code produced
26 by recent earlier versions of Emacs, but the reverse is not true.
28 @vindex no-byte-compile
29 If you do not want a Lisp file to be compiled, ever, put a file-local
30 variable binding for @code{no-byte-compile} into it, like this:
33 ;; -*-no-byte-compile: t; -*-
36 @xref{Compilation Errors}, for how to investigate errors occurring in
40 * Speed of Byte-Code:: An example of speedup from byte compilation.
41 * Compilation Functions:: Byte compilation functions.
42 * Docs and Compilation:: Dynamic loading of documentation strings.
43 * Dynamic Loading:: Dynamic loading of individual functions.
44 * Eval During Compile:: Code to be evaluated when you compile.
45 * Compiler Errors:: Handling compiler error messages.
46 * Byte-Code Objects:: The data type used for byte-compiled functions.
47 * Disassembly:: Disassembling byte-code; how to read byte-code.
50 @node Speed of Byte-Code
51 @section Performance of Byte-Compiled Code
53 A byte-compiled function is not as efficient as a primitive function
54 written in C, but runs much faster than the version written in Lisp.
60 "Return time before and after N iterations of a loop."
61 (let ((t1 (current-time-string)))
62 (while (> (setq n (1- n))
64 (list t1 (current-time-string))))
70 @result{} ("Wed Mar 11 21:10:19 2009"
71 "Wed Mar 11 21:10:41 2009") ; @r{22 seconds}
75 (byte-compile 'silly-loop)
76 @result{} @r{[Compiled code not shown]}
81 @result{} ("Wed Mar 11 21:12:26 2009"
82 "Wed Mar 11 21:12:32 2009") ; @r{6 seconds}
86 In this example, the interpreted code required 22 seconds to run,
87 whereas the byte-compiled code required 6 seconds. These results are
88 representative, but actual results will vary greatly.
90 @node Compilation Functions
91 @comment node-name, next, previous, up
92 @section The Compilation Functions
93 @cindex compilation functions
95 You can byte-compile an individual function or macro definition with
96 the @code{byte-compile} function. You can compile a whole file with
97 @code{byte-compile-file}, or several files with
98 @code{byte-recompile-directory} or @code{batch-byte-compile}.
100 The byte compiler produces error messages and warnings about each file
101 in a buffer called @samp{*Compile-Log*}. These report things in your
102 program that suggest a problem but are not necessarily erroneous.
104 @cindex macro compilation
105 Be careful when writing macro calls in files that you may someday
106 byte-compile. Macro calls are expanded when they are compiled, so the
107 macros must already be defined for proper compilation. For more
108 details, see @ref{Compiling Macros}. If a program does not work the
109 same way when compiled as it does when interpreted, erroneous macro
110 definitions are one likely cause (@pxref{Problems with Macros}).
111 Inline (@code{defsubst}) functions are less troublesome; if you
112 compile a call to such a function before its definition is known, the
113 call will still work right, it will just run slower.
115 Normally, compiling a file does not evaluate the file's contents or
116 load the file. But it does execute any @code{require} calls at top
117 level in the file. One way to ensure that necessary macro definitions
118 are available during compilation is to require the file that defines
119 them (@pxref{Named Features}). To avoid loading the macro definition files
120 when someone @emph{runs} the compiled program, write
121 @code{eval-when-compile} around the @code{require} calls (@pxref{Eval
124 @defun byte-compile symbol
125 This function byte-compiles the function definition of @var{symbol},
126 replacing the previous definition with the compiled one. The function
127 definition of @var{symbol} must be the actual code for the function;
128 i.e., the compiler does not follow indirection to another symbol.
129 @code{byte-compile} returns the new, compiled definition of
132 If @var{symbol}'s definition is a byte-code function object,
133 @code{byte-compile} does nothing and returns @code{nil}. Lisp records
134 only one function definition for any symbol, and if that is already
135 compiled, non-compiled code is not available anywhere. So there is no
136 way to ``compile the same definition again.''
140 (defun factorial (integer)
141 "Compute factorial of INTEGER."
143 (* integer (factorial (1- integer)))))
148 (byte-compile 'factorial)
151 "^H\301U\203^H^@@\301\207\302^H\303^HS!\"\207"
152 [integer 1 * factorial]
153 4 "Compute factorial of INTEGER."]
158 The result is a byte-code function object. The string it contains is
159 the actual byte-code; each character in it is an instruction or an
160 operand of an instruction. The vector contains all the constants,
161 variable names and function names used by the function, except for
162 certain primitives that are coded as special instructions.
164 If the argument to @code{byte-compile} is a @code{lambda} expression,
165 it returns the corresponding compiled code, but does not store
169 @deffn Command compile-defun &optional arg
170 This command reads the defun containing point, compiles it, and
171 evaluates the result. If you use this on a defun that is actually a
172 function definition, the effect is to install a compiled version of that
175 @code{compile-defun} normally displays the result of evaluation in the
176 echo area, but if @var{arg} is non-@code{nil}, it inserts the result
177 in the current buffer after the form it compiled.
180 @deffn Command byte-compile-file filename &optional load
181 This function compiles a file of Lisp code named @var{filename} into a
182 file of byte-code. The output file's name is made by changing the
183 @samp{.el} suffix into @samp{.elc}; if @var{filename} does not end in
184 @samp{.el}, it adds @samp{.elc} to the end of @var{filename}.
186 Compilation works by reading the input file one form at a time. If it
187 is a definition of a function or macro, the compiled function or macro
188 definition is written out. Other forms are batched together, then each
189 batch is compiled, and written so that its compiled code will be
190 executed when the file is read. All comments are discarded when the
193 This command returns @code{t} if there were no errors and @code{nil}
194 otherwise. When called interactively, it prompts for the file name.
196 If @var{load} is non-@code{nil}, this command loads the compiled file
197 after compiling it. Interactively, @var{load} is the prefix argument.
202 -rw-r--r-- 1 lewis 791 Oct 5 20:31 push.el
206 (byte-compile-file "~/emacs/push.el")
212 -rw-r--r-- 1 lewis 791 Oct 5 20:31 push.el
213 -rw-rw-rw- 1 lewis 638 Oct 8 20:25 push.elc
218 @deffn Command byte-recompile-directory directory &optional flag force
219 @cindex library compilation
220 This command recompiles every @samp{.el} file in @var{directory} (or
221 its subdirectories) that needs recompilation. A file needs
222 recompilation if a @samp{.elc} file exists but is older than the
225 When a @samp{.el} file has no corresponding @samp{.elc} file,
226 @var{flag} says what to do. If it is @code{nil}, this command ignores
227 these files. If @var{flag} is 0, it compiles them. If it is neither
228 @code{nil} nor 0, it asks the user whether to compile each such file,
229 and asks about each subdirectory as well.
231 Interactively, @code{byte-recompile-directory} prompts for
232 @var{directory} and @var{flag} is the prefix argument.
234 If @var{force} is non-@code{nil}, this command recompiles every
235 @samp{.el} file that has a @samp{.elc} file.
237 The returned value is unpredictable.
240 @defun batch-byte-compile &optional noforce
241 This function runs @code{byte-compile-file} on files specified on the
242 command line. This function must be used only in a batch execution of
243 Emacs, as it kills Emacs on completion. An error in one file does not
244 prevent processing of subsequent files, but no output file will be
245 generated for it, and the Emacs process will terminate with a nonzero
248 If @var{noforce} is non-@code{nil}, this function does not recompile
249 files that have an up-to-date @samp{.elc} file.
252 % emacs -batch -f batch-byte-compile *.el
256 @defun byte-code code-string data-vector max-stack
257 @cindex byte-code interpreter
258 This function actually interprets byte-code. A byte-compiled function
259 is actually defined with a body that calls @code{byte-code}. Don't call
260 this function yourself---only the byte compiler knows how to generate
261 valid calls to this function.
263 In Emacs version 18, byte-code was always executed by way of a call to
264 the function @code{byte-code}. Nowadays, byte-code is usually executed
265 as part of a byte-code function object, and only rarely through an
266 explicit call to @code{byte-code}.
269 @node Docs and Compilation
270 @section Documentation Strings and Compilation
271 @cindex dynamic loading of documentation
273 Functions and variables loaded from a byte-compiled file access their
274 documentation strings dynamically from the file whenever needed. This
275 saves space within Emacs, and makes loading faster because the
276 documentation strings themselves need not be processed while loading the
277 file. Actual access to the documentation strings becomes slower as a
278 result, but this normally is not enough to bother users.
280 Dynamic access to documentation strings does have drawbacks:
284 If you delete or move the compiled file after loading it, Emacs can no
285 longer access the documentation strings for the functions and variables
289 If you alter the compiled file (such as by compiling a new version),
290 then further access to documentation strings in this file will
291 probably give nonsense results.
294 If your site installs Emacs following the usual procedures, these
295 problems will never normally occur. Installing a new version uses a new
296 directory with a different name; as long as the old version remains
297 installed, its files will remain unmodified in the places where they are
300 However, if you have built Emacs yourself and use it from the
301 directory where you built it, you will experience this problem
302 occasionally if you edit and recompile Lisp files. When it happens, you
303 can cure the problem by reloading the file after recompiling it.
305 You can turn off this feature at compile time by setting
306 @code{byte-compile-dynamic-docstrings} to @code{nil}; this is useful
307 mainly if you expect to change the file, and you want Emacs processes
308 that have already loaded it to keep working when the file changes.
309 You can do this globally, or for one source file by specifying a
310 file-local binding for the variable. One way to do that is by adding
311 this string to the file's first line:
314 -*-byte-compile-dynamic-docstrings: nil;-*-
317 @defvar byte-compile-dynamic-docstrings
318 If this is non-@code{nil}, the byte compiler generates compiled files
319 that are set up for dynamic loading of documentation strings.
322 @cindex @samp{#@@@var{count}}
324 The dynamic documentation string feature writes compiled files that
325 use a special Lisp reader construct, @samp{#@@@var{count}}. This
326 construct skips the next @var{count} characters. It also uses the
327 @samp{#$} construct, which stands for ``the name of this file, as a
328 string.'' It is usually best not to use these constructs in Lisp source
329 files, since they are not designed to be clear to humans reading the
332 @node Dynamic Loading
333 @section Dynamic Loading of Individual Functions
335 @cindex dynamic loading of functions
337 When you compile a file, you can optionally enable the @dfn{dynamic
338 function loading} feature (also known as @dfn{lazy loading}). With
339 dynamic function loading, loading the file doesn't fully read the
340 function definitions in the file. Instead, each function definition
341 contains a place-holder which refers to the file. The first time each
342 function is called, it reads the full definition from the file, to
343 replace the place-holder.
345 The advantage of dynamic function loading is that loading the file
346 becomes much faster. This is a good thing for a file which contains
347 many separate user-callable functions, if using one of them does not
348 imply you will probably also use the rest. A specialized mode which
349 provides many keyboard commands often has that usage pattern: a user may
350 invoke the mode, but use only a few of the commands it provides.
352 The dynamic loading feature has certain disadvantages:
356 If you delete or move the compiled file after loading it, Emacs can no
357 longer load the remaining function definitions not already loaded.
360 If you alter the compiled file (such as by compiling a new version),
361 then trying to load any function not already loaded will usually yield
365 These problems will never happen in normal circumstances with
366 installed Emacs files. But they are quite likely to happen with Lisp
367 files that you are changing. The easiest way to prevent these problems
368 is to reload the new compiled file immediately after each recompilation.
370 The byte compiler uses the dynamic function loading feature if the
371 variable @code{byte-compile-dynamic} is non-@code{nil} at compilation
372 time. Do not set this variable globally, since dynamic loading is
373 desirable only for certain files. Instead, enable the feature for
374 specific source files with file-local variable bindings. For example,
375 you could do it by writing this text in the source file's first line:
378 -*-byte-compile-dynamic: t;-*-
381 @defvar byte-compile-dynamic
382 If this is non-@code{nil}, the byte compiler generates compiled files
383 that are set up for dynamic function loading.
386 @defun fetch-bytecode function
387 If @var{function} is a byte-code function object, this immediately
388 finishes loading the byte code of @var{function} from its
389 byte-compiled file, if it is not fully loaded already. Otherwise,
390 it does nothing. It always returns @var{function}.
393 @node Eval During Compile
394 @section Evaluation During Compilation
396 These features permit you to write code to be evaluated during
397 compilation of a program.
399 @defspec eval-and-compile body@dots{}
400 This form marks @var{body} to be evaluated both when you compile the
401 containing code and when you run it (whether compiled or not).
403 You can get a similar result by putting @var{body} in a separate file
404 and referring to that file with @code{require}. That method is
405 preferable when @var{body} is large. Effectively @code{require} is
406 automatically @code{eval-and-compile}, the package is loaded both when
407 compiling and executing.
409 @code{autoload} is also effectively @code{eval-and-compile} too. It's
410 recognized when compiling, so uses of such a function don't produce
411 ``not known to be defined'' warnings.
413 Most uses of @code{eval-and-compile} are fairly sophisticated.
415 If a macro has a helper function to build its result, and that macro
416 is used both locally and outside the package, then
417 @code{eval-and-compile} should be used to get the helper both when
418 compiling and then later when running.
420 If functions are defined programmatically (with @code{fset} say), then
421 @code{eval-and-compile} can be used to have that done at compile-time
422 as well as run-time, so calls to those functions are checked (and
423 warnings about ``not known to be defined'' suppressed).
426 @defspec eval-when-compile body@dots{}
427 This form marks @var{body} to be evaluated at compile time but not when
428 the compiled program is loaded. The result of evaluation by the
429 compiler becomes a constant which appears in the compiled program. If
430 you load the source file, rather than compiling it, @var{body} is
433 @cindex compile-time constant
434 If you have a constant that needs some calculation to produce,
435 @code{eval-when-compile} can do that at compile-time. For example,
439 (eval-when-compile (regexp-opt '("aaa" "aba" "abb"))))
442 @cindex macros, at compile time
443 If you're using another package, but only need macros from it (the
444 byte compiler will expand those), then @code{eval-when-compile} can be
445 used to load it for compiling, but not executing. For example,
449 (require 'my-macro-package)) ;; only macros needed from this
452 The same sort of thing goes for macros and @code{defsubst} functions
453 defined locally and only for use within the file. They are needed for
454 compiling the file, but in most cases they are not needed for
455 execution of the compiled file. For example,
459 (unless (fboundp 'some-new-thing)
460 (defmacro 'some-new-thing ()
461 (compatibility code))))
465 This is often good for code that's only a fallback for compatibility
466 with other versions of Emacs.
468 @strong{Common Lisp Note:} At top level, @code{eval-when-compile} is analogous to the Common
469 Lisp idiom @code{(eval-when (compile eval) @dots{})}. Elsewhere, the
470 Common Lisp @samp{#.} reader macro (but not when interpreting) is closer
471 to what @code{eval-when-compile} does.
474 @node Compiler Errors
475 @section Compiler Errors
476 @cindex compiler errors
478 Byte compilation outputs all errors and warnings into the buffer
479 @samp{*Compile-Log*}. The messages include file names and line
480 numbers that identify the location of the problem. The usual Emacs
481 commands for operating on compiler diagnostics work properly on
484 However, the warnings about functions that were used but not
485 defined are always ``located'' at the end of the file, so these
486 commands won't find the places they are really used. To do that,
487 you must search for the function names.
489 You can suppress the compiler warning for calling an undefined
490 function @var{func} by conditionalizing the function call on an
491 @code{fboundp} test, like this:
494 (if (fboundp '@var{func}) ...(@var{func} ...)...)
498 The call to @var{func} must be in the @var{then-form} of the
499 @code{if}, and @var{func} must appear quoted in the call to
500 @code{fboundp}. (This feature operates for @code{cond} as well.)
502 You can tell the compiler that a function is defined using
503 @code{declare-function} (@pxref{Declaring Functions}). Likewise, you
504 can tell the compiler that a variable is defined using @code{defvar}
505 with no initial value.
507 You can suppress the compiler warning for a specific use of an
508 undefined variable @var{variable} by conditionalizing its use on a
509 @code{boundp} test, like this:
512 (if (boundp '@var{variable}) ...@var{variable}...)
516 The reference to @var{variable} must be in the @var{then-form} of the
517 @code{if}, and @var{variable} must appear quoted in the call to
520 You can suppress any and all compiler warnings within a certain
521 expression using the construct @code{with-no-warnings}:
523 @c This is implemented with a defun, but conceptually it is
526 @defspec with-no-warnings body@dots{}
527 In execution, this is equivalent to @code{(progn @var{body}...)},
528 but the compiler does not issue warnings for anything that occurs
531 We recommend that you use this construct around the smallest
532 possible piece of code, to avoid missing possible warnings other than one
533 one you intend to suppress.
536 More precise control of warnings is possible by setting the variable
537 @code{byte-compile-warnings}.
539 @node Byte-Code Objects
540 @section Byte-Code Function Objects
541 @cindex compiled function
542 @cindex byte-code function
544 Byte-compiled functions have a special data type: they are
545 @dfn{byte-code function objects}.
547 Internally, a byte-code function object is much like a vector;
548 however, the evaluator handles this data type specially when it appears
549 as a function to be called. The printed representation for a byte-code
550 function object is like that for a vector, with an additional @samp{#}
551 before the opening @samp{[}.
553 A byte-code function object must have at least four elements; there is
554 no maximum number, but only the first six elements have any normal use.
559 The list of argument symbols.
562 The string containing the byte-code instructions.
565 The vector of Lisp objects referenced by the byte code. These include
566 symbols used as function names and variable names.
569 The maximum stack size this function needs.
572 The documentation string (if any); otherwise, @code{nil}. The value may
573 be a number or a list, in case the documentation string is stored in a
574 file. Use the function @code{documentation} to get the real
575 documentation string (@pxref{Accessing Documentation}).
578 The interactive spec (if any). This can be a string or a Lisp
579 expression. It is @code{nil} for a function that isn't interactive.
582 Here's an example of a byte-code function object, in printed
583 representation. It is the definition of the command
584 @code{backward-sexp}.
588 "^H\204^F^@@\301^P\302^H[!\207"
595 The primitive way to create a byte-code object is with
596 @code{make-byte-code}:
598 @defun make-byte-code &rest elements
599 This function constructs and returns a byte-code function object
600 with @var{elements} as its elements.
603 You should not try to come up with the elements for a byte-code
604 function yourself, because if they are inconsistent, Emacs may crash
605 when you call the function. Always leave it to the byte compiler to
606 create these objects; it makes the elements consistent (we hope).
608 You can access the elements of a byte-code object using @code{aref};
609 you can also use @code{vconcat} to create a vector with the same
613 @section Disassembled Byte-Code
614 @cindex disassembled byte-code
616 People do not write byte-code; that job is left to the byte
617 compiler. But we provide a disassembler to satisfy a cat-like
618 curiosity. The disassembler converts the byte-compiled code into
621 The byte-code interpreter is implemented as a simple stack machine.
622 It pushes values onto a stack of its own, then pops them off to use them
623 in calculations whose results are themselves pushed back on the stack.
624 When a byte-code function returns, it pops a value off the stack and
625 returns it as the value of the function.
627 In addition to the stack, byte-code functions can use, bind, and set
628 ordinary Lisp variables, by transferring values between variables and
631 @deffn Command disassemble object &optional buffer-or-name
632 This command displays the disassembled code for @var{object}. In
633 interactive use, or if @var{buffer-or-name} is @code{nil} or omitted,
634 the output goes in a buffer named @samp{*Disassemble*}. If
635 @var{buffer-or-name} is non-@code{nil}, it must be a buffer or the
636 name of an existing buffer. Then the output goes there, at point, and
637 point is left before the output.
639 The argument @var{object} can be a function name, a lambda expression
640 or a byte-code object. If it is a lambda expression, @code{disassemble}
641 compiles it and disassembles the resulting compiled code.
644 Here are two examples of using the @code{disassemble} function. We
645 have added explanatory comments to help you relate the byte-code to the
646 Lisp source; these do not appear in the output of @code{disassemble}.
650 (defun factorial (integer)
651 "Compute factorial of an integer."
653 (* integer (factorial (1- integer)))))
663 (disassemble 'factorial)
664 @print{} byte-code for factorial:
665 doc: Compute factorial of an integer.
670 0 varref integer ; @r{Get the value of @code{integer}}
671 ; @r{and push it onto the stack.}
672 1 constant 1 ; @r{Push 1 onto stack.}
676 2 eqlsign ; @r{Pop top two values off stack, compare}
677 ; @r{them, and push result onto stack.}
681 3 goto-if-nil 1 ; @r{Pop and test top of stack;}
682 ; @r{if @code{nil}, go to 1,}
684 6 constant 1 ; @r{Push 1 onto top of stack.}
685 7 return ; @r{Return the top element}
690 8:1 varref integer ; @r{Push value of @code{integer} onto stack.}
691 9 constant factorial ; @r{Push @code{factorial} onto stack.}
692 10 varref integer ; @r{Push value of @code{integer} onto stack.}
693 11 sub1 ; @r{Pop @code{integer}, decrement value,}
694 ; @r{push new value onto stack.}
695 12 call 1 ; @r{Call function @code{factorial} using}
696 ; @r{the first (i.e., the top) element}
697 ; @r{of the stack as the argument;}
698 ; @r{push returned value onto stack.}
702 13 mult ; @r{Pop top two values off stack, multiply}
703 ; @r{them, and push result onto stack.}
704 14 return ; @r{Return the top element of stack.}
708 The @code{silly-loop} function is somewhat more complex:
712 (defun silly-loop (n)
713 "Return time before and after N iterations of a loop."
714 (let ((t1 (current-time-string)))
715 (while (> (setq n (1- n))
717 (list t1 (current-time-string))))
722 (disassemble 'silly-loop)
723 @print{} byte-code for silly-loop:
724 doc: Return time before and after N iterations of a loop.
727 0 constant current-time-string ; @r{Push}
728 ; @r{@code{current-time-string}}
729 ; @r{onto top of stack.}
733 1 call 0 ; @r{Call @code{current-time-string}}
734 ; @r{with no argument,}
735 ; @r{pushing result onto stack.}
739 2 varbind t1 ; @r{Pop stack and bind @code{t1}}
740 ; @r{to popped value.}
744 3:1 varref n ; @r{Get value of @code{n} from}
745 ; @r{the environment and push}
746 ; @r{the value onto the stack.}
747 4 sub1 ; @r{Subtract 1 from top of stack.}
751 5 dup ; @r{Duplicate the top of the stack;}
752 ; @r{i.e., copy the top of}
753 ; @r{the stack and push the}
754 ; @r{copy onto the stack.}
755 6 varset n ; @r{Pop the top of the stack,}
756 ; @r{and bind @code{n} to the value.}
758 ; @r{In effect, the sequence @code{dup varset}}
759 ; @r{copies the top of the stack}
760 ; @r{into the value of @code{n}}
761 ; @r{without popping it.}
765 7 constant 0 ; @r{Push 0 onto stack.}
766 8 gtr ; @r{Pop top two values off stack,}
767 ; @r{test if @var{n} is greater than 0}
768 ; @r{and push result onto stack.}
772 9 goto-if-not-nil 1 ; @r{Goto 1 if @code{n} > 0}
773 ; @r{(this continues the while loop)}
778 12 varref t1 ; @r{Push value of @code{t1} onto stack.}
779 13 constant current-time-string ; @r{Push @code{current-time-string}}
780 ; @r{onto top of stack.}
781 14 call 0 ; @r{Call @code{current-time-string} again.}
785 15 unbind 1 ; @r{Unbind @code{t1} in local environment.}
786 16 list2 ; @r{Pop top two elements off stack,}
787 ; @r{create a list of them,}
788 ; @r{and push list onto stack.}
789 17 return ; @r{Return value of the top of stack.}
795 arch-tag: f78e3050-2f0a-4dee-be27-d9979a0a2289