Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from http://www.ncbi.nlm.nih.gov/IEB/ToolBox/CPP_DOC/doxyhtml/ncbi__system_8cpp_source.html below:

NCBI C++ ToolKit: src/corelib/ncbi_system.cpp Source File

madvise(caddr_t,

,

);

(1,

\

(times(&

) == (clock_t)(-1)) {

(3,

);

clock_t tick = sysconf(_SC_CLK_TCK);

(!tick || tick == (clock_t)(-1))

(!tick || tick == (clock_t)(-1))

(tick == (clock_t)(-1))

.tms_utime/(tick ? tick : 1) << (tick ?

:

));

.tms_stime/(tick ? tick : 1) << (tick ?

:

));

(

.tms_stime +

.tms_utime)/(tick ? tick : 1) << (tick ?

:

));

rl.rlim_cur = rl.rlim_max = max_size;

std::set_new_handler(

);

rl.rlim_cur = rl.rlim_max = RLIM_INFINITY;

(setrlimit(RLIMIT_DATA, &rl) != 0) {

(setrlimit(RLIMIT_AS, &rl) != 0) {

std::set_new_handler(

);

(getrlimit(RLIMIT_DATA, &rl) != 0) {

rl.rlim_cur = max_size;

rl.rlim_cur = RLIM_INFINITY;

(setrlimit(RLIMIT_DATA, &rl) != 0) {

(getrlimit(RLIMIT_AS, &rlas) != 0) {

rl.rlim_max = rlas.rlim_max;

(setrlimit(RLIMIT_AS, &rl) != 0) {

std::set_new_handler(

);

cur_soft_limit = 0;

(getrlimit(RLIMIT_DATA, &rl) != 0) {

rl.rlim_max = max_size;

(rl.rlim_cur > max_size) {

rl.rlim_cur = max_size;

cur_soft_limit = rl.rlim_cur;

rl.rlim_max = RLIM_INFINITY;

(setrlimit(RLIMIT_DATA, &rl) != 0) {

(getrlimit(RLIMIT_AS, &rlas) != 0) {

rlas.rlim_max = max_size;

(rlas.rlim_cur > cur_soft_limit) {

rlas.rlim_cur = cur_soft_limit;

cur_soft_limit = rlas.rlim_cur;

rlas.rlim_max = RLIM_INFINITY;

(setrlimit(RLIMIT_AS, &rlas) != 0) {

std::set_new_handler(

);

(getrlimit(RLIMIT_AS, &rl) != 0) {

(rl.rlim_cur == RLIM_INFINITY) {

(getrlimit(RLIMIT_AS, &rl) != 0) {

(rl.rlim_max == RLIM_INFINITY) {

(signal(SIGXCPU, SIG_IGN) != SIG_ERR);

terminate_delay_time,

( max_cpu_time ) {

rl.rlim_cur = max_cpu_time;

rl.rlim_max = max_cpu_time + terminate_delay_time;

rl.rlim_cur = rl.rlim_max = RLIM_INFINITY;

(setrlimit(RLIMIT_CPU, &rl) != 0) {

terminate_delay_time,

cpu = 0;

GetSystemInfo(&

);

cpu = (

)

.dwNumberOfProcessors;

host_basic_info_data_t hinfo;

mach_msg_type_number_t hinfo_count = HOST_BASIC_INFO_COUNT;

rc = host_info(mach_host_self(), HOST_BASIC_INFO, (host_info_t)&hinfo, &hinfo_count);

(rc == KERN_SUCCESS) {

cpu = hinfo.avail_cpus;

x = sysconf(_SC_NPROC_ONLN);

x = sysconf(_SC_NPROCESSORS_ONLN);

=

(v);

mib[2] = { CTL_HW, HW_NCPU };

(sysctl(mib, 2, &v, &

,

, 0) == 0) {

cpu = (x <= 0 ? 1 : (

)x);

DWORD_PTR proc_mask = 0, sys_mask = 0;

(!::GetProcessAffinityMask(::GetCurrentProcess(), &proc_mask, &sys_mask)) {

(; proc_mask; proc_mask >>= 1) {

(total_cpus == 1) {

cpu_set_t* cpuset_ptr = CPU_ALLOC(total_cpus);

(cpuset_ptr ==

) {

cpuset_size = CPU_ALLOC_SIZE(total_cpus);

CPU_ZERO_S(cpuset_size, cpuset_ptr);

(sched_getaffinity(getpid(), cpuset_size, cpuset_ptr) != 0) {

CPU_FREE(cpuset_ptr);

= CPU_COUNT_S(cpuset_size, cpuset_ptr);

CPU_FREE(cpuset_ptr);

(

< 0) ? 0 :

(

);

(clock_gettime(CLOCK_UPTIME, &ts) == 0) {

timeval boottime;

=

(boottime);

mib[2] = { CTL_KERN, KERN_BOOTTIME };

(sysctl(mib, 2, &boottime, &

,

, 0) < 0) {

atomic<unsigned long> cached_value;

= cached_value.load(memory_order_relaxed);

GetSystemInfo(&

);

= (

long)

.dwPageSize;

x = sysconf(_SC_PAGESIZE);

x = sysconf(_SC_PAGE_SIZE);

cached_value.store(

, memory_order_relaxed);

atomic<unsigned long> cached_value;

= cached_value.load(memory_order_relaxed);

GetSystemInfo(&

);

= (

long)

.dwAllocationGranularity;

cached_value.store(

, memory_order_relaxed);

atomic<Uint8> cached_value;

= cached_value.load(memory_order_relaxed);

.dwLength =

(

);

( ::GlobalMemoryStatusEx(&

) ) {

num_pages = sysconf(_SC_PHYS_PAGES);

(

(num_pages) != -1L) {

=

(physmem);

(sysctl(mib, 2, &physmem, &

,

, 0) == 0 &&

==

(physmem)){

vm_statistics vm_stat;

mach_port_t my_host = mach_host_self();

mach_msg_type_number_t

= HOST_VM_INFO_COUNT;

(host_statistics(my_host, HOST_VM_INFO,

(integer_t*) &vm_stat, &

) == KERN_SUCCESS) {

(

(vm_stat.free_count) +

(vm_stat.active_count) +

(vm_stat.inactive_count) +

(vm_stat.wire_count) );

(sysmp(MP_SAGET, MPSA_RMINFO, &rmi,

(rmi)) >= 0) {

cached_value.store(

, memory_order_relaxed);

.dwLength =

(

);

( ::GlobalMemoryStatusEx(&

) ) {

.ullAvailPhys;

num_pages = sysconf(_SC_AVPHYS_PAGES);

(

(num_pages) != -1L) {

mib[2] = { CTL_HW, HW_USERMEM };

=

(mem);

(sysctl(mib, 2, &mem, &

,

, 0) == 0 &&

==

(mem)){

vm_statistics vm_stat;

mach_port_t my_host = mach_host_self();

mach_msg_type_number_t

= HOST_VM_INFO_COUNT;

(host_statistics(my_host, HOST_VM_INFO,

(integer_t*) &vm_stat, &

) == KERN_SUCCESS) {

(sysmp(MP_SAGET, MPSA_RMINFO, &rmi,

(rmi)) >= 0) {

atomic<clock_t> cached_value;

= cached_value.load(memory_order_relaxed);

clock_t

= sysconf(_SC_CLK_TCK);

(!

||

== (clock_t)(-1))

= CLK_TCK;

(

&&

!= (clock_t)(-1)) {

cached_value.store(

, memory_order_relaxed);

( !total ) { total = &scratch; }

( !resident ) { resident = &scratch; }

( !shared ) { shared = &scratch; }

page_fault_count;

SIZE_T peak_working_set_size;

SIZE_T working_set_size;

SIZE_T quota_peak_paged_pool_usage;

SIZE_T quota_paged_pool_usage;

SIZE_T quota_peak_nonpaged_pool_usage;

SIZE_T quota_nonpaged_pool_usage;

SIZE_T pagefile_usage;

SIZE_T peak_pagefile_usage;

(STDMETHODCALLTYPE

* dllGetProcessMemoryInfo)

dllGetProcessMemoryInfo = psapi_dll.

(

, &dllGetProcessMemoryInfo);

(dllGetProcessMemoryInfo) {

dllGetProcessMemoryInfo(GetCurrentProcess(), counters,

(counters));

*total = counters.quota_paged_pool_usage +

counters.quota_nonpaged_pool_usage;

*resident = counters.working_set_size;

statm >> *total >> *resident >> *shared;

*resident *= page_size;

*shared *= page_size;

*total = (size_t)

;

*resident = (size_t)

;

memset(&ru,

,

(ru));

(getrusage(RUSAGE_SELF, &ru) == 0 && ru.ru_maxrss > 0) {

memset(&

,

,

(

));

(times(&

) != (clock_t)(-1)) {

clock_t ticks =

.tms_utime +

.tms_stime;

*resident = _DIV0(ru.ru_idrss, ticks);

*shared = _DIV0(ru.ru_ixrss, ticks);

*total = _DIV0(ru.ru_ixrss + ru.ru_idrss + ru.ru_isrss, ticks);

task_flavor_t flavor = MACH_TASK_BASIC_INFO;

mach_task_basic_info t_info;

mach_msg_type_number_t t_info_count = MACH_TASK_BASIC_INFO_COUNT;

task_flavor_t flavor = TASK_BASIC_INFO;

task_basic_info t_info;

mach_msg_type_number_t t_info_count = TASK_BASIC_INFO_COUNT;

(task_info(mach_task_self(), flavor, (task_info_t)&t_info, &t_info_count) == KERN_SUCCESS) {

*total = *resident = t_info.resident_size;

FILETIME ft_creation, ft_exit, ft_kernel, ft_user;

(!::GetProcessTimes(GetCurrentProcess(),

&ft_creation, &ft_exit, &ft_kernel, &ft_user)) {

( system_time ) {

*system_time = (ft_kernel.dwLowDateTime +

((

) ft_kernel.dwHighDateTime << 32)) * 1.0e-7;

*user_time = (ft_user.dwLowDateTime +

((

) ft_user.dwHighDateTime << 32)) * 1.0e-7;

clock_t

= times(&

);

(

== (clock_t)(-1) ) {

clock_t tick = sysconf(_SC_CLK_TCK);

(!tick || tick == (clock_t)(-1))

(!tick || tick == (clock_t)(-1))

(tick == (clock_t)(-1)) {

( system_time ) {

*system_time = (double)

.tms_stime / (

)tick;

*user_time = (double)

.tms_utime / (

)tick;

rlim_t cur_limit = -1;

rlim_t max_limit = -1;

(getrlimit(RLIMIT_NOFILE, &rlim) == 0) {

cur_limit = rlim.rlim_cur;

max_limit = rlim.rlim_max;

cur_limit =

rlim_t

(sysconf(_SC_OPEN_MAX));

DIR* dir = opendir(

);

(readdir(dir) !=

) {

(cur_limit > 0) {

max_fd =

(cur_limit);

(cur_limit > INT_MAX) {

(

fd = 0; fd < max_fd; ++fd) {

(fcntl(fd, F_GETFD, 0) == -1) {

(errno == EBADF) {

(cur_limit > INT_MAX)

*soft_limit = INT_MAX;

*soft_limit =

(cur_limit);

(max_limit > INT_MAX)

*hard_limit = INT_MAX;

*hard_limit =

(max_limit);

thread_count = 0;

DIR* dir = opendir(

);

(readdir(dir) !=

)

(thread_count <= 0)

thread_count;

(11,

);

adv = MADV_NORMAL;

;

adv = MADV_RANDOM;

;

adv = MADV_SEQUENTIAL;

;

adv = MADV_WILLNEED;

;

adv = MADV_DONTNEED;

;

adv = MADV_DONTFORK;

adv = MADV_MERGEABLE;

adv = MADV_UNMERGEABLE;

( madvise((

*)

,

, adv) != 0 ) {

x_errno = errno; \

ERR_POST_X(13,

<<

Sleep((mc_sec + (kMicroSecondsPerMilliSecond / 2)) / kMicroSecondsPerMilliSecond);

timespec delay, unslept;

memset(&unslept, 0,

(unslept));

(nanosleep(&delay, &unslept) < 0) {

memset(&unslept, 0,

(unslept));

((sec = sleep(sec)) > 0) {

timeval delay;

(select(0, (fd_set*) 0, (fd_set*) 0, (fd_set*) 0, &delay) < 0) {

dumpname[64],

[64];

wcscat( wcscat( wcscpy(dumpname, L

), _ltow(GetCurrentProcessId(),

, 10)), L

);

dumpname[64],

[64];

(

( strcpy(dumpname,

), _ltoa(GetCurrentProcessId(),

, 10)),

);

hf = CreateFile(dumpname,

GENERIC_WRITE, 0,

, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL,

);

MINIDUMP_EXCEPTION_INFORMATION ei;

ei.ThreadId = GetCurrentThreadId();

ei.ExceptionPointers = ep;

ei.ClientPointers =

;

GetCurrentProcess(), GetCurrentProcessId(),

hf, MiniDumpNormal, &ei,

,

);

cerr <<

<<

<< ep->ExceptionRecord->ExceptionCode <<

<< ep->ExceptionRecord->ExceptionAddress << endl;

EXCEPTION_EXECUTE_HANDLER;

SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOGPFAULTERRORBOX |

SEM_NOOPENFILEERRORBOX);

_set_error_mode(_OUT_TO_STDERR);

( !IsDebuggerPresent() ) {

_CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDERR);

_CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE);

_CrtSetReportFile(_CRT_ERROR, _CRTDBG_FILE_STDERR);

_CrtSetReportMode(_CRT_ERROR, _CRTDBG_MODE_FILE);

_CrtSetReportFile(_CRT_ASSERT, _CRTDBG_FILE_STDERR);

_CrtSetReportMode(_CRT_ASSERT, _CRTDBG_MODE_FILE);

std::ignore =

;

(getenv(

)) {

eax, ebx, ecx, edx;

eax = cpuid[0], ebx = cpuid[1], ecx = cpuid[2], edx = cpuid[3];

(

:

(eax),

(ebx),

(ecx),

(edx) :

(1));

( !(ecx & (1<<20)) )

message->assign(

);

*instruction_set;

TRegisters = std::array<int,4>;

TRegisters registers;

vector<TRegisters> m_Data;

vector<TRegisters> m_ExtData;

CPUID = [](TRegisters&

,

func_id) {

__cpuid(

.data(), func_id);

(

:

(

[0]),

(

[1]),

(

[2]),

(

[3]) :

(func_id));

CPUID_EX = [](TRegisters&

,

func_id,

sub_id) {

__cpuidex(

.data(), func_id, sub_id);

(

:

(

[0]),

(

[1]),

(

[2]),

(

[3]) :

(func_id),

(sub_id));

CPUID(registers, 0);

nIds = registers[0];

(

= 0;

<= nIds; ++

) {

CPUID_EX(registers,

, 0);

m_Data.push_back(registers);

memset(vendor, 0,

(vendor));

*

*

(vendor) = m_Data[0][1];

*

*

(vendor + 4) = m_Data[0][3];

*

*

(vendor + 8) = m_Data[0][2];

CPUID(registers, 0x80000000);

nExIds = registers[0];

(

= 0x80000000;

<= nExIds; ++

) {

CPUID_EX(registers,

, 0);

m_ExtData.push_back(registers);

(nExIds >= (

)0x80000001) {

(nExIds >= (

)0x80000004) {

memset(brand, 0,

(brand));

memcpy(brand, m_ExtData[2].

(),

(registers));

memcpy(brand + 16, m_ExtData[3].

(),

(registers));

memcpy(brand + 32, m_ExtData[4].

(),

(registers));

list<string> supported;

list<string> unsupported;

= [&supported,&unsupported](

feature,

is_supported) {

supported.push_back(feature);

unsupported.push_back(feature);

cout << endl <<

<< endl;

(

feature : supported) {

cout << feature <<

;

cout << endl <<

<< endl;

(

feature : unsupported) {

cout << feature <<

;

static string VendorStr(void)

static bool AVX512PF(void)

static bool CMPXCHG16B(void)

static bool AVX512F(void)

static bool PCLMULQDQ(void)

static bool OSXSAVE(void)

static string BrandStr(void)

static void Print(void)

Print human-readable list of supported and not supported CPU features.

static bool AVX512CD(void)

static bool PREFETCHWT1(void)

static bool FSGSBASE(void)

static bool SYSCALL(void)

static bool AVX512ER(void)

static const InstructionSet & IS(void)

static bool MONITOR(void)

static bool _3DNOWEXT(void)

static bool INVPCID(void)

static clock_t GetClockTicksPerSecond(void)

Get number of (statistics) clock ticks per second.

static unsigned int GetCpuCount(void)

Return number of active CPUs/cores (never less than 1).

static unsigned long GetVirtualMemoryPageSize(void)

Return virtual memory page size.

static unsigned int GetCpuCountAllowed(void)

Return number of allowed to use CPUs/cores for the current thread.

static Uint8 GetAvailPhysicalMemorySize(void)

Return the amount of physical memory currently available on the system ("free"), in bytes.

static unsigned long GetVirtualMemoryAllocationGranularity(void)

Return size of an allocation unit (usually it is a multiple of page size).

static double GetUptime(void)

Get system uptime in seconds.

static Uint8 GetTotalPhysicalMemorySize(void)

Return the amount of actual/total physical memory, in bytes.

static string GetUserName(void)

Get actual user name for the current process.

static string GetUserNameByUID(uid_t uid)

Look up user name by given numeric user ID.

static string GetUserName(void)

Get name of the current user.

void(*)(CSeq_entry_Handle seh, IWorkbench *wb, const CSerialObject &obj) handler

static const char si[8][64]

EInterruptOnSignal

Interrupt on signal mode.

@ eInterruptOnSignal

Cancel operation if interrupted by a signal.

#define ERR_POST_X_ONCE(err_subcode, message)

Error posting only once during program execution with default error code and given error subcode.

#define ERR_POST_X(err_subcode, message)

Error posting with default error code and given error subcode.

TFunc GetEntryPoint_Func(const string &name, TFunc *func)

Get DLLs entry point (function).

void Critical(CExceptionArgs_Base &args)

static void SetFromErrno(void)

Set last error using current "errno" code.

void Warning(CExceptionArgs_Base &args)

static void Set(ECode code)

Set last error using native error code enum.

static void SetErrno(int errno_code)

Set last error using errno code.

Int8 GetLength(void) const

Get size of file.

int64_t Int8

8-byte (64-bit) signed integer

uint64_t Uint8

8-byte (64-bit) unsigned integer

#define END_NCBI_SCOPE

End previously defined NCBI scope.

#define BEGIN_NCBI_SCOPE

Define ncbi namespace.

IO_PREFIX::ifstream CNcbiIfstream

Portable alias for ifstream.

const long kMilliSecondsPerSecond

Number milliseconds in one second.

const long kMicroSecondsPerSecond

Number of microseconds in one second.

const long kNanoSecondsPerSecond

Number of nanoseconds in one second.

#define INVALID_HANDLE_VALUE

A value for an invalid file handle.

#define HANDLE

An abstraction for a file handle.

unsigned int

A callback function used to compare two keys in a database.

Definition of all error codes used in corelib (xncbi.lib).

where both of them are integers Note

static void hex(unsigned char c)

const struct ncbi::grid::netcache::search::fields::SIZE size

const GenericPointer< typename T::ValueType > T2 value

Defines MS Windows specific private functions and classes.

Private UNIX specific features.

Static variables safety - create on demand, destroy on application termination.

#define FALSE

bool replacment for C indicating false.

static CSafeStatic< CTime > s_TimeSet

bool SetCpuTimeLimit(unsigned int max_cpu_time, unsigned int terminate_delay_time, TLimitsPrintHandler handler, TLimitsPrintParameter parameter)

[UNIX only] Set CPU time usage limit.

bool MemoryAdvise(void *addr, size_t len, EMemoryAdvise advise)

[UNIX only] Advise on memory usage for specified memory region.

bool SetMemoryLimit(size_t max_size, TLimitsPrintHandler handler, TLimitsPrintParameter parameter)

[UNIX only] Set memory limit.

std::atomic< bool > s_IsHandlerActive

bool SetMemoryLimitSoft(size_t max_size, TLimitsPrintHandler handler, TLimitsPrintParameter parameter)

[UNIX only] Set soft memory limit.

void SleepMilliSec(unsigned long ml_sec, EInterruptOnSignal onsignal)

static TLimitsPrintParameter s_PrintHandlerParam

void SleepSec(unsigned long sec, EInterruptOnSignal onsignal)

Sleep.

static size_t s_MemoryLimitHard

static bool s_DoneSuppressSystemMessageBox

static size_t s_CpuTimeLimit

bool SetMemoryLimitHard(size_t max_size, TLimitsPrintHandler handler, TLimitsPrintParameter parameter)

[UNIX only] Set hard memory limit.

bool IsSuppressedDebugSystemMessageBox(void)

Check if system message box has been suppressed for debug library.

static void s_DefaultPrintHandler(void)

static bool s_SuppressedDebugSystemMessageBox

size_t GetVirtualMemoryLimitHard(void)

[UNIX only] Get "hard" memory limit of the virtual memory (address space) in bytes for a current proc...

bool GetCurrentProcessTimes(double *user_time, double *system_time)

void DisableSuppressSystemMessageBox(void)

Prevent run of SuppressSystemMessageBox().

static void s_SetPrintHandler(TLimitsPrintHandler handler, TLimitsPrintParameter parameter)

bool GetMemoryUsage(size_t *total, size_t *resident, size_t *shared)

void SuppressSystemMessageBox(TSuppressSystemMessageBox mode)

Suppress popup messages on execution errors.

bool VerifyCpuCompatibility(string *message)

CPU.

static void s_NewHandler(void)

static void s_SignalHandler(int sig)

std::atomic< ELimitsExitCode > s_Reason

size_t GetVirtualMemoryLimitSoft(void)

[UNIX only] Get "soft" memory limit of the virtual memory (address space) in bytes for a current proc...

static size_t s_MemoryLimitSoft

std::atomic< bool > s_IsHandlerSet

int GetProcessFDCount(int *soft_limit, int *hard_limit)

static void s_HandlerGuard(void)

DEFINE_STATIC_FAST_MUTEX(s_Limits_Handler_Mutex)

static char * s_ReservedMemory

static bool s_EnableSuppressSystemMessageBox

Suppress Diagnostic Popup Messages (all MS-Win specific)

int GetProcessThreadCount(void)

[Linux only] Provides the number of threads in the current process.

void SleepMicroSec(unsigned long mc_sec, EInterruptOnSignal onsignal)

static LONG CALLBACK _SEH_Handler(EXCEPTION_POINTERS *ep)

static TLimitsPrintHandler s_PrintHandler

int TSuppressSystemMessageBox

Binary OR of "ESuppressSystemMessageBox".

void * TLimitsPrintParameter

Type of parameter for print handler.

EMemoryAdvise

Memory advise.

@ eMADV_WillNeed

Expect access in the near future.

@ eMADV_Mergeable

KSM may merge identical pages.

@ eMADV_Normal

No further special treatment – by default.

@ eMADV_Random

Expect random page references.

@ eMADV_DontNeed

Do not expect access in the near future.

@ eMADV_Sequential

Expect sequential page references.

@ eMADV_DoFork

Do inherit across fork() – by default.

@ eMADV_DontFork

Don't inherit across fork()

@ eMADV_Unmergeable

KSM may not merge identical pages – by default.

@ fSuppress_Debug

Debug library.

@ fSuppress_System

System errors.

@ fSuppress_Runtime

Runtime library.

@ fSuppress_Exception

Unhandled exceptions.

void(* TLimitsPrintHandler)(ELimitsExitCode, size_t, CTime &, TLimitsPrintParameter)

Type of handler for printing a dump information after generating any limitation event.

@ eLEC_Cpu

CPU time usage limit.

@ eLEC_Memory

Memory limit.

Define class Dll and for Portable DLL handling.

Defines NCBI C++ Toolkit portable error codes.

Defines classes: CDirEntry, CFile, CDir, CSymLink, CMemoryFile, CFileUtil, CFileLock,...

Multi-threading – mutexes; rw-locks; semaphore.

double r(size_t dimension_, const Int4 *score_, const double *prob_, double theta_)

static SLJIT_INLINE sljit_ins st(sljit_gpr r, sljit_s32 d, sljit_gpr x, sljit_gpr b)

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4