REDROOM
PHP 8.2.31
Path:
Logout
Edit File
Size: 206.56 KB
Close
/proc/self/root/home/nshryvcy/lscache/priv/4/e/0/4e084daf0a93bd54
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
4e084daf0a93bd54
206.56 KB
lrw-rw----
2025-09-05 08:03:56
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).