The Win32_PerfFormattedData_PerfOS_Memory formatted data class provides pre-calculated performance data from performance counters that monitor the physical and virtual memory on the computer. Physical memory is the amount of random access memory (RAM) on the computer. Virtual memory consists of space in physical memory and on disk. Many of the memory counters monitor paging, which is the movement of pages of code and data between disk and physical memory. Excessive paging, a symptom of a memory shortage, can cause delays which interfere with all system processes.

This class represents the Memory object in System Monitor and returns the same data you see in System Monitor. The original data source is the PerfOS performance library. The corresponding raw data class is Win32_PerfRawData_PerfOS_Memory. Data is dynamically provided for this class from the performance library object by the WmiPerfInst provider.

Windows Server 2003 and Windows XP:  WMI data for this class is supplied by the Formatted Performance Data Provider.

The following syntax is simplified from MOF code and shows all of the inherited properties, including the Frequency and Timestamp properties required for class display in System Monitor. For more information about required property qualifiers, see Property Qualifiers for Performance Counter Classes. For more information about CounterType values, see WMI Performance Counter Types.

class Win32_PerfFormattedData_PerfOS_Memory : Win32_PerfFormattedData
{
  uint64 AvailableBytes;
  uint64 AvailableKBytes;
  uint64 AvailableMBytes;
  uint64 CacheBytes;
  uint64 CacheBytesPeak;
  uint32 CacheFaultsPerSec;
  string Caption;
  uint64 CommitLimit;
  uint64 CommittedBytes;
  uint32 DemandZeroFaultsPerSec;
  string Description;
  uint32 FreeSystemPageTableEntries;
  uint64 Frequency_Object;
  uint64 Frequency_PerfTime;
  uint64 Frequency_Sys100NS;
  string Name;
  uint32 PageFaultsPerSec;
  uint32 PageReadsPerSec;
  uint32 PagesInputPerSec;
  uint32 PagesOutputPerSec;
  uint32 PagesPerSec;
  uint32 PageWritesPerSec;
  uint32 PercentCommittedBytesInUse;
  uint32 PoolNonpagedAllocs;
  uint64 PoolNonpagedBytes;
  uint32 PoolPagedAllocs;
  uint64 PoolPagedBytes;
  uint64 PoolPagedResidentBytes;
  uint64 SystemCacheResidentBytes;
  uint64 SystemCodeResidentBytes;
  uint64 SystemCodeTotalBytes;
  uint64 SystemDriverResidentBytes;
  uint64 SystemDriverTotalBytes;
  uint64 Timestamp_Object;
  uint64 Timestamp_PerfTime;
  uint64 Timestamp_Sys100NS;
  uint32 TransitionFaultsPerSec;
  uint32 WriteCopiesPerSec;
};

Methods

The Win32_PerfFormattedData_PerfOS_Memory class does not define any methods.

Properties

The Win32_PerfFormattedData_PerfOS_Memory class defines the following properties.

AvailableBytes

Data type: uint64
Access type: Read-only
Qualifiers: CookingType("PERF_COUNTER_RAWCOUNT"), Counter("AvailableBytes"), PerfTimeStamp("Timestamp_PerfTime"), PerfTimeFreq("Frequency_PerfTime")

Amount of physical memory in bytes available to processes running on the computer. This value is calculated by summing space on the Zeroed, Free, and Standby memory lists. Free memory is ready for use; Zeroed memory is pages of memory filled with zeros to prevent later processes from seeing data used by a previous process. Standby memory is memory removed from a process's working set (its physical memory) on route to disk, but is still available to be recalled. This property displays the last observed value only; it is not an average.

For more information about using uint64 values in scripts, see Scripting in WMI.

AvailableKBytes

Data type: uint64
Access type: Read-only
Qualifiers: CookingType("PERF_COUNTER_RAWCOUNT"), Counter("AvailableKBytes"), PerfTimeStamp("Timestamp_PerfTime"), PerfTimeFreq("Frequency_PerfTime")

Amount of physical memory available to processes running on the computer, in kilobytes. It is calculated by summing space on the Zeroed, Free, and Standby memory lists. Free memory is ready for use; Zeroed memory contains memory pages filled with zeros to prevent later processes from seeing data used by a previous Process. Standby memory is memory removed from a process' working set (its physical memory), but is still available to be recalled. This property displays the last observed value only; it is not an average.

For more information about using uint64 values in scripts, see Scripting in WMI.

AvailableMBytes

Data type: uint64
Access type: Read-only
Qualifiers: CookingType("PERF_COUNTER_RAWCOUNT"), Counter("AvailableMBytes"), PerfTimeStamp("Timestamp_PerfTime"), PerfTimeFreq("Frequency_PerfTime")

Amount of physical memory available to processes running on the computer, in megabytes. It is calculated by summing space on the Zeroed, Free, and Standby memory lists. Free memory is ready for use; Zeroed memory contains memory pages filled with zeros to prevent later processes from seeing data used by a previous process. Standby memory is memory removed from a process' working set (its physical memory), but is still available to be recalled. This property displays the last observed value only; it is not an average.

For more information about using uint64 values in scripts, see Scripting in WMI.

CacheBytes

Data type: uint64
Access type: Read-only
Qualifiers: CookingType("PERF_COUNTER_RAWCOUNT"), Counter("CacheBytes"), PerfTimeStamp("Timestamp_PerfTime"), PerfTimeFreq("Frequency_PerfTime")

Number of bytes currently being used by the file system cache. The file system cache is an area of physical memory that stores recently used pages of data for applications. The operating system continually adjusts the size of the cache, making it as large as it can while still preserving the minimum required number of available bytes for processes. This property displays the last observed value only; it is not an average.

For more information about using uint64 values in scripts, see Scripting in WMI.

CacheBytesPeak

Data type: uint64
Access type: Read-only
Qualifiers: CookingType("PERF_COUNTER_RAWCOUNT"), Counter("CacheBytesPeak"), PerfTimeStamp("Timestamp_PerfTime"), PerfTimeFreq("Frequency_PerfTime")

Maximum number of CacheBytes after the system was last restarted. This value might be larger than the current size of the cache. CacheBytes is the sum of the System Cache Resident Bytes, System Driver Resident Bytes, System Code Resident Bytes, and Pool Paged Resident Bytes counters. This property displays the last observed value only; it is not an average.

For more information about using uint64 values in scripts, see Scripting in WMI.

CacheFaultsPerSec

Data type: uint32
Access type: Read-only
Qualifiers: CookingType("PERF_COUNTER_COUNTER"), Counter("CacheFaultsPerSec"), PerfTimeStamp("Timestamp_PerfTime"), PerfTimeFreq("Frequency_PerfTime")

Number of faults which occur when a page is not found in the file system cache and must be retrieved from elsewhere in memory (a soft fault) or from disk (a hard fault). The file system cache is an area of physical memory that stores recently used pages of data for applications. Cache activity is a reliable indicator of most application I/O operations. This property counts the number of faults without regard for the number of pages faulted in each operation.

Caption

Data type: string
Access type: Read-only

Short textual description (one-line string) for the statistic or metric. This property is inherited from CIM_StatisticalInformation.

CommitLimit

Data type: uint64
Access type: Read-only
Qualifiers: CookingType("PERF_COUNTER_LARGE_RAWCOUNT"), Counter("CommitLimit"), PerfTimeStamp("Timestamp_PerfTime"), PerfTimeFreq("Frequency_PerfTime")

Amount of virtual memory, in bytes, that can be committed without having to extend the paging files. Committed memory is physical memory for which space has been reserved on the disk paging files. Each logical disk drive has one paging file. If the paging files are be expanded, the CommitLimit value increases accordingly. This property displays the last observed value only; it is not an average.

For more information about using uint64 values in scripts, see Scripting in WMI.

CommittedBytes

Data type: uint64
Access type: Read-only
Qualifiers: CookingType("PERF_COUNTER_LARGE_RAWCOUNT"), Counter("CommittedBytes"), PerfTimeStamp("Timestamp_PerfTime"), PerfTimeFreq("Frequency_PerfTime")

Amount of committed virtual memory, in bytes. Committed memory is physical memory for which space has been reserved on the disk paging file in case it must be written back to disk. This property displays the last observed value only; it is not an average.

For more information about using uint64 values in scripts, see Scripting in WMI.

DemandZeroFaultsPerSec

Data type: uint32
Access type: Read-only
Qualifiers: CookingType("PERF_COUNTER_COUNTER"), Counter("DemandZeroFaultsPerSec"), PerfTimeStamp("Timestamp_PerfTime"), PerfTimeFreq("Frequency_PerfTime")

Number of page faults that require a zeroed page to satisfy the fault. Zeroed pages, pages emptied of previously stored data and filled with zeros, are a security feature. They prevent processes from seeing data stored by earlier processes that used the memory space. The operating system maintains a list of zeroed pages to accelerate this process. This property counts numbers of faults, without regard to the numbers of pages retrieved to satisfy the fault. This property displays the difference between the values observed in the last two samples, divided by the duration of the sample interval.

Description

Data type: string
Access type: Read-only

Textual description of the statistic or metric. This property is inherited from CIM_StatisticalInformation.

FreeSystemPageTableEntries

Data type: uint32
Access type: Read-only
Qualifiers: CookingType("PERF_COUNTER_RAWCOUNT"), Counter("FreeSystemPageTableEntries"), PerfTimeStamp("Timestamp_PerfTime"), PerfTimeFreq("Frequency_PerfTime")

Number of page table entries not being used by the system. This property displays the last observed value only; it is not an average.

Frequency_Object

Data type: uint64
Access type: Read-only

Frequency, in ticks per second, of Timestamp_Object. This property is defined by the provider. This property is inherited from Win32_Perf.

For more information about using uint64 values in scripts, see Scripting in WMI.

Frequency_PerfTime

Data type: uint64
Access type: Read-only

Frequency, in ticks per second, of Timestamp_Perftime. A value could be obtained by calling the Windows function QueryPerformanceCounter. This property is inherited from Win32_Perf.

For more information about using uint64 values in scripts, see Scripting in WMI.

Frequency_Sys100NS

Data type: uint64
Access type: Read-only

Frequency, in ticks per second, of Timestamp_Sys100NS (10000000). This property is inherited from Win32_Perf.

For more information about using uint64 values in scripts, see Scripting in WMI.

Name

Data type: string
Access type: Read-only
Qualifiers: Key, MaxLen(256)

Label by which the statistic or metric is known. This property is inherited from CIM_StatisticalInformation.

PageFaultsPerSec

Data type: uint32
Access type: Read-only
Qualifiers: CookingType("PERF_COUNTER_COUNTER"), Counter("PageFaultsPerSec"), PerfTimeStamp("Timestamp_PerfTime"), PerfTimeFreq("Frequency_PerfTime")

Overall rate at which faulted pages are handled by the processor. A page fault occurs when a process requires code or data that is not in its working set (its space in physical memory). This property includes both hard faults (those that require disk access) and soft faults (where the faulted page is found elsewhere in physical memory.) Most processors can handle large numbers of soft faults without consequence. However, hard faults can cause significant delays. This property displays the difference between the values observed in the last two samples, divided by the duration of the sample interval.

PageReadsPerSec

Data type: uint32
Access type: Read-only
Qualifiers: CookingType("PERF_COUNTER_COUNTER"), Counter("PageReadsPerSec"), PerfTimeStamp("Timestamp_PerfTime"), PerfTimeFreq("Frequency_PerfTime")

Number of times the disk was read to resolve hard page faults. (Hard page faults occur when a process requires code or data that is not in its working set or elsewhere in physical memory, and must be retrieved from disk.) This property was designed as a primary indicator of the kinds of faults that cause system-wide delays. It includes read operations to satisfy faults in the file system cache (usually requested by applications) and in non-cached mapped memory files. This property counts the number of read operations, without regard to the number of pages retrieved by each operation. The value is the difference between the values observed in the last two samples, divided by the duration of the sample interval.

PagesInputPerSec

Data type: uint32
Access type: Read-only
Qualifiers: CookingType("PERF_COUNTER_COUNTER"), Counter("PagesInputPerSec"), PerfTimeStamp("Timestamp_PerfTime"), PerfTimeFreq("Frequency_PerfTime")

Number of pages read from disk to resolve hard page faults. Hard page faults occur when a process requires code or data that is not in its working set or elsewhere in physical memory, and must be retrieved from disk. This property was designed as a primary indicator of the kinds of faults that cause system-wide delays. It includes pages retrieved to satisfy faults in the file system cache (usually requested by applications) and in non-cached mapped memory files. This property counts the numbers of pages, and can be compared to other counts of pages, such as the PageFaultsPerSec property in Win32_PerfFormattedData_PerfOS_Memory, without conversion. This property displays the difference between the values observed in the last two samples, divided by the duration of the sample interval.

PagesOutputPerSec

Data type: uint32
Access type: Read-only
Qualifiers: CookingType("PERF_COUNTER_COUNTER"), Counter("PagesOutputPerSec"), PerfTimeStamp("Timestamp_PerfTime"), PerfTimeFreq("Frequency_PerfTime")

Number of pages written to disk to free up space in physical memory. Pages are written back to disk only if they are changed in physical memory, so they are likely to hold data, not code. A high rate of page output might indicate a memory shortage. The operating system writes more pages back to disk to free up space when physical memory is in short supply. This property counts numbers of pages, and can be compared to other counts of pages, without conversion. This property displays the difference between the values observed in the last two samples, divided by the duration of the sample interval.

PagesPerSec

Data type: uint32
Access type: Read-only
Qualifiers: CookingType("PERF_COUNTER_COUNTER"), Counter("PagesPerSec"), PerfTimeStamp("Timestamp_PerfTime"), PerfTimeFreq("Frequency_PerfTime")

Number of pages read from or written to the disk to resolve hard page faults. Hard page faults occur when a process requires code or data that is not in its working set or elsewhere in physical memory, and must be retrieved from disk. This property was designed as a primary indicator of the kinds of faults that cause system-wide delays. It is the sum of the PagesInputPerSec and PagesOutputPerSec properties in the Win32_PerfFormattedData_PerfOS_Memory class. It is counted in numbers of pages, so it can be compared to other counts of pages, such as the PageFaultsPerSec property in Win32_PerfFormattedData_PerfOS_Memory, without conversion. It includes pages retrieved to satisfy faults in the file system cache, usually requested by applications and non-cached mapped memory files. This property displays the difference between the values observed in the last two samples, divided by the duration of the sample interval.

PageWritesPerSec

Data type: uint32
Access type: Read-only
Qualifiers: CookingType("PERF_COUNTER_COUNTER"), Counter("PageWritesPerSec"), PerfTimeStamp("Timestamp_PerfTime"), PerfTimeFreq("Frequency_PerfTime")

Number of times pages were written to disk to free up space in physical memory. Pages are written to disk only if they are changed while in physical memory, so they are likely to hold data, not code. This property counts write operations, without regard to the number of pages written in each operation. The value is the difference between the values observed in the last two samples, divided by the duration of the sample interval.

PercentCommittedBytesInUse

Data type: uint32
Access type: Read-only
Qualifiers: CookingType("PERF_RAW_FRACTION"), Counter("PercentCommittedBytesInUse"), PerfTimeStamp("Timestamp_PerfTime"), PerfTimeFreq("Frequency_PerfTime"), Base("PercentCommittedBytesInUse_Base")

Ratio of memory bytes committed to the memory commit limit. Committed memory is physical memory in use for which space has been reserved in the paging file should it must be written to disk. The commit limit is determined by the size of the paging file. If the paging file is enlarged, the commit limit increases, and the ratio is reduced. The value is the current percentage value only; it is not an average.

PoolNonpagedAllocs

Data type: uint32
Access type: Read-only
Qualifiers: CookingType("PERF_COUNTER_RAWCOUNT"), Counter("PoolNonpagedAllocs"), PerfTimeStamp("Timestamp_PerfTime"), PerfTimeFreq("Frequency_PerfTime")

Number of calls to allocate space in the nonpaged pool, regardless of the amount of space allocated in each call. The nonpaged pool is an area of system memory area for objects that cannot be written to disk, and must remain in physical memory as long as they are allocated. This property displays the last observed value only; it is not an average.

PoolNonpagedBytes

Data type: uint64
Access type: Read-only
Qualifiers: CookingType("PERF_COUNTER_LARGE_RAWCOUNT"), Counter("PoolNonpagedBytes"), PerfTimeStamp("Timestamp_PerfTime"), PerfTimeFreq("Frequency_PerfTime")

Number of bytes in the nonpaged pool, an area of system memory (physical memory used by the operating system) for objects that cannot be written to disk, but must remain in physical memory as long as they are allocated. Win32_PerfFormattedData_PerfOS_Memory.Pool Nonpaged Bytes is calculated differently than Win32_PerfFormattedData_PerfProc_Process.Pool Nonpaged Bytes for processes, so it might not equal Process: Pool Nonpaged Bytes: _Total. The value is the last observed value only; it is not an average.

For more information about using uint64 values in scripts, see Scripting in WMI.

PoolPagedAllocs

Data type: uint32
Access type: Read-only
Qualifiers: CookingType("PERF_COUNTER_RAWCOUNT"), Counter("PoolPagedAllocs"), PerfTimeStamp("Timestamp_PerfTime"), PerfTimeFreq("Frequency_PerfTime")

Number of calls to allocate space in the paged pool, regardless of the amount of space allocated in each call. The paged pool is physical memory used by the operating system for objects that can be written to disk when they are not being used. This property displays the last observed value only; it is not an average.

PoolPagedBytes

Data type: uint64
Access type: Read-only
Qualifiers: CookingType("PERF_COUNTER_LARGE_RAWCOUNT"), Counter("PoolPagedBytes"), PerfTimeStamp("Timestamp_PerfTime"), PerfTimeFreq("Frequency_PerfTime")

Number of bytes in the paged pool, physical memory used by the operating system, for objects that can be written to disk when they are not being used. The Win32_PerfFormattedData_PerfOS_Memory.PoolPagedBytes is calculated differently than Win32_PerfFormattedData_PerfProc_Process.PoolPagedBytes, so it might not equal the total of PoolPagedBytes for all instances of Win32_PerfFormattedData_PerfProc_Process. This property displays the last observed value only; it is not an average.

For more information about using uint64 values in scripts, see Scripting in WMI.

PoolPagedResidentBytes

Data type: uint64
Access type: Read-only
Qualifiers: CookingType("PERF_COUNTER_LARGE_RAWCOUNT"), Counter("PoolPagedResidentBytes"), PerfTimeStamp("Timestamp_PerfTime"), PerfTimeFreq("Frequency_PerfTime")

Current size of the paged pool, physical memory used by the operating system, in bytes. The paged pool contains objects that can be written to disk when they are not being used. Space used by the paged and nonpaged pools is taken from physical memory, so a pool that is too large denies memory space to processes. This property displays the last observed value only; it is not an average.

For more information about using uint64 values in scripts, see Scripting in WMI.

SystemCacheResidentBytes

Data type: uint64
Access type: Read-only
Qualifiers: CookingType("PERF_COUNTER_LARGE_RAWCOUNT"), Counter("SystemCacheResidentBytes"), PerfTimeStamp("Timestamp_PerfTime"), PerfTimeFreq("Frequency_PerfTime")

Number of bytes of pageable operating system code in the file system cache. This value is a component of Win32_PerfFormattedData_PerfOS_Memory.SystemCodeResidentBytes that represent all pageable operating system code that is currently in physical memory. This property displays the last observed value only; it is not an average.

For more information about using uint64 values in scripts, see Scripting in WMI.

SystemCodeResidentBytes

Data type: uint64
Access type: Read-only
Qualifiers: CookingType("PERF_COUNTER_LARGE_RAWCOUNT"), Counter("SystemCodeResidentBytes"), PerfTimeStamp("Timestamp_PerfTime"), PerfTimeFreq("Frequency_PerfTime")

Number of bytes of operating system code currently in physical memory that can be written to disk when not in use. This value is a component of Win32_PerfFormattedData_PerfOS_Memory.SystemCodeTotalBytes, which also includes operating system code on disk. SystemCodeResidentBytes and SystemCodeTotalBytes include code can be written to disk. This property displays the last observed value only; it is not an average.

For more information about using uint64 values in scripts, see Scripting in WMI.

SystemCodeTotalBytes

Data type: uint64
Access type: Read-only
Qualifiers: CookingType("PERF_COUNTER_LARGE_RAWCOUNT"), Counter("SystemCodeTotalBytes"), PerfTimeStamp("Timestamp_PerfTime"), PerfTimeFreq("Frequency_PerfTime")

Number of bytes of pageable operating system code currently in virtual memory. It is a measure of the amount of physical memory being used by the operating system that can be written to disk when not in use. This property includes code that can be written to disk. This property displays the last observed value only; it is not an average.

For more information about using uint64 values in scripts, see Scripting in WMI.

SystemDriverResidentBytes

Data type: uint64
Access type: Read-only
Qualifiers: CookingType("PERF_COUNTER_LARGE_RAWCOUNT"), Counter("SystemDriverResidentBytes"), PerfTimeStamp("Timestamp_PerfTime"), PerfTimeFreq("Frequency_PerfTime")

Number of bytes of pageable physical memory being used by device drivers. It is the working set, the physical memory area, of the drivers. This value is a component of Win32_PerfFormattedData_PerfOS_Memory.SystemDriverTotalBytes, which also includes driver memory that has been written to disk. SystemDriverResidentBytes and SystemDriverTotalBytes include memory that can be written to disk.

For more information about using uint64 values in scripts, see Scripting in WMI.

SystemDriverTotalBytes

Data type: uint64
Access type: Read-only
Qualifiers: CookingType("PERF_COUNTER_LARGE_RAWCOUNT"), Counter("SystemDriverTotalBytes"), PerfTimeStamp("Timestamp_PerfTime"), PerfTimeFreq("Frequency_PerfTime")

Number of bytes of pageable virtual memory currently being used by device drivers. Pageable memory can be written to disk when it is not being used. It includes physical memory Win32_PerfFormattedData_PerfOS_Memory.SystemDriverResidentBytes, code, and data paged to disk. It is a component of Win32_PerfFormattedData_PerfOS_Memory.SystemCodeTotalBytes. This property displays the last observed value only; it is not an average.

For more information about using uint64 values in scripts, see Scripting in WMI.

Timestamp_Object

Data type: uint64
Access type: Read-only

Object-defined timestamp, defined by the provider. This property is inherited from Win32_Perf.

For more information about using uint64 values in scripts, see Scripting in WMI.

Timestamp_PerfTime

Data type: uint64
Access type: Read-only

High Performance counter timestamp. A value could be obtained by calling the Windows function QueryPerformanceCounter. This property is inherited from Win32_Perf.

For more information about using uint64 values in scripts, see Scripting in WMI.

Timestamp_Sys100NS

Data type: uint64
Access type: Read-only

Timestamp value in 100 nanosecond units. This property is inherited from Win32_Perf.

For more information about using uint64 values in scripts, see Scripting in WMI.

TransitionFaultsPerSec

Data type: uint32
Access type: Read-only
Qualifiers: CookingType("PERF_COUNTER_COUNTER"), Counter("TransitionFaultsPerSec"), PerfTimeStamp("Timestamp_PerfTime"), PerfTimeFreq("Frequency_PerfTime")

Number of page faults resolved by recovering pages that were on the modified page list, on the standby list, or being written to disk at the time of the page fault. The pages were recovered without additional disk activity. Transition faults are counted in numbers of faults, without regard for the number of pages faulted in each operation. This property displays the difference between the values observed in the last two samples, divided by the duration of the sample interval.

WriteCopiesPerSec

Data type: uint32
Access type: Read-only
Qualifiers: CookingType("PERF_COUNTER_COUNTER"), Counter("WriteCopiesPerSec"), PerfTimeStamp("Timestamp_PerfTime"), PerfTimeFreq("Frequency_PerfTime")

Number of page faults caused by attempts to write that have been satisfied by copying the page from elsewhere in physical memory. This is an economical way of sharing data because pages are only copied when they are written. Otherwise, the page is shared. This property counts the number of copies, without regard for the number of pages copied in each operation. The value is the difference between the values observed in the last two samples, divided by the duration of the sample interval.

Remarks

All classes derived from Win32_Perf are designed to be used with a refresher object. For more information about how to create and use a refresher object in C++, see Accessing Performance Data in C++. For more information about how to create and use a refresher object using scripts, see Refreshing WMI Data in Scripts.

The performance class and property qualifiers determine how to interpret the class data. For more information, see Class Qualifiers for Performance Counter Classes and Property Qualifiers for Performance Counter Classes.

Examples

For script code examples, see WMI Tasks for Scripts and Applications and the TechNet ScriptCenter Script Repository.

For C++ code examples, see WMI C++ Application Examples.

Requirements

See Also

Performance Counter Classes
Accessing WMI Preinstalled Performance Classes
WMI Tasks: Performance Monitoring
Accessing Performance Data in Script

Send comments about this topic to Microsoft

Build date: 8/20/2008