?HAMA

Navigation

Breadcrumbs

/ / proc / thread-self / root / var / softaculous / ostic17 / language

Create

Create File | Create Folder | Upload Files | Run Command

Edit File Size: 423.13 KB

/proc/thread-self/root/var/softaculous/ostic17/language/pt_BR.phar

Text Base64

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

Base64 mode: content will be decoded on save.

Exit & Reset

Directory Contents

Dirs: 0 × Files: 6

Sort:

Enable drag-to-move

Name	Size	Perms	Modified	Actions
nl.phar	389.95 KB	lrw-r--r--	2025-02-05 11:13:50	Edit Download recursive recursive
pt_BR.phar	423.13 KB	lrw-r--r--	2025-02-05 11:13:50	Edit Download recursive recursive
ru.phar	563.98 KB	lrw-r--r--	2025-02-05 11:13:50	Edit Download recursive recursive
uk.phar	565.71 KB	lrw-r--r--	2025-02-05 11:13:50	Edit Download recursive recursive
zh_CN.phar	349.54 KB	lrw-r--r--	2025-02-05 11:13:50	Edit Download recursive recursive
zh_TW.phar	308.08 KB	lrw-r--r--	2025-02-05 11:13:50	Edit Download recursive recursive