?HAMA

Navigation

Breadcrumbs

/ / opt / hc_python / lib64 / python3.12 / site-packages / aenum / doc

Create

Create File | Create Folder | Upload Files | Run Command

Edit File Size: 133.54 KB

/opt/hc_python/lib64/python3.12/site-packages/aenum/doc/aenum.pdf

Text Base64

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

Base64 mode: content will be decoded on save.

Exit & Reset

Directory Contents

Dirs: 0 × Files: 2

Sort:

Enable drag-to-move

	Name	Size	Perms	Modified	Actions
	aenum.pdf	133.54 KB	lrw-r--r--	2025-04-04 08:01:57	Edit Download recursive recursive
	aenum.rst	45.54 KB	lrw-r--r--	2025-04-04 08:01:57	Edit Download recursive recursive