В преамбуле:
def mswap(a, b):
    return f'''{a} ^= {b}; {b} ^= {a}; {a} ^= {b}'''

В f-строке:
    if (ex < x) | (ey < y):
        {mswap("x", "ex")}
        {mswap("y", "ey")}

# ha-ha :)
def draw_circle(ptr, cx, cy, r, col):
    if (ptr >= {RECT_MEM+RECT_SIZE*RECT_NUM}):
        return ptr
    ptr[0] = 1
    set_rect(ptr, cx - r, cy - r, 2*r, 2*r)
    ptr[5] = col
    return ptr + {RECT_SIZE}

fg:#CEB7A6
bg:#2F435A
fill:#000000
btn:{}^
btn:zZ^
###############
#*###&   &###*#
# #####z##### #
# ##### ##### #
#}##### #####}#
# ##### ##### #
# ####   #### #
#      @      #
# ####   #### #
#%#####%#####%#
#             #
# #####Z##### #
# #*   {   *# #
# ########### #
#             #

diff --git a/include/linux/cpufreq.h b/include/linux/cpufreq.h
index 3a4cefb25ba61c..9ca4211c063f39 100644
--- a/include/linux/cpufreq.h
+++ b/include/linux/cpufreq.h
@@ -1124,10 +1124,9 @@ static inline int parse_perf_domain(int cpu, const char *list_name,
 				    const char *cell_name,
 				    struct of_phandle_args *args)
 {
-	struct device_node *cpu_np;
 	int ret;

-	cpu_np = of_cpu_device_node_get(cpu);
+	struct device_node *cpu_np __free(device_node) = of_cpu_device_node_get(cpu);
 	if (!cpu_np)
 		return -ENODEV;

@@ -1135,9 +1134,6 @@ static inline int parse_perf_domain(int cpu, const char *list_name,
 					 args);
 	if (ret < 0)
 		return ret;
-
-	of_node_put(cpu_np);
-
 	return 0;
 }

void *ptr __attribute__((__cleanup__(free))) = NULL;
...
ptr = malloc(32);

#define DEFINE_FREE(_name, _type, _free) \
	static inline void __free_##_name(void *p) { _type _T = *(_type *)p; _free; }

IMAPAccount LOGIN
Host imap.mail.ru
User LOGIN@mail.ru
Pass PASSWD
SSLType IMAPS
CertificateFile /etc/ssl/certs/ca-certificates.crt

IMAPStore LOGIN-remote
UseUTF8Mailboxes yes
Account LOGIN

MaildirStore LOGIN-local
SubFolders Verbatim
Path ~/Downloads/Mail/
Inbox ~/Downloads/Mail/Inbox

Channel Login
Far :Login-remote:
Near :Login-local:
Patterns *
Create Both
Expunge Both
SyncState *

Dialog is a domain-specific language for creating interactive fiction. It is heavily inspired by Inform 7 (Graham Nelson et al. 2006) and Prolog (Alain Colmerauer et al. 1972), and substantially different from both.

import Game.Metadata
import Game.MyNat.Multiplication


World "Tutorial"
Level 1
Title "The rfl tactic"

Introduction
"
# Read this first

Each level in this game involves proving a mathematical theorem (the \"Goal\").
The goal will be a statement about *numbers*. Some numbers in this game have known values.
Those numbers have names like $37$. Other numbers will be secret. They're called things
like $x$ and $q$. We know $x$ is a number, we just don't know which one.

In this first level we're going to prove the theorem that $37x + q = 37x + q$.
You can see `x q : ℕ` in the *Objects* below, which means that `x` and `q`
are numbers.

We solve goals in Lean using *Tactics*, and the first tactic we're
going to learn is called `rfl`, which proves all theorems of the form $X = X$.

Prove that $37x+q=37x+q$ by casting the `rfl` tactic.
"

/-- If $x$ and $q$ are arbitrary natural numbers, then $37x+q=37x+q.$ -/
Statement (x q : ℕ) : 37 * x + q = 37 * x + q := by
  Hint "In order to use the tactic `rfl` you can enter it in the text box
  under the goal and hit \"Execute\"."
  rfl

TacticDoc rfl
"
## Summary

`rfl` proves goals of the form `X = X`.

In other words, the `rfl` tactic will close any goal of the
form `A = B` if `A` and `B` are *identical*.

`rfl` is short for \"reflexivity (of equality)\".

## Example:

If the goal looks like this:

```
x + 37 = x + 37
```

then `rfl` will close it. But if it looks like `0 + x = x` then `rfl` won't work, because even
though $0+x$ and $x$ are always equal as *numbers*, they are not equal as *terms*.
The only term which is identical to `0 + x` is `0 + x`.

## Details

`rfl` is short for \"reflexivity of equality\".

## Game Implementation

*Note that our `rfl` is weaker than the version used in core Lean and `mathlib`,
for pedagogical purposes; mathematicians do not distinguish between propositional
and definitional equality because they think about definitions in a different way
to type theorists (`zero_add` and `add_zero` are both \"facts\" as far
as mathematicians are concerned, and who cares what the definition of addition is).*
"

NewTactic rfl

Conclusion
"
Congratulations! You completed your first verified proof!

Remember that `rfl` is a *tactic*. If you ever want information about the `rfl` tactic,
you can click on `rfl` in the list of tactics on the right.

Now click on \"Next\" to learn about the `rw` tactic.
"