REDROOM
PHP 8.2.31
Path:
Logout
Edit File
Size: 175.34 KB
Close
/home/nshryvcy/lscache/priv/2/a/e/2ae749e2c6a635c2
Text
Base64
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
Base64 mode: content will be decoded on save.
Save
Close
Exit & Reset
Directory Contents
Dirs: 0 × Files: 1
Delete Selected
Select All
Select None
Sort:
Name
Size
Modified
Enable drag-to-move
Name
Size
Perms
Modified
Actions
2ae749e2c6a635c2
175.34 KB
lrw-rw----
2025-09-05 08:13:55
Edit
Download
Rename
Chmod
Change Date
Delete
OK
Cancel
recursive
OK
Cancel
recursive
OK
Cancel
Zip Selected
If ZipArchive is unavailable, a
.tar
will be created (no compression).