?HAMA

Navigation

Breadcrumbs

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

Create

Create File | Create Folder | Upload Files | Run Command

Edit File Size: 389.95 KB

/proc/thread-self/root/var/softaculous/ostic17/language/nl.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